Use idle task to perform incremental marking steps.

src/heap/incremental-marking.cc

Index: src/heap/incremental-marking.cc
diff --git a/src/heap/incremental-marking.cc b/src/heap/incremental-marking.cc
index 106b72e3c9729feeaa1069d0e8e2723edbfb0405..67cba89aacd377687ef646d95dc07a7de0dbdc99 100644
--- a/src/heap/incremental-marking.cc
+++ b/src/heap/incremental-marking.cc
@@ -43,7 +43,8 @@ IncrementalMarking::IncrementalMarking(Heap* heap)
       weak_closure_was_overapproximated_(false),
       weak_closure_approximation_rounds_(0),
       request_type_(COMPLETE_MARKING),
-      gc_callback_flags_(kNoGCCallbackFlags) {}
+      gc_callback_flags_(kNoGCCallbackFlags),
+      pending_incremental_marking_task_(false) {}
 
 
 void IncrementalMarking::RecordWriteSlow(HeapObject* obj, Object** slot,
@@ -500,6 +501,7 @@ void IncrementalMarking::Start(int mark_compact_flags,
   }
 
   heap_->new_space()->LowerInlineAllocationLimit(kAllocatedThreshold);
+  ScheduleIncrementalMarkingTask();
 }
 
 
@@ -1030,5 +1032,69 @@ void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
 void IncrementalMarking::ClearIdleMarkingDelayCounter() {
   idle_marking_delay_counter_ = 0;
 }
+
+
+void IncrementalMarking::ScheduleIncrementalMarkingTask() {
+  if (!pending_incremental_marking_task_) {
+    v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(heap_->isolate());
+    if (V8::GetCurrentPlatform()->IdleTasksEnabled(isolate)) {
+      pending_incremental_marking_task_ = true;
+      auto task = new IncrementalMarkingTask(heap_->isolate());
+      V8::GetCurrentPlatform()->CallIdleOnForegroundThread(isolate, task);
+    }
+  }
+}
+
+
+void IncrementalMarking::NotifyIncrementalMarkingTaskRunning() {
+  pending_incremental_marking_task_ = false;
+}
+
+
+IncrementalMarkingTask::Progress IncrementalMarkingTask::Step(
+    Heap* heap, double deadline_in_ms) {
+  IncrementalMarking* incremental_marking = heap->incremental_marking();
+  MarkCompactCollector* mark_compact_collector = heap->mark_compact_collector();
+  if (incremental_marking->IsStopped()) {
+    return kDone;
+  }
+  if (mark_compact_collector->sweeping_in_progress()) {
+    if (mark_compact_collector->IsSweepingCompleted()) {
+      mark_compact_collector->EnsureSweepingCompleted();
+    }

[Hannes Payer (out of office), 2015/08/05 12:35:44]

A follow-up CL could check if there is still time after waiting for sweeper
threads and perform incremental marking steps.

[ulan, 2015/08/05 12:45:40]

Acknowledged.

+    return kMoreWork;
+  }
+  const double remaining_idle_time_in_ms = heap->AdvanceIncrementalMarking(

[Hannes Payer (out of office), 2015/08/05 12:35:44]

AdvanceIncrementalMarking is always called with step size 0, let's remove this
parameter

[ulan, 2015/08/05 12:45:40]

I'll do it in a separate CL to avoid conflicts with Michael's CL.

+      0, deadline_in_ms, IncrementalMarking::NoForcedStepActions());
+  if (remaining_idle_time_in_ms > 0.0) {
+    heap->TryFinalizeIdleIncrementalMarking(remaining_idle_time_in_ms);
+  }
+  return incremental_marking->IsStopped() ? kDone : kMoreWork;
+}
+
+
+void IncrementalMarkingTask::RunInternal(double deadline_in_seconds) {
+  double deadline_in_ms =
+      deadline_in_seconds *
+      static_cast<double>(base::Time::kMillisecondsPerSecond);
+  Heap* heap = isolate_->heap();
+  double start_ms = heap->MonotonicallyIncreasingTimeInMs();
+  heap->incremental_marking()->NotifyIncrementalMarkingTaskRunning();
+  if (Step(heap, deadline_in_ms) == kMoreWork) {
+    heap->incremental_marking()->ScheduleIncrementalMarkingTask();
+  }
+  if (FLAG_trace_idle_notification) {
+    double current_time_ms = heap->MonotonicallyIncreasingTimeInMs();
+    double idle_time_in_ms = deadline_in_ms - start_ms;
+    double deadline_difference = deadline_in_ms - current_time_ms;
+    PrintIsolate(isolate_, "%8.0f ms: ", isolate_->time_millis_since_init());
+    PrintF(
+        "Idle task: requested idle time %.2f ms, used idle time %.2f "
+        "ms, deadline usage %.2f ms\n",
+        idle_time_in_ms, idle_time_in_ms - deadline_difference,
+        deadline_difference);
+  }
+}
+
 }  // namespace internal
 }  // namespace v8