Implement async AbortAll for the compiler dispatcher

src/compiler-dispatcher/compiler-dispatcher.cc

 // 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.
 
 #include "src/compiler-dispatcher/compiler-dispatcher.h"
 
 #include "include/v8-platform.h"
 #include "include/v8.h"
 #include "src/base/platform/time.h"
 #include "src/cancelable-task.h"
@@ skipping 34 matching lines @@
 
     case CompileJobStatus::kCompiled:
       job->FinalizeCompilingOnMainThread();
       break;
 
     case CompileJobStatus::kFailed:
     case CompileJobStatus::kDone:
       break;
   }
 
-  if (job->status() == CompileJobStatus::kFailed) {
-    DCHECK(isolate->has_pending_exception());
-    if (exception_handling == ExceptionHandling::kSwallow) {
-      isolate->clear_pending_exception();
-    }
-  } else {
-    DCHECK(!isolate->has_pending_exception());
+  DCHECK_EQ(job->status() == CompileJobStatus::kFailed,
+            isolate->has_pending_exception());
+  if (job->status() == CompileJobStatus::kFailed &&
+      exception_handling == ExceptionHandling::kSwallow) {
+    isolate->clear_pending_exception();
   }
   return job->status() != CompileJobStatus::kFailed;
 }
 
 bool IsFinished(CompilerDispatcherJob* job) {
   return job->status() == CompileJobStatus::kDone ||
          job->status() == CompileJobStatus::kFailed;
 }
 
 bool CanRunOnAnyThread(CompilerDispatcherJob* job) {
@@ skipping 18 matching lines @@
       UNREACHABLE();
   }
 }
 
 // Theoretically we get 50ms of idle time max, however it's unlikely that
 // we'll get all of it so try to be a conservative.
 const double kMaxIdleTimeToExpectInMs = 40;
 
 }  // namespace
 
+class CompilerDispatcher::AbortTask : public CancelableTask {
+ public:
+  AbortTask(Isolate* isolate, CancelableTaskManager* task_manager,
+            CompilerDispatcher* dispatcher);
+  ~AbortTask() override;
+
+  // CancelableTask implementation.
+  void RunInternal() override;
+
+ private:
+  CompilerDispatcher* dispatcher_;
+
+  DISALLOW_COPY_AND_ASSIGN(AbortTask);
+};
+
+CompilerDispatcher::AbortTask::AbortTask(Isolate* isolate,
+                                         CancelableTaskManager* task_manager,
+                                         CompilerDispatcher* dispatcher)
+    : CancelableTask(isolate, task_manager), dispatcher_(dispatcher) {}
+
+CompilerDispatcher::AbortTask::~AbortTask() {}
+
+void CompilerDispatcher::AbortTask::RunInternal() {
+  dispatcher_->AbortInactiveJobs();
+}
+
 class CompilerDispatcher::BackgroundTask : public CancelableTask {
  public:
   BackgroundTask(Isolate* isolate, CancelableTaskManager* task_manager,
                  CompilerDispatcher* dispatcher);
   ~BackgroundTask() override;
 
   // CancelableTask implementation.
   void RunInternal() override;
 
  private:
@@ skipping 39 matching lines @@
   dispatcher_->DoIdleWork(deadline_in_seconds);
 }
 
 CompilerDispatcher::CompilerDispatcher(Isolate* isolate, Platform* platform,
                                        size_t max_stack_size)
     : isolate_(isolate),
       platform_(platform),
       max_stack_size_(max_stack_size),
       tracer_(new CompilerDispatcherTracer(isolate_)),
       task_manager_(new CancelableTaskManager()),
+      abort_(false),
       idle_task_scheduled_(false),
       num_scheduled_background_tasks_(0),
-      main_thread_blocking_on_job_(nullptr) {}
+      main_thread_blocking_on_job_(nullptr),
+      block_for_testing_(false),
+      semaphore_for_testing_(0) {}
 
 CompilerDispatcher::~CompilerDispatcher() {
   // To avoid crashing in unit tests due to unfished jobs.
   AbortAll(BlockingBehavior::kBlock);
   task_manager_->CancelAndWait();
 }
 
 bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
   if (!IsEnabled()) return false;
 
+  {
+    base::LockGuard<base::Mutex> lock(&mutex_);
+    if (abort_) return false;
+  }
+
   // We only handle functions (no eval / top-level code / wasm) that are
   // attached to a script.
   if (!function->script()->IsScript() || !function->is_function() ||
       function->asm_function() || function->native()) {
     return false;
   }
 
   if (IsEnqueued(function)) return true;
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       isolate_, tracer_.get(), function, max_stack_size_));
@@ skipping 34 matching lines @@
   CHECK(job != jobs_.end());
 
   WaitForJobIfRunningOnBackground(job->second.get());
   while (!IsFinished(job->second.get())) {
     DoNextStepOnMainThread(isolate_, job->second.get(),
                            ExceptionHandling::kThrow);
   }
   bool result = job->second->status() != CompileJobStatus::kFailed;
   job->second->ResetOnMainThread();
   jobs_.erase(job);
+  if (jobs_.empty()) {
+    base::LockGuard<base::Mutex> lock(&mutex_);
+    abort_ = false;
+  }
   return result;
 }
 
 void CompilerDispatcher::AbortAll(BlockingBehavior blocking) {
-  // TODO(jochen): Implement support for non-blocking abort.
-  DCHECK(blocking == BlockingBehavior::kBlock);
-  for (auto& kv : jobs_) {
-    WaitForJobIfRunningOnBackground(kv.second.get());
-    kv.second->ResetOnMainThread();
+  bool background_tasks_running =
+      task_manager_->Cancel() == CancelableTaskManager::kTaskRunning;
+  if (!background_tasks_running || blocking == BlockingBehavior::kBlock) {
+    for (auto& kv : jobs_) {

[vogelheim, 2017/01/04 12:58:08]

kv ???

[jochen (gone - plz use gerrit), 2017/01/04 13:18:31]

key/value... guess "it" is the more common name

+      WaitForJobIfRunningOnBackground(kv.second.get());

[vogelheim, 2017/01/04 12:58:08]

If !background_tasks_running, we expect WaitForJobIfRunningOnBackground to
always be a no-op, right?

[jochen (gone - plz use gerrit), 2017/01/04 13:18:31]

right

+      kv.second->ResetOnMainThread();
+    }
+    jobs_.clear();
+    {
+      base::LockGuard<base::Mutex> lock(&mutex_);
+      DCHECK(pending_background_jobs_.empty());
+      DCHECK(running_background_jobs_.empty());
+      abort_ = false;
+    }
+    return;
   }
-  jobs_.clear();
+
+  {
+    base::LockGuard<base::Mutex> lock(&mutex_);
+    abort_ = true;
+    pending_background_jobs_.clear();
+  }
+  AbortInactiveJobs();
+
+  // All running background jobs might already have scheduled idle tasks instead
+  // of abort tasks. Schedule a single abort task here to make sure they get
+  // processed as soon as possible (and not first when we have idle time).
+  ScheduleAbortTask();
+}
+
+void CompilerDispatcher::AbortInactiveJobs() {
+  {
+    base::LockGuard<base::Mutex> lock(&mutex_);
+    // Since we schedule two abort tasks per async abort, we might end up
+    // here with nothing left to do.
+    if (!abort_) return;
+  }
+  for (auto it = jobs_.begin(); it != jobs_.end();) {
+    auto job = it;
+    ++it;
+    {
+      base::LockGuard<base::Mutex> lock(&mutex_);
+      if (running_background_jobs_.find(job->second.get()) !=
+          running_background_jobs_.end()) {
+        continue;
+      }
+    }
+    job->second->ResetOnMainThread();
+    jobs_.erase(job);
+  }
+  if (jobs_.empty()) {
+    base::LockGuard<base::Mutex> lock(&mutex_);
+    abort_ = false;
+  }
 }
 
 CompilerDispatcher::JobMap::const_iterator CompilerDispatcher::GetJobFor(
     Handle<SharedFunctionInfo> shared) const {
   if (!shared->script()->IsScript()) return jobs_.end();
   std::pair<int, int> key(Script::cast(shared->script())->id(),
                           shared->function_literal_id());
   auto range = jobs_.equal_range(key);
   for (auto job = range.first; job != range.second; ++job) {
     if (job->second->IsAssociatedWith(shared)) return job;
@@ skipping 11 matching lines @@
   }
   platform_->CallIdleOnForegroundThread(
       v8_isolate, new IdleTask(isolate_, task_manager_.get(), this));
 }
 
 void CompilerDispatcher::ScheduleIdleTaskIfNeeded() {
   if (jobs_.empty()) return;
   ScheduleIdleTaskFromAnyThread();
 }
 
+void CompilerDispatcher::ScheduleAbortTask() {
+  v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
+  platform_->CallOnForegroundThread(
+      v8_isolate, new AbortTask(isolate_, task_manager_.get(), this));
+}
+
 void CompilerDispatcher::ConsiderJobForBackgroundProcessing(
     CompilerDispatcherJob* job) {
   if (!CanRunOnAnyThread(job)) return;
   {
     base::LockGuard<base::Mutex> lock(&mutex_);
     pending_background_jobs_.insert(job);
   }
   ScheduleMoreBackgroundTasksIfNeeded();
 }
 
@@ skipping 19 matching lines @@
     base::LockGuard<base::Mutex> lock(&mutex_);
     --num_scheduled_background_tasks_;
     if (!pending_background_jobs_.empty()) {
       auto it = pending_background_jobs_.begin();
       job = *it;
       pending_background_jobs_.erase(it);
       running_background_jobs_.insert(job);
     }
   }
   if (job == nullptr) return;
+
+  if (V8_UNLIKELY(block_for_testing_.Value())) {
+    block_for_testing_.SetValue(false);
+    semaphore_for_testing_.Wait();
+  }
+
   DoNextStepOnBackgroundThread(job);
 
   ScheduleMoreBackgroundTasksIfNeeded();
   // Unconditionally schedule an idle task, as all background steps have to be
   // followed by a main thread step.
   ScheduleIdleTaskFromAnyThread();
 
   {
     base::LockGuard<base::Mutex> lock(&mutex_);
     running_background_jobs_.erase(job);
 
+    if (running_background_jobs_.empty() && abort_) {
+      // This is the last background job that finished. The abort task
+      // scheduled by AbortAll might already have ran, so schedule another
+      // one to be on the safe side.
+      ScheduleAbortTask();
+    }
+
     if (main_thread_blocking_on_job_ == job) {
       main_thread_blocking_on_job_ = nullptr;
       main_thread_blocking_signal_.NotifyOne();
     }
   }
   // Don't touch |this| anymore after this point, as it might have been
   // deleted.
 }
 
 void CompilerDispatcher::DoIdleWork(double deadline_in_seconds) {
+  bool aborted = false;
   {
     base::LockGuard<base::Mutex> lock(&mutex_);
     idle_task_scheduled_ = false;
+    aborted = abort_;
+  }
+
+  if (aborted) {
+    AbortInactiveJobs();
+    return;
   }
 
   // Number of jobs that are unlikely to make progress during any idle callback
   // due to their estimated duration.
   size_t too_long_jobs = 0;
 
   // Iterate over all available jobs & remaining time. For each job, decide
   // whether to 1) skip it (if it would take too long), 2) erase it (if it's
   // finished), or 3) make progress on it.
   double idle_time_in_seconds =
@@ skipping 40 matching lines @@
       lock.reset();
       DoNextStepOnMainThread(isolate_, job->second.get(),
                              ExceptionHandling::kSwallow);
     }
   }
   if (jobs_.size() > too_long_jobs) ScheduleIdleTaskIfNeeded();
 }
 
 }  // namespace internal
 }  // namespace v8