Use idle task to perform incremental marking steps.

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/v8.h"
 
 #include "src/heap/incremental-marking.h"
 
 #include "src/code-stubs.h"
 #include "src/compilation-cache.h"
@@ skipping 25 matching lines @@
       bytes_scanned_(0),
       allocated_(0),
       write_barriers_invoked_since_last_step_(0),
       idle_marking_delay_counter_(0),
       no_marking_scope_depth_(0),
       unscanned_bytes_of_large_object_(0),
       was_activated_(false),
       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,
                                          Object* value) {
   if (BaseRecordWrite(obj, slot, value) && slot != NULL) {
     MarkBit obj_bit = Marking::MarkBitFrom(obj);
     if (Marking::IsBlack(obj_bit)) {
       // Object is not going to be rescanned we need to record the slot.
       heap_->mark_compact_collector()->RecordSlot(obj, slot, value);
     }
@@ skipping 436 matching lines @@
     StartMarking();
     heap_->mark_compact_collector()->SetFlags(Heap::kNoGCFlags);
   } else {
     if (FLAG_trace_incremental_marking) {
       PrintF("[IncrementalMarking] Start sweeping.\n");
     }
     state_ = SWEEPING;
   }
 
   heap_->new_space()->LowerInlineAllocationLimit(kAllocatedThreshold);
+  ScheduleIncrementalMarkingTask();
 }
 
 
 void IncrementalMarking::StartMarking() {
   if (FLAG_trace_incremental_marking) {
     PrintF("[IncrementalMarking] Start marking\n");
   }
 
   is_compacting_ = !FLAG_never_compact &&
                    heap_->mark_compact_collector()->StartCompaction(
@@ skipping 510 matching lines @@
 
 
 void IncrementalMarking::IncrementIdleMarkingDelayCounter() {
   idle_marking_delay_counter_++;
 }
 
 
 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