[heap] Refactor incremental marking step.

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"
 #include "src/heap/gc-tracer.h"
 #include "src/heap/mark-compact-inl.h"
 #include "src/heap/object-stats.h"
 #include "src/heap/objects-visiting-inl.h"
 #include "src/heap/objects-visiting.h"
 #include "src/tracing/trace-event.h"
 #include "src/v8.h"
 
 namespace v8 {
 namespace internal {
 
-IncrementalMarking::StepActions IncrementalMarking::IdleStepActions() {
-  return StepActions(IncrementalMarking::NO_GC_VIA_STACK_GUARD,
-                     IncrementalMarking::FORCE_MARKING,
-                     IncrementalMarking::DO_NOT_FORCE_COMPLETION);
-}
-
 IncrementalMarking::IncrementalMarking(Heap* heap)
     : heap_(heap),
       observer_(*this, kAllocatedThreshold),
       state_(STOPPED),
       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),
@@ skipping 1012 matching lines @@
 }
 
 
 void IncrementalMarking::Epilogue() {
   was_activated_ = false;
   finalize_marking_completed_ = false;
   incremental_marking_finalization_rounds_ = 0;
 }
 
 double IncrementalMarking::AdvanceIncrementalMarking(
-    double deadline_in_ms, IncrementalMarking::StepActions step_actions) {
+    double deadline_in_ms, CompletionAction completion_action,
+    ForceCompletionAction force_completion) {
   DCHECK(!IsStopped());
 
+  double remaining_time_in_ms = 0.0;
   intptr_t step_size_in_bytes = GCIdleTimeHandler::EstimateMarkingStepSize(
-      GCIdleTimeHandler::kIncrementalMarkingStepTimeInMs,
+      kStepSizeInMs,
       heap()->tracer()->IncrementalMarkingSpeedInBytesPerMillisecond());
-  double remaining_time_in_ms = 0.0;
 
   do {
-    Step(step_size_in_bytes, step_actions.completion_action,
-         step_actions.force_marking, step_actions.force_completion);
+    Step(step_size_in_bytes, completion_action, force_completion);
     remaining_time_in_ms =
         deadline_in_ms - heap()->MonotonicallyIncreasingTimeInMs();
-  } while (!heap_->mark_compact_collector()->marking_deque()->IsEmpty() &&
-           remaining_time_in_ms >=
-               2.0 * GCIdleTimeHandler::kIncrementalMarkingStepTimeInMs &&
-           !IsComplete() &&
+  } while (remaining_time_in_ms >= kStepSizeInMs && !IsComplete() &&
            !heap()->mark_compact_collector()->marking_deque()->IsEmpty());
   return remaining_time_in_ms;
 }
 
 
-void IncrementalMarking::OldSpaceStep(intptr_t allocated) {
-  if (IsStopped() && ShouldActivateEvenWithoutIdleNotification()) {
-    heap()->StartIncrementalMarking(Heap::kNoGCFlags, kNoGCCallbackFlags,
-                                    "old space step");
-  } else {
-    Step(allocated * kFastMarking / kInitialMarkingSpeed, GC_VIA_STACK_GUARD);
-  }
-}
-
-
 void IncrementalMarking::SpeedUp() {
   bool speed_up = false;
 
   if ((steps_count_ % kMarkingSpeedAccellerationInterval) == 0) {
     if (FLAG_trace_incremental_marking) {
       heap()->isolate()->PrintWithTimestamp(
           "[IncrementalMarking] Speed up marking after %d steps\n",
           static_cast<int>(kMarkingSpeedAccellerationInterval));
     }
     speed_up = true;
@@ skipping 69 matching lines @@
       (heap_->mark_compact_collector()->sweeper().IsSweepingCompleted() ||
        !FLAG_concurrent_sweeping)) {
     heap_->mark_compact_collector()->EnsureSweepingCompleted();
   }
   if (!heap_->mark_compact_collector()->sweeping_in_progress()) {
     bytes_scanned_ = 0;
     StartMarking();
   }
 }
 
-intptr_t IncrementalMarking::Step(intptr_t allocated_bytes,
-                                  CompletionAction action,
-                                  ForceMarkingAction marking,
-                                  ForceCompletionAction completion) {
-  DCHECK(allocated_bytes >= 0);
-
+void IncrementalMarking::NotifyAllocatedBytes(intptr_t allocated_bytes) {
   if (heap_->gc_state() != Heap::NOT_IN_GC || !FLAG_incremental_marking ||
       (state_ != SWEEPING && state_ != MARKING)) {
-    return 0;
+    return;
   }
 
   allocated_ += allocated_bytes;
 
-  if (marking == DO_NOT_FORCE_MARKING && allocated_ < kAllocatedThreshold &&
-      write_barriers_invoked_since_last_step_ <
+  if (allocated_ >= kAllocatedThreshold ||
+      write_barriers_invoked_since_last_step_ >=
           kWriteBarriersInvokedThreshold) {
-    return 0;
-  }
-
-  // If an idle notification happened recently, we delay marking steps.
-  if (marking == DO_NOT_FORCE_MARKING &&
-      heap_->RecentIdleNotificationHappened()) {
-    return 0;
-  }
-
-  intptr_t bytes_processed = 0;
-  {
-    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();
-
     // The marking speed is driven either by the allocation rate or by the rate
     // 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_);
-    allocated_ = 0;
-    write_barriers_invoked_since_last_step_ = 0;
+    Step(bytes_to_process, GC_VIA_STACK_GUARD, FORCE_COMPLETION);
+  }
+}
 
-    bytes_scanned_ += bytes_to_process;
+void IncrementalMarking::Step(intptr_t bytes_to_process,
+                              CompletionAction action,
+                              ForceCompletionAction completion) {
+  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();
 
-    if (state_ == SWEEPING) {
-      TRACE_GC(heap_->tracer(), GCTracer::Scope::MC_INCREMENTAL_SWEEPING);
-      FinalizeSweeping();
+  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);
+    } 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,
+                               EmbedderHeapTracer::AdvanceTracingActions(
+                                   EmbedderHeapTracer::ForceCompletionAction::
+                                       DO_NOT_FORCE_COMPLETION));
     }
 
-    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 (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 {
-        const double kWrapperTracngStepMs = 1.0;
-        const double wrapper_deadline =
-            heap_->MonotonicallyIncreasingTimeInMs() + kWrapperTracngStepMs;
-        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,
-                                 EmbedderHeapTracer::AdvanceTracingActions(
-                                     EmbedderHeapTracer::ForceCompletionAction::
-                                         DO_NOT_FORCE_COMPLETION));
-      }
-
-      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();
-        }
+        IncrementIdleMarkingDelayCounter();
       }
     }
+  }
 
-    steps_count_++;
+  steps_count_++;
 
-    // Speed up marking if we are marking too slow or if we are almost done
-    // with marking.
-    SpeedUp();
+  // 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);
-  }
-  return bytes_processed;
+  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);
 }
 
 
 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;
@@ skipping 17 matching lines @@
   idle_marking_delay_counter_++;
 }
 
 
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
 
 }  // namespace internal
 }  // namespace v8