Revert "Reland "[heap] Improve embedder tracing during incremental marking""

This reverts commit 81b5f713.

Revert "[heap] Cleanup embedder tracing APIs"

This reverts commit ce02d86b.

Tbr: mlippautz@chromium.org
Change-Id: I5900ac3c070c93b869c9173316a466d39287713a
Reviewed-on: https://chromium-review.googlesource.com/c/1350111Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Commit-Queue: Jakob Kummerow <jkummerow@chromium.org>
Cr-Commit-Position: refs/heads/master@{#57806}

src/heap/embedder-tracing.cc

@@ -5,31 +5,22 @@
 #include "src/heap/embedder-tracing.h"
 
 #include "src/base/logging.h"
-#include "src/objects/embedder-data-slot.h"
-#include "src/objects/js-objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
-void LocalEmbedderHeapTracer::SetRemoteTracer(EmbedderHeapTracer* tracer) {
-  if (remote_tracer_) remote_tracer_->isolate_ = nullptr;
-
-  remote_tracer_ = tracer;
-  if (remote_tracer_)
-    remote_tracer_->isolate_ = reinterpret_cast<v8::Isolate*>(isolate_);
-}
-
 void LocalEmbedderHeapTracer::TracePrologue() {
   if (!InUse()) return;
 
+  CHECK(cached_wrappers_to_trace_.empty());
   num_v8_marking_worklist_was_empty_ = 0;
-  embedder_worklist_empty_ = false;
   remote_tracer_->TracePrologue();
 }
 
 void LocalEmbedderHeapTracer::TraceEpilogue() {
   if (!InUse()) return;
 
+  CHECK(cached_wrappers_to_trace_.empty());
   remote_tracer_->TraceEpilogue();
 }
 
@@ -45,59 +36,37 @@ void LocalEmbedderHeapTracer::EnterFinalPause() {
 bool LocalEmbedderHeapTracer::Trace(double deadline) {
   if (!InUse()) return true;
 
+  DCHECK_EQ(0, NumberOfCachedWrappersToTrace());
   return remote_tracer_->AdvanceTracing(deadline);
 }
 
 bool LocalEmbedderHeapTracer::IsRemoteTracingDone() {
-  return !InUse() || remote_tracer_->IsTracingDone();
+  return (InUse()) ? cached_wrappers_to_trace_.empty() &&
+                         remote_tracer_->IsTracingDone()
+                   : true;
 }
 
-void LocalEmbedderHeapTracer::SetEmbedderStackStateForNextFinalization(
-    EmbedderHeapTracer::EmbedderStackState stack_state) {
+void LocalEmbedderHeapTracer::RegisterWrappersWithRemoteTracer() {
   if (!InUse()) return;
 
-  embedder_stack_state_ = stack_state;
-}
-
-LocalEmbedderHeapTracer::ProcessingScope::ProcessingScope(
-    LocalEmbedderHeapTracer* tracer)
-    : tracer_(tracer) {
-  wrapper_cache_.reserve(kWrapperCacheSize);
-}
-
-LocalEmbedderHeapTracer::ProcessingScope::~ProcessingScope() {
-  if (!wrapper_cache_.empty()) {
-    tracer_->remote_tracer()->RegisterV8References(std::move(wrapper_cache_));
+  if (cached_wrappers_to_trace_.empty()) {
+    return;
   }
-  tracer_->embedder_worklist_empty_ = empty_worklist_;
-}
-
-void LocalEmbedderHeapTracer::ProcessingScope::TracePossibleWrapper(
-    JSObject* js_object) {
-  DCHECK(js_object->IsApiWrapper());
-  if (js_object->GetEmbedderFieldCount() < 2) return;
 
-  void* pointer0;
-  void* pointer1;
-  if (EmbedderDataSlot(js_object, 0).ToAlignedPointer(&pointer0) && pointer0 &&
-      EmbedderDataSlot(js_object, 1).ToAlignedPointer(&pointer1)) {
-    wrapper_cache_.push_back({pointer0, pointer1});
-  }
-  FlushWrapperCacheIfFull();
+  remote_tracer_->RegisterV8References(cached_wrappers_to_trace_);
+  cached_wrappers_to_trace_.clear();
 }
 
-void LocalEmbedderHeapTracer::ProcessingScope::FlushWrapperCacheIfFull() {
-  if (wrapper_cache_.size() == wrapper_cache_.capacity()) {
-    tracer_->remote_tracer()->RegisterV8References(std::move(wrapper_cache_));
-    wrapper_cache_.clear();
-    wrapper_cache_.reserve(kWrapperCacheSize);
-  }
+bool LocalEmbedderHeapTracer::RequiresImmediateWrapperProcessing() {
+  const size_t kTooManyWrappers = 16000;
+  return cached_wrappers_to_trace_.size() > kTooManyWrappers;
 }
 
-void LocalEmbedderHeapTracer::ProcessingScope::AddWrapperInfoForTesting(
-    WrapperInfo info) {
-  wrapper_cache_.push_back(info);
-  FlushWrapperCacheIfFull();
+void LocalEmbedderHeapTracer::SetEmbedderStackStateForNextFinalization(
+    EmbedderHeapTracer::EmbedderStackState stack_state) {
+  if (!InUse()) return;
+
+  embedder_stack_state_ = stack_state;
 }
 
 }  // namespace internal

src/heap/embedder-tracing.h

@@ -13,32 +13,10 @@ namespace v8 {
 namespace internal {
 
 class Heap;
-class JSObject;
 
 class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final {
  public:
   typedef std::pair<void*, void*> WrapperInfo;
-  typedef std::vector<WrapperInfo> WrapperCache;
-
-  class V8_EXPORT_PRIVATE ProcessingScope {
-   public:
-    explicit ProcessingScope(LocalEmbedderHeapTracer* tracer);
-    ~ProcessingScope();
-
-    void TracePossibleWrapper(JSObject* js_object);
-    void set_not_done() { empty_worklist_ = false; }
-
-    void AddWrapperInfoForTesting(WrapperInfo info);
-
-   private:
-    static constexpr size_t kWrapperCacheSize = 1000;
-
-    void FlushWrapperCacheIfFull();
-
-    LocalEmbedderHeapTracer* const tracer_;
-    WrapperCache wrapper_cache_;
-    bool empty_worklist_ = true;
-  };
 
   explicit LocalEmbedderHeapTracer(Isolate* isolate) : isolate_(isolate) {}
 
@@ -46,24 +24,44 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final {
     if (remote_tracer_) remote_tracer_->isolate_ = nullptr;
   }
 
-  bool InUse() const { return remote_tracer_ != nullptr; }
   EmbedderHeapTracer* remote_tracer() const { return remote_tracer_; }
 
-  void SetRemoteTracer(EmbedderHeapTracer* tracer);
+  void SetRemoteTracer(EmbedderHeapTracer* tracer) {
+    if (remote_tracer_) remote_tracer_->isolate_ = nullptr;
+
+    remote_tracer_ = tracer;
+    if (remote_tracer_)
+      remote_tracer_->isolate_ = reinterpret_cast<v8::Isolate*>(isolate_);
+  }
+
+  bool InUse() const { return remote_tracer_ != nullptr; }
+
   void TracePrologue();
   void TraceEpilogue();
   void EnterFinalPause();
   bool Trace(double deadline);
   bool IsRemoteTracingDone();
 
+  size_t NumberOfCachedWrappersToTrace() {
+    return cached_wrappers_to_trace_.size();
+  }
+  void AddWrapperToTrace(WrapperInfo entry) {
+    cached_wrappers_to_trace_.push_back(entry);
+  }
+  void ClearCachedWrappersToTrace() { cached_wrappers_to_trace_.clear(); }
+  void RegisterWrappersWithRemoteTracer();
+
+  // In order to avoid running out of memory we force tracing wrappers if there
+  // are too many of them.
+  bool RequiresImmediateWrapperProcessing();
+
   void NotifyV8MarkingWorklistWasEmpty() {
     num_v8_marking_worklist_was_empty_++;
   }
-
   bool ShouldFinalizeIncrementalMarking() {
     static const size_t kMaxIncrementalFixpointRounds = 3;
     return !FLAG_incremental_marking_wrappers || !InUse() ||
-           (IsRemoteTracingDone() && embedder_worklist_empty_) ||
+           IsRemoteTracingDone() ||
            num_v8_marking_worklist_was_empty_ > kMaxIncrementalFixpointRounds;
   }
 
@@ -71,16 +69,14 @@ class V8_EXPORT_PRIVATE LocalEmbedderHeapTracer final {
       EmbedderHeapTracer::EmbedderStackState stack_state);
 
  private:
+  typedef std::vector<WrapperInfo> WrapperCache;
+
   Isolate* const isolate_;
+  WrapperCache cached_wrappers_to_trace_;
   EmbedderHeapTracer* remote_tracer_ = nullptr;
-
   size_t num_v8_marking_worklist_was_empty_ = 0;
   EmbedderHeapTracer::EmbedderStackState embedder_stack_state_ =
       EmbedderHeapTracer::kUnknown;
-  // Indicates whether the embedder worklist was observed empty on the main
-  // thread. This is opportunistic as concurrent marking tasks may hold local
-  // segments of potential embedder fields to move to the main thread.
-  bool embedder_worklist_empty_ = false;
 
   friend class EmbedderStackStateScope;
 };

src/heap/heap.cc

@@ -2965,6 +2965,9 @@ void Heap::RegisterDeserializedObjectsForBlackAllocation(
       }
     }
   }
+  // We potentially deserialized wrappers which require registering with the
+  // embedder as the marker will not find them.
+  local_embedder_heap_tracer()->RegisterWrappersWithRemoteTracer();
 
   // Large object space doesn't use reservations, so it needs custom handling.
   for (HeapObject* object : large_objects) {
@@ -4544,6 +4547,18 @@ EmbedderHeapTracer* Heap::GetEmbedderHeapTracer() const {
   return local_embedder_heap_tracer()->remote_tracer();
 }
 
+void Heap::TracePossibleWrapper(JSObject* js_object) {
+  DCHECK(js_object->IsApiWrapper());
+  if (js_object->GetEmbedderFieldCount() < 2) return;
+  void* pointer0;
+  void* pointer1;
+  if (EmbedderDataSlot(js_object, 0).ToAlignedPointer(&pointer0) && pointer0 &&
+      EmbedderDataSlot(js_object, 1).ToAlignedPointer(&pointer1)) {
+    local_embedder_heap_tracer()->AddWrapperToTrace(
+        std::pair<void*, void*>(pointer0, pointer1));
+  }
+}
+
 void Heap::RegisterExternallyReferencedObject(Address* location) {
   // The embedder is not aware of whether numbers are materialized as heap
   // objects are just passed around as Smis.

src/heap/heap.h

@@ -893,6 +893,7 @@ class Heap {
   void SetEmbedderHeapTracer(EmbedderHeapTracer* tracer);
   EmbedderHeapTracer* GetEmbedderHeapTracer() const;
 
+  void TracePossibleWrapper(JSObject* js_object);
   void RegisterExternallyReferencedObject(Address* location);
   void SetEmbedderStackStateForNextFinalizaton(
       EmbedderHeapTracer::EmbedderStackState stack_state);

src/heap/incremental-marking.cc

@@ -8,7 +8,6 @@
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/heap/concurrent-marking.h"
-#include "src/heap/embedder-tracing.h"
 #include "src/heap/gc-idle-time-handler.h"
 #include "src/heap/gc-tracer.h"
 #include "src/heap/heap-inl.h"
@@ -816,31 +815,39 @@ intptr_t IncrementalMarking::ProcessMarkingWorklist(
     int size = VisitObject(obj->map(), obj);
     bytes_processed += size - unscanned_bytes_of_large_object_;
   }
+  // Report all found wrappers to the embedder. This is necessary as the
+  // embedder could potentially invalidate wrappers as soon as V8 is done
+  // with its incremental marking processing. Any cached wrappers could
+  // result in broken pointers at this point.
+  heap_->local_embedder_heap_tracer()->RegisterWrappersWithRemoteTracer();
   return bytes_processed;
 }
 
 void IncrementalMarking::EmbedderStep(double duration_ms) {
-  constexpr size_t kObjectsToProcessBeforeInterrupt = 500;
+  constexpr int kObjectsToProcessBeforeInterrupt = 100;
 
   TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_INCREMENTAL_EMBEDDER_TRACING);
-  double deadline = heap_->MonotonicallyIncreasingTimeInMs() + duration_ms;
-  do {
-    {
-      LocalEmbedderHeapTracer::ProcessingScope scope(
-          heap_->local_embedder_heap_tracer());
-      HeapObject* object;
-      size_t cnt = 0;
-      while (marking_worklist()->embedder()->Pop(0, &object)) {
-        scope.TracePossibleWrapper(JSObject::cast(object));
-        if (++cnt == kObjectsToProcessBeforeInterrupt) {
-          cnt = 0;
-          scope.set_not_done();
-          break;
-        }
+
+  const double deadline =
+      heap_->MonotonicallyIncreasingTimeInMs() + duration_ms;
+
+  HeapObject* object;
+  int cnt = 0;
+  while (marking_worklist()->embedder()->Pop(0, &object)) {
+    heap_->TracePossibleWrapper(JSObject::cast(object));
+    if (++cnt == kObjectsToProcessBeforeInterrupt) {
+      cnt = 0;
+      if (heap_->MonotonicallyIncreasingTimeInMs() > deadline) {
+        break;
       }
     }
+  }
+
+  heap_->local_embedder_heap_tracer()->RegisterWrappersWithRemoteTracer();
+  if (!heap_->local_embedder_heap_tracer()
+           ->ShouldFinalizeIncrementalMarking()) {
     heap_->local_embedder_heap_tracer()->Trace(deadline);
-  } while (heap_->MonotonicallyIncreasingTimeInMs() < deadline);
+  }
 }
 
 void IncrementalMarking::Hurry() {
@@ -950,11 +957,6 @@ void IncrementalMarking::Epilogue() {
   finalize_marking_completed_ = false;
 }
 
-bool IncrementalMarking::ShouldDoEmbedderStep() {
-  return state_ == MARKING && FLAG_incremental_marking_wrappers &&
-         heap_->local_embedder_heap_tracer()->InUse();
-}
-
 double IncrementalMarking::AdvanceIncrementalMarking(
     double deadline_in_ms, CompletionAction completion_action,
     StepOrigin step_origin) {
@@ -963,22 +965,27 @@ double IncrementalMarking::AdvanceIncrementalMarking(
   TRACE_EVENT0("v8", "V8.GCIncrementalMarking");
   TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL);
   DCHECK(!IsStopped());
+  DCHECK_EQ(
+      0, heap_->local_embedder_heap_tracer()->NumberOfCachedWrappersToTrace());
 
   double remaining_time_in_ms = 0.0;
+  intptr_t step_size_in_bytes = GCIdleTimeHandler::EstimateMarkingStepSize(
+      kStepSizeInMs,
+      heap()->tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
+
+  const bool incremental_wrapper_tracing =
+      state_ == MARKING && FLAG_incremental_marking_wrappers &&
+      heap_->local_embedder_heap_tracer()->InUse();
   do {
-    if (ShouldDoEmbedderStep() && trace_wrappers_toggle_) {
+    if (incremental_wrapper_tracing && trace_wrappers_toggle_) {
       EmbedderStep(kStepSizeInMs);
     } else {
-      const intptr_t step_size_in_bytes =
-          GCIdleTimeHandler::EstimateMarkingStepSize(
-              kStepSizeInMs,
-              heap()->tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
       Step(step_size_in_bytes, completion_action, step_origin);
     }
     trace_wrappers_toggle_ = !trace_wrappers_toggle_;
     remaining_time_in_ms =
         deadline_in_ms - heap()->MonotonicallyIncreasingTimeInMs();
-  } while (remaining_time_in_ms > kStepSizeInMs && !IsComplete() &&
+  } while (remaining_time_in_ms >= kStepSizeInMs && !IsComplete() &&
            !marking_worklist()->IsEmpty());
   return remaining_time_in_ms;
 }
@@ -1030,54 +1037,49 @@ void IncrementalMarking::AdvanceIncrementalMarkingOnAllocation() {
     return;
   }
 
-  HistogramTimerScope incremental_marking_scope(
-      heap_->isolate()->counters()->gc_incremental_marking());
-  TRACE_EVENT0("v8", "V8.GCIncrementalMarking");
-  TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL);
-
-  if (ShouldDoEmbedderStep() && trace_wrappers_toggle_) {
-    EmbedderStep(kMaxStepSizeInMs);
-  } else {
-    size_t bytes_to_process =
-        StepSizeToKeepUpWithAllocations() + StepSizeToMakeProgress();
-    if (bytes_to_process >= IncrementalMarking::kMinStepSizeInBytes) {
-      // The first step after Scavenge will see many allocated bytes.
-      // Cap the step size to distribute the marking work more uniformly.
-      size_t max_step_size = GCIdleTimeHandler::EstimateMarkingStepSize(
-          kMaxStepSizeInMs,
-          heap()->tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
-      bytes_to_process = Min(bytes_to_process, max_step_size);
-      size_t bytes_processed = 0;
-      if (FLAG_concurrent_marking) {
-        bytes_processed = Step(bytes_to_process, GC_VIA_STACK_GUARD,
-                               StepOrigin::kV8, WorklistToProcess::kBailout);
-        bytes_to_process = (bytes_processed >= bytes_to_process)
-                               ? 0
-                               : bytes_to_process - bytes_processed;
-        size_t current_bytes_marked_concurrently =
-            heap()->concurrent_marking()->TotalMarkedBytes();
-        // The concurrent_marking()->TotalMarkedBytes() is not monothonic for a
-        // short period of time when a concurrent marking task is finishing.
-        if (current_bytes_marked_concurrently > bytes_marked_concurrently_) {
-          bytes_marked_ahead_of_schedule_ +=
-              current_bytes_marked_concurrently - bytes_marked_concurrently_;
-          bytes_marked_concurrently_ = current_bytes_marked_concurrently;
-        }
-      }
-      if (bytes_marked_ahead_of_schedule_ >= bytes_to_process) {
-        // Steps performed in tasks and concurrently have put us ahead of
-        // schedule. We skip processing of marking dequeue here and thus shift
-        // marking time from inside V8 to standalone tasks.
-        bytes_marked_ahead_of_schedule_ -= bytes_to_process;
-        bytes_processed += bytes_to_process;
-        bytes_to_process = IncrementalMarking::kMinStepSizeInBytes;
+  size_t bytes_to_process =
+      StepSizeToKeepUpWithAllocations() + StepSizeToMakeProgress();
+
+  if (bytes_to_process >= IncrementalMarking::kMinStepSizeInBytes) {
+    HistogramTimerScope incremental_marking_scope(
+        heap_->isolate()->counters()->gc_incremental_marking());
+    TRACE_EVENT0("v8", "V8.GCIncrementalMarking");
+    TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL);
+    // The first step after Scavenge will see many allocated bytes.
+    // Cap the step size to distribute the marking work more uniformly.
+    size_t max_step_size = GCIdleTimeHandler::EstimateMarkingStepSize(
+        kMaxStepSizeInMs,
+        heap()->tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
+    bytes_to_process = Min(bytes_to_process, max_step_size);
+    size_t bytes_processed = 0;
+    if (FLAG_concurrent_marking) {
+      bytes_processed = Step(bytes_to_process, GC_VIA_STACK_GUARD,
+                             StepOrigin::kV8, WorklistToProcess::kBailout);
+      bytes_to_process = (bytes_processed >= bytes_to_process)
+                             ? 0
+                             : bytes_to_process - bytes_processed;
+      size_t current_bytes_marked_concurrently =
+          heap()->concurrent_marking()->TotalMarkedBytes();
+      // The concurrent_marking()->TotalMarkedBytes() is not monothonic for a
+      // short period of time when a concurrent marking task is finishing.
+      if (current_bytes_marked_concurrently > bytes_marked_concurrently_) {
+        bytes_marked_ahead_of_schedule_ +=
+            current_bytes_marked_concurrently - bytes_marked_concurrently_;
+        bytes_marked_concurrently_ = current_bytes_marked_concurrently;
       }
-      bytes_processed += Step(bytes_to_process, GC_VIA_STACK_GUARD,
-                              StepOrigin::kV8, WorklistToProcess::kAll);
-      bytes_allocated_ -= Min(bytes_allocated_, bytes_processed);
     }
+    if (bytes_marked_ahead_of_schedule_ >= bytes_to_process) {
+      // Steps performed in tasks and concurrently have put us ahead of
+      // schedule. We skip processing of marking dequeue here and thus shift
+      // marking time from inside V8 to standalone tasks.
+      bytes_marked_ahead_of_schedule_ -= bytes_to_process;
+      bytes_processed += bytes_to_process;
+      bytes_to_process = IncrementalMarking::kMinStepSizeInBytes;
+    }
+    bytes_processed += Step(bytes_to_process, GC_VIA_STACK_GUARD,
+                            StepOrigin::kV8, WorklistToProcess::kAll);
+    bytes_allocated_ -= Min(bytes_allocated_, bytes_processed);
   }
-  trace_wrappers_toggle_ = !trace_wrappers_toggle_;
 }
 
 size_t IncrementalMarking::Step(size_t bytes_to_process,

src/heap/incremental-marking.h

@@ -177,8 +177,6 @@ class V8_EXPORT_PRIVATE IncrementalMarking {
   size_t Step(size_t bytes_to_process, CompletionAction action,
               StepOrigin step_origin,
               WorklistToProcess worklist_to_process = WorklistToProcess::kAll);
-
-  bool ShouldDoEmbedderStep();
   void EmbedderStep(double duration);
 
   inline void RestartIfNotMarking();

src/heap/mark-compact-inl.h

@@ -74,8 +74,7 @@ V8_INLINE int
 MarkingVisitor<fixed_array_mode, retaining_path_mode,
                MarkingState>::VisitEmbedderTracingSubclass(Map map, T* object) {
   if (heap_->local_embedder_heap_tracer()->InUse()) {
-    marking_worklist()->embedder()->Push(MarkCompactCollectorBase::kMainThread,
-                                         object);
+    heap_->TracePossibleWrapper(object);
   }
   int size = T::BodyDescriptor::SizeOf(map, object);
   T::BodyDescriptor::IterateBody(map, object, size, this);

src/heap/mark-compact.cc

@@ -1487,7 +1487,6 @@ void MarkCompactCollector::ProcessEphemeronsUntilFixpoint() {
 
     work_to_do = work_to_do || !marking_worklist()->IsEmpty() ||
                  heap()->concurrent_marking()->ephemeron_marked() ||
-                 !marking_worklist()->IsEmbedderEmpty() ||
                  !heap()->local_embedder_heap_tracer()->IsRemoteTracingDone();
     ++iterations;
   }
@@ -1615,14 +1614,11 @@ void MarkCompactCollector::ProcessEphemeronsLinear() {
 void MarkCompactCollector::PerformWrapperTracing() {
   if (heap_->local_embedder_heap_tracer()->InUse()) {
     TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_MARK_EMBEDDER_TRACING);
-    {
-      LocalEmbedderHeapTracer::ProcessingScope scope(
-          heap_->local_embedder_heap_tracer());
-      HeapObject* object;
-      while (marking_worklist()->embedder()->Pop(kMainThread, &object)) {
-        scope.TracePossibleWrapper(JSObject::cast(object));
-      }
+    HeapObject* object;
+    while (marking_worklist()->embedder()->Pop(kMainThread, &object)) {
+      heap_->TracePossibleWrapper(JSObject::cast(object));
     }
+    heap_->local_embedder_heap_tracer()->RegisterWrappersWithRemoteTracer();
     heap_->local_embedder_heap_tracer()->Trace(
         std::numeric_limits<double>::infinity());
   }
@@ -1783,8 +1779,7 @@ void MarkCompactCollector::MarkLiveObjects() {
         // once.
         PerformWrapperTracing();
         ProcessMarkingWorklist();
-      } while (!heap_->local_embedder_heap_tracer()->IsRemoteTracingDone() ||
-               !marking_worklist()->IsEmbedderEmpty());
+      } while (!heap_->local_embedder_heap_tracer()->IsRemoteTracingDone());
       DCHECK(marking_worklist()->IsEmbedderEmpty());
       DCHECK(marking_worklist()->IsEmpty());
     }

src/heap/mark-compact.h

@@ -235,8 +235,6 @@ enum class RememberedSetUpdatingMode { ALL, OLD_TO_NEW_ONLY };
 // Base class for minor and full MC collectors.
 class MarkCompactCollectorBase {
  public:
-  static const int kMainThread = 0;
-
   virtual ~MarkCompactCollectorBase() = default;
 
   virtual void SetUp() = 0;
@@ -247,6 +245,7 @@ class MarkCompactCollectorBase {
   inline Isolate* isolate();
 
  protected:
+  static const int kMainThread = 0;
   explicit MarkCompactCollectorBase(Heap* heap)
       : heap_(heap), old_to_new_slots_(0) {}
 

src/heap/scavenger.cc

@@ -279,6 +279,10 @@ void ScavengerCollector::CollectGarbage() {
 
   // Update how much has survived scavenge.
   heap_->IncrementYoungSurvivorsCounter(heap_->SurvivedNewSpaceObjectSize());
+
+  // Scavenger may find new wrappers by iterating objects promoted onto a black
+  // page.
+  heap_->local_embedder_heap_tracer()->RegisterWrappersWithRemoteTracer();
 }
 
 void ScavengerCollector::HandleSurvivingNewLargeObjects() {

test/unittests/heap/embedder-tracing-unittest.cc

@@ -83,14 +83,6 @@ TEST(LocalEmbedderHeapTracer, EnterFinalPauseForwards) {
   local_tracer.EnterFinalPause();
 }
 
-TEST(LocalEmbedderHeapTracer, IsRemoteTracingDoneForwards) {
-  StrictMock<MockEmbedderHeapTracer> remote_tracer;
-  LocalEmbedderHeapTracer local_tracer(nullptr);
-  local_tracer.SetRemoteTracer(&remote_tracer);
-  EXPECT_CALL(remote_tracer, IsTracingDone());
-  local_tracer.IsRemoteTracingDone();
-}
-
 TEST(LocalEmbedderHeapTracer, EnterFinalPauseDefaultStackStateUnkown) {
   StrictMock<MockEmbedderHeapTracer> remote_tracer;
   LocalEmbedderHeapTracer local_tracer(nullptr);
@@ -160,19 +152,52 @@ TEST(LocalEmbedderHeapTracer, IsRemoteTracingDoneIncludesRemote) {
   local_tracer.IsRemoteTracingDone();
 }
 
-TEST(LocalEmbedderHeapTracer, RegisterV8ReferencesWithRemoteTracer) {
+TEST(LocalEmbedderHeapTracer, NumberOfCachedWrappersToTraceExcludesRemote) {
+  LocalEmbedderHeapTracer local_tracer(nullptr);
+  StrictMock<MockEmbedderHeapTracer> remote_tracer;
+  local_tracer.SetRemoteTracer(&remote_tracer);
+  local_tracer.NumberOfCachedWrappersToTrace();
+}
+
+TEST(LocalEmbedderHeapTracer, RegisterWrappersWithRemoteTracer) {
   StrictMock<MockEmbedderHeapTracer> remote_tracer;
   LocalEmbedderHeapTracer local_tracer(nullptr);
   local_tracer.SetRemoteTracer(&remote_tracer);
-  {
-    LocalEmbedderHeapTracer::ProcessingScope scope(&local_tracer);
-    scope.AddWrapperInfoForTesting(CreateWrapperInfo());
-    EXPECT_CALL(remote_tracer, RegisterV8References(_));
-  }
+  local_tracer.AddWrapperToTrace(CreateWrapperInfo());
+  EXPECT_EQ(1u, local_tracer.NumberOfCachedWrappersToTrace());
+  EXPECT_CALL(remote_tracer, RegisterV8References(_));
+  local_tracer.RegisterWrappersWithRemoteTracer();
+  EXPECT_EQ(0u, local_tracer.NumberOfCachedWrappersToTrace());
   EXPECT_CALL(remote_tracer, IsTracingDone()).WillOnce(Return(false));
   EXPECT_FALSE(local_tracer.IsRemoteTracingDone());
 }
 
+TEST(LocalEmbedderHeapTracer, TraceFinishes) {
+  StrictMock<MockEmbedderHeapTracer> remote_tracer;
+  LocalEmbedderHeapTracer local_tracer(nullptr);
+  local_tracer.SetRemoteTracer(&remote_tracer);
+  local_tracer.AddWrapperToTrace(CreateWrapperInfo());
+  EXPECT_EQ(1u, local_tracer.NumberOfCachedWrappersToTrace());
+  EXPECT_CALL(remote_tracer, RegisterV8References(_));
+  local_tracer.RegisterWrappersWithRemoteTracer();
+  EXPECT_CALL(remote_tracer, AdvanceTracing(_)).WillOnce(Return(true));
+  EXPECT_TRUE(local_tracer.Trace(std::numeric_limits<double>::infinity()));
+  EXPECT_EQ(0u, local_tracer.NumberOfCachedWrappersToTrace());
+}
+
+TEST(LocalEmbedderHeapTracer, TraceDoesNotFinish) {
+  StrictMock<MockEmbedderHeapTracer> remote_tracer;
+  LocalEmbedderHeapTracer local_tracer(nullptr);
+  local_tracer.SetRemoteTracer(&remote_tracer);
+  local_tracer.AddWrapperToTrace(CreateWrapperInfo());
+  EXPECT_EQ(1u, local_tracer.NumberOfCachedWrappersToTrace());
+  EXPECT_CALL(remote_tracer, RegisterV8References(_));
+  local_tracer.RegisterWrappersWithRemoteTracer();
+  EXPECT_CALL(remote_tracer, AdvanceTracing(_)).WillOnce(Return(false));
+  EXPECT_FALSE(local_tracer.Trace(1.0));
+  EXPECT_EQ(0u, local_tracer.NumberOfCachedWrappersToTrace());
+}
+
 TEST_F(LocalEmbedderHeapTracerWithIsolate, SetRemoteTracerSetsIsolate) {
   StrictMock<MockEmbedderHeapTracer> remote_tracer;
   LocalEmbedderHeapTracer local_tracer(isolate());