Use the ThreadPool for all isolates and native ports. Previously,

runtime/lib/isolate.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "platform/assert.h"
 #include "vm/bootstrap_natives.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/exceptions.h"
 #include "vm/longjump.h"
-#include "vm/message.h"
+#include "vm/message_handler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/port.h"
 #include "vm/resolver.h"
 #include "vm/snapshot.h"
 #include "vm/thread.h"
 
 namespace dart {
 
 class IsolateStartData {
  public:
-  IsolateStartData(Isolate* isolate,
-                   char* library_url,
+  IsolateStartData(char* library_url,
                    char* class_name,
                    intptr_t port_id)
-      : isolate_(isolate),
-        library_url_(library_url),
+      : library_url_(library_url),
         class_name_(class_name),
         port_id_(port_id) {}
 
-  Isolate* isolate_;
   char* library_url_;
   char* class_name_;
   intptr_t port_id_;
 };
 
 
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 static uint8_t* SerializeObject(const Instance& obj) {
   uint8_t* result = NULL;
   SnapshotWriter writer(Snapshot::kMessage, &result, &allocator);
   writer.WriteObject(obj.raw());
   writer.FinalizeBuffer();
   return result;
 }
 
 
-// TODO(turnidge): Taking down the whole vm when an isolate fails is
-// bad.  Change this.
-static void ProcessError(const Object& obj) {
+static void StoreError(Isolate* isolate, const Object& obj) {
   ASSERT(obj.IsError());
   Error& error = Error::Handle();
   error ^= obj.raw();
-  OS::PrintErr("%s\n", error.ToErrorCString());
-  exit(255);
+  isolate->object_store()->set_sticky_error(error);
 }
 
 
 static void ThrowErrorException(Exceptions::ExceptionType type,
                                 const char* error_msg,
                                 const char* library_url,
                                 const char* class_name) {
   String& str = String::Handle();
   String& name = String::Handle();
   str ^= String::New(error_msg);
@@ skipping 32 matching lines @@
   arguments.Add(&Integer::Handle(Integer::New(port_id)));
   const Object& result = Object::Handle(
       DartEntry::InvokeStatic(function, arguments, kNoArgumentNames));
   if (!result.IsError()) {
     PortMap::SetLive(port_id);
   }
   return result.raw();
 }
 
 
-static void RunIsolate(uword parameter) {
-  IsolateStartData* data = reinterpret_cast<IsolateStartData*>(parameter);
-  Isolate* isolate = data->isolate_;
+static bool RunIsolate(uword parameter) {
+  Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
+  IsolateStartData* data =
+      reinterpret_cast<IsolateStartData*>(isolate->spawn_data());
+  isolate->set_spawn_data(NULL);
   char* library_url = data->library_url_;
   char* class_name = data->class_name_;
   intptr_t port_id = data->port_id_;

[siva, 2012/04/18 22:05:00]

When is data deleted in the new scheme?

[turnidge, 2012/04/19 19:46:55]

That was missing.  Added.

-  delete data;
 
-  Isolate::SetCurrent(isolate);
-  // Intialize stack limit in case we are running isolate in a
-  // different thread than in which it was initialized.
-  isolate->SetStackLimitFromCurrentTOS(reinterpret_cast<uword>(&isolate));
-  LongJump* base = isolate->long_jump_base();
-  LongJump jump;
-  isolate->set_long_jump_base(&jump);
-  if (setjmp(*jump.Set()) == 0) {
+  {
+    StartIsolateScope start_scope(isolate);
     Zone zone(isolate);
     HandleScope handle_scope(isolate);
     ASSERT(ClassFinalizer::FinalizePendingClasses());
     // Lookup the target class by name, create an instance and call the run
     // method.
     const String& lib_name = String::Handle(String::NewSymbol(library_url));
+    free(library_url);
     const Library& lib = Library::Handle(Library::LookupLibrary(lib_name));
     ASSERT(!lib.IsNull());
     const String& cls_name = String::Handle(String::NewSymbol(class_name));
+    free(class_name);
     const Class& target_class = Class::Handle(lib.LookupClass(cls_name));
     // TODO(iposva): Deserialize or call the constructor after allocating.
     // For now, we only support a non-parameterized or raw target class.
     const Instance& target = Instance::Handle(Instance::New(target_class));
     Object& result = Object::Handle();
 
     // Invoke the default constructor.
     const String& period = String::Handle(String::New("."));
     String& constructor_name = String::Handle(String::Concat(cls_name, period));
     const Function& default_constructor =
         Function::Handle(target_class.LookupConstructor(constructor_name));
     if (!default_constructor.IsNull()) {
       GrowableArray<const Object*> arguments(1);
       arguments.Add(&target);
       arguments.Add(&Smi::Handle(Smi::New(Function::kCtorPhaseAll)));
       const Array& kNoArgumentNames = Array::Handle();
       result = DartEntry::InvokeStatic(default_constructor,
                                        arguments,
                                        kNoArgumentNames);
       if (result.IsError()) {
-        ProcessError(result);
+        StoreError(isolate, result);
+        return false;
       }
       ASSERT(result.IsNull());
     }
 
     // Invoke the "_run" method.
     const Function& target_function = Function::Handle(Resolver::ResolveDynamic(
         target, String::Handle(String::NewSymbol("_run")), 2, 0));
     // TODO(iposva): Proper error checking here.
     ASSERT(!target_function.IsNull());
     // TODO(iposva): Allocate the proper port number here.
     const Object& local_port = Object::Handle(ReceivePortCreate(port_id));
     if (local_port.IsError()) {
-      ProcessError(local_port);
+      StoreError(isolate, local_port);
+      return false;
     }
     GrowableArray<const Object*> arguments(1);
     arguments.Add(&local_port);
     const Array& kNoArgumentNames = Array::Handle();
     result = DartEntry::InvokeDynamic(target,
                                       target_function,
                                       arguments,
                                       kNoArgumentNames);
     if (result.IsError()) {
-      ProcessError(result);
+      StoreError(isolate, result);
+      return false;
     }
     ASSERT(result.IsNull());
-    free(class_name);
-    free(library_url);
-    result = isolate->StandardRunLoop();
-    if (result.IsError()) {
-      ProcessError(result);
-    }
-    ASSERT(result.IsNull());
+  }
+  return true;
+}
 
-  } else {
+
+static void ShutdownIsolate(uword parameter) {
+  Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
+  SwitchIsolateScope switch_scope(isolate);
+  {
     Zone zone(isolate);
     HandleScope handle_scope(isolate);
-    const Error& error = Error::Handle(
-        Isolate::Current()->object_store()->sticky_error());
-    const char* errmsg = error.ToErrorCString();
-    OS::PrintErr("%s\n", errmsg);
-    exit(255);
+    Error& error = Error::Handle();
+    error = isolate->object_store()->sticky_error();
+    if (!error.IsNull()) {
+      OS::PrintErr("%s\n", error.ToErrorCString());
+      exit(255);
+    }
   }
-  isolate->set_long_jump_base(base);
   Dart::ShutdownIsolate();
 }
 
 
 static bool CheckArguments(const char* library_url, const char* class_name) {
   Isolate* isolate = Isolate::Current();
   Zone zone(isolate);
   HandleScope handle_scope(isolate);
   String& name = String::Handle();
   if (!ClassFinalizer::FinalizePendingClasses()) {
@@ skipping 70 matching lines @@
   const char* isolate_name = BuildIsolateName(library_url, class_name, "main");
   if (callback == NULL) {
     error = strdup("Null callback specified for isolate creation\n");
   } else if (callback(isolate_name, callback_data, &error)) {
     spawned_isolate = Isolate::Current();
     ASSERT(spawned_isolate != NULL);
     // Check arguments to see if the specified library and classes are
     // loaded, this check will throw an exception if they are not loaded.
     if (init_successful && CheckArguments(library_url, class_name)) {
       port_id = spawned_isolate->main_port();
-      uword data = reinterpret_cast<uword>(
-          new IsolateStartData(spawned_isolate,
-                               strdup(library_url),
-                               strdup(class_name),
-                               port_id));
-      int result = Thread::Start(RunIsolate, data);
-      if (result != 0) {
-        FATAL1("Failed to start isolate thread %d", result);
-      }
+      spawned_isolate->set_spawn_data(
+          reinterpret_cast<uword>(
+              new IsolateStartData(strdup(library_url),
+                                   strdup(class_name),
+                                   port_id)));
+      Isolate::SetCurrent(NULL);
+      spawned_isolate->message_handler()->Run(
+          Dart::thread_pool(), RunIsolate, ShutdownIsolate,
+          reinterpret_cast<uword>(spawned_isolate));
     } else {
       // Error spawning the isolate, maybe due to initialization errors or
       // errors while loading the application into spawned isolate, shut
       // it down and report error.
       // Make sure to grab the error message out of the isolate before it has
       // been shutdown and to allocate it in the preserved isolates zone.
       {
         Zone zone(spawned_isolate);
         HandleScope scope(spawned_isolate);
         const Error& err_obj = Error::Handle(
@@ skipping 104 matching lines @@
         String::Handle(String::NewSymbol(function_name()));
 
     const Library& lib = Library::Handle(Library::LookupLibrary(lib_url));
     if (lib.IsNull() || lib.IsError()) {
       return Function::null();
     }
     return lib.LookupLocalFunction(func_name);
   }
 
   void Cleanup() {
-    Isolate* saved = Isolate::Current();
-    Isolate::SetCurrent(isolate());
+    SwitchIsolateScope switch_scope(isolate());
     Dart::ShutdownIsolate();
-    Isolate::SetCurrent(saved);
   }
 
  private:
   Isolate* isolate_;
   char* library_url_;
   char* function_name_;
 };
 
 
 static bool CreateIsolate(SpawnState* state, char** error) {
@@ skipping 30 matching lines @@
     }
   }
   if (!retval) {
     Dart::ShutdownIsolate();
   }
   Isolate::SetCurrent(parent_isolate);
   return retval;
 }
 
 
-static void RunIsolate2(uword parameter) {
-  SpawnState* state = reinterpret_cast<SpawnState*>(parameter);
-  Isolate* isolate = state->isolate();
-
-  Isolate::SetCurrent(isolate);
-  // Intialize stack limit in case we are running isolate in a
-  // different thread than in which it was initialized.
-  isolate->SetStackLimitFromCurrentTOS(reinterpret_cast<uword>(&isolate));
-
+static bool RunIsolate2(uword parameter) {
+  Isolate* isolate = reinterpret_cast<Isolate*>(parameter);
+  SpawnState* state = reinterpret_cast<SpawnState*>(isolate->spawn_data());
+  isolate->set_spawn_data(NULL);
   {
+    StartIsolateScope start_scope(isolate);
     Zone zone(isolate);
     HandleScope handle_scope(isolate);
     ASSERT(ClassFinalizer::FinalizePendingClasses());
     Object& result = Object::Handle();
 
     const Function& func = Function::Handle(state->ResolveFunction());
     delete state;
     state = NULL;
     ASSERT(!func.IsNull());
 
     GrowableArray<const Object*> args(0);
     const Array& kNoArgNames = Array::Handle();
     result = DartEntry::InvokeStatic(func, args, kNoArgNames);
     if (result.IsError()) {
-      ProcessError(result);
+      StoreError(isolate, result);
+      return false;
     }
-
-    result = isolate->StandardRunLoop();
-    if (result.IsError()) {
-      ProcessError(result);
-    }
-    ASSERT(result.IsNull());
   }
-  Dart::ShutdownIsolate();
+  return true;
 }
 
 
 DEFINE_NATIVE_ENTRY(isolate_spawnFunction, 1) {
   GET_NATIVE_ARGUMENT(Closure, closure, arguments->At(0));
   const Function& func = Function::Handle(closure.function());
   const Class& cls = Class::Handle(func.owner());
   if (!func.IsClosureFunction() || !func.is_static() || !cls.IsTopLevel()) {
     const String& msg = String::Handle(String::New(
         "spawnFunction expects to be passed a closure to a top-level static "
@@ skipping 18 matching lines @@
   // Try to create a SendPort for the new isolate.
   const Object& port = Object::Handle(
       DartLibraryCalls::NewSendPort(state->isolate()->main_port()));
   if (port.IsError()) {
     state->Cleanup();
     delete state;
     Exceptions::PropagateError(port);
   }
 
   // Start the new isolate.
-  int result = Thread::Start(RunIsolate2, reinterpret_cast<uword>(state));
-  if (result != 0) {
-    const String& msg = String::Handle(String::NewFormatted(
-        "Failed to start thread for isolate '%s'.  Error code '%d'.",
-        state->isolate()->name(), result));
-    state->Cleanup();
-    delete state;
-    ThrowIsolateSpawnException(msg);
-  }
+  state->isolate()->set_spawn_data(reinterpret_cast<uword>(state));
+  state->isolate()->message_handler()->Run(
+      Dart::thread_pool(), RunIsolate2, ShutdownIsolate,
+      reinterpret_cast<uword>(state->isolate()));
 
   arguments->SetReturn(port);
 }
 
 
 DEFINE_NATIVE_ENTRY(isolate_getPortInternal, 0) {
   const Object& port = Object::Handle(ReceivePortCreate(isolate->main_port()));
   if (port.IsError()) {
     Exceptions::PropagateError(port);
   }
   arguments->SetReturn(port);
 }
 
 }  // namespace dart