Use background tasks for the compiler dispatcher

src/compiler-dispatcher/compiler-dispatcher.h

Index: src/compiler-dispatcher/compiler-dispatcher.h
diff --git a/src/compiler-dispatcher/compiler-dispatcher.h b/src/compiler-dispatcher/compiler-dispatcher.h
index fea141e22f970ff9112290707539ca5d4c574015..390d1b7c90a280c0239bfef70474cc83e51a714f 100644
--- a/src/compiler-dispatcher/compiler-dispatcher.h
+++ b/src/compiler-dispatcher/compiler-dispatcher.h
@@ -7,9 +7,12 @@
 
 #include <map>
 #include <memory>
+#include <set>
 #include <utility>
 
 #include "src/base/macros.h"
+#include "src/base/platform/condition-variable.h"
+#include "src/base/platform/mutex.h"
 #include "src/globals.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
@@ -55,15 +58,23 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
 
  private:
   FRIEND_TEST(CompilerDispatcherTest, IdleTaskSmallIdleTime);
+  FRIEND_TEST(IgnitionCompilerDispatcherTest, CompileOnBackgroundThread);
+  FRIEND_TEST(IgnitionCompilerDispatcherTest, FinishNowWithBackgroundTask);
 
   typedef std::multimap<std::pair<int, int>,
                         std::unique_ptr<CompilerDispatcherJob>>
       JobMap;
+  class BackgroundTask;
   class IdleTask;
 
+  void EnsureNotOnBackground(CompilerDispatcherJob* job);
   bool IsEnabled() const;
   JobMap::const_iterator GetJobFor(Handle<SharedFunctionInfo> shared) const;
+  void ConsiderJobForBackgroundProcessing(CompilerDispatcherJob* job);
+  void ScheduleMoreBackgroundTasksIfNeeded();
+  void ScheduleIdleTaskFromAnyThread();
   void ScheduleIdleTaskIfNeeded();
+  void DoBackgroundWork();
   void DoIdleWork(double deadline_in_seconds);
 
   Isolate* isolate_;
@@ -71,12 +82,31 @@ class V8_EXPORT_PRIVATE CompilerDispatcher {
   size_t max_stack_size_;
   std::unique_ptr<CompilerDispatcherTracer> tracer_;
 
-  bool idle_task_scheduled_;
-
   // Mapping from (script id, function literal id) to job. We use a multimap,
   // as script id is not necessarily unique.
   JobMap jobs_;
 
+  // The following members can be accessed from any thread. Methods need to hold
+  // the mutex |mutex_| while accessing them.
+  base::Mutex mutex_;
+
+  bool idle_task_scheduled_;
+
+  // Number of currently scheduled BackgroundTask objects.
+  size_t num_scheduled_background_tasks_;
+
+  // The set of CompilerDispatcherJobs that can be advanced on any thread.
+  std::set<CompilerDispatcherJob*> pending_background_jobs_;

[marja, 2017/01/03 10:42:41]

Why a set, why not a FIFO? (Ah, found out the answer to that question later, but
leaving the comment here anyway.)

Afaics this impl doesn't give a guarantee that any given task will be executed
ever (it might be that we always pick some other task to run). Ofc if we really
need it, then we run it...

-----

So you chose set over a FIFO queue because you need to check whether a given job
is there or not. Idk why not unordered_set though?

[jochen (gone - plz use gerrit), 2017/01/03 12:59:36]

changed to unordered_set

+
+  // The set of CompilerDispatcherJobs currently processed on background
+  // threads.
+  std::set<CompilerDispatcherJob*> running_background_jobs_;

[marja, 2017/01/03 10:42:41]

Ditto

+
+  // If not nullptr, then the main thread waits for the task processing
+  // this job, and blocks on the ConditionVariable main_thread_blocking_signal_.
+  CompilerDispatcherJob* main_thread_blocking_on_job_;
+  base::ConditionVariable main_thread_blocking_signal_;
+
   DISALLOW_COPY_AND_ASSIGN(CompilerDispatcher);
 };