Add RPC and UI for reachable size of an object / all instances of a class.

runtime/vm/object_graph.cc

 // 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.
 
 #include "vm/object_graph.h"
 
 #include "vm/dart.h"
 #include "vm/growable_array.h"
 #include "vm/isolate.h"
 #include "vm/object.h"
@@ skipping 168 matching lines @@
 }
 
 
 void ObjectGraph::IterateObjectsFrom(const Object& root,
                                      ObjectGraph::Visitor* visitor) {
   NoSafepointScope no_safepoint_scope_;
   Stack stack(isolate());
   RawObject* root_raw = root.raw();
   stack.VisitPointer(&root_raw);
   stack.TraverseGraph(visitor);
-  // TODO(koda): Optimize if we only visited a small subgraph.
   Unmarker::UnmarkAll(isolate());
 }
 
+
+class InstanceAccumulator : public ObjectVisitor {
+ public:
+  explicit InstanceAccumulator(ObjectGraph::Stack* stack,
+                               intptr_t class_id,
+                               Isolate* isolate)
+    : ObjectVisitor(isolate), stack_(stack), class_id_(class_id) { }
+
+  void VisitObject(RawObject* obj) {
+    if (obj->GetClassId() == class_id_) {
+      RawObject* rawobj = obj;
+      stack_->VisitPointer(&rawobj);
+    }
+  }
+
+ private:
+  ObjectGraph::Stack* stack_;
+  const intptr_t class_id_;
+
+  DISALLOW_COPY_AND_ASSIGN(InstanceAccumulator);
+};
+
+
+void ObjectGraph::IterateObjectsFrom(intptr_t class_id,
+                                     ObjectGraph::Visitor* visitor) {
+  NoSafepointScope no_safepoint_scope_;
+  Stack stack(isolate());
+
+  InstanceAccumulator accumulator(&stack, class_id, isolate());
+  isolate()->heap()->IterateObjects(&accumulator);
+
+  stack.TraverseGraph(visitor);
+  Unmarker::UnmarkAll(isolate());
+}
+
 
 class SizeVisitor : public ObjectGraph::Visitor {
  public:
   SizeVisitor() : size_(0) { }
   intptr_t size() const { return size_; }
   virtual bool ShouldSkip(RawObject* obj) const { return false; }
   virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
     RawObject* obj = it->Get();
     if (ShouldSkip(obj)) {
       return kBacktrack;
@@ skipping 30 matching lines @@
   SizeVisitor total;
   IterateObjects(&total);
   intptr_t size_total = total.size();
   SizeExcludingObjectVisitor excluding_obj(obj);
   IterateObjects(&excluding_obj);
   intptr_t size_excluding_obj = excluding_obj.size();
   return size_total - size_excluding_obj;
 }
 
 
+intptr_t ObjectGraph::SizeReachableByInstance(const Object& obj) {
+  SizeVisitor total;
+  IterateObjectsFrom(obj, &total);
+  return total.size();
+}
+
+
 intptr_t ObjectGraph::SizeRetainedByClass(intptr_t class_id) {
   SizeVisitor total;
   IterateObjects(&total);
   intptr_t size_total = total.size();
   SizeExcludingClassVisitor excluding_class(class_id);
   IterateObjects(&excluding_class);
   intptr_t size_excluding_class = excluding_class.size();
   return size_total - size_excluding_class;
 }
 
 
+intptr_t ObjectGraph::SizeReachableByClass(intptr_t class_id) {
+  SizeVisitor total;
+  IterateObjectsFrom(class_id, &total);
+  return total.size();
+}
+
+
 class RetainingPathVisitor : public ObjectGraph::Visitor {
  public:
   // We cannot use a GrowableObjectArray, since we must not trigger GC.
   RetainingPathVisitor(RawObject* obj, const Array& path)
       : thread_(Thread::Current()), obj_(obj), path_(path), length_(0) {
     ASSERT(Thread::Current()->no_safepoint_scope_depth() != 0);
   }
 
   intptr_t length() const { return length_; }
 
@@ skipping 210 matching lines @@
   {
     WritePointerVisitor ptr_writer(isolate(), stream);
     isolate()->IterateObjectPointers(&ptr_writer, false, false);
   }
   stream->WriteUnsigned(0);
   IterateObjects(&visitor);
   return visitor.count() + 1;  // + root
 }
 
 }  // namespace dart