Refactored PathTracer in heap.cc....

src/heap.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 5163 matching lines @@
 }
 
 
 void HeapIterator::reset() {
   // Restart the iterator.
   Shutdown();
   Init();
 }
 
 
-#ifdef DEBUG
+#if defined(DEBUG) || defined(LIVE_OBJECT_LIST)
 
-static bool search_for_any_global;
-static Object* search_target;
-static bool found_target;
-static List<Object*> object_stack(20);
+void PathTracer::TracePathFrom(Object** root) {

[marklam, 2011/02/20 00:41:15]

TracePathFrom() used to be MarkRootObjectRecursively().

+  if (search_for_any_global_) {
+    ASSERT(search_target_ == NULL);
+  } else {
+    ASSERT(search_target_->IsHeapObject());
+  }
+  found_target_ = false;
+  object_stack_.Clear();
+
+  MarkRecursively(root);
+  UnmarkRecursively(root);
+  ProcessResults();

[marklam, 2011/02/20 00:41:15]

ProcessResults() is introduced as a virtual method to allow a subclass to
customize it.  Technically, this tracer class can be used to do other things
instead of just printing a path.  LOL will use it to print more verbose
information with some filtering added.  There are other uses for it as well that
I'm still exploring.

+}
 
 
-// Tags 0, 1, and 3 are used. Use 2 for marking visited HeapObject.
-static const int kMarkTag = 2;
-
-static void MarkObjectRecursively(Object** p);
-class MarkObjectVisitor : public ObjectVisitor {
- public:
-  void VisitPointers(Object** start, Object** end) {
-    // Copy all HeapObject pointers in [start, end)
-    for (Object** p = start; p < end; p++) {
-      if ((*p)->IsHeapObject())
-        MarkObjectRecursively(p);
-    }
-  }
-};
-
-static MarkObjectVisitor mark_visitor;
-
-static void MarkObjectRecursively(Object** p) {
+void PathTracer::MarkRecursively(Object** p) {

[marklam, 2011/02/20 00:41:15]

MarkRecursively() used to be MarkObjectRecursively() in heap.cc.

   if (!(*p)->IsHeapObject()) return;
 
   HeapObject* obj = HeapObject::cast(*p);
 
   Object* map = obj->map();
 
   if (!map->IsHeapObject()) return;  // visited before
 
-  if (found_target) return;  // stop if target found
-  object_stack.Add(obj);
-  if ((search_for_any_global && obj->IsJSGlobalObject()) ||
-      (!search_for_any_global && (obj == search_target))) {
-    found_target = true;
+  if (found_target_) return;  // stop if target found
+  object_stack_.Add(obj);
+  if ((search_for_any_global_ && obj->IsJSGlobalObject()) ||
+      (!search_for_any_global_ && (obj == search_target_))) {
+    found_target_ = true;
     return;
   }
 
+  bool is_global_context = obj->IsGlobalContext();
+
   // not visited yet
   Map* map_p = reinterpret_cast<Map*>(HeapObject::cast(map));
 
   Address map_addr = map_p->address();
 
   obj->set_map(reinterpret_cast<Map*>(map_addr + kMarkTag));
 
-  MarkObjectRecursively(&map);
+  // Scan the object body.
+  if (is_global_context && skip_weak_refs_) {
+    // This is specialized to scan Context's properly.
+    Object** start = reinterpret_cast<Object**>(obj->address() +
+                                                Context::kHeaderSize);
+    Object** end = reinterpret_cast<Object**>(obj->address() +
+        Context::kHeaderSize + Context::FIRST_WEAK_SLOT * kPointerSize);
+    mark_visitor.VisitPointers(start, end);
+  } else {
+    obj->IterateBody(map_p->instance_type(), obj->SizeFromMap(map_p),
+                     &mark_visitor);
+  }

[marklam, 2011/02/20 00:41:15]

The pre-existing code would scan all entries in the object body.  However, the
Context object contains implicit 2 weak ref pointers that are treated specially
by GC.  For LOL's leak debugging, the weak refs should not be scanned either. 
Hence, I added the option to skip them here. 

 
-  obj->IterateBody(map_p->instance_type(), obj->SizeFromMap(map_p),
-                   &mark_visitor);
+  // Scan the map after the body because the body is a lot more interesting
+  // when doing leak detection.
+  MarkRecursively(&map);

[marklam, 2011/02/20 00:41:15]

I moved the tracing of the map after the tracing of the body because in the
memory leak debugging work of LOL, the user is more likely to be interested in
the reference paths via the body properties than then map.  I don't expect this
to cause any problems for the existing heap debugging tracers.  If there's an
issue, please let me know and I can abstract this further.   Thanks. 

 
-  if (!found_target)  // don't pop if found the target
-    object_stack.RemoveLast();
+  if (!found_target_)  // don't pop if found the target
+    object_stack_.RemoveLast();
 }
 
 
-static void UnmarkObjectRecursively(Object** p);
-class UnmarkObjectVisitor : public ObjectVisitor {
- public:
-  void VisitPointers(Object** start, Object** end) {
-    // Copy all HeapObject pointers in [start, end)
-    for (Object** p = start; p < end; p++) {
-      if ((*p)->IsHeapObject())
-        UnmarkObjectRecursively(p);
-    }
-  }
-};
-
-static UnmarkObjectVisitor unmark_visitor;
-
-static void UnmarkObjectRecursively(Object** p) {
+void PathTracer::UnmarkRecursively(Object** p) {

[marklam, 2011/02/20 00:41:15]

UnmarkRecursively() used to be called UnmarkObjectRecursively() in heap.cc.

   if (!(*p)->IsHeapObject()) return;
 
   HeapObject* obj = HeapObject::cast(*p);
 
   Object* map = obj->map();
 
   if (map->IsHeapObject()) return;  // unmarked already
 
   Address map_addr = reinterpret_cast<Address>(map);
 
   map_addr -= kMarkTag;
 
   ASSERT_TAG_ALIGNED(map_addr);
 
   HeapObject* map_p = HeapObject::FromAddress(map_addr);
 
   obj->set_map(reinterpret_cast<Map*>(map_p));
 
-  UnmarkObjectRecursively(reinterpret_cast<Object**>(&map_p));
+  UnmarkRecursively(reinterpret_cast<Object**>(&map_p));
 
   obj->IterateBody(Map::cast(map_p)->instance_type(),
                    obj->SizeFromMap(Map::cast(map_p)),
                    &unmark_visitor);
 }
 
 
-static void MarkRootObjectRecursively(Object** root) {
-  if (search_for_any_global) {
-    ASSERT(search_target == NULL);
-  } else {
-    ASSERT(search_target->IsHeapObject());
-  }
-  found_target = false;
-  object_stack.Clear();
-
-  MarkObjectRecursively(root);
-  UnmarkObjectRecursively(root);
-
-  if (found_target) {
+void PathTracer::ProcessResults() {
+  if (found_target_) {
     PrintF("=====================================\n");
     PrintF("====        Path to object       ====\n");
     PrintF("=====================================\n\n");
 
-    ASSERT(!object_stack.is_empty());
-    for (int i = 0; i < object_stack.length(); i++) {
+    ASSERT(!object_stack_.is_empty());
+    for (int i = 0; i < object_stack_.length(); i++) {
       if (i > 0) PrintF("\n     |\n     |\n     V\n\n");
-      Object* obj = object_stack[i];
+      Object* obj = object_stack_[i];
       obj->Print();
     }
     PrintF("=====================================\n");
   }
 }
+#endif  // DEBUG || LIVE_OBJECT_LIST
 
 
-// Helper class for visiting HeapObjects recursively.
-class MarkRootVisitor: public ObjectVisitor {
- public:
-  void VisitPointers(Object** start, Object** end) {
-    // Visit all HeapObject pointers in [start, end)
-    for (Object** p = start; p < end; p++) {
-      if ((*p)->IsHeapObject())
-        MarkRootObjectRecursively(p);
-    }
-  }
-};
-
-
+#ifdef DEBUG
 // Triggers a depth-first traversal of reachable objects from roots
 // and finds a path to a specific heap object and prints it.
 void Heap::TracePathToObject(Object* target) {
-  search_target = target;
-  search_for_any_global = false;
-
-  MarkRootVisitor root_visitor;
-  IterateRoots(&root_visitor, VISIT_ONLY_STRONG);
+  PathTracer tracer(target, false, PathTracer::kFindAll, false);
+  IterateRoots(&tracer, VISIT_ONLY_STRONG);
 }
 
 
 // Triggers a depth-first traversal of reachable objects from roots
 // and finds a path to any global object and prints it. Useful for
 // determining the source for leaks of global objects.
 void Heap::TracePathToGlobal() {
-  search_target = NULL;
-  search_for_any_global = true;
-
-  MarkRootVisitor root_visitor;
-  IterateRoots(&root_visitor, VISIT_ONLY_STRONG);
+  PathTracer tracer(NULL, true, PathTracer::kFindAll, false);
+  IterateRoots(&tracer, VISIT_ONLY_STRONG);
 }
 #endif
 
 
 static intptr_t CountTotalHolesSize() {
   intptr_t holes_size = 0;
   OldSpaces spaces;
   for (OldSpace* space = spaces.next();
        space != NULL;
        space = spaces.next()) {
@@ skipping 232 matching lines @@
 void ExternalStringTable::TearDown() {
   new_space_strings_.Free();
   old_space_strings_.Free();
 }
 
 
 List<Object*> ExternalStringTable::new_space_strings_;
 List<Object*> ExternalStringTable::old_space_strings_;
 
 } }  // namespace v8::internal