Use background tasks for the compiler dispatcher

src/compiler-dispatcher/compiler-dispatcher.h

 // Copyright 2016 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_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_
 #define V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_
 
 #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"
 
 namespace v8 {
 
 class Platform;
 
 namespace internal {
 
 class CompilerDispatcherJob;
@@ skipping 25 matching lines @@
   bool FinishNow(Handle<SharedFunctionInfo> function);
 
   // Aborts a given job. Blocks if requested.
   void Abort(Handle<SharedFunctionInfo> function, BlockingBehavior blocking);
 
   // Aborts all jobs. Blocks if requested.
   void AbortAll(BlockingBehavior blocking);
 
  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_;
   Platform* platform_;
   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);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_