Run Crankshaft on a separate thread.

src/v8threads.cc

 // Copyright 2008 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 85 matching lines @@
 
 bool Locker::IsActive() {
   return active_;
 }
 
 
 Locker::~Locker() {
   ASSERT(isolate_->thread_manager()->IsLockedByCurrentThread());
   if (has_lock_) {
     if (isolate_->IsDefaultIsolate()) {
-      isolate_->Exit();
+      isolate_->Exit(false);
     }
     if (top_level_) {
       isolate_->thread_manager()->FreeThreadResources();
     } else {
       isolate_->thread_manager()->ArchiveThread();
     }
     isolate_->thread_manager()->Unlock();
   }
 }
 
 
 Unlocker::Unlocker(v8::Isolate* isolate)
   : isolate_(reinterpret_cast<i::Isolate*>(isolate)) {
   if (isolate_ == NULL) {
     isolate_ = i::Isolate::GetDefaultIsolateForLocking();
   }
   ASSERT(isolate_->thread_manager()->IsLockedByCurrentThread());
   if (isolate_->IsDefaultIsolate()) {
-    isolate_->Exit();
+    // Small hack to make sure ArchiveThread does not see an unlocked
+    // view of the isolate.
+    isolate_->Exit(false);
   }
   isolate_->thread_manager()->ArchiveThread();
   isolate_->thread_manager()->Unlock();
 }
 
 
 Unlocker::~Unlocker() {
   ASSERT(!isolate_->thread_manager()->IsLockedByCurrentThread());
   isolate_->thread_manager()->Lock();
   isolate_->thread_manager()->RestoreThread();
@@ skipping 67 matching lines @@
     state->set_terminate_on_restore(false);
   }
   state->set_id(ThreadId::Invalid());
   state->Unlink();
   state->LinkInto(ThreadState::FREE_LIST);
   return true;
 }
 
 
 void ThreadManager::Lock() {
+  ASSERT(!IsLockedByCurrentThread());
   mutex_->Lock();
   mutex_owner_ = ThreadId::Current();
   ASSERT(IsLockedByCurrentThread());
 }
 
 
 void ThreadManager::Unlock() {
+  ASSERT(IsLockedByCurrentThread());
   mutex_owner_ = ThreadId::Invalid();
   mutex_->Unlock();
 }
 
 
 static int ArchiveSpacePerThread() {
   return HandleScopeImplementer::ArchiveSpacePerThread() +
                         Isolate::ArchiveSpacePerThread() +
 #ifdef ENABLE_DEBUGGER_SUPPORT
                           Debug::ArchiveSpacePerThread() +
@@ skipping 233 matching lines @@
 // Acknowledge the preemption by the receiving thread.
 void ContextSwitcher::PreemptionReceived() {
   ASSERT(Locker::IsLocked());
   // There is currently no accounting being done for this. But could be in the
   // future, which is why we leave this in.
 }
 
 
 }  // namespace internal
 }  // namespace v8