Run Crankshaft on a separate thread.

src/isolate.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 23 matching lines @@
 #include "codegen.h"
 #include "compilation-cache.h"
 #include "debug.h"
 #include "deoptimizer.h"
 #include "heap-profiler.h"
 #include "hydrogen.h"
 #include "isolate.h"
 #include "lithium-allocator.h"
 #include "log.h"
 #include "messages.h"
+#include "optimizing-compiler-thread.h"
 #include "platform.h"
 #include "regexp-stack.h"
 #include "runtime-profiler.h"
 #include "scopeinfo.h"
 #include "serialize.h"
 #include "simulator.h"
 #include "spaces.h"
 #include "stub-cache.h"
 #include "version.h"
 #include "vm-state-inl.h"
@@ skipping 1491 matching lines @@
   SetIsolateThreadLocals(saved_isolate, saved_data);
 }
 
 
 void Isolate::Deinit() {
   if (state_ == INITIALIZED) {
     TRACE_ISOLATE(deinit);
 
     if (FLAG_hydrogen_stats) HStatistics::Instance()->Print();
 
+    if (FLAG_optimize_in_parallel) {
+      ASSERT(optimizing_compiler_thread_);
+      optimizing_compiler_thread_->StopThread();
+      delete optimizing_compiler_thread_;
+      optimizing_compiler_thread_ = NULL;
+    }
+
     // We must stop the logger before we tear down other components.
     logger_->EnsureTickerStopped();
 
     delete deoptimizer_data_;
     deoptimizer_data_ = NULL;
     if (FLAG_preemption) {
       v8::Locker locker;
       v8::Locker::StopPreemption();
     }
     builtins_.TearDown();
@@ skipping 20 matching lines @@
 }
 
 
 void Isolate::SetIsolateThreadLocals(Isolate* isolate,
                                      PerIsolateThreadData* data) {
   Thread::SetThreadLocal(isolate_key_, isolate);
   Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
 }
 
 
+void Isolate::queue_for_optimization(Handle<JSFunction> function) {
+  ASSERT(FLAG_optimize_in_parallel);
+  optimizing_compiler_thread_->QueueForOptimization(function);
+}
+
+
 Isolate::~Isolate() {
   TRACE_ISOLATE(destructor);
 
   // Has to be called while counters_ are still alive.
   zone_.DeleteKeptSegment();
 
   delete[] assembler_spare_buffer_;
   assembler_spare_buffer_ = NULL;
 
   delete unicode_cache_;
@@ skipping 252 matching lines @@
     LOG(this, LogCompiledFunctions());
   }
 
   CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, state_)),
            Internals::kIsolateStateOffset);
   CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, embedder_data_)),
            Internals::kIsolateEmbedderDataOffset);
   CHECK_EQ(static_cast<int>(OFFSET_OF(Isolate, heap_.roots_)),
            Internals::kIsolateRootsOffset);
 
+  if (FLAG_optimize_in_parallel) {
+    optimizing_compiler_thread_ = new OptimizingCompilerThread(this);
+    optimizing_compiler_thread_->Start();
+  }
+
   state_ = INITIALIZED;
   time_millis_at_init_ = OS::TimeCurrentMillis();
   return true;
 }
 
 
 // Initialized lazily to allow early
 // v8::V8::SetAddHistogramSampleFunction calls.
 StatsTable* Isolate::stats_table() {
   if (stats_table_ == NULL) {
@@ skipping 74 matching lines @@
 
 #ifdef DEBUG
 #define ISOLATE_FIELD_OFFSET(type, name, ignored)                       \
 const intptr_t Isolate::name##_debug_offset_ = OFFSET_OF(Isolate, name##_);
 ISOLATE_INIT_LIST(ISOLATE_FIELD_OFFSET)
 ISOLATE_INIT_ARRAY_LIST(ISOLATE_FIELD_OFFSET)
 #undef ISOLATE_FIELD_OFFSET
 #endif
 
 } }  // namespace v8::internal