[heap] Integrate embedder heap tracer into incremental marking

src/heap/incremental-marking.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/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
 #include "src/conversions.h"
 #include "src/heap/gc-idle-time-handler.h"
@@ skipping 724 matching lines @@
     } else {
       new_age = FLAG_retain_maps_for_n_gc;
     }
     // Compact the array and update the age.
     if (new_age != age) {
       retained_maps->Set(i + 1, Smi::FromInt(new_age));
     }
   }
 }
 
-
 void IncrementalMarking::FinalizeIncrementally() {
   TRACE_GC(heap()->tracer(), GCTracer::Scope::MC_INCREMENTAL_FINALIZE_BODY);
   DCHECK(!finalize_marking_completed_);
   DCHECK(IsMarking());
 
   double start = heap_->MonotonicallyIncreasingTimeInMs();
 
   int old_marking_deque_top =
       heap_->mark_compact_collector()->marking_deque()->top();
 
@@ skipping 12 matching lines @@
     // Map retaining is needed for perfromance, not correctness,
     // so we can do it only once at the beginning of the finalization.
     RetainMaps();
   }
   ProcessWeakCells();
 
   int marking_progress =
       abs(old_marking_deque_top -
           heap_->mark_compact_collector()->marking_deque()->top());
 
+  marking_progress +=
+      static_cast<int>(heap_->mark_compact_collector()->wrappers_to_trace());
+
   double end = heap_->MonotonicallyIncreasingTimeInMs();
   double delta = end - start;
   heap_->tracer()->AddMarkingTime(delta);
   if (FLAG_trace_incremental_marking) {
     PrintF(
         "[IncrementalMarking] Finalize incrementally round %d, "
         "spent %d ms, marking progress %d.\n",
         static_cast<int>(delta), incremental_marking_finalization_rounds_,
         marking_progress);
   }
@@ skipping 253 matching lines @@
           ->FinalIncrementalMarkCompactSpeedInBytesPerMillisecond());
   double remaining_time_in_ms = 0.0;
   intptr_t bytes_processed = 0;
 
   do {
     bytes_processed =
         Step(step_size_in_bytes, step_actions.completion_action,
              step_actions.force_marking, step_actions.force_completion);
     remaining_time_in_ms =
         deadline_in_ms - heap()->MonotonicallyIncreasingTimeInMs();
-  } while (bytes_processed > 0 &&
+  } while (!heap_->mark_compact_collector()->marking_deque()->IsEmpty() &&
            remaining_time_in_ms >=
                2.0 * GCIdleTimeHandler::kIncrementalMarkingStepTimeInMs &&
            !IsComplete() &&
            !heap()->mark_compact_collector()->marking_deque()->IsEmpty());
   return remaining_time_in_ms;
 }
 
 
 void IncrementalMarking::OldSpaceStep(intptr_t allocated) {
   if (IsStopped() && ShouldActivateEvenWithoutIdleNotification()) {
@@ skipping 137 matching lines @@
     write_barriers_invoked_since_last_step_ = 0;
 
     bytes_scanned_ += bytes_to_process;
 
     // TODO(hpayer): Do not account for sweeping finalization while marking.
     if (state_ == SWEEPING) {
       FinalizeSweeping();
     }
 
     if (state_ == MARKING) {
-      bytes_processed = ProcessMarkingDeque(bytes_to_process);
-      if (FLAG_incremental_marking_wrappers &&
-          heap_->UsingEmbedderHeapTracer()) {
+      const bool incremental_wrapper_tracing =
+          FLAG_incremental_marking_wrappers && heap_->UsingEmbedderHeapTracer();
+      const bool process_wrappers =
+          incremental_wrapper_tracing &&
+          (heap_->mark_compact_collector()
+               ->RequiresImmediateWrapperProcessing() ||
+           heap_->mark_compact_collector()->marking_deque()->IsEmpty());
+      bool wrapper_work_left = incremental_wrapper_tracing;
+      if (!process_wrappers) {
+        bytes_processed = ProcessMarkingDeque(bytes_to_process);
+      } else {
+        const double kWrapperTracngStepMs = 1.0;
+        const double wrapper_deadline =
+            heap_->MonotonicallyIncreasingTimeInMs() + kWrapperTracngStepMs;
         TRACE_GC(heap()->tracer(),
                  GCTracer::Scope::MC_INCREMENTAL_WRAPPER_TRACING);
-        // This currently marks through all registered wrappers and does not
-        // respect bytes_to_process.
-        // TODO(hpayer): Integrate incremental marking of wrappers into
-        // bytes_to_process logic.
         heap_->mark_compact_collector()
             ->RegisterWrappersWithEmbedderHeapTracer();
-        heap_->mark_compact_collector()->embedder_heap_tracer()->AdvanceTracing(
-            0,
-            EmbedderHeapTracer::AdvanceTracingActions(
-                EmbedderHeapTracer::ForceCompletionAction::FORCE_COMPLETION));
+        wrapper_work_left =
+            heap_->mark_compact_collector()
+                ->embedder_heap_tracer()
+                ->AdvanceTracing(wrapper_deadline,
+                                 EmbedderHeapTracer::AdvanceTracingActions(
+                                     EmbedderHeapTracer::ForceCompletionAction::
+                                         DO_NOT_FORCE_COMPLETION));
       }
-      if (heap_->mark_compact_collector()->marking_deque()->IsEmpty()) {
+
+      if (heap_->mark_compact_collector()->marking_deque()->IsEmpty() &&
+          !wrapper_work_left) {
         if (completion == FORCE_COMPLETION ||
             IsIdleMarkingDelayCounterLimitReached()) {
           if (!finalize_marking_completed_) {
             FinalizeMarking(action);
           } else {
             MarkingComplete(action);
           }
         } else {
           IncrementIdleMarkingDelayCounter();
         }
@@ skipping 43 matching lines @@
 void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 }  // namespace internal
 }  // namespace v8