Calculates retaining paths through user fields and ignores VM objects

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"
 #include "vm/object_store.h"
 #include "vm/raw_object.h"
 #include "vm/reusable_handles.h"
 #include "vm/visitor.h"
 
 namespace dart {
 
 // The state of a pre-order, depth-first traversal of an object graph.
 // When a node is visited, *all* its children are pushed to the stack at once.
 // We insert a sentinel between the node and its children on the stack, to
 // remember that the node has been visited. The node is kept on the stack while
 // its children are processed, to give the visitor a complete chain of parents.
 //
 // TODO(koda): Potential optimizations:
 // - Use tag bits for compact Node and sentinel representations.
 class ObjectGraph::Stack : public ObjectPointerVisitor {
  public:
   explicit Stack(Isolate* isolate)
-      : ObjectPointerVisitor(isolate), data_(kInitialCapacity) {}
+      : ObjectPointerVisitor(isolate),
+        include_vm_obj(true),
+        data_(kInitialCapacity) {}
 
   // Marks and pushes. Used to initialize this stack with roots.
   virtual void VisitPointers(RawObject** first, RawObject** last) {
     for (RawObject** current = first; current <= last; ++current) {
       if ((*current)->IsHeapObject() && !(*current)->IsMarked()) {
+        if (!include_vm_obj) {

[cbernaschina, 2017/07/25 21:09:22]

Can we make this more generic?

Maybe storing a function pointer or a functor object that is optionally passed
to ObjectGraph::IterateObjects and will filter out elements?

[danunez, 2017/07/25 22:24:54]

I like this idea and we discussed this a bit offline. We found that
ObjectGraph::IterateObjects will have to take in said function pointer/functor.

I was curious if others had a preferred way of making this change.

+          Object& o = Object::Handle(*current);

[rmacnak, 2017/07/25 21:55:21]

Allocating a handle here is too expensive.

*current->GetClassId()

[danunez, 2017/07/25 22:24:54]

RawObject::GetClassId() is private. I can make it public to avoid the handle.

[rmacnak, 2017/07/26 00:25:40]

Make ObjectGraph::Stack a friend instead. I'm sort of surprised it isn't already
given all the other RawObject going on in this function.

+          intptr_t cid = o.GetClassId();
+          if (cid < kInstanceCid && cid != kContextCid) {
+            continue;
+          }
+        }
         (*current)->SetMarkBit();
         Node node;
         node.ptr = current;
         node.obj = *current;
         data_.Add(node);
       }
     }
   }
 
   // Traverses the object graph from the current state.
@@ skipping 17 matching lines @@
           obj->VisitPointers(this);
           break;
         case ObjectGraph::Visitor::kBacktrack:
           break;
         case ObjectGraph::Visitor::kAbort:
           return;
       }
     }
   }
 
+  bool include_vm_obj;

[rmacnak, 2017/07/25 21:55:21]

include_vm_objects_

[danunez, 2017/07/25 22:24:54]

Done.

+
  private:
   struct Node {
     RawObject** ptr;  // kSentinel for the sentinel node.
     RawObject* obj;
   };
 
   static RawObject** const kSentinel;
   static const intptr_t kInitialCapacity = 1024;
   static const intptr_t kNoParent = -1;
 
@@ skipping 288 matching lines @@
 };
 
 intptr_t ObjectGraph::RetainingPath(Object* obj, const Array& path) {
   NoSafepointScope no_safepoint_scope_;
   HeapIterationScope iteration_scope(true);
   // To break the trivial path, the handle 'obj' is temporarily cleared during
   // the search, but restored before returning.
   RawObject* raw = obj->raw();
   *obj = Object::null();
   RetainingPathVisitor visitor(raw, path);
-  IterateObjects(&visitor);
+  IterateObjectsNoVM(&visitor);
+  if (visitor.length() == 0) {
+    IterateObjects(&visitor);
+  }
   *obj = raw;
   return visitor.length();
 }
 
 class InboundReferencesVisitor : public ObjectVisitor,
                                  public ObjectPointerVisitor {
  public:
   // We cannot use a GrowableObjectArray, since we must not trigger GC.
   InboundReferencesVisitor(Isolate* isolate,
                            RawObject* target,
@@ skipping 235 matching lines @@
 
   intptr_t object_count = visitor.count();
   if (roots == kVM) {
     object_count += 1;  // root
   } else {
     object_count += 2;  // root and stack
   }
   return object_count;
 }
 
+void ObjectGraph::IterateObjectsNoVM(ObjectGraph::Visitor* visitor) {

[rmacnak, 2017/07/25 21:55:21]

Place next to ObjectGraph::IterateObjects.

[danunez, 2017/07/25 22:24:54]

I can do this, but I will also have to move IterateUserFields() as well, since
it is a static function declared and defined in object_graph.cc.

+  NoSafepointScope no_safepoint_scope_;
+  Stack stack(isolate());
+  IterateUserFields(&stack);
+  stack.include_vm_obj = false;
+  stack.TraverseGraph(visitor);
+  Unmarker::UnmarkAll(isolate());
+}
+
 }  // namespace dart