Add the --i-like-slow-isolate-spawn flag for those who like slow spawning.

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 "include/dart_native_api.h"
 #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/lockers.h"
 #include "vm/longjump.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/service.h"
 #include "vm/snapshot.h"
 #include "vm/symbols.h"
 #include "vm/unicode.h"
 
 namespace dart {
 
+DEFINE_FLAG(bool, i_like_slow_isolate_spawn, false,
+            "Block the parent thread when loading spawned isolates.");
+
 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);
 }
 
 
 DEFINE_NATIVE_ENTRY(CapabilityImpl_factory, 1) {
   ASSERT(TypeArguments::CheckedHandle(arguments->NativeArgAt(0)).IsNull());
   uint64_t id = isolate->random()->NextUInt64();
   return Capability::New(id);
@@ skipping 173 matching lines @@
       ctx = Closure::context(closure);
       ASSERT(ctx.num_variables() == 0);
 #endif
       // Get the parent function so that we get the right function name.
       func = func.parent_function();
 
       bool fatal_errors = fatalErrors.IsNull() ? true : fatalErrors.value();
       Dart_Port on_exit_port = onExit.IsNull() ? ILLEGAL_PORT : onExit.Id();
       Dart_Port on_error_port = onError.IsNull() ? ILLEGAL_PORT : onError.Id();
 
-      Dart::thread_pool()->Run(new SpawnIsolateTask(
-          new IsolateSpawnState(port.Id(),
-                                isolate->origin_id(),
-                                isolate->init_callback_data(),
-                                func,
-                                message,
-                                paused.value(),
-                                fatal_errors,
-                                on_exit_port,
-                                on_error_port)));
+      ThreadPool::Task* spawn_task =
+          new SpawnIsolateTask(
+              new IsolateSpawnState(port.Id(),
+                                    isolate->origin_id(),
+                                    isolate->init_callback_data(),
+                                    func,
+                                    message,
+                                    paused.value(),
+                                    fatal_errors,
+                                    on_exit_port,
+                                    on_error_port));
+      if (FLAG_i_like_slow_isolate_spawn) {
+        // We block the parent isolate while the child isolate loads.
+        Isolate* saved = Isolate::Current();

[siva, 2015/11/23 20:56:01]

I think
Isolate* saved = isolate;
should also work, isolate is a local variable here.

+        Thread::ExitIsolate();
+        spawn_task->Run();
+        delete spawn_task;
+        spawn_task = NULL;
+        Thread::EnterIsolate(saved);
+      } else {
+        Dart::thread_pool()->Run(spawn_task);
+      }
       return Object::null();
     }
   }
   const String& msg = String::Handle(String::New(
       "Isolate.spawn expects to be passed a static or top-level function"));
   Exceptions::ThrowArgumentError(msg);
   return Object::null();
 }
 
 
@@ skipping 92 matching lines @@
       utf8_package_map[i] = String2UTF8(String::Cast(entry));
     }
     // NULL terminated array.
     utf8_package_map[len] = NULL;
   }
 
   bool fatal_errors = fatalErrors.IsNull() ? true : fatalErrors.value();
   Dart_Port on_exit_port = onExit.IsNull() ? ILLEGAL_PORT : onExit.Id();
   Dart_Port on_error_port = onError.IsNull() ? ILLEGAL_PORT : onError.Id();
 
-  IsolateSpawnState* state = new IsolateSpawnState(
-      port.Id(),
-      isolate->init_callback_data(),
-      canonical_uri,
-      utf8_package_root,
-      const_cast<const char**>(utf8_package_map),
-      args,
-      message,
-      paused.value(),
-      fatal_errors,
-      on_exit_port,
-      on_error_port);
+  IsolateSpawnState* state =
+      new IsolateSpawnState(
+          port.Id(),
+          isolate->init_callback_data(),
+          canonical_uri,
+          utf8_package_root,
+          const_cast<const char**>(utf8_package_map),
+          args,
+          message,
+          paused.value(),
+          fatal_errors,
+          on_exit_port,
+          on_error_port);
+
   // If we were passed a value then override the default flags state for
   // checked mode.
   if (!checked.IsNull()) {
     state->isolate_flags()->set_checked(checked.value());
   }
 
-  Dart::thread_pool()->Run(new SpawnIsolateTask(state));
+  ThreadPool::Task* spawn_task = new SpawnIsolateTask(state);
+  if (FLAG_i_like_slow_isolate_spawn) {
+    // We block the parent isolate while the child isolate loads.
+    Isolate* saved = Isolate::Current();

[siva, 2015/11/23 20:56:01]

Ditto.

+    Thread::ExitIsolate();
+    spawn_task->Run();
+    delete spawn_task;
+    spawn_task = NULL;
+    Thread::EnterIsolate(saved);
+  } else {
+    Dart::thread_pool()->Run(spawn_task);
+  }
   return Object::null();
 }
 
 
 DEFINE_NATIVE_ENTRY(Isolate_getPortAndCapabilitiesOfCurrentIsolate, 0) {
   const Array& result = Array::Handle(Array::New(3));
   result.SetAt(0, SendPort::Handle(SendPort::New(isolate->main_port())));
   result.SetAt(1, Capability::Handle(
                       Capability::New(isolate->pause_capability())));
   result.SetAt(2, Capability::Handle(
@@ skipping 13 matching lines @@
   MessageWriter writer(&data, &allocator, false);
   writer.WriteMessage(msg);
 
   PortMap::PostMessage(new Message(port.Id(),
                                    data, writer.BytesWritten(),
                                    Message::kOOBPriority));
   return Object::null();
 }
 
 }  // namespace dart