Revert of [complier] Enable parallel eager inner function compilation with compiler dispatcher.

src/compiler-dispatcher/compiler-dispatcher-job.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-job.h"
 
 #include "src/assert-scope.h"
 #include "src/compilation-info.h"
 #include "src/compiler-dispatcher/compiler-dispatcher-tracer.h"
 #include "src/compiler.h"
@@ skipping 48 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(TwoByteWrapper);
 };
 
 }  // namespace
 
 CompilerDispatcherJob::CompilerDispatcherJob(Isolate* isolate,
                                              CompilerDispatcherTracer* tracer,
                                              Handle<SharedFunctionInfo> shared,
                                              size_t max_stack_size)
-    : status_(CompileJobStatus::kInitial),
-      isolate_(isolate),
+    : isolate_(isolate),
       tracer_(tracer),
       shared_(Handle<SharedFunctionInfo>::cast(
           isolate_->global_handles()->Create(*shared))),
       max_stack_size_(max_stack_size),
       trace_compiler_dispatcher_jobs_(FLAG_trace_compiler_dispatcher_jobs) {
   HandleScope scope(isolate_);
   DCHECK(!shared_->outer_scope_info()->IsTheHole(isolate_));
   Handle<Script> script(Script::cast(shared_->script()), isolate_);
   Handle<String> source(String::cast(script->source()), isolate_);
   if (trace_compiler_dispatcher_jobs_) {
     PrintF("CompilerDispatcherJob[%p] created for ", static_cast<void*>(this));
     shared_->ShortPrint();
-    PrintF(" in initial state.\n");
+    PrintF("\n");
   }
 }
 
-CompilerDispatcherJob::CompilerDispatcherJob(Isolate* isolate,
-                                             CompilerDispatcherTracer* tracer,
-                                             Handle<SharedFunctionInfo> shared,
-                                             FunctionLiteral* literal,
-                                             size_t max_stack_size)
-    : status_(CompileJobStatus::kAnalyzed),
-      isolate_(isolate),
-      tracer_(tracer),
-      shared_(Handle<SharedFunctionInfo>::cast(
-          isolate_->global_handles()->Create(*shared))),
-      max_stack_size_(max_stack_size),
-      zone_(new Zone(isolate->allocator(), ZONE_NAME)),
-      parse_info_(new ParseInfo(
-          zone_.get(), Handle<Script>(Script::cast(shared->script())))),
-      compile_info_(
-          new CompilationInfo(parse_info_.get(), Handle<JSFunction>::null())),
-      trace_compiler_dispatcher_jobs_(FLAG_trace_compiler_dispatcher_jobs) {
-  parse_info_->set_literal(literal);
-  parse_info_->set_shared_info(shared);
-  parse_info_->set_function_literal_id(shared->function_literal_id());
-  parse_info_->set_language_mode(literal->scope()->language_mode());
-  if (trace_compiler_dispatcher_jobs_) {
-    PrintF("CompilerDispatcherJob[%p] created for ", static_cast<void*>(this));
-    shared_->ShortPrint();
-    PrintF(" in Analyzed state.\n");
-  }
-}
-
 CompilerDispatcherJob::~CompilerDispatcherJob() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   DCHECK(status_ == CompileJobStatus::kInitial ||
          status_ == CompileJobStatus::kDone);
   i::GlobalHandles::Destroy(Handle<Object>::cast(shared_).location());
 }
 
 bool CompilerDispatcherJob::IsAssociatedWith(
     Handle<SharedFunctionInfo> shared) const {
   return *shared_ == *shared;
@@ skipping 149 matching lines @@
     source_ = Handle<String>::null();
   }
   if (!wrapper_.is_null()) {
     i::GlobalHandles::Destroy(Handle<Object>::cast(wrapper_).location());
     wrapper_ = Handle<String>::null();
   }
 
   if (parse_info_->literal() == nullptr) {
     status_ = CompileJobStatus::kFailed;
   } else {
-    status_ = CompileJobStatus::kReadyToAnalyze;
+    status_ = CompileJobStatus::kReadyToAnalyse;
   }
 
   DeferredHandleScope scope(isolate_);
   {
     Handle<Script> script(Script::cast(shared_->script()), isolate_);
 
     parse_info_->set_script(script);
     Handle<ScopeInfo> outer_scope_info(
         handle(ScopeInfo::cast(shared_->outer_scope_info())));
     if (outer_scope_info->length() > 0) {
@@ skipping 10 matching lines @@
     parse_info_->set_unicode_cache(nullptr);
     parser_.reset();
     unicode_cache_.reset();
     character_stream_.reset();
   }
   handles_from_parsing_.reset(scope.Detach());
 
   return status_ != CompileJobStatus::kFailed;
 }
 
-bool CompilerDispatcherJob::AnalyzeOnMainThread() {
+bool CompilerDispatcherJob::PrepareToCompileOnMainThread() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
-  DCHECK(status() == CompileJobStatus::kReadyToAnalyze);
-  COMPILER_DISPATCHER_TRACE_SCOPE(tracer_, kAnalyze);
+  DCHECK(status() == CompileJobStatus::kReadyToAnalyse);
+  COMPILER_DISPATCHER_TRACE_SCOPE(tracer_, kPrepareToCompile);
   if (trace_compiler_dispatcher_jobs_) {
-    PrintF("CompilerDispatcherJob[%p]: Analyzing\n", static_cast<void*>(this));
+    PrintF("CompilerDispatcherJob[%p]: Preparing to compile\n",
+           static_cast<void*>(this));
   }
 
   compile_info_.reset(
       new CompilationInfo(parse_info_.get(), Handle<JSFunction>::null()));
 
   DeferredHandleScope scope(isolate_);
-  {
-    if (Compiler::Analyze(parse_info_.get())) {
-      status_ = CompileJobStatus::kAnalyzed;
-    } else {
-      status_ = CompileJobStatus::kFailed;
-      if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
-    }
+  if (Compiler::Analyze(parse_info_.get())) {
+    compile_job_.reset(
+        Compiler::PrepareUnoptimizedCompilationJob(compile_info_.get()));
   }
   compile_info_->set_deferred_handles(scope.Detach());
 
-  return status_ != CompileJobStatus::kFailed;
-}
-
-bool CompilerDispatcherJob::PrepareToCompileOnMainThread() {
-  DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
-  DCHECK(status() == CompileJobStatus::kAnalyzed);
-  COMPILER_DISPATCHER_TRACE_SCOPE(tracer_, kPrepareToCompile);
-
-  compile_job_.reset(
-      Compiler::PrepareUnoptimizedCompilationJob(compile_info_.get()));
   if (!compile_job_.get()) {
     if (!isolate_->has_pending_exception()) isolate_->StackOverflow();
     status_ = CompileJobStatus::kFailed;
     return false;
   }
 
   CHECK(compile_job_->can_execute_on_background_thread());
   status_ = CompileJobStatus::kReadyToCompile;
   return true;
 }
@@ skipping 79 matching lines @@
     case CompileJobStatus::kInitial:
       return tracer_->EstimatePrepareToParseInMs();
 
     case CompileJobStatus::kReadyToParse:
       return tracer_->EstimateParseInMs(parse_info_->end_position() -
                                         parse_info_->start_position());
 
     case CompileJobStatus::kParsed:
       return tracer_->EstimateFinalizeParsingInMs();
 
-    case CompileJobStatus::kReadyToAnalyze:
-      return tracer_->EstimateAnalyzeInMs();
-
-    case CompileJobStatus::kAnalyzed:
+    case CompileJobStatus::kReadyToAnalyse:
       return tracer_->EstimatePrepareToCompileInMs();
 
     case CompileJobStatus::kReadyToCompile:
       return tracer_->EstimateCompileInMs(
           parse_info_->literal()->ast_node_count());
 
     case CompileJobStatus::kCompiled:
       return tracer_->EstimateFinalizeCompilingInMs();
 
     case CompileJobStatus::kFailed:
     case CompileJobStatus::kDone:
       return 0.0;
   }
 
   UNREACHABLE();
   return 0.0;
 }
 
 void CompilerDispatcherJob::ShortPrint() {
   DCHECK(ThreadId::Current().Equals(isolate_->thread_id()));
   shared_->ShortPrint();
 }
 
 }  // namespace internal
 }  // namespace v8