Use a custom parser implementation instead of perflib.

Removes the dependency on perflib, avoids bugs in the perflib parser
whose fixes would not be readily available for ahat to use in the short
term, and avoids the need to pull in additional dependencies required to
use future versions of perflib.

Improves heap dump processing performance by 30-50% on some examples now
that we can avoid overheads due to the impedance mismatch between
perflib's object representation and ahat's object representation.

Other relevant changes included in this CL:
* Introduce enums for root types and basic types.
* Compute instance sizes on demand rather than eagerly.
* Introduce an abstraction for a collection of instances sorted by id.

Bug: 28312815
Bug: 33769446
Bug: 65356532
Test: m ahat-test, this change fixes all previously failing tests.
Change-Id: Ib14c294aa745cb03b02fa81d1544c78ff35e1edc

1 files changed, 54 insertions, 42 deletions

diff --git a/tools/ahat/test/DiffFieldsTest.java b/tools/ahat/test/DiffFieldsTest.java
index 7dc519d60b..19399757a6 100644
--- a/tools/ahat/test/DiffFieldsTest.java
+++ b/tools/ahat/test/DiffFieldsTest.java
@@ -19,6 +19,7 @@ package com.android.ahat;
 import com.android.ahat.heapdump.DiffFields;
 import com.android.ahat.heapdump.DiffedFieldValue;
 import com.android.ahat.heapdump.FieldValue;
+import com.android.ahat.heapdump.Type;
 import com.android.ahat.heapdump.Value;
 import java.util.ArrayList;
 import java.util.List;
@@ -28,14 +29,25 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNull;
 
 public class DiffFieldsTest {
+  // Give more convenient abstract names for different types.
+  private static final Type t0 = Type.OBJECT;
+  private static final Type t1 = Type.BOOLEAN;
+  private static final Type t2 = Type.CHAR;
+  private static final Type t3 = Type.FLOAT;
+  private static final Type t4 = Type.DOUBLE;
+  private static final Type t5 = Type.BYTE;
+  private static final Type t6 = Type.SHORT;
+  private static final Type t7 = Type.INT;
+  private static final Type t8 = Type.LONG;
+
   @Test
   public void normalMatchedDiffedFieldValues() {
-    FieldValue normal1 = new FieldValue("name", "type", Value.pack(1));
-    FieldValue normal2 = new FieldValue("name", "type", Value.pack(2));
+    FieldValue normal1 = new FieldValue("name", t0, Value.pack(1));
+    FieldValue normal2 = new FieldValue("name", t0, Value.pack(2));
 
     DiffedFieldValue x = DiffedFieldValue.matched(normal1, normal2);
     assertEquals("name", x.name);
-    assertEquals("type", x.type);
+    assertEquals(t0, x.type);
     assertEquals(Value.pack(1), x.current);
     assertEquals(Value.pack(2), x.baseline);
     assertEquals(DiffedFieldValue.Status.MATCHED, x.status);
@@ -43,19 +55,19 @@ public class DiffFieldsTest {
 
   @Test
   public void nulledMatchedDiffedFieldValues() {
-    FieldValue normal = new FieldValue("name", "type", Value.pack(1));
-    FieldValue nulled = new FieldValue("name", "type", null);
+    FieldValue normal = new FieldValue("name", t0, Value.pack(1));
+    FieldValue nulled = new FieldValue("name", t0, null);
 
     DiffedFieldValue x = DiffedFieldValue.matched(normal, nulled);
     assertEquals("name", x.name);
-    assertEquals("type", x.type);
+    assertEquals(t0, x.type);
     assertEquals(Value.pack(1), x.current);
     assertNull(x.baseline);
     assertEquals(DiffedFieldValue.Status.MATCHED, x.status);
 
     DiffedFieldValue y = DiffedFieldValue.matched(nulled, normal);
     assertEquals("name", y.name);
-    assertEquals("type", y.type);
+    assertEquals(t0, y.type);
     assertNull(y.current);
     assertEquals(Value.pack(1), y.baseline);
     assertEquals(DiffedFieldValue.Status.MATCHED, y.status);
@@ -63,44 +75,44 @@ public class DiffFieldsTest {
 
   @Test
   public void normalAddedDiffedFieldValues() {
-    FieldValue normal = new FieldValue("name", "type", Value.pack(1));
+    FieldValue normal = new FieldValue("name", t0, Value.pack(1));
 
     DiffedFieldValue x = DiffedFieldValue.added(normal);
     assertEquals("name", x.name);
-    assertEquals("type", x.type);
+    assertEquals(t0, x.type);
     assertEquals(Value.pack(1), x.current);
     assertEquals(DiffedFieldValue.Status.ADDED, x.status);
   }
 
   @Test
   public void nulledAddedDiffedFieldValues() {
-    FieldValue nulled = new FieldValue("name", "type", null);
+    FieldValue nulled = new FieldValue("name", t0, null);
 
     DiffedFieldValue x = DiffedFieldValue.added(nulled);
     assertEquals("name", x.name);
-    assertEquals("type", x.type);
+    assertEquals(t0, x.type);
     assertNull(x.current);
     assertEquals(DiffedFieldValue.Status.ADDED, x.status);
   }
 
   @Test
   public void normalDeletedDiffedFieldValues() {
-    FieldValue normal = new FieldValue("name", "type", Value.pack(1));
+    FieldValue normal = new FieldValue("name", t0, Value.pack(1));
 
     DiffedFieldValue x = DiffedFieldValue.deleted(normal);
     assertEquals("name", x.name);
-    assertEquals("type", x.type);
+    assertEquals(t0, x.type);
     assertEquals(Value.pack(1), x.baseline);
     assertEquals(DiffedFieldValue.Status.DELETED, x.status);
   }
 
   @Test
   public void nulledDeletedDiffedFieldValues() {
-    FieldValue nulled = new FieldValue("name", "type", null);
+    FieldValue nulled = new FieldValue("name", t0, null);
 
     DiffedFieldValue x = DiffedFieldValue.deleted(nulled);
     assertEquals("name", x.name);
-    assertEquals("type", x.type);
+    assertEquals(t0, x.type);
     assertNull(x.baseline);
     assertEquals(DiffedFieldValue.Status.DELETED, x.status);
   }
@@ -108,21 +120,21 @@ public class DiffFieldsTest {
   @Test
   public void basicDiff() {
     List<FieldValue> a = new ArrayList<FieldValue>();
-    a.add(new FieldValue("n0", "t0", null));
-    a.add(new FieldValue("n2", "t2", null));
-    a.add(new FieldValue("n3", "t3", null));
-    a.add(new FieldValue("n4", "t4", null));
-    a.add(new FieldValue("n5", "t5", null));
-    a.add(new FieldValue("n6", "t6", null));
+    a.add(new FieldValue("n0", t0, null));
+    a.add(new FieldValue("n2", t2, null));
+    a.add(new FieldValue("n3", t3, null));
+    a.add(new FieldValue("n4", t4, null));
+    a.add(new FieldValue("n5", t5, null));
+    a.add(new FieldValue("n6", t6, null));
 
     List<FieldValue> b = new ArrayList<FieldValue>();
-    b.add(new FieldValue("n0", "t0", null));
-    b.add(new FieldValue("n1", "t1", null));
-    b.add(new FieldValue("n2", "t2", null));
-    b.add(new FieldValue("n3", "t3", null));
-    b.add(new FieldValue("n5", "t5", null));
-    b.add(new FieldValue("n6", "t6", null));
-    b.add(new FieldValue("n7", "t7", null));
+    b.add(new FieldValue("n0", t0, null));
+    b.add(new FieldValue("n1", t1, null));
+    b.add(new FieldValue("n2", t2, null));
+    b.add(new FieldValue("n3", t3, null));
+    b.add(new FieldValue("n5", t5, null));
+    b.add(new FieldValue("n6", t6, null));
+    b.add(new FieldValue("n7", t7, null));
 
     // Note: The expected result makes assumptions about the implementation of
     // field diff to match the order of the returned fields. If the
@@ -145,22 +157,22 @@ public class DiffFieldsTest {
   @Test
   public void reorderedDiff() {
     List<FieldValue> a = new ArrayList<FieldValue>();
-    a.add(new FieldValue("n0", "t0", null));
-    a.add(new FieldValue("n1", "t1", null));
-    a.add(new FieldValue("n2", "t2", null));
-    a.add(new FieldValue("n3", "t3", null));
-    a.add(new FieldValue("n4", "t4", null));
-    a.add(new FieldValue("n5", "t5", null));
-    a.add(new FieldValue("n6", "t6", null));
+    a.add(new FieldValue("n0", t0, null));
+    a.add(new FieldValue("n1", t1, null));
+    a.add(new FieldValue("n2", t2, null));
+    a.add(new FieldValue("n3", t3, null));
+    a.add(new FieldValue("n4", t4, null));
+    a.add(new FieldValue("n5", t5, null));
+    a.add(new FieldValue("n6", t6, null));
 
     List<FieldValue> b = new ArrayList<FieldValue>();
-    b.add(new FieldValue("n4", "t4", null));
-    b.add(new FieldValue("n1", "t1", null));
-    b.add(new FieldValue("n3", "t3", null));
-    b.add(new FieldValue("n0", "t0", null));
-    b.add(new FieldValue("n5", "t5", null));
-    b.add(new FieldValue("n2", "t2", null));
-    b.add(new FieldValue("n6", "t6", null));
+    b.add(new FieldValue("n4", t4, null));
+    b.add(new FieldValue("n1", t1, null));
+    b.add(new FieldValue("n3", t3, null));
+    b.add(new FieldValue("n0", t0, null));
+    b.add(new FieldValue("n5", t5, null));
+    b.add(new FieldValue("n2", t2, null));
+    b.add(new FieldValue("n6", t6, null));
 
     // Note: The expected result makes assumptions about the implementation of
     // field diff to match the order of the returned fields. If the