Rank most retaining instances for each class.

runtime/observatory/lib/object_graph.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library object_graph;
 
 import 'dart:typed_data';
 
 import 'dominator_tree.dart';
 
@@ skipping 20 matching lines @@
   }
 
   static const int dataBitsPerByte = 7;
   static const int byteMask = (1 << dataBitsPerByte) - 1;
   static const int maxUnsignedDataPerByte = byteMask;
 }
 
 class ObjectVertex {
   // Never null. The isolate root has id 0.
   final int _id;
+  bool get isRoot => _id == 0;
+  // TODO(koda): Include units in object graph metadata.
+  int addressForWordSize(int bytesPerWord) => _id * 2 * bytesPerWord;
   // null for VM-heap objects.
   int _shallowSize;
   int get shallowSize => _shallowSize;
   int _retainedSize;
   int get retainedSize => _retainedSize;
   // null for VM-heap objects.
   int _classId;
   int get classId => _classId;
   final List<ObjectVertex> succ = new List<ObjectVertex>();
   ObjectVertex(this._id) : _retainedSize = 0;
@@ skipping 17 matching lines @@
       obj.succ.add(_asVertex(last));
       last = stream.readUnsigned();
     }
   }
 
   ObjectGraph(ReadStream reader) {
     while (reader.pendingBytes > 0) {
       _addFrom(reader);
     }
     _computeRetainedSizes();
+    _mostRetained = new List<ObjectVertex>.from(
+        vertices.where((u) => !u.isRoot));
+    _mostRetained.sort((u, v) => v.retainedSize - u.retainedSize);
   }
 
   Iterable<ObjectVertex> get vertices => _idToVertex.values;
+  List<ObjectVertex> _mostRetained;
 
   ObjectVertex get root => _asVertex(0);
   
+  Iterable<ObjectVertex> getMostRetained({int classId, int limit}) {
+    var result = _mostRetained;
+    if (classId != null) {
+      result = result.where((u) => u.classId == classId);
+    }
+    if (limit != null) {
+      result = result.take(limit);
+    }
+    return result;
+  }
+  
   void _computeRetainedSizes() {
     // The retained size for an object is the sum of the shallow sizes of
     // all its descendants in the dominator tree (including itself).
     var d = new Dominator();
     for (ObjectVertex u in vertices) {
       if (u.shallowSize != null) {
         u._retainedSize = u.shallowSize;
         d.addEdges(u, u.succ.where((ObjectVertex v) => v.shallowSize != null));
       }
     }
@@ skipping 17 matching lines @@
       var v = leaves.removeLast();
       var u = d.dominator(v);
       if (u == null) continue;
       u._retainedSize += v._retainedSize;
       if (--degree[u] == 0) {
         leaves.add(u);
       }
     }
   }
 }