Implement async AbortAll 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 <unordered_set>
 #include <utility>
 
+#include "src/base/atomic-utils.h"
 #include "src/base/macros.h"
 #include "src/base/platform/condition-variable.h"
 #include "src/base/platform/mutex.h"
+#include "src/base/platform/semaphore.h"
 #include "src/globals.h"
 #include "testing/gtest/include/gtest/gtest_prod.h"
 
 namespace v8 {
 
 class Platform;
 
 namespace internal {
 
 class CancelableTaskManager;
@@ skipping 52 matching lines @@
   // 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);
+  FRIEND_TEST(IgnitionCompilerDispatcherTest,
+              AsyncAbortAllPendingBackgroundTask);
+  FRIEND_TEST(IgnitionCompilerDispatcherTest,
+              AsyncAbortAllRunningBackgroundTask);
+  FRIEND_TEST(IgnitionCompilerDispatcherTest, FinishNowDuringAbortAll);
 
   typedef std::multimap<std::pair<int, int>,
                         std::unique_ptr<CompilerDispatcherJob>>
       JobMap;
+  class AbortTask;
   class BackgroundTask;
   class IdleTask;
 
   void WaitForJobIfRunningOnBackground(CompilerDispatcherJob* job);
   bool IsEnabled() const;
+  void AbortInactiveJobs();
   JobMap::const_iterator GetJobFor(Handle<SharedFunctionInfo> shared) const;
   void ConsiderJobForBackgroundProcessing(CompilerDispatcherJob* job);
   void ScheduleMoreBackgroundTasksIfNeeded();
   void ScheduleIdleTaskFromAnyThread();
   void ScheduleIdleTaskIfNeeded();
+  void ScheduleAbortTask();
   void DoBackgroundWork();
   void DoIdleWork(double deadline_in_seconds);
 
   Isolate* isolate_;
   Platform* platform_;
   size_t max_stack_size_;
   std::unique_ptr<CompilerDispatcherTracer> tracer_;
 
   std::unique_ptr<CancelableTaskManager> task_manager_;
 
   // 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_;
 
+  // True if the dispatcher is in the process of aborting running tasks.
+  bool abort_;
+
   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::unordered_set<CompilerDispatcherJob*> pending_background_jobs_;
 
   // The set of CompilerDispatcherJobs currently processed on background
   // threads.
   std::unordered_set<CompilerDispatcherJob*> running_background_jobs_;
 
   // 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_;
 
+  // Test support.
+  base::AtomicValue<bool> block_for_testing_;
+  base::Semaphore semaphore_for_testing_;
+
   DISALLOW_COPY_AND_ASSIGN(CompilerDispatcher);
 };
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_COMPILER_DISPATCHER_COMPILER_DISPATCHER_H_