[observatory] Add an "ownership" analysis for the heap snapshot.

runtime/observatory/lib/src/heap_snapshot/heap_snapshot.dart

 // Copyright (c) 2016, 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.
 
 part of heap_snapshot;
 
 class HeapSnapshot implements M.HeapSnapshot {
   ObjectGraph graph;
   DateTime timestamp;
   int get objects => graph.vertexCount;
   int get references => graph.edgeCount;
   int get size => graph.internalSize + graph.externalSize;
   HeapSnapshotDominatorNode dominatorTree;
   HeapSnapshotMergedDominatorNode mergedDominatorTree;
   List<MergedVertex> classReferences;
+  List<OwnershipClass> ownershipClasses;
 
   static Future sleep([Duration duration = const Duration(microseconds: 0)]) {
     final Completer completer = new Completer();
     new Timer(duration, () => completer.complete());
     return completer.future;
   }
 
   Stream<List> loadProgress(S.Isolate isolate, S.RawHeapSnapshot raw) {
     final progress = new StreamController<List>.broadcast();
     progress.add(['', 0.0]);
     graph = new ObjectGraph(raw.chunks, raw.count);
     var signal = (String description, double p) {
       progress.add([description, p]);
       return sleep();
     };
     (() async {
       timestamp = new DateTime.now();
       final stream = graph.process();
       stream.listen((status) {
         status[1] /= 2.0;
         progress.add(status);
       });
       await stream.last;
       dominatorTree = new HeapSnapshotDominatorNode(isolate, graph.root);
       mergedDominatorTree =
           new HeapSnapshotMergedDominatorNode(isolate, graph.mergedRoot);
       classReferences = await buildMergedVertices(isolate, graph, signal);
+      ownershipClasses = buildOwnershipClasses(isolate, graph);
       progress.close();
     }());
     return progress.stream;
   }
 
   Future<List<MergedVertex>> buildMergedVertices(
       S.Isolate isolate, ObjectGraph graph, signal) async {
     final cidToMergedVertex = {};
 
     int count = 0;
@@ skipping 40 matching lines @@
           target.incomingEdges.add(edge);
         }
         edge.count++;
         // An over-estimate if there are multiple references to the same object.
         edge.shallowSize += vertex2.shallowSize ?? 0;
       }
     }
     return cidToMergedVertex.values.toList();
   }
 
+  buildOwnershipClasses(S.Isolate isolate, ObjectGraph graph) {
+    var numCids = graph.numCids;
+    var classes = new List();
+    for (var cid = 0; cid < numCids; cid++) {
+      var size = graph.getOwnedByCid(cid);
+      if (size != 0) {
+        classes.add(new OwnershipClass(cid, isolate, size));
+      }
+    }
+    return classes;
+  }
+
   List<Future<S.ServiceObject>> getMostRetained(S.Isolate isolate,
       {int classId, int limit}) {
     var result = [];
     for (ObjectVertex v
         in graph.getMostRetained(classId: classId, limit: limit)) {
       result.add(
           isolate.getObjectByAddress(v.address).then((S.ServiceObject obj) {
         if (obj is S.HeapObject) {
           obj.retainedSize = v.retainedSize;
         } else {
@@ skipping 147 matching lines @@
   final MergedEdge edge;
   S.Class get target => edge.sourceVertex != vertex
       ? edge.sourceVertex.clazz
       : edge.targetVertex.clazz;
   int get count => edge.count;
   int get shallowSize => edge.shallowSize;
   int get retainedSize => edge.retainedSize;
 
   HeapSnapshotClassOutbound(this.vertex, this.edge);
 }
+
+class OwnershipClass {

[cbernaschina, 2017/08/29 21:07:00]

ditto

[rmacnak, 2017/08/29 23:59:34]

Done.

+  final int cid;
+  final S.Isolate isolate;
+  S.Class get clazz => isolate.getClassByCid(cid);
+  final int size;
+
+  OwnershipClass(this.cid, this.isolate, this.size);
+}