Revert of [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 {
 
 enum class ExceptionHandling { kSwallow, kThrow };
 
 bool DoNextStepOnMainThread(Isolate* isolate, CompilerDispatcherJob* job,
                             ExceptionHandling exception_handling) {
   DCHECK(ThreadId::Current().Equals(isolate->thread_id()));
   switch (job->status()) {
     case CompileJobStatus::kInitial:
       job->PrepareToParseOnMainThread();
       break;
 
     case CompileJobStatus::kReadyToParse:
       job->Parse();
       break;
 
     case CompileJobStatus::kParsed:
       job->FinalizeParsingOnMainThread();
       break;
 
-    case CompileJobStatus::kReadyToAnalyze:
-      job->AnalyzeOnMainThread();
-      break;
-
-    case CompileJobStatus::kAnalyzed:
+    case CompileJobStatus::kReadyToAnalyse:
       job->PrepareToCompileOnMainThread();
       break;
 
     case CompileJobStatus::kReadyToCompile:
       job->Compile();
       break;
 
     case CompileJobStatus::kCompiled:
       job->FinalizeCompilingOnMainThread();
       break;
@@ skipping 167 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::CanEnqueue(Handle<SharedFunctionInfo> function) {
+bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
   if (!IsEnabled()) return false;
 
   DCHECK(FLAG_ignition);
 
   if (memory_pressure_level_.Value() != MemoryPressureLevel::kNone) {
     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_toplevel() ||
       function->asm_function() || function->native()) {
     return false;
   }
 
-  return true;
-}
-
-bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function) {
-  if (!CanEnqueue(function)) return false;
   if (IsEnqueued(function)) return true;
 
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: enqueuing ");
     function->ShortPrint();
-    PrintF(" for parse and compile\n");
+    PrintF("\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::EnqueueAndStep(Handle<SharedFunctionInfo> function) {
   if (!Enqueue(function)) return false;
 
   if (trace_compiler_dispatcher_) {
     PrintF("CompilerDispatcher: stepping ");
     function->ShortPrint();
     PrintF("\n");
   }
   JobMap::const_iterator job = GetJobFor(function);
   DoNextStepOnMainThread(isolate_, job->second.get(),
                          ExceptionHandling::kSwallow);
   ConsiderJobForBackgroundProcessing(job->second.get());
   return true;
 }
 
-bool CompilerDispatcher::Enqueue(Handle<SharedFunctionInfo> function,
-                                 FunctionLiteral* literal) {
-  if (!CanEnqueue(function)) return false;
-  if (IsEnqueued(function)) return true;
-
-  if (trace_compiler_dispatcher_) {
-    PrintF("CompilerDispatcher: enqueuing ");
-    function->ShortPrint();
-    PrintF(" for compile\n");
-  }
-
-  std::unique_ptr<CompilerDispatcherJob> job(new CompilerDispatcherJob(
-      isolate_, tracer_.get(), function, literal, 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::IsEnabled() const {
+  v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate_);
+  return FLAG_compiler_dispatcher && platform_->IdleTasksEnabled(v8_isolate);
 }
 
-bool CompilerDispatcher::EnqueueAndStep(Handle<SharedFunctionInfo> function,
-                                        FunctionLiteral* literal) {
-  if (!Enqueue(function, literal)) return false;
-
-  if (trace_compiler_dispatcher_) {
-    PrintF("CompilerDispatcher: stepping ");
-    function->ShortPrint();
-    PrintF("\n");
-  }
-  JobMap::const_iterator job = GetJobFor(function);
-  DoNextStepOnMainThread(isolate_, job->second.get(),
-                         ExceptionHandling::kSwallow);
-  ConsiderJobForBackgroundProcessing(job->second.get());
-  return true;
-}
-
-bool CompilerDispatcher::IsEnabled() const { return FLAG_compiler_dispatcher; }
-
 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");
   }
 
-  bool result = FinishNow(job->second.get());
+  WaitForJobIfRunningOnBackground(job->second.get());
+  while (!IsFinished(job->second.get())) {
+    DoNextStepOnMainThread(isolate_, job->second.get(),
+                           ExceptionHandling::kThrow);
+  }
+  bool result = job->second->status() != CompileJobStatus::kFailed;
 
   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;
-}
-
-bool CompilerDispatcher::FinishAllNow() {
-  if (trace_compiler_dispatcher_) {
-    PrintF("CompilerDispatcher: finishing all jobs now\n");
-  }
-
-  bool result = true;
-  for (auto& it : jobs_) {
-    result &= 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;
-  }
-  return result;
 }
 
 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 ");
@@ skipping 276 matching lines @@
       lock.reset();
       DoNextStepOnMainThread(isolate_, job->second.get(),
                              ExceptionHandling::kSwallow);
     }
   }
   if (jobs_.size() > too_long_jobs) ScheduleIdleTaskIfNeeded();
 }
 
 }  // namespace internal
 }  // namespace v8