Use EmbedderHeapTracer instead of object grouping when trace_embedder_heap flag is set

src/heap/mark-compact.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/heap/mark-compact.h"
 
 #include "src/base/atomicops.h"
 #include "src/base/bits.h"
 #include "src/base/sys-info.h"
 #include "src/code-stubs.h"
@@ skipping 1898 matching lines @@
     Map* map = object->map();
     if (map == filler_map) continue;
 
     DCHECK(object->IsHeapObject());
     DCHECK(heap()->Contains(object));
     DCHECK(!Marking::IsWhite(Marking::MarkBitFrom(object)));
 
     MarkBit map_mark = Marking::MarkBitFrom(map);
     MarkObject(map, map_mark);
 
+    if (UsingEmbedderHeapTracer() && object->IsJSObject()) {

[Hannes Payer (out of office), 2016/04/01 11:13:36]

As discussed offline, move this code to the proper object visitor which gets
called by IterateBody.

[Marcel Hlopko, 2016/04/01 12:47:20]

Gave it a try, my tests still pass, so I hope I found a correct place, but ptal
to be sure.

+      JSObject* js_object = JSObject::cast(object);
+
+      if (js_object->GetInternalFieldCount() >= 2 &&
+          js_object->WasConstructedFromApiFunction() &&
+          js_object->GetInternalField(0) != heap()->undefined_value() &&
+          js_object->GetInternalField(1) != heap()->undefined_value()) {
+        wrappers_to_trace().push_back(std::pair<void*, void*>(

[Hannes Payer (out of office), 2016/04/01 11:13:36]

Could these be Object*?

[Marcel Hlopko, 2016/04/01 12:47:20]

I'm afraid they cannot, from the v8 side they are just smis, just accidentally
pointing to the blink objects (but v8 doesn't know that).

+            reinterpret_cast<void*>(js_object->GetInternalField(0)),
+            reinterpret_cast<void*>(js_object->GetInternalField(1))));
+      }
+    }
+
     MarkCompactMarkingVisitor::IterateBody(map, object);
   }
 }
 
 
 // Sweep the heap for overflowed objects, clear their overflow bits, and
 // push them on the marking stack.  Stop early if the marking stack fills
 // before sweeping completes.  If sweeping completes, there are no remaining
 // overflowed objects in the heap so the overflow flag on the markings stack
 // is cleared.
@@ skipping 26 matching lines @@
 // pointers.  After: the marking stack is empty and there are no overflowed
 // objects in the heap.
 void MarkCompactCollector::ProcessMarkingDeque() {
   EmptyMarkingDeque();
   while (marking_deque_.overflowed()) {
     RefillMarkingDeque();
     EmptyMarkingDeque();
   }
 }
 
+bool MarkCompactCollector::UsingEmbedderHeapTracer() const {
+  return FLAG_trace_embedder_heap && heap_->embedder_heap_tracer();
+}
 
 // Mark all objects reachable (transitively) from objects on the marking
 // stack including references only considered in the atomic marking pause.
 void MarkCompactCollector::ProcessEphemeralMarking(
     ObjectVisitor* visitor, bool only_process_harmony_weak_collections) {
   bool work_to_do = true;
   DCHECK(marking_deque_.IsEmpty() && !marking_deque_.overflowed());
+  v8::Isolate* api_isolate = reinterpret_cast<v8::Isolate*>(isolate());

[Hannes Payer (out of office), 2016/04/01 11:13:36]

This method now looks really complicated. Can we decouple these two modes?

[Marcel Hlopko, 2016/04/01 12:47:20]

I was not happy with the split into 2 methods, so I splitted it into 3... Wdyt?

+  if (!only_process_harmony_weak_collections && UsingEmbedderHeapTracer()) {
+    heap()->embedder_heap_tracer()->TraceRoots(api_isolate);
+  }
   while (work_to_do) {
     if (!only_process_harmony_weak_collections) {
-      isolate()->global_handles()->IterateObjectGroups(
-          visitor, &IsUnmarkedHeapObjectWithHeap);
-      MarkImplicitRefGroups(&MarkCompactMarkingVisitor::MarkObject);
+      if (UsingEmbedderHeapTracer()) {
+        heap_->embedder_heap_tracer()->TraceWrappableFrom(api_isolate,
+                                                          wrappers_to_trace_);
+        wrappers_to_trace_.clear();
+      } else {
+        isolate()->global_handles()->IterateObjectGroups(
+            visitor, &IsUnmarkedHeapObjectWithHeap);
+        MarkImplicitRefGroups(&MarkCompactMarkingVisitor::MarkObject);
+      }
     }
     ProcessWeakCollections();
     work_to_do = !marking_deque_.IsEmpty();
     ProcessMarkingDeque();
   }
+  if (!only_process_harmony_weak_collections && UsingEmbedderHeapTracer()) {
+    heap()->embedder_heap_tracer()->ClearTracingMarks(api_isolate);
+  }
 }
 
 
 void MarkCompactCollector::ProcessTopOptimizedFrame(ObjectVisitor* visitor) {
   for (StackFrameIterator it(isolate(), isolate()->thread_local_top());
        !it.done(); it.Advance()) {
     if (it.frame()->type() == StackFrame::JAVA_SCRIPT) {
       return;
     }
     if (it.frame()->type() == StackFrame::OPTIMIZED) {
@@ skipping 1831 matching lines @@
     MarkBit mark_bit = Marking::MarkBitFrom(host);
     if (Marking::IsBlack(mark_bit)) {
       RelocInfo rinfo(isolate(), pc, RelocInfo::CODE_TARGET, 0, host);
       RecordRelocSlot(host, &rinfo, target);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8