[turbofan] Enable concurrent (re)compilation.

Refactor the TurboFan pipeline to allow for concurrent recompilation in
the same way that Crankshaft does it. For now we limit the concurrent
phases to scheduling, instruction selection, register allocation and
jump threading.

R=mstarzinger@chromium.org, ahaas@chromium.org, jarin@chromium.org

Review URL: https://codereview.chromium.org/1179393008

Cr-Commit-Position: refs/heads/master@{#35818}

src/compiler.cc

@@ -706,9 +706,9 @@ bool GetOptimizedCodeNow(CompilationInfo* info) {
   TRACE_EVENT0("v8", "V8.OptimizeCode");
 
   bool use_turbofan = UseTurboFan(info);
-  OptimizedCompileJob* job = use_turbofan
-                                 ? compiler::Pipeline::NewCompilationJob(info)
-                                 : new (info->zone()) HCompilationJob(info);
+  base::SmartPointer<OptimizedCompileJob> job(
+      use_turbofan ? compiler::Pipeline::NewCompilationJob(info)
+                   : new HCompilationJob(info));
 
   // Parsing is not required when optimizing from existing bytecode.
   if (!use_turbofan || !info->shared_info()->HasBytecodeArray()) {
@@ -755,9 +755,9 @@ bool GetOptimizedCodeLater(CompilationInfo* info) {
   }
 
   bool use_turbofan = UseTurboFan(info);
-  OptimizedCompileJob* job = use_turbofan
-                                 ? compiler::Pipeline::NewCompilationJob(info)
-                                 : new (info->zone()) HCompilationJob(info);
+  base::SmartPointer<OptimizedCompileJob> job(
+      use_turbofan ? compiler::Pipeline::NewCompilationJob(info)
+                   : new HCompilationJob(info));
 
   // All handles below this point will be allocated in a deferred handle scope
   // that is detached and handed off to the background thread when we return.
@@ -778,7 +778,8 @@ bool GetOptimizedCodeLater(CompilationInfo* info) {
   TRACE_EVENT0("v8", "V8.RecompileSynchronous");
 
   if (job->CreateGraph() != OptimizedCompileJob::SUCCEEDED) return false;
-  isolate->optimizing_compile_dispatcher()->QueueForOptimization(job);
+  isolate->optimizing_compile_dispatcher()->QueueForOptimization(job.get());
+  job.Detach();  // The background recompile job owns this now.
 
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Queued ");
@@ -1725,7 +1726,7 @@ MaybeHandle<Code> Compiler::GetOptimizedCodeForOSR(Handle<JSFunction> function,
 
 void Compiler::FinalizeOptimizedCompileJob(OptimizedCompileJob* job) {
   // Take ownership of compilation info.  Deleting compilation info
-  // also tears down the zone and the recompile job.
+  // also tears down the zone.
   base::SmartPointer<CompilationInfo> info(job->info());
   Isolate* isolate = info->isolate();
 
@@ -1761,6 +1762,7 @@ void Compiler::FinalizeOptimizedCompileJob(OptimizedCompileJob* job) {
         PrintF("]\n");
       }
       info->closure()->ReplaceCode(*info->code());
+      delete job;
       return;
     }
   }
@@ -1772,6 +1774,7 @@ void Compiler::FinalizeOptimizedCompileJob(OptimizedCompileJob* job) {
     PrintF(" because: %s]\n", GetBailoutReason(info->bailout_reason()));
   }
   info->closure()->ReplaceCode(shared->code());
+  delete job;
 }
 
 void Compiler::PostInstantiation(Handle<JSFunction> function,

src/compiler.h

@@ -571,7 +571,8 @@ class CompilationInfo {
 // Each of the three phases can either fail, bail-out to full code generator or
 // succeed. Apart from their return value, the status of the phase last run can
 // be checked using {last_status()} as well.
-class OptimizedCompileJob: public ZoneObject {
+// TODO(mstarzinger): Make CompilationInfo base embedded.
+class OptimizedCompileJob {
  public:
   explicit OptimizedCompileJob(CompilationInfo* info, const char* compiler_name)
       : info_(info), compiler_name_(compiler_name), last_status_(SUCCEEDED) {}

src/compiler/ia32/instruction-selector-ia32.cc

@@ -60,11 +60,16 @@ class IA32OperandGenerator final : public OperandGenerator {
       case IrOpcode::kRelocatableInt64Constant:
         return true;
       case IrOpcode::kHeapConstant: {
+// TODO(bmeurer): We must not dereference handles concurrently. If we
+// really have to this here, then we need to find a way to put this
+// information on the HeapConstant node already.
+#if 0
         // Constants in new space cannot be used as immediates in V8 because
         // the GC does not scan code objects when collecting the new generation.
         Handle<HeapObject> value = OpParameter<Handle<HeapObject>>(node);
         Isolate* isolate = value->GetIsolate();
         return !isolate->heap()->InNewSpace(*value);
+#endif
       }
       default:
         return false;

src/compiler/pipeline-statistics.h

@@ -7,6 +7,8 @@
 
 #include <string>
 
+#include "src/base/platform/elapsed-timer.h"
+#include "src/base/smart-pointers.h"
 #include "src/compilation-statistics.h"
 #include "src/compiler/zone-pool.h"
 
@@ -22,6 +24,7 @@ class PipelineStatistics : public Malloced {
   ~PipelineStatistics();
 
   void BeginPhaseKind(const char* phase_kind_name);
+  void EndPhaseKind();
 
  private:
   size_t OuterZoneSize() {
@@ -43,7 +46,6 @@ class PipelineStatistics : public Malloced {
   };
 
   bool InPhaseKind() { return !phase_kind_stats_.scope_.is_empty(); }
-  void EndPhaseKind();
 
   friend class PhaseScope;
   bool InPhase() { return !phase_stats_.scope_.is_empty(); }