Add d8 API for spawning function on a new thread.

src/d8.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 
 // Defined when linking against shared lib on Windows.
 #if defined(USING_V8_SHARED) && !defined(V8_SHARED)
 #define V8_SHARED
 #endif
 
@@ skipping 127 matching lines @@
 
  private:
   friend class Shell;
   friend class RealmScope;
   Isolate* isolate_;
   int realm_count_;
   int realm_current_;
   int realm_switch_;
   Persistent<Context>* realms_;
   Persistent<Value> realm_shared_;
+  ArrayBuffer::Allocator* array_buffer_allocator_;
 
   int RealmIndexOrThrow(const v8::FunctionCallbackInfo<v8::Value>& args,
                         int arg_offset);
   int RealmFind(Handle<Context> context);
 };
 
 
 LineEditor *LineEditor::current_ = NULL;
 
 
@@ skipping 26 matching lines @@
 
 #ifndef V8_SHARED
 CounterMap* Shell::counter_map_;
 base::OS::MemoryMappedFile* Shell::counters_file_ = NULL;
 CounterCollection Shell::local_counters_;
 CounterCollection* Shell::counters_ = &local_counters_;
 base::Mutex Shell::context_mutex_;
 const base::TimeTicks Shell::kInitialTicks =
     base::TimeTicks::HighResolutionNow();
 Persistent<Context> Shell::utility_context_;
+Worker Shell::worker_;
+i::List<v8::SharedArrayBuffer::Contents> Shell::externalized_shared_contents_;
 #endif  // !V8_SHARED
 
 Persistent<Context> Shell::evaluation_context_;
 ShellOptions Shell::options;
 const char* Shell::kPrompt = "d8> ";
 
 #ifndef V8_SHARED
 bool CounterMap::Match(void* key1, void* key2) {
   const char* name1 = reinterpret_cast<const char*>(key1);
   const char* name2 = reinterpret_cast<const char*>(key2);
@@ skipping 450 matching lines @@
                        String::NewFromUtf8(args.GetIsolate(), *file),
                        false,
                        true)) {
       Throw(args.GetIsolate(), "Error executing file");
       return;
     }
   }
 }
 
 
+#ifndef V8_SHARED
+void Shell::WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  HandleScope handle_scope(isolate);
+  if (args.Length() < 1 || !args[0]->IsFunction()) {
+    Throw(args.GetIsolate(), "1st argument must be function");
+    return;
+  }
+  if (args.Length() >= 2 && !args[1]->IsSharedArrayBuffer()) {
+    Throw(args.GetIsolate(), "2nd argument must be SharedArrayBuffer");
+    return;
+  }
+
+  String::Utf8Value function_string(args[0]->ToString());
+  v8::SharedArrayBuffer::Contents contents;
+  if (args.Length() >= 2) {
+    Handle<SharedArrayBuffer> sab = Handle<SharedArrayBuffer>::Cast(args[1]);
+    contents = sab->Externalize();
+    externalized_shared_contents_.Add(contents);
+  }
+  worker_.StartExecuteInThread(isolate, *function_string, contents);
+}
+
+
+void Shell::WorkerJoin(const v8::FunctionCallbackInfo<v8::Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  HandleScope handle_scope(isolate);
+  Handle<Value> result = worker_.WaitForThread(isolate);
+  args.GetReturnValue().Set(result);
+}
+#endif  // !V8_SHARED
+
+
 void Shell::Quit(const v8::FunctionCallbackInfo<v8::Value>& args) {
   int exit_code = args[0]->Int32Value();
   OnExit(args.GetIsolate());
   exit(exit_code);
 }
 
 
 void Shell::Version(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(
       String::NewFromUtf8(args.GetIsolate(), V8::GetVersion()));
@@ skipping 311 matching lines @@
   realm_template->SetAccessor(String::NewFromUtf8(isolate, "shared"),
                               RealmSharedGet, RealmSharedSet);
   global_template->Set(String::NewFromUtf8(isolate, "Realm"), realm_template);
 
 #ifndef V8_SHARED
   Handle<ObjectTemplate> performance_template = ObjectTemplate::New(isolate);
   performance_template->Set(String::NewFromUtf8(isolate, "now"),
                             FunctionTemplate::New(isolate, PerformanceNow));
   global_template->Set(String::NewFromUtf8(isolate, "performance"),
                        performance_template);
+
+  Handle<ObjectTemplate> worker_template = ObjectTemplate::New(isolate);
+  worker_template->Set(String::NewFromUtf8(isolate, "new"),
+                       FunctionTemplate::New(isolate, WorkerNew));
+  worker_template->Set(String::NewFromUtf8(isolate, "join"),
+                       FunctionTemplate::New(isolate, WorkerJoin));
+  global_template->Set(String::NewFromUtf8(isolate, "Worker"), worker_template);
 #endif  // !V8_SHARED
 
   Handle<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
   AddOSMethods(isolate, os_templ);
   global_template->Set(String::NewFromUtf8(isolate, "os"), os_templ);
 
   return global_template;
 }
 
 
@@ skipping 357 matching lines @@
 
 
 void SourceGroup::WaitForThread() {
   if (thread_ == NULL) return;
   if (Shell::options.last_run) {
     thread_->Join();
   } else {
     done_semaphore_.Wait();
   }
 }
+
+
+Worker::Worker() : thread_(NULL), script_(NULL), result_json_(NULL) {}
+
+
+Worker::~Worker() { Cleanup(); }
+
+
+void Worker::StartExecuteInThread(
+    Isolate* isolate, const char* function_string,
+    const v8::SharedArrayBuffer::Contents& contents) {
+  if (thread_) {
+    Throw(isolate, "Only one worker allowed");
+    return;
+  }
+
+  static const char format[] = "JSON.stringify((%s).call(this, sab));";

[binji, 2015/06/15 19:11:48]

Better way to do this?

+  size_t len = strlen(function_string) + sizeof(format);
+
+  script_ = new char[len + 1];
+  snprintf(script_, len, format, function_string);
+  script_[len] = 0;
+
+  contents_ = contents;
+
+  thread_ = new WorkerThread(this);
+  thread_->Start();
+}
+
+
+Handle<Value> Worker::WaitForThread(Isolate* isolate) {
+  EscapableHandleScope handle_scope(isolate);
+  Handle<Value> result;
+
+  if (thread_ == NULL) return result;
+  thread_->Join();
+
+  if (result_json_) {
+    Local<String> result_json = String::NewFromUtf8(isolate, result_json_);
+    MaybeLocal<Value> maybe_result = JSON::Parse(isolate, result_json);
+    if (!maybe_result.IsEmpty()) {
+      result = maybe_result.ToLocalChecked();
+    }
+  }
+
+  Cleanup();
+  return handle_scope.Escape(Local<Value>::Cast(result));
+}
+
+
+void Worker::ExecuteInThread() {

[binji, 2015/06/15 19:11:48]

A lot of this function is copy/paste from other places in the file. Is it worth
trying to refactor?

+  ShellArrayBufferAllocator allocator;
+  Isolate::CreateParams create_params;
+  create_params.array_buffer_allocator = &allocator;
+  Isolate* isolate = Isolate::New(create_params);
+  {
+    Isolate::Scope iscope(isolate);
+    {
+      HandleScope scope(isolate);
+      PerIsolateData data(isolate);
+      Local<Context> context = Shell::CreateEvaluationContext(isolate);
+      {
+        Context::Scope cscope(context);
+        PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));
+
+        Handle<String> sab_name = String::NewFromUtf8(isolate, "sab");
+        if (contents_.Data()) {
+          Handle<v8::SharedArrayBuffer> sab = v8::SharedArrayBuffer::New(
+              isolate, contents_.Data(), contents_.ByteLength());
+          context->Global()->Set(sab_name, sab);
+        } else {
+          context->Global()->Set(sab_name, v8::Undefined(isolate));
+        }
+
+        Handle<String> file_name = String::NewFromUtf8(isolate, "unnamed");
+        Handle<String> source = String::NewFromUtf8(isolate, script_);
+
+        TryCatch try_catch(isolate);
+        Handle<Script> script =
+            Shell::CompileString(isolate, source, file_name,
+                                 Shell::options.compile_options, Shell::SCRIPT);
+        result_json_ = NULL;
+        if (script.IsEmpty()) {
+          // Print errors that happened during compilation.
+          // TODO(binji): support debugger?
+          Shell::ReportException(isolate, &try_catch);
+        } else {
+          Handle<Value> result = script->Run();
+          if (result->IsString()) {
+            Handle<String> str_result = Handle<String>::Cast(result);
+            v8::String::Utf8Value str(str_result);
+            result_json_ = new char[str.length() + 1];
+            memcpy(result_json_, *str, str.length() + 1);
+          }
+        }
+      }
+    }
+  }
+  Shell::CollectGarbage(isolate);
+  isolate->Dispose();
+}
+
+
+void Worker::Cleanup() {
+  delete thread_;
+  thread_ = NULL;
+  delete[] script_;
+  script_ = NULL;
+  delete[] result_json_;
+  result_json_ = NULL;
+}
 #endif  // !V8_SHARED
 
 
 void SetFlagsFromString(const char* flags) {
   v8::V8::SetFlagsFromString(flags, static_cast<int>(strlen(flags)));
 }
 
 
 bool Shell::SetOptions(int argc, char* argv[]) {
   bool logfile_per_isolate = false;
@@ skipping 154 matching lines @@
       Context::Scope cscope(context);
       PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));
       options.isolate_sources[0].Execute(isolate);
     }
   }
   CollectGarbage(isolate);
 #ifndef V8_SHARED
   for (int i = 1; i < options.num_isolates; ++i) {
     options.isolate_sources[i].WaitForThread();
   }
+  CleanupWorker(isolate);
 #endif  // !V8_SHARED
   return 0;
 }
 
 
 void Shell::CollectGarbage(Isolate* isolate) {
   if (options.send_idle_notification) {
     const double kLongIdlePauseInSeconds = 1.0;
     isolate->ContextDisposedNotification();
     isolate->IdleNotificationDeadline(
         g_platform->MonotonicallyIncreasingTime() + kLongIdlePauseInSeconds);
   }
   if (options.invoke_weak_callbacks) {
     // By sending a low memory notifications, we will try hard to collect all
     // garbage and will therefore also invoke all weak callbacks of actually
     // unreachable persistent handles.
     isolate->LowMemoryNotification();
   }
 }
 
 
 #ifndef V8_SHARED
+void Shell::CleanupWorker(Isolate* isolate) {
+  {
+    HandleScope scope(isolate);
+    worker_.WaitForThread(isolate);
+  }
+  PerIsolateData* data = PerIsolateData::Get(isolate);
+
+  for (int i = 0; i < externalized_shared_contents_.length(); ++i) {
+    const v8::SharedArrayBuffer::Contents& contents =
+        externalized_shared_contents_[i];
+    data->array_buffer_allocator_->Free(contents.Data(), contents.ByteLength());
+  }
+  externalized_shared_contents_.Clear();
+}
+
+
 static void DumpHeapConstants(i::Isolate* isolate) {
   i::Heap* heap = isolate->heap();
 
   // Dump the INSTANCE_TYPES table to the console.
   printf("# List of known V8 instance types.\n");
 #define DUMP_TYPE(T) printf("  %d: \"%s\",\n", i::T, #T);
   printf("INSTANCE_TYPES = {\n");
   INSTANCE_TYPE_LIST(DUMP_TYPE)
   printf("}\n");
 #undef DUMP_TYPE
@@ skipping 99 matching lines @@
     create_params.create_histogram_callback = CreateHistogram;
     create_params.add_histogram_sample_callback = AddHistogramSample;
   }
 #endif
   Isolate* isolate = Isolate::New(create_params);
   DumbLineEditor dumb_line_editor(isolate);
   {
     Isolate::Scope scope(isolate);
     Initialize(isolate);
     PerIsolateData data(isolate);
+    data.array_buffer_allocator_ = create_params.array_buffer_allocator;
     InitializeDebugger(isolate);
 
 #ifndef V8_SHARED
     if (options.dump_heap_constants) {
       DumpHeapConstants(reinterpret_cast<i::Isolate*>(isolate));
       return 0;
     }
 #endif
 
     if (options.stress_opt || options.stress_deopt) {
@@ skipping 58 matching lines @@
 }
 
 }  // namespace v8
 
 
 #ifndef GOOGLE3
 int main(int argc, char* argv[]) {
   return v8::Shell::Main(argc, argv);
 }
 #endif