[turbofan] Enable concurrent (re)compilation.

src/compiler.cc

 // Copyright 2012 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.h"
 
 #include <algorithm>
 
 #include "src/ast-numbering.h"
 #include "src/bootstrapper.h"
@@ skipping 313 matching lines @@
 
 #define DEF_VISIT(type)                        \
   void Visit##type(type* node) override {      \
     HOptimizedGraphBuilder::Visit##type(node); \
   }
   DECLARATION_NODE_LIST(DEF_VISIT)
 #undef DEF_VISIT
 };
 
 
+OptimizedCompileJob::~OptimizedCompileJob() { delete pipeline_; }
+
+
 OptimizedCompileJob::Status OptimizedCompileJob::CreateGraph() {
   DCHECK(info()->IsOptimizing());
   DCHECK(!info()->IsCompilingForDebugging());
 
   // Do not use Crankshaft/TurboFan if we need to be able to set break points.
   if (isolate()->debug()->has_break_points()) {
     return RetryOptimization(kDebuggerHasBreakPoints);
   }
 
   // Limit the number of times we try to optimize functions.
@@ skipping 49 matching lines @@
     } else if (FLAG_turbo_type_feedback) {
       info()->MarkAsTypeFeedbackEnabled();
       info()->EnsureFeedbackVector();
     }
     if (!info()->shared_info()->asm_function() ||
         FLAG_turbo_asm_deoptimization) {
       info()->MarkAsDeoptimizationEnabled();
     }
 
     Timer t(this, &time_taken_to_create_graph_);
-    compiler::Pipeline pipeline(info());
-    pipeline.GenerateCode();
-    if (!info()->code().is_null()) {
+    pipeline_ = new compiler::Pipeline(info());
+    if (pipeline_->CreateGraph()) {
       return SetLastStatus(SUCCEEDED);
     }
+    delete pipeline_;
+    pipeline_ = nullptr;
   }
 
   if (!isolate()->use_crankshaft() || dont_crankshaft) {
     // Crankshaft is entirely disabled.
     return SetLastStatus(FAILED);
   }
 
   Scope* scope = info()->scope();
   if (LUnallocated::TooManyParameters(scope->num_parameters())) {
     // Crankshaft would require too many Lithium operands.
@@ skipping 57 matching lines @@
 }
 
 
 OptimizedCompileJob::Status OptimizedCompileJob::OptimizeGraph() {
   DisallowHeapAllocation no_allocation;
   DisallowHandleAllocation no_handles;
   DisallowHandleDereference no_deref;
   DisallowCodeDependencyChange no_dependency_change;
 
   DCHECK(last_status() == SUCCEEDED);
-  // TODO(turbofan): Currently everything is done in the first phase.
-  if (!info()->code().is_null()) {
-    return last_status();
+  Timer t(this, &time_taken_to_optimize_);
+  if (pipeline_) {
+    if (pipeline_->OptimizeGraph()) return SetLastStatus(SUCCEEDED);
+    return SetLastStatus(BAILED_OUT);
   }
-
-  Timer t(this, &time_taken_to_optimize_);
   DCHECK(graph_ != NULL);
   BailoutReason bailout_reason = kNoReason;
 
   if (graph_->Optimize(&bailout_reason)) {
     chunk_ = LChunk::NewChunk(graph_);
     if (chunk_ != NULL) return SetLastStatus(SUCCEEDED);
   } else if (bailout_reason != kNoReason) {
     graph_builder_->Bailout(bailout_reason);
   }
 
   return SetLastStatus(BAILED_OUT);
 }
 
 
 OptimizedCompileJob::Status OptimizedCompileJob::GenerateCode() {
   DCHECK(last_status() == SUCCEEDED);
-  // TODO(turbofan): Currently everything is done in the first phase.
-  if (!info()->code().is_null()) {
-    info()->dependencies()->Commit(info()->code());
-    if (info()->is_deoptimization_enabled()) {
-      info()->parse_info()->context()->native_context()->AddOptimizedCode(
-          *info()->code());
-    }
-    RecordOptimizationStats();
-    return last_status();
-  }
-
   DCHECK(!info()->dependencies()->HasAborted());
   DisallowCodeDependencyChange no_dependency_change;
   DisallowJavascriptExecution no_js(isolate());
   {  // Scope for timer.
     Timer timer(this, &time_taken_to_codegen_);
+    if (pipeline_) {
+      Handle<Code> optimized_code = pipeline_->CreateCode();
+      if (optimized_code.is_null()) return SetLastStatus(BAILED_OUT);
+      DCHECK(optimized_code.is_identical_to(info()->code()));
+      info()->dependencies()->Commit(info()->code());
+      if (info()->is_deoptimization_enabled()) {
+        info()->parse_info()->context()->native_context()->AddOptimizedCode(
+            *info()->code());
+      }
+      RecordOptimizationStats();
+      return SetLastStatus(SUCCEEDED);
+    }
     DCHECK(chunk_ != NULL);
     DCHECK(graph_ != NULL);
     // Deferred handles reference objects that were accessible during
     // graph creation.  To make sure that we don't encounter inconsistencies
     // between graph creation and code generation, we disallow accessing
     // objects through deferred handles during the latter, with exceptions.
     DisallowDeferredHandleDereference no_deferred_handle_deref;
     Handle<Code> optimized_code = chunk_->Codegen();
     if (optimized_code.is_null()) {
       if (info()->bailout_reason() == kNoReason) {
@@ skipping 973 matching lines @@
       RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, info.get(), shared);
       if (info->shared_info()->SearchOptimizedCodeMap(
               info->context()->native_context(), info->osr_ast_id()) == -1) {
         InsertCodeIntoOptimizedCodeMap(info.get());
       }
       if (FLAG_trace_opt) {
         PrintF("[completed optimizing ");
         info->closure()->ShortPrint();
         PrintF("]\n");
       }
+      // TODO(bmeurer): Improve resource management for OptimizedCompileJob.
+      job->~OptimizedCompileJob();
       return Handle<Code>(*info->code());
     }
   }
 
   DCHECK(job->last_status() != OptimizedCompileJob::SUCCEEDED);
   if (FLAG_trace_opt) {
     PrintF("[aborted optimizing ");
     info->closure()->ShortPrint();
     PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));
   }
+  // TODO(bmeurer): Improve resource management for OptimizedCompileJob.
+  job->~OptimizedCompileJob();
   return Handle<Code>::null();
 }
 
 
 bool Compiler::DebuggerWantsEagerCompilation(Isolate* isolate,
                                              bool allow_lazy_without_ctx) {
   if (LiveEditFunctionTracker::IsActive(isolate)) return true;
   Debug* debug = isolate->debug();
   bool debugging = debug->is_active() || debug->has_break_points();
   return debugging && !allow_lazy_without_ctx;
@@ skipping 32 matching lines @@
 
 
 #if DEBUG
 void CompilationInfo::PrintAstForTesting() {
   PrintF("--- Source from AST ---\n%s\n",
          PrettyPrinter(isolate(), zone()).PrintProgram(function()));
 }
 #endif
 }  // namespace internal
 }  // namespace v8