GC: Refactor public incremental marking interface in heap

src/heap/heap.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/v8.h"
 
 #include "src/accessors.h"
 #include "src/api.h"
 #include "src/base/bits.h"
 #include "src/base/once.h"
@@ skipping 751 matching lines @@
   }
   // We must not compact the weak fixed list here, as we may be in the middle
   // of writing to it, when the GC triggered. Instead, we reset the root value.
   set_weak_stack_trace_list(Smi::FromInt(0));
 }
 
 
 void Heap::HandleGCRequest() {
   if (incremental_marking()->request_type() ==
       IncrementalMarking::COMPLETE_MARKING) {
-    CollectAllGarbage(Heap::kNoGCFlags, "GC interrupt");
+    CollectAllGarbage(Heap::kNoGCFlags, "GC interrupt",
+                      incremental_marking()->CallbackFlags());
     return;
   }
   DCHECK(FLAG_overapproximate_weak_closure);
   if (!incremental_marking()->weak_closure_was_overapproximated()) {
     OverApproximateWeakClosure("GC interrupt");
   }
 }
 
 
 void Heap::OverApproximateWeakClosure(const char* gc_reason) {
@@ skipping 216 matching lines @@
   set_retained_maps(ArrayList::cast(empty_fixed_array()));
   tracer()->AddContextDisposalTime(base::OS::TimeCurrentMillis());
   MemoryReducer::Event event;
   event.type = MemoryReducer::kContextDisposed;
   event.time_ms = MonotonicallyIncreasingTimeInMs();
   memory_reducer_.NotifyContextDisposed(event);
   return ++contexts_disposed_;
 }
 
 
+void Heap::StartIncrementalMarking(int gc_flags,
+                                   const GCCallbackFlags gc_callback_flags,
+                                   const char* reason) {
+  incremental_marking()->Start(gc_flags, gc_callback_flags, reason);
+}
+
+
 void Heap::StartIdleIncrementalMarking() {
   gc_idle_time_handler_.ResetNoProgressCounter();
-  incremental_marking()->Start(kReduceMemoryFootprintMask);
+  StartIncrementalMarking(kReduceMemoryFootprintMask, kNoGCCallbackFlags,
+                          "idle");
 }
 
 
 void Heap::MoveElements(FixedArray* array, int dst_index, int src_index,
                         int len) {
   if (len == 0) return;
 
   DCHECK(array->map() != fixed_cow_array_map());
   Object** dst_objects = array->data_start() + dst_index;
   MemMove(dst_objects, array->data_start() + src_index, len * kPointerSize);
@@ skipping 3761 matching lines @@
   heap_state.used_new_space_size = new_space_.Size();
   heap_state.new_space_capacity = new_space_.Capacity();
   heap_state.new_space_allocation_throughput_in_bytes_per_ms =
       tracer()->NewSpaceAllocationThroughputInBytesPerMillisecond();
   return heap_state;
 }
 
 
 double Heap::AdvanceIncrementalMarking(
     intptr_t step_size_in_bytes, double deadline_in_ms,
-    IncrementalMarking::ForceCompletionAction completion) {
+    IncrementalMarking::StepActions step_actions) {
   DCHECK(!incremental_marking()->IsStopped());
+
+  if (step_size_in_bytes == 0) {
+    GCIdleTimeHandler::HeapState heap_state = ComputeHeapState();

[Hannes Payer (out of office), 2015/08/04 15:05:59]

You don't need the heap_state for that. Just call EstimateMarkingStepSize with
incremental marking speed. Also, document that in the API.

[Michael Lippautz, 2015/08/04 15:53:06]

Done.

+    step_size_in_bytes = GCIdleTimeHandler::EstimateMarkingStepSize(
+        static_cast<size_t>(GCIdleTimeHandler::kIncrementalMarkingStepTimeInMs),
+        heap_state.incremental_marking_speed_in_bytes_per_ms);
+  }
+
   double remaining_time_in_ms = 0.0;
   do {
-    incremental_marking()->Step(step_size_in_bytes,
-                                IncrementalMarking::NO_GC_VIA_STACK_GUARD,
-                                IncrementalMarking::FORCE_MARKING, completion);
+    incremental_marking()->Step(
+        step_size_in_bytes, step_actions.completion_action,
+        step_actions.force_marking, step_actions.force_completion);
     remaining_time_in_ms = deadline_in_ms - MonotonicallyIncreasingTimeInMs();
   } while (remaining_time_in_ms >=
                2.0 * GCIdleTimeHandler::kIncrementalMarkingStepTimeInMs &&
            !incremental_marking()->IsComplete() &&
            !mark_compact_collector_.marking_deque()->IsEmpty());
   return remaining_time_in_ms;
 }
 
 
 bool Heap::PerformIdleTimeAction(GCIdleTimeAction action,
                                  GCIdleTimeHandler::HeapState heap_state,
                                  double deadline_in_ms) {
   bool result = false;
   switch (action.type) {
     case DONE:
       result = true;
       break;
     case DO_INCREMENTAL_MARKING: {
-      const double remaining_idle_time_in_ms = AdvanceIncrementalMarking(
-          action.parameter, deadline_in_ms,
-          IncrementalMarking::DO_NOT_FORCE_COMPLETION);
+      const double remaining_idle_time_in_ms =
+          AdvanceIncrementalMarking(action.parameter, deadline_in_ms,
+                                    IncrementalMarking::NoForcedStepActions());
       if (remaining_idle_time_in_ms > 0.0) {
         action.additional_work = TryFinalizeIdleIncrementalMarking(
             remaining_idle_time_in_ms, heap_state.size_of_objects,
             heap_state.final_incremental_mark_compact_speed_in_bytes_per_ms);
       }
       break;
     }
     case DO_FULL_GC: {
       DCHECK(contexts_disposed_ > 0);
       HistogramTimerScope scope(isolate_->counters()->gc_context());
@@ skipping 2031 matching lines @@
     *object_type = "CODE_TYPE";                                                \
     *object_sub_type = "CODE_AGE/" #name;                                      \
     return true;
     CODE_AGE_LIST_COMPLETE(COMPARE_AND_RETURN_NAME)
 #undef COMPARE_AND_RETURN_NAME
   }
   return false;
 }
 }  // namespace internal
 }  // namespace v8