Run Crankshaft on a separate thread.

src/api.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 18 matching lines @@
 
 #include <math.h>  // For isnan.
 #include <string.h>  // For memcpy, strlen.
 #include "../include/v8-debug.h"
 #include "../include/v8-profiler.h"
 #include "../include/v8-testing.h"
 #include "bootstrapper.h"
 #include "compiler.h"
 #include "conversions-inl.h"
 #include "counters.h"
+#include "crankshaft-thread.h"

[danno, 2012/05/22 10:32:19]

crankshaft -> optimizing_compiler

 #include "debug.h"
 #include "deoptimizer.h"
 #include "execution.h"
 #include "global-handles.h"
 #include "heap-profiler.h"
 #include "messages.h"
 #ifdef COMPRESS_STARTUP_DATA_BZ2
 #include "natives.h"
 #endif
 #include "parser.h"
@@ skipping 5321 matching lines @@
 
 
 Isolate* Isolate::New() {
   i::Isolate* isolate = new i::Isolate();
   return reinterpret_cast<Isolate*>(isolate);
 }
 
 
 void Isolate::Dispose() {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
+  bool to_lock = false;
+
+  if (i::FLAG_concurrent_crankshaft) {
+    // We need to acquire the Isolate lock before tearing it down
+    // since the crankshaft thread could be compiling a function in
+    // this isolate.
+    to_lock = !isolate->thread_manager()->IsLockedByCurrentThread();
+    if (to_lock)
+      isolate->thread_manager()->Lock();
+  }
+
   if (!ApiCheck(!isolate->IsInUse(),
                 "v8::Isolate::Dispose()",
                 "Disposing the isolate that is entered by a thread.")) {
     return;
   }
   isolate->TearDown();

[danno, 2012/05/22 10:32:19]

How do you ensure that the compiler thread properly terminates and cleans itself
up (i.e. doesn't do any further compilation) after the TearDown is complete?

[sanjoy, 2012/05/22 11:38:55]

V8::TearDown stops the compiler thread.

+  if (to_lock)
+    isolate->thread_manager()->Unlock();
 }
 
 
 void Isolate::Enter() {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(this);
   isolate->Enter();
 }
 
 
 void Isolate::Exit() {
@@ skipping 1015 matching lines @@
 
 
 char* HandleScopeImplementer::Iterate(ObjectVisitor* v, char* storage) {
   HandleScopeImplementer* scope_implementer =
       reinterpret_cast<HandleScopeImplementer*>(storage);
   scope_implementer->IterateThis(v);
   return storage + ArchiveSpacePerThread();
 }
 
 } }  // namespace v8::internal