Introduce a flag for tracing retaining path in GC.

src/heap/heap.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 148 matching lines @@
   set_native_contexts_list(NULL);
   set_array_buffers_list(Smi::FromInt(0));
   set_allocation_sites_list(Smi::FromInt(0));
   set_encountered_weak_collections(Smi::FromInt(0));
   set_encountered_weak_cells(Smi::FromInt(0));
   // Put a dummy entry in the remembered pages so we can find the list the
   // minidump even if there are no real unmapped pages.
   RememberUnmappedPage(NULL, false);
 
   ClearObjectStats(true);
+
+#ifdef TRACE_RETAINING_PATH
+  ClearRetainingInfo();
+#endif
 }
 
 
 intptr_t Heap::Capacity() {
   if (!HasBeenSetUp()) return 0;
 
   return new_space_.Capacity() + old_pointer_space_->Capacity() +
          old_data_space_->Capacity() + code_space_->Capacity() +
          map_space_->Capacity() + cell_space_->Capacity() +
          property_cell_space_->Capacity();
@@ skipping 428 matching lines @@
 
   // Process pretenuring feedback and update allocation sites.
   ProcessPretenuringFeedback();
 
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     Verify();
   }
 #endif
 
+#ifdef TRACE_RETAINING_PATH
+  ClearRetainingInfo();
+#endif
+
   AllowHeapAllocation for_the_rest_of_the_epilogue;
 
 #ifdef DEBUG
   if (FLAG_print_global_handles) isolate_->global_handles()->Print();
   if (FLAG_print_handles) PrintHandles();
   if (FLAG_gc_verbose) Print();
   if (FLAG_code_stats) ReportCodeStatistics("After GC");
 #endif
   if (FLAG_deopt_every_n_garbage_collections > 0) {
     // TODO(jkummerow/ulan/jarin): This is not safe! We can't assume that
@@ skipping 4410 matching lines @@
 
 
 void Heap::IterateSmiRoots(ObjectVisitor* v) {
   // Acquire execution access since we are going to read stack limit values.
   ExecutionAccess access(isolate());
   v->VisitPointers(&roots_[kSmiRootsStart], &roots_[kRootListLength]);
   v->Synchronize(VisitorSynchronization::kSmiRootList);
 }
 
 
+#ifdef TRACE_RETAINING_PATH
+#define TRACE_ROOT(root) SetCurrentRootRetainer(std::string(root))
+#else
+#define TRACE_ROOT(root)
+#endif
+
+
 void Heap::IterateStrongRoots(ObjectVisitor* v, VisitMode mode) {
+  TRACE_ROOT("[strong root list]");
   v->VisitPointers(&roots_[0], &roots_[kStrongRootListLength]);
   v->Synchronize(VisitorSynchronization::kStrongRootList);
 
+  TRACE_ROOT("[internalized string]");
   v->VisitPointer(bit_cast<Object**>(&hidden_string_));
   v->Synchronize(VisitorSynchronization::kInternalizedString);
 
+  TRACE_ROOT("[bootstrapper]");
   isolate_->bootstrapper()->Iterate(v);
   v->Synchronize(VisitorSynchronization::kBootstrapper);
+
+  TRACE_ROOT("[isolate threads]");
   isolate_->Iterate(v);
   v->Synchronize(VisitorSynchronization::kTop);
+
+  TRACE_ROOT("[isolate relocatable]");
   Relocatable::Iterate(isolate_, v);
   v->Synchronize(VisitorSynchronization::kRelocatable);
 
+  TRACE_ROOT("[deoptimizer data]");
   if (isolate_->deoptimizer_data() != NULL) {
     isolate_->deoptimizer_data()->Iterate(v);
   }
   v->Synchronize(VisitorSynchronization::kDebug);
+
+  TRACE_ROOT("[compilation cache]");
   isolate_->compilation_cache()->Iterate(v);
   v->Synchronize(VisitorSynchronization::kCompilationCache);
 
   // Iterate over local handles in handle scopes.
+  TRACE_ROOT("[internal handles]");
   isolate_->handle_scope_implementer()->Iterate(v);
+  TRACE_ROOT("[internal deferred handles]");
   isolate_->IterateDeferredHandles(v);
   v->Synchronize(VisitorSynchronization::kHandleScope);
 
   // Iterate over the builtin code objects and code stubs in the
   // heap. Note that it is not necessary to iterate over code objects
   // on scavenge collections.
+  TRACE_ROOT("[builtins]");
   if (mode != VISIT_ALL_IN_SCAVENGE) {
     isolate_->builtins()->IterateBuiltins(v);
   }
   v->Synchronize(VisitorSynchronization::kBuiltins);
 
   // Iterate over global handles.
+  TRACE_ROOT("[global handles]");
   switch (mode) {
     case VISIT_ONLY_STRONG:
       isolate_->global_handles()->IterateStrongRoots(v);
       break;
     case VISIT_ALL_IN_SCAVENGE:
       isolate_->global_handles()->IterateNewSpaceStrongAndDependentRoots(v);
       break;
     case VISIT_ALL_IN_SWEEP_NEWSPACE:
     case VISIT_ALL:
       isolate_->global_handles()->IterateAllRoots(v);
       break;
   }
   v->Synchronize(VisitorSynchronization::kGlobalHandles);
 
   // Iterate over eternal handles.
+  TRACE_ROOT("[eternal handles]");
   if (mode == VISIT_ALL_IN_SCAVENGE) {
     isolate_->eternal_handles()->IterateNewSpaceRoots(v);
   } else {
     isolate_->eternal_handles()->IterateAllRoots(v);
   }
   v->Synchronize(VisitorSynchronization::kEternalHandles);
 
+  TRACE_ROOT("[isolate inactive threads]");
   // Iterate over pointers being held by inactive threads.
   isolate_->thread_manager()->Iterate(v);
   v->Synchronize(VisitorSynchronization::kThreadManager);
 
   // Iterate over the pointers the Serialization/Deserialization code is
   // holding.
   // During garbage collection this keeps the partial snapshot cache alive.
   // During deserialization of the startup snapshot this creates the partial
   // snapshot cache and deserializes the objects it refers to.  During
   // serialization this does nothing, since the partial snapshot cache is
   // empty.  However the next thing we do is create the partial snapshot,
   // filling up the partial snapshot cache with objects it needs as we go.
+  TRACE_ROOT("[serializer/deserializer]");
   SerializerDeserializer::Iterate(isolate_, v);
   // We don't do a v->Synchronize call here, because in debug mode that will
   // output a flag to the snapshot.  However at this point the serializer and
   // deserializer are deliberately a little unsynchronized (see above) so the
   // checking of the sync flag in the snapshot would fail.
+  TRACE_ROOT("[]");
 }
 
 
 // TODO(1236194): Since the heap size is configurable on the command line
 // and through the API, we should gracefully handle the case that the heap
 // size is not big enough to fit all the initial objects.
 bool Heap::ConfigureHeap(int max_semi_space_size, int max_old_space_size,
                          int max_executable_size, size_t code_range_size) {
   if (HasBeenSetUp()) return false;
 
@@ skipping 386 matching lines @@
   roots_[kStackLimitRootIndex] = reinterpret_cast<Object*>(
       (isolate_->stack_guard()->jslimit() & ~kSmiTagMask) | kSmiTag);
   roots_[kRealStackLimitRootIndex] = reinterpret_cast<Object*>(
       (isolate_->stack_guard()->real_jslimit() & ~kSmiTagMask) | kSmiTag);
 }
 
 
 void Heap::NotifyDeserializationComplete() { deserialization_complete_ = true; }
 
 
+#ifdef TRACE_RETAINING_PATH
+void Heap::SetCurrentRetainer(HeapObject* obj) { current_retainer_ = obj; }
+
+
+void Heap::SetCurrentRootRetainer(std::string root) {
+  current_root_retainer_ = root;
+}
+
+
+void Heap::PrintRetainingPath(HeapObject* obj, const char* comment) {
+  PrintF("Retaining path for %s [%p]:\n", comment, static_cast<void*>(obj));
+  obj->ShortPrint();
+  PrintF("\n");
+  while (retainer_.count(obj) && retainer_[obj] != NULL) {
+    PrintF("^^^^^^^^\n");
+    obj = retainer_[obj];
+#ifdef OBJECT_PRINT
+    obj->Print();
+#else
+    obj->ShortPrint();
+#endif
+    PrintF("\n");
+  }
+  if (root_retainer_.count(obj)) {
+    PrintF("^^^^^^^^\n");
+    PrintF("%s\n", root_retainer_[obj].c_str());
+  }
+  PrintF("End of retaining path.\n");
+}
+
+
+void Heap::AddRetainedObject(HeapObject* obj) {
+  if (retainer_.count(obj)) return;
+  retainer_[obj] = current_retainer_;
+  if (current_retainer_ == NULL) {
+    root_retainer_[obj] = current_root_retainer_;
+  }
+  const char* filter = FLAG_trace_retaining_path_for;
+  if (obj->IsJSObject() && *filter != 0) {
+    JSObject* jsobj = JSObject::cast(obj);
+    String* name = jsobj->constructor_name();
+    if (!strcmp(filter, name->ToCString().get())) {
+      PrintRetainingPath(obj, filter);
+    }
+  }
+  if (FLAG_track_detached_contexts && obj->IsNativeContext()) {
+    FixedArray* dc = detached_contexts();
+    int length = dc->length();
+    for (int i = 0; i < length; i += 2) {
+      int mark_sweeps = Smi::cast(dc->get(i))->value();
+      if (mark_sweeps > 5 && WeakCell::cast(dc->get(i + 1))->value() == obj) {

[Hannes Payer (out of office), 2015/02/06 13:31:31]

make 5 a constant

+        PrintRetainingPath(obj, "detached context");
+      }
+    }
+  }
+}
+
+
+void Heap::ClearRetainingInfo() {
+  retainer_.clear();
+  root_retainer_.clear();
+  current_retainer_ = NULL;
+  current_root_retainer_ = "";
+}
+#endif
+

[Hannes Payer (out of office), 2015/02/06 13:31:32]

+1 newline

 void Heap::TearDown() {
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) {
     Verify();
   }
 #endif
 
   UpdateMaximumCommitted();
 
   if (FLAG_print_cumulative_gc_stat) {
@@ skipping 951 matching lines @@
       static_cast<int>(object_sizes_last_time_[index]));
   CODE_AGE_LIST_COMPLETE(ADJUST_LAST_TIME_OBJECT_COUNT)
 #undef ADJUST_LAST_TIME_OBJECT_COUNT
 
   MemCopy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
   MemCopy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
   ClearObjectStats();
 }
 }
 }  // namespace v8::internal