[heap] Do more incremental marking work in tasks.

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 15 matching lines @@
       is_compacting_(false),
       steps_count_(0),
       old_generation_space_available_at_start_of_incremental_(0),
       old_generation_space_used_at_start_of_incremental_(0),
       bytes_rescanned_(0),
       should_hurry_(false),
       marking_speed_(0),
       bytes_scanned_(0),
       allocated_(0),
       write_barriers_invoked_since_last_step_(0),
+      bytes_marked_ahead_of_schedule_(0),
       idle_marking_delay_counter_(0),
       unscanned_bytes_of_large_object_(0),
       was_activated_(false),
       black_allocation_(false),
       finalize_marking_completed_(false),
       incremental_marking_finalization_rounds_(0),
       request_type_(NONE) {}
 
 bool IncrementalMarking::BaseRecordWrite(HeapObject* obj, Object* value) {
   HeapObject* value_heap_obj = HeapObject::cast(value);
@@ skipping 1002 matching lines @@
 
 
 void IncrementalMarking::Epilogue() {
   was_activated_ = false;
   finalize_marking_completed_ = false;
   incremental_marking_finalization_rounds_ = 0;
 }
 
 double IncrementalMarking::AdvanceIncrementalMarking(
     double deadline_in_ms, CompletionAction completion_action,
-    ForceCompletionAction force_completion) {
+    ForceCompletionAction force_completion, StepOrigin step_origin) {
   DCHECK(!IsStopped());
 
   double remaining_time_in_ms = 0.0;
   intptr_t step_size_in_bytes = GCIdleTimeHandler::EstimateMarkingStepSize(
       kStepSizeInMs,
       heap()->tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
 
   do {
-    Step(step_size_in_bytes, completion_action, force_completion);
+    Step(step_size_in_bytes, completion_action, force_completion, step_origin);
     remaining_time_in_ms =
         deadline_in_ms - heap()->MonotonicallyIncreasingTimeInMs();
   } while (remaining_time_in_ms >= kStepSizeInMs && !IsComplete() &&
            !heap()->mark_compact_collector()->marking_deque()->IsEmpty());
   return remaining_time_in_ms;
 }
 
 
 void IncrementalMarking::SpeedUp() {
   bool speed_up = false;
@@ skipping 99 matching lines @@
     // at which we are having to check the color of objects in the write
     // barrier.
     // It is possible for a tight non-allocating loop to run a lot of write
     // barriers before we get here and check them (marking can only take place
     // on
     // allocation), so to reduce the lumpiness we don't use the write barriers
     // invoked since last step directly to determine the amount of work to do.
     intptr_t bytes_to_process =
         marking_speed_ *
         Max(allocated_, write_barriers_invoked_since_last_step_);
-    Step(bytes_to_process, GC_VIA_STACK_GUARD, FORCE_COMPLETION);
+    Step(bytes_to_process, GC_VIA_STACK_GUARD, FORCE_COMPLETION,
+         StepOrigin::kV8);
   }
 }
 
 void IncrementalMarking::Step(intptr_t bytes_to_process,
                               CompletionAction action,
-                              ForceCompletionAction completion) {
+                              ForceCompletionAction completion,
+                              StepOrigin step_origin) {
   HistogramTimerScope incremental_marking_scope(
       heap_->isolate()->counters()->gc_incremental_marking());
   TRACE_EVENT0("v8", "V8.GCIncrementalMarking");
   TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL);
   double start = heap_->MonotonicallyIncreasingTimeInMs();
 
   bytes_scanned_ += bytes_to_process;
 
   allocated_ = 0;
   write_barriers_invoked_since_last_step_ = 0;
 
   if (state_ == SWEEPING) {
     TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL_SWEEPING);
     FinalizeSweeping();
   }
 
   intptr_t bytes_processed = 0;
   if (state_ == MARKING) {
     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);
+      if (step_origin == StepOrigin::kV8 &&
+          bytes_marked_ahead_of_schedule_ >= bytes_to_process) {
+        // Steps performed in tasks 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;
+      } else {
+        bytes_processed = ProcessMarkingDeque(bytes_to_process);
+        if (step_origin == StepOrigin::kTask) {
+          bytes_marked_ahead_of_schedule_ += bytes_processed;
+        }
+      }
     } else {
       const double wrapper_deadline =
           heap_->MonotonicallyIncreasingTimeInMs() + kStepSizeInMs;
       TRACE_GC(heap()->tracer(),
                GCTracer::Scope::MC_INCREMENTAL_WRAPPER_TRACING);
       heap_->mark_compact_collector()->RegisterWrappersWithEmbedderHeapTracer();
       wrapper_work_left =
           heap_->mark_compact_collector()
               ->embedder_heap_tracer()
               ->AdvanceTracing(wrapper_deadline,
@@ skipping 22 matching lines @@
   // Speed up marking if we are marking too slow or if we are almost done
   // with marking.
   SpeedUp();
 
   double end = heap_->MonotonicallyIncreasingTimeInMs();
   double duration = (end - start);
   // Note that we report zero bytes here when sweeping was in progress or
   // when we just started incremental marking. In these cases we did not
   // process the marking deque.
   heap_->tracer()->AddIncrementalMarkingStep(duration, bytes_processed);
+  if (FLAG_trace_incremental_marking) {
+    heap_->isolate()->PrintWithTimestamp(
+        "[IncrementalMarking] Step %s %d bytes (%d) in %.1f\n",
+        step_origin == StepOrigin::kV8 ? "in v8" : "in task",
+        static_cast<int>(bytes_processed), static_cast<int>(bytes_to_process),
+        duration);
+  }
 }
 
 
 void IncrementalMarking::ResetStepCounters() {
   steps_count_ = 0;
   old_generation_space_available_at_start_of_incremental_ =
       SpaceLeftInOldSpace();
   old_generation_space_used_at_start_of_incremental_ =
       heap_->PromotedTotalSize();
   bytes_rescanned_ = 0;
   marking_speed_ = kInitialMarkingSpeed;
   bytes_scanned_ = 0;
   write_barriers_invoked_since_last_step_ = 0;
+  bytes_marked_ahead_of_schedule_ = 0;
 }
 
 
 int64_t IncrementalMarking::SpaceLeftInOldSpace() {
   return heap_->MaxOldGenerationSize() - heap_->PromotedSpaceSizeOfObjects();
 }
 
 
 bool IncrementalMarking::IsIdleMarkingDelayCounterLimitReached() {
   return idle_marking_delay_counter_ > kMaxIdleMarkingDelayCounter;
 }
 
 
 void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 
 }  // namespace internal
 }  // namespace v8