Use idle task to perform incremental marking steps.

src/heap/incremental-marking-job.h

Index: src/heap/incremental-marking-job.h
diff --git a/src/heap/incremental-marking-job.h b/src/heap/incremental-marking-job.h
new file mode 100644
index 0000000000000000000000000000000000000000..c35e82723b3a131ef4eb7461621d9980d1b8af6a
--- /dev/null
+++ b/src/heap/incremental-marking-job.h
@@ -0,0 +1,81 @@
+// 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.
+
+#ifndef V8_HEAP_INCREMENTAL_MARKING_JOB_H_
+#define V8_HEAP_INCREMENTAL_MARKING_JOB_H_
+
+#include "src/cancelable-task.h"
+
+namespace v8 {
+namespace internal {
+
+class Heap;
+class Isolate;
+
+// The incremental marking job uses platform tasks to perform incremental
+// marking steps. The job posts an idle and a delayed task with a large delay.
+// The delayed task performs steps only if the idle task is not making progress.
+// We expect this to be a rare event since incremental marking should finish
+// quickly with the help of the mutator and the idle task.
+// The delayed task guarantees that we eventually finish incremental marking
+// even if the mutator becomes idle and the platform stops running idle tasks,
+// which can happen for background tab in Chrome.

[Michael Lippautz, 2015/09/08 10:16:26]

nit: s/tab/tabs/

[ulan, 2015/09/08 11:34:53]

Done.

+class IncrementalMarkingJob {
+ public:
+  class IdleTask : public CancelableIdleTask {
+   public:
+    explicit IdleTask(Isolate* isolate, IncrementalMarkingJob* job)
+        : CancelableIdleTask(isolate), job_(job) {}
+    enum Progress { kDone, kMoreWork };
+    static Progress Step(Heap* heap, double deadline_in_ms);
+    // CancelableIdleTask overrides.
+    void RunInternal(double deadline_in_seconds) override;
+
+   private:
+    IncrementalMarkingJob* job_;
+  };
+
+  class DelayedTask : public CancelableTask {
+   public:
+    explicit DelayedTask(Isolate* isolate, IncrementalMarkingJob* job)
+        : CancelableTask(isolate), job_(job) {}
+    static void Step(Heap* heap);
+    // CancelableTask overrides.
+    void RunInternal() override;
+
+   private:
+    IncrementalMarkingJob* job_;
+  };
+
+  IncrementalMarkingJob()
+      : idle_task_pending_(false),
+        delayed_task_pending_(false),
+        made_progress_since_last_delayed_task_(false) {}
+
+  bool ShouldForceMarkingStep() {
+    return !made_progress_since_last_delayed_task_;
+  }
+
+  bool IdleTaskPending() { return idle_task_pending_; }
+
+  void Start(Heap* heap) {

[Michael Lippautz, 2015/09/08 10:16:26]

IncrementalMarkingJob is reused as far as I see. We should reset the member
fields on start, as we might end up with made_progress_since_last_delayed_task_
= true from the last round. (After fixing NotifyProgress())

[ulan, 2015/09/08 11:34:53]

Added a comment explaining why we shouldn't reset the fields.

+    ScheduleIdleTask(heap);
+    ScheduleDelayedTask(heap);
+  }
+
+  void NotifyIdleTask();
+  void NotifyDelayedTask();
+  void NotifyProgress();
+  void ScheduleIdleTask(Heap* heap);
+  void ScheduleDelayedTask(Heap* heap);
+
+ private:
+  bool idle_task_pending_;
+  bool delayed_task_pending_;
+  bool made_progress_since_last_delayed_task_;
+};
+}
+}  // namespace v8::internal
+
+#endif  // V8_HEAP_INCREMENTAL_MARKING_JOB_H_