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 1455 matching lines @@
       inner_pointer_to_code_cache_(NULL),
       write_input_buffer_(NULL),
       global_handles_(NULL),
       context_switcher_(NULL),
       thread_manager_(NULL),
       fp_stubs_generated_(false),
       has_installed_extensions_(false),
       string_tracker_(NULL),
       regexp_stack_(NULL),
       date_cache_(NULL),
-      context_exit_happened_(false) {
+      context_exit_happened_(false),
+      to_delete_(false) {
   TRACE_ISOLATE(constructor);
 
   memset(isolate_addresses_, 0,
       sizeof(isolate_addresses_[0]) * (kIsolateAddressCount + 1));
 
   heap_.isolate_ = this;
   zone_.isolate_ = this;
   stack_guard_.isolate_ = this;
 
   // ThreadManager is initialized early to support locking an isolate
@@ skipping 28 matching lines @@
 #undef ISOLATE_INIT_EXECUTE
 
 #define ISOLATE_INIT_ARRAY_EXECUTE(type, name, length)                         \
   memset(name##_, 0, sizeof(type) * length);
   ISOLATE_INIT_ARRAY_LIST(ISOLATE_INIT_ARRAY_EXECUTE)
 #undef ISOLATE_INIT_ARRAY_EXECUTE
 }
 
 void Isolate::TearDown() {
   TRACE_ISOLATE(tear_down);
+  ASSERT(!FLAG_concurrent_crankshaft ||
+         thread_manager()->IsLockedByCurrentThread());
 
   // Temporarily set this isolate as current so that various parts of
   // the isolate can access it in their destructors without having a
   // direct pointer. We don't use Enter/Exit here to avoid
   // initializing the thread data.
   PerIsolateThreadData* saved_data = CurrentPerIsolateThreadData();
   Isolate* saved_isolate = UncheckedCurrent();
   SetIsolateThreadLocals(this, NULL);
 
   Deinit();
 
   { ScopedLock lock(process_wide_mutex_);
     thread_data_table_->RemoveAllThreads(this);
   }
 
-  if (!IsDefaultIsolate()) {
+  if (!IsDefaultIsolate() && !FLAG_concurrent_crankshaft) {
     delete this;
   }
 
+  if (FLAG_concurrent_crankshaft)
+    to_delete_ = true;
+
   // Restore the previous current isolate.
   SetIsolateThreadLocals(saved_isolate, saved_data);
 }
 
 
 void Isolate::Deinit() {
   if (state_ == INITIALIZED) {
     TRACE_ISOLATE(deinit);
 
     if (FLAG_hydrogen_stats) HStatistics::Instance()->Print();
@@ skipping 34 matching lines @@
 void Isolate::SetIsolateThreadLocals(Isolate* isolate,
                                      PerIsolateThreadData* data) {
   Thread::SetThreadLocal(isolate_key_, isolate);
   Thread::SetThreadLocal(per_isolate_thread_data_key_, data);
 }
 
 
 Isolate::~Isolate() {
   TRACE_ISOLATE(destructor);
 
+  ASSERT(!FLAG_concurrent_crankshaft || to_delete());
+
   // Has to be called while counters_ are still alive.
   zone_.DeleteKeptSegment();
 
   delete[] assembler_spare_buffer_;
   assembler_spare_buffer_ = NULL;
 
   delete unicode_cache_;
   unicode_cache_ = NULL;
 
   delete date_cache_;
@@ skipping 266 matching lines @@
 // v8::V8::SetAddHistogramSampleFunction calls.
 StatsTable* Isolate::stats_table() {
   if (stats_table_ == NULL) {
     stats_table_ = new StatsTable;
   }
   return stats_table_;
 }
 
 
 void Isolate::Enter() {
+  if (FLAG_concurrent_crankshaft) {
+    bool to_lock = !thread_manager()->IsLockedByCurrentThread();
+    if (to_lock)
+      thread_manager()->Lock();
+    lock_history_.Add(to_lock);
+  }
+
   Isolate* current_isolate = NULL;
   PerIsolateThreadData* current_data = CurrentPerIsolateThreadData();
   if (current_data != NULL) {
     current_isolate = current_data->isolate_;
     ASSERT(current_isolate != NULL);
     if (current_isolate == this) {
       ASSERT(Current() == this);
       ASSERT(entry_stack_ != NULL);
       ASSERT(entry_stack_->previous_thread_data == NULL ||
              entry_stack_->previous_thread_data->thread_id().Equals(
@@ skipping 23 matching lines @@
                                             entry_stack_);
   entry_stack_ = item;
 
   SetIsolateThreadLocals(this, data);
 
   // In case it's the first time some thread enters the isolate.
   set_thread_id(data->thread_id());
 }
 
 
-void Isolate::Exit() {
+void Isolate::Exit(bool auto_unlock) {
   ASSERT(entry_stack_ != NULL);
   ASSERT(entry_stack_->previous_thread_data == NULL ||
          entry_stack_->previous_thread_data->thread_id().Equals(
              ThreadId::Current()));
 
   if (--entry_stack_->entry_count > 0) return;
 
   ASSERT(CurrentPerIsolateThreadData() != NULL);
   ASSERT(CurrentPerIsolateThreadData()->isolate_ == this);
 
   // Pop the stack.
   EntryStackItem* item = entry_stack_;
   entry_stack_ = item->previous_item;
 
   PerIsolateThreadData* previous_thread_data = item->previous_thread_data;
   Isolate* previous_isolate = item->previous_isolate;
 
   delete item;
 
+  if (FLAG_concurrent_crankshaft) {
+    if (lock_history_.RemoveLast() && auto_unlock)
+      thread_manager()->Unlock();
+  }
+
   // Reinit the current thread for the isolate it was running before this one.
   SetIsolateThreadLocals(previous_isolate, previous_thread_data);
 }
 
 
 #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