[complier] Enable parallel eager inner function compilation with 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"
+#include "src/compilation-info.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-job.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
 #include "src/flags.h"
 #include "src/objects-inl.h"
 
 namespace v8 {
 namespace internal {
 
 namespace {
 
@@ skipping 198 matching lines @@
     PrintF("CompilerDispatcher: dispatcher is disabled\n");
   }
 }
 
 CompilerDispatcher::~CompilerDispatcher() {
   // To avoid crashing in unit tests due to unfished jobs.
   AbortAll(BlockingBehavior::kBlock);
   task_manager_->CancelAndWait();
 }
 
-bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
+bool CompilerDispatcher::CanEnqueueJobs() {
   if (!IsEnabled()) return false;
 
   if (memory_pressure_level_.Value() != MemoryPressureLevel::kNone) {
     return false;
   }
 
   {
     base::LockGuard<base::Mutex> lock(&mutex_);
-    if (abort_) return false;
+    return !abort_;
   }
+}
+
+bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
+  if (!CanEnqueueJobs()) 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;

[marja, 2017/01/10 09:58:54]

Doesn't this break the "if enqueue fails, it must be a stack overflow" logic?
This can fail for the above reasons as well? Should this be a CHECK instead?

(But esp. the CanEnqueueJobs cannot be made a CHECK I guess, so that'll still
break the logic.)

[rmcilroy, 2017/01/12 12:31:55]

Yeah, this was part of the WIP stuff I hadn't quite worked out before our
discussion on Monday. I've changed the logic in compiler.cc now so that it tries
to enqueue the job, but if that fails, it will compile eagerly there and then.

   }
 
   if (IsEnqueued(function)) return true;
 
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: enqueuing ");
     function->ShortPrint();
-    PrintF("\n");
+    PrintF(" for parse and compile\n");
   }
 
   std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
       isolate_, tracer_.get(), function, max_stack_size_));
   std::pair<int, int> key(Script::cast(function->script())->id(),
                           function->function_literal_id());
   jobs_.insert(std::make_pair(key, std::move(job)));
   ScheduleIdleTaskIfNeeded();
   return true;
 }
 
+bool CompilerDispatcher::Enqueue(Zone* zone, ParseInfo* parse_info,
+                                 CompilationInfo* compile_info,
+                                 CompilationJob* compilation_job) {
+  if (!CanEnqueueJobs()) return false;
+
+  DCHECK(compile_info->has_shared_info());
+  Handle<SharedFunctionInfo> function = compile_info->shared_info();
+
+  if (IsEnqueued(function)) return true;
+
+  if (trace_compiler_dispatcher_) {
+    PrintF("CompilerDispatcher: enqueuing");
+    function->ShortPrint();
+    PrintF(" for compile\n");
+  }
+
+  CompilerDispatcherJob* job(new CompilerDispatcherJob(
+      isolate_, tracer_.get(), zone, parse_info, compile_info, compilation_job,
+      max_stack_size_));
+  std::pair<int, int> key(Script::cast(function->script())->id(),
+                          function->function_literal_id());
+  jobs_.insert(std::make_pair(key, job));
+  ConsiderJobForBackgroundProcessing(job);
+  ScheduleIdleTaskIfNeeded();
+  return true;
+}
+
 bool CompilerDispatcher::IsEnabled() const {
   v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
   return FLAG_compiler_dispatcher && platform_->IdleTasksEnabled(v8_isolate);
 }
 
 bool CompilerDispatcher::IsEnqueued(Handle<SharedFunctionInfo> function) const {
   return GetJobFor(function) != jobs_.end();
 }
 
 void CompilerDispatcher::WaitForJobIfRunningOnBackground(
     CompilerDispatcherJob* job) {
   base::LockGuard<base::Mutex> lock(&mutex_);
   if (running_background_jobs_.find(job) == running_background_jobs_.end()) {
     pending_background_jobs_.erase(job);
     return;
   }
   DCHECK_NULL(main_thread_blocking_on_job_);
   main_thread_blocking_on_job_ = job;
   while (main_thread_blocking_on_job_ != nullptr) {
     main_thread_blocking_signal_.Wait(&mutex_);
   }
   DCHECK(pending_background_jobs_.find(job) == pending_background_jobs_.end());
   DCHECK(running_background_jobs_.find(job) == running_background_jobs_.end());
 }
 
+bool CompilerDispatcher::FinishNow(CompilerDispatcherJob* job) {
+  WaitForJobIfRunningOnBackground(job);
+  while (!IsFinished(job)) {
+    DoNextStepOnMainThread(isolate_, job, ExceptionHandling::kThrow);
+  }
+  bool result = job->status() != CompileJobStatus::kFailed;
+  job->ResetOnMainThread();
+  return result;
+}
+
 bool CompilerDispatcher::FinishNow(Handle<SharedFunctionInfo> function) {
   JobMap::const_iterator job = GetJobFor(function);
   CHECK(job != jobs_.end());
 
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: finishing ");
     function->ShortPrint();
     PrintF(" now\n");
   }
 
-  WaitForJobIfRunningOnBackground(job->second.get());
-  while (!IsFinished(job->second.get())) {
-    DoNextStepOnMainThread(isolate_, job->second.get(),
-                           ExceptionHandling::kThrow);
-  }
-  bool result = job->second->status() != CompileJobStatus::kFailed;
+  bool result = FinishNow(job->second.get());
 
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: finished working on ");
     function->ShortPrint();
     PrintF(": %s\n", result ? "success" : "failure");
     tracer_->DumpStatistics();
   }
 
-  job->second->ResetOnMainThread();
   jobs_.erase(job);
   if (jobs_.empty()) {
     base::LockGuard<base::Mutex> lock(&mutex_);
     abort_ = false;
   }
   return result;
 }
 
+void CompilerDispatcher::FinishAllNow() {
+  if (trace_compiler_dispatcher_) {
+    PrintF("CompilerDispatcher: finishing all jobs now\n");
+  }
+
+  for (auto& it : jobs_) {
+    FinishNow(it.second.get());
+  }
+
+  if (trace_compiler_dispatcher_) {
+    PrintF("CompilerDispatcher: finished all jobs\n");
+  }
+
+  jobs_.clear();
+  {
+    base::LockGuard<base::Mutex> lock(&mutex_);
+    DCHECK(pending_background_jobs_.empty());
+    DCHECK(running_background_jobs_.empty());
+    abort_ = false;
+  }
+}
+
 void CompilerDispatcher::AbortAll(BlockingBehavior blocking) {
   bool background_tasks_running =
       task_manager_->TryAbortAll() == CancelableTaskManager::kTaskRunning;
   if (!background_tasks_running || blocking == BlockingBehavior::kBlock) {
     for (auto& it : jobs_) {
       WaitForJobIfRunningOnBackground(it.second.get());
       if (trace_compiler_dispatcher_) {
         PrintF("CompilerDispatcher: aborted ");
         it.second->ShortPrint();
         PrintF("\n");
       }
       it.second->ResetOnMainThread();
     }
     jobs_.clear();
     {
       base::LockGuard<base::Mutex> lock(&mutex_);
       DCHECK(pending_background_jobs_.empty());
       DCHECK(running_background_jobs_.empty());
       abort_ = false;
     }
-    return;

[marja, 2017/01/10 09:58:54]

Why?

[rmcilroy, 2017/01/12 12:31:55]

Opps not sure how that happened - that explains the failing tests... Added back.

   }
 
   {
     base::LockGuard<base::Mutex> lock(&mutex_);
     abort_ = true;
     pending_background_jobs_.clear();
   }
   AbortInactiveJobs();
 
   // All running background jobs might already have scheduled idle tasks instead
@@ skipping 253 matching lines @@
       lock.reset();
       DoNextStepOnMainThread(isolate_, job->second.get(),
                              ExceptionHandling::kSwallow);
     }
   }
   if (jobs_.size() > too_long_jobs) ScheduleIdleTaskIfNeeded();
 }
 
 }  // namespace internal
 }  // namespace v8