ObjectGraph::RetainingPath

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 189 matching lines @@
 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;
 }
 
+
+class RetainingPathVisitor : public ObjectGraph::Visitor {
+ public:
+  RetainingPathVisitor(RawObject* obj, const Array& path)
+      : obj_(obj), path_(path), length_(0) {
+    ASSERT(Isolate::Current()->no_gc_scope_depth() != 0);

[turnidge, 2014/05/20 18:00:38]

We could consider clearing path_ here.

Are we unable to use a GrowableArray because it might trigger gc during growth?

[koda, 2014/05/20 20:37:49]

Yes, we need to avoid GC during the search.

+  }
+  intptr_t length() const { return length_; }

[turnidge, 2014/05/20 18:00:38]

blank line here would help me.

[koda, 2014/05/20 20:37:49]

Done.

+  virtual Direction VisitObject(ObjectGraph::StackIterator* it) {
+    if (it->Get() != obj_) {
+      return kProceed;
+    }
+    Object& parent = Object::Handle();
+    for (length_ = 0; it->MoveToParent(); ++length_) {
+      if (length_ < path_.Length()) {

[Cutch, 2014/05/20 17:39:12]

Could we allow path to be Array::null() and call like this:

// Query the length.
intptr_t l = RetainingPath(obj, Array::null());

// Allocate array length.
const Array& arr = Array::Handle(Array::New(l));

// Call again to get actual path.
RetainingPath(obj, arr);

[koda, 2014/05/20 20:37:49]

Done. Although I expect the common use will be to pass in an array with a
reasonable upper bound, rather than making two calls.

+        parent = it->Get();
+        path_.SetAt(length_, parent);
+      }
+    }
+    return kAbort;
+  }
+ private:
+  RawObject* obj_;
+  const Array& path_;
+  intptr_t length_;
+};
+
+
+intptr_t ObjectGraph::RetainingPath(Object* obj, const Array& path) {
+  NoGCScope no_gc_scope_;

[turnidge, 2014/05/20 18:00:38]

Maybe comment on what you are doing here with obj and raw.  I know you comment
in the header file, but perhaps commenting here would be more clear. 
"Temporarily clear the object handle so that blah" or whatever.

[koda, 2014/05/20 20:37:49]

Done.

+  RawObject* raw = obj->raw();
+  *obj = Object::null();
+  RetainingPathVisitor visitor(raw, path);
+  IterateObjects(&visitor);
+  *obj = raw;
+  return visitor.length();
+}
+
 }  // namespace dart