mini_racer 0.1.4 → 0.1.5.pre.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0508a6995a631050ed4470222e522e2794322f2a
-  data.tar.gz: a42ed52c3df8490ce8e3a5766ecb5389dc813971
+  metadata.gz: e83c651e071c15dd06c626097c2e865b4dbf9fe0
+  data.tar.gz: 9e39ecff4b86fcd9176bcf198fafa7ca99afcf9e
 SHA512:
-  metadata.gz: 963c946ed997001fb18d8f81e2da1a0a17c9554588b693a129a88a830631c5bf8c7a0a222944443ec97efe393d72f6981da0d938c24e1d0a5454a780c5b7d646
-  data.tar.gz: 26aa65a782780c47bb3e3683ca196e4cd26f2bd03fdf6ceca1862bb8d22f2bdf2477845b5ff096cf28cdb1713fddb35b7a3cbbc1703947772b3dca397bee5852
+  metadata.gz: 4c2ad4fb2d10c44ff6018d02d86ae4631b71a6ec95106c6d70329418b6a9f9e0d5b48fba472b5a455c33dca25ed876d57355a867e5b295adcd1716b8645abc68
+  data.tar.gz: cca28fca48a330ce45713f59e485301456a2f2e332bec7fbcfc8d539244e6762a8a9210c75cacb5484a200216d37188673f549ab5735775d26e4c39855e60a99

data/.travis.yml

@@ -8,7 +8,7 @@ matrix:
   include:
     - rvm: 2.2
       os: osx
-      osx_image: xcode7.3
+      osx_image: xcode8
 dist: trusty
 sudo: true
 before_install:

data/CHANGELOG

@@ -1,3 +1,10 @@
+10-10-2017
+
+- 0.1.5
+
+  - Support for snapshots, shared isolates, runtime flags thanks to @wk8
+  - Fix timeout behavior when it occurs in an attached Ruby method
+
 19-05-2016
 
 - 0.1.4

data/README.md

@@ -8,7 +8,7 @@ MiniRacer provides a minimal two way bridge between the V8 JavaScript engine and
 
 It was created as an alternative to the excellent [therubyracer](https://github.com/cowboyd/therubyracer). Unlike therubyracer, mini_racer only implements a minimal bridge. This reduces the surface area making upgrading v8 much simpler and exhaustive testing simpler.
 
-MiniRacer has an adapter for [execjs](https://github.com/sstephenson/execjs) so it can be used directly with Rails projects to minify assets, run babel or compile CoffeeScript.
+MiniRacer has an adapter for [execjs](https://github.com/rails/execjs) so it can be used directly with Rails projects to minify assets, run babel or compile CoffeeScript.
 
 ## Features
 
@@ -88,6 +88,144 @@ puts context.eval("counter")
 
 ```
 
+### Snapshots
+
+Contexts can be created with pre-loaded snapshots:
+
+```ruby
+
+snapshot = MiniRacer::Snapshot.new('function hello() { return "world!"; }')
+
+context = MiniRacer::Context.new(snapshot: snapshot)
+
+context.eval("hello()")
+# => "world!"
+
+```
+
+Snapshots can come in handy for example if you want your contexts to be pre-loaded for effiency. It uses [V8 snapshots](http://v8project.blogspot.com/2015/09/custom-startup-snapshots.html) under the hood; see [this link](http://v8project.blogspot.com/2015/09/custom-startup-snapshots.html) for caveats using these, in particular:
+
+```
+There is an important limitation to snapshots: they can only capture V8’s
+heap. Any interaction from V8 with the outside is off-limits when creating the
+snapshot. Such interactions include:
+
+ * defining and calling API callbacks (i.e. functions created via v8::FunctionTemplate)
+ * creating typed arrays, since the backing store may be allocated outside of V8
+
+And of course, values derived from sources such as `Math.random` or `Date.now`
+are fixed once the snapshot has been captured. They are no longer really random
+nor reflect the current time.
+```
+
+Also note that snapshots can be warmed up, using the `warmup!` method, which allows you to call functions which are otherwise lazily compiled to get them to compile right away; any side effect of your warm up code being then dismissed. [More details on warming up here](https://github.com/electron/electron/issues/169#issuecomment-76783481), and a small example:
+
+```ruby
+
+snapshot = MiniRacer::Snapshot.new('var counter = 0; function hello() { counter++; return "world! "; }')
+
+snapshot.warmup!('hello()')
+
+context = MiniRacer::Context.new(snapshot: snapshot)
+
+context.eval('hello()')
+# => "world! 1"
+context.eval('counter')
+# => 1
+
+```
+
+### Shared isolates
+
+By default, MiniRacer's contexts each have their own isolate (V8 runtime). For efficiency, it is possible to re-use an isolate across contexts:
+
+```ruby
+
+isolate = MiniRacer::Isolate.new
+
+context1 = MiniRacer::Context.new(isolate: isolate)
+context2 = MiniRacer::Context.new(isolate: isolate)
+
+context1.isolate == context2.isolate
+# => true
+```
+
+The main benefit of this is avoiding creating/destroying isolates when not needed (for example if you use a lot of contexts).
+
+The caveat with this is that a given isolate can only execute one context at a time, so don't share isolates across contexts that you want to run concurrently.
+
+Also, note that if you want to use shared isolates together with snapshots, you need to first create an isolate with that snapshot, and then create contexts from that isolate:
+
+```ruby
+snapshot = MiniRacer::Snapshot.new('function hello() { return "world!"; }')
+
+isolate = MiniRacer::Isolate.new(snapshot)
+
+context = MiniRacer::Context.new(isolate: isolate)
+
+context.eval("hello()")
+# => "world!"
+```
+
+Re-using the same isolate over and over again means V8's garbage collector will have to run to clean it up every now and then; it's possible to trigger a _blocking_ V8 GC run inside your isolate by running the `idle_notification` method on it, which takes a single argument: the amount of time (in milliseconds) that V8 should use at most for garbage collecting:
+
+```ruby
+isolate = MiniRacer::Isolate.new
+
+context = MiniRacer::Context.new(isolate: isolate)
+
+# do stuff with that context...
+
+# give up to 100ms for V8 garbage collection
+isolate.idle_notification(100)
+
+```
+
+This can come in handy to force V8 GC runs for example in between requests if you use MiniRacer on a web application.
+
+Note that this method maps directly to [`v8::Isolate::IdleNotification`](http://bespin.cz/~ondras/html/classv8_1_1Isolate.html#aea16cbb2e351de9a3ae7be2b7cb48297), and that in particular its return value is the same (true if there is no further garbage to collect, false otherwise) and the same caveats apply, in particular that `there is no guarantee that the [call will return] within the time limit.`
+
+### V8 Runtime flags
+
+It is possible to set V8 Runtime flags:
+
+```ruby
+MiniRacer::Platform.set_flags! :noconcurrent_recompilation, max_inlining_levels: 10
+```
+
+This can come in handy if you want to use MiniRacer with Unicorn, which doesn't seem to alwatys appreciate V8's liberal use of threading:
+```ruby
+MiniRacer::Platform.set_flags! :noconcurrent_recompilation, :noconcurrent_sweeping
+```
+
+Or else to unlock experimental features in V8, for example tail recursion optimization:
+```ruby
+MiniRacer::Platform.set_flags! :harmony
+
+js = <<-JS
+'use strict';
+var f = function f(n){
+  if (n <= 0) {
+    return  'foo';
+  }
+  return f(n - 1);
+}
+
+f(1e6);
+JS
+
+context = MiniRacer::Context.new
+
+context.eval js
+# => "foo"
+```
+The same code without the harmony runtime flag results in a `MiniRacer::RuntimeError: RangeError: Maximum call stack size exceeded` exception.
+Please refer to http://node.green/ as a reference on other harmony features.
+
+A list of all V8 runtime flags can be found using `node --v8-options`, or else by perusing [the V8 source code for flags (make sure to use the right version of V8)](https://github.com/v8/v8/blob/master/src/flag-definitions.h).
+
+Note that runtime flags must be set before any other operation (e.g. creating a context, a snapshot or an isolate), otherwise an exception will be thrown.
+
 ## Performance
 
 The `bench` folder contains benchmark.

data/ext/mini_racer_extension/extconf.rb

@@ -17,6 +17,28 @@ if ENV['CXX']
   CONFIG['CXX'] = ENV['CXX']
 end
 
+CXX11_TEST = <<EOS
+#if __cplusplus <= 199711L
+#   error A compiler that supports at least C++11 is required in order to compile this project.
+#endif
+EOS
+
+`echo "#{CXX11_TEST}" | #{CONFIG['CXX']} -std=c++0x -x c++ -E -`
+unless $?.success?
+  warn <<EOS
+
+
+WARNING: C++11 support is required for compiling mini_racer. Please make sure
+you are using a compiler that supports at least C++11. Examples of such
+compilers are GCC 4.7+ and Clang 3.2+.
+
+If you are using Travis, consider either migrating your bulid to Ubuntu Trusty or
+installing GCC 4.8. See mini_racer's README.md for more information.
+
+
+EOS
+end
+
 CONFIG['LDSHARED'] = '$(CXX) -shared' unless RUBY_PLATFORM =~ /darwin/
 if CONFIG['warnflags']
   CONFIG['warnflags'].gsub!('-Wdeclaration-after-statement', '')

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -1,11 +1,12 @@
 #include <stdio.h>
 #include <ruby.h>
 #include <ruby/thread.h>
-#include <include/v8.h>
-#include <include/libplatform/libplatform.h>
+#include <v8.h>
+#include <libplatform/libplatform.h>
 #include <ruby/encoding.h>
 #include <pthread.h>
 #include <unistd.h>
+#include <mutex>
 
 using namespace v8;
 
@@ -19,11 +20,28 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
   virtual void Free(void* data, size_t) { free(data); }
 };
 
+typedef struct {
+    const char* data;
+    int raw_size;
+} SnapshotInfo;
+
 typedef struct {
     Isolate* isolate;
-    Persistent<Context>* context;
     ArrayBufferAllocator* allocator;
+    StartupData* startup_data;
     bool interrupted;
+
+    // how many references to this isolate exist
+    // we can't rely on Ruby's GC for this, because when destroying
+    // objects, Ruby will destroy ruby objects first, then call the
+    // extenstion's deallocators. In this case, that means it would
+    // call `deallocate_isolate` _before_ `deallocate`, causing a segfault
+    int refs_count;
+} IsolateInfo;
+
+typedef struct {
+    IsolateInfo* isolate_info;
+    Persistent<Context>* context;
 } ContextInfo;
 
 typedef struct {
@@ -46,42 +64,71 @@ static VALUE rb_eScriptTerminatedError;
 static VALUE rb_eParseError;
 static VALUE rb_eScriptRuntimeError;
 static VALUE rb_cJavaScriptFunction;
+static VALUE rb_eSnapshotError;
+static VALUE rb_ePlatformAlreadyInitializedError;
 
+static VALUE rb_cFailedV8Conversion;
 static VALUE rb_cDateTime = Qnil;
 
 static Platform* current_platform = NULL;
+static std::mutex platform_lock;
+
+static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
+    bool platform_already_initialized = false;
+
+    platform_lock.lock();
 
-static void init_v8() {
     if (current_platform == NULL) {
-	V8::InitializeICU();
-	current_platform = platform::CreateDefaultPlatform();
-	V8::InitializePlatform(current_platform);
-	V8::Initialize();
+        V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), (int)RSTRING_LEN(flag_as_str));
+    } else {
+        platform_already_initialized = true;
     }
+
+    platform_lock.unlock();
+
+    // important to raise outside of the lock
+    if (platform_already_initialized) {
+        rb_raise(rb_ePlatformAlreadyInitializedError, "The V8 platform is already initialized");
+    }
+
+    return Qnil;
 }
 
-void* breaker(void *d) {
-  EvalParams* data = (EvalParams*)d;
-  usleep(data->timeout*1000);
-  pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
-  V8::TerminateExecution(data->context_info->isolate);
-  return NULL;
+static void init_v8() {
+    // no need to wait for the lock if already initialized
+    if (current_platform != NULL) return;
+
+    platform_lock.lock();
+
+    if (current_platform == NULL) {
+        V8::InitializeICU();
+        current_platform = platform::CreateDefaultPlatform();
+        V8::InitializePlatform(current_platform);
+        V8::Initialize();
+    }
+
+    platform_lock.unlock();
 }
 
 void*
 nogvl_context_eval(void* arg) {
+
     EvalParams* eval_params = (EvalParams*)arg;
     EvalResult* result = eval_params->result;
-    Isolate* isolate = eval_params->context_info->isolate;
+    Isolate* isolate = eval_params->context_info->isolate_info->isolate;
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
 
     TryCatch trycatch(isolate);
 
     Local<Context> context = eval_params->context_info->context->Get(isolate);
-
     Context::Scope context_scope(context);
 
+    // in gvl flag
+    isolate->SetData(0, (void*)false);
+    // terminate ASAP
+    isolate->SetData(1, (void*)false);
+
     MaybeLocal<Script> parsed_script = Script::Compile(context, *eval_params->eval);
     result->parsed = !parsed_script.IsEmpty();
     result->executed = false;
@@ -93,19 +140,8 @@ nogvl_context_eval(void* arg) {
 	result->message->Reset(isolate, trycatch.Exception());
     } else {
 
-	pthread_t breaker_thread;
-
-	if (eval_params->timeout > 0) {
-	   pthread_create(&breaker_thread, NULL, breaker, (void*)eval_params);
-	}
-
 	MaybeLocal<Value> maybe_value = parsed_script.ToLocalChecked()->Run(context);
 
-	if (eval_params->timeout > 0) {
-	    pthread_cancel(breaker_thread);
-	    pthread_join(breaker_thread, NULL);
-	}
-
 	result->executed = !maybe_value.IsEmpty();
 
 	if (result->executed) {
@@ -130,6 +166,8 @@ nogvl_context_eval(void* arg) {
 		Local<String> v8_message = String::NewFromUtf8(isolate, buf, NewStringType::kNormal, (int)len).ToLocalChecked();
 		result->message->Reset(isolate, v8_message);
 	    } else if(trycatch.HasTerminated()) {
+
+
 		result->terminated = true;
 		result->message = new Persistent<Value>();
 		Local<String> tmp = String::NewFromUtf8(isolate, "JavaScript was terminated (either by timeout or explicitly)");
@@ -142,6 +180,9 @@ nogvl_context_eval(void* arg) {
 	}
     }
 
+    isolate->SetData(0, (void*)true);
+
+
     return NULL;
 }
 
@@ -175,6 +216,9 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
       for(uint32_t i=0; i < arr->Length(); i++) {
 	  Local<Value> element = arr->Get(i);
 	  VALUE rb_elem = convert_v8_to_ruby(isolate, element);
+	  if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
+	    return rb_elem;
+	  }
           rb_ary_push(rb_array, rb_elem);
       }
       return rb_array;
@@ -193,6 +237,9 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
     }
 
     if (value->IsObject()) {
+
+	TryCatch trycatch(isolate);
+
 	VALUE rb_hash = rb_hash_new();
 	Local<Context> context = Context::New(isolate);
 	Local<Object> object = value->ToObject();
@@ -203,6 +250,14 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
 	     Local<Value> key = props->Get(i);
 	     VALUE rb_key = convert_v8_to_ruby(isolate, key);
 	     Local<Value> value = object->Get(key);
+	     // this may have failed due to Get raising
+
+	     if (trycatch.HasCaught()) {
+		 // TODO isolate code that translates execption to ruby
+		 // exception so we can properly return it
+		 return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
+	     }
+
 	     VALUE rb_value = convert_v8_to_ruby(isolate, value);
 	     rb_hash_aset(rb_hash, rb_key, rb_value);
 	    }
@@ -233,7 +288,6 @@ static Handle<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
         {
             return scope.Escape(Number::New(isolate, (double)fixnum));
         }
-        
         return scope.Escape(Integer::New(isolate, (int)fixnum));
     case T_FLOAT:
 	return scope.Escape(Number::New(isolate, NUM2DBL(value)));
@@ -273,7 +327,6 @@ static Handle<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
             {
                 value = rb_funcall(value, rb_intern("to_time"), 0);
             }
-            
             value = rb_funcall(value, rb_intern("to_f"), 0);
             return scope.Escape(Date::New(isolate, NUM2DBL(value) * 1000));
         }
@@ -296,9 +349,127 @@ static Handle<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
 
 static void unblock_eval(void *ptr) {
     EvalParams* eval = (EvalParams*)ptr;
-    eval->context_info->interrupted = true;
+    eval->context_info->isolate_info->interrupted = true;
 }
 
+static VALUE rb_snapshot_size(VALUE self, VALUE str) {
+    SnapshotInfo* snapshot_info;
+    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+
+    return INT2NUM(snapshot_info->raw_size);
+}
+
+static VALUE rb_snapshot_load(VALUE self, VALUE str) {
+    SnapshotInfo* snapshot_info;
+    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+
+    init_v8();
+
+    StartupData startup_data = V8::CreateSnapshotDataBlob(RSTRING_PTR(str));
+
+    if (startup_data.data == NULL && startup_data.raw_size == 0) {
+        rb_raise(rb_eSnapshotError, "Could not create snapshot, most likely the source is incorrect");
+    }
+
+    snapshot_info->data = startup_data.data;
+    snapshot_info->raw_size = startup_data.raw_size;
+
+    return Qnil;
+}
+
+static VALUE rb_snapshot_warmup(VALUE self, VALUE str) {
+    SnapshotInfo* snapshot_info;
+    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+
+    init_v8();
+
+    StartupData cold_startup_data = {snapshot_info->data, snapshot_info->raw_size};
+    StartupData warm_startup_data = V8::WarmUpSnapshotDataBlob(cold_startup_data, RSTRING_PTR(str));
+
+    if (warm_startup_data.data == NULL && warm_startup_data.raw_size == 0) {
+        rb_raise(rb_eSnapshotError, "Could not warm up snapshot, most likely the source is incorrect");
+    } else {
+        delete[] snapshot_info->data;
+
+        snapshot_info->data = warm_startup_data.data;
+        snapshot_info->raw_size = warm_startup_data.raw_size;
+    }
+
+    return self;
+}
+
+static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    init_v8();
+
+    isolate_info->allocator = new ArrayBufferAllocator();
+    isolate_info->interrupted = false;
+    isolate_info->refs_count = 1;
+
+    Isolate::CreateParams create_params;
+    create_params.array_buffer_allocator = isolate_info->allocator;
+
+    StartupData* startup_data = NULL;
+    if (!NIL_P(snapshot)) {
+        SnapshotInfo* snapshot_info;
+        Data_Get_Struct(snapshot, SnapshotInfo, snapshot_info);
+
+        int raw_size = snapshot_info->raw_size;
+        char* data = new char[raw_size];
+        memcpy(data, snapshot_info->data, sizeof(char) * raw_size);
+
+        startup_data = new StartupData;
+        startup_data->data = data;
+        startup_data->raw_size = raw_size;
+
+        create_params.snapshot_blob = startup_data;
+    }
+
+    isolate_info->startup_data = startup_data;
+    isolate_info->isolate = Isolate::New(create_params);
+
+    return Qnil;
+}
+
+static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    return isolate_info->isolate->IdleNotification(NUM2INT(idle_time_in_ms)) ? Qtrue : Qfalse;
+}
+
+static VALUE rb_context_init_with_isolate(VALUE self, VALUE isolate) {
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+
+    init_v8();
+
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(isolate, IsolateInfo, isolate_info);
+
+    context_info->isolate_info = isolate_info;
+    isolate_info->refs_count++;
+
+    {
+    Locker lock(isolate_info->isolate);
+    Isolate::Scope isolate_scope(isolate_info->isolate);
+    HandleScope handle_scope(isolate_info->isolate);
+
+    Local<Context> context = Context::New(isolate_info->isolate);
+
+    context_info->context = new Persistent<Context>();
+    context_info->context->Reset(isolate_info->isolate, context);
+    }
+
+    if (Qnil == rb_cDateTime && rb_funcall(rb_cObject, rb_intern("const_defined?"), 1, rb_str_new2("DateTime")) == Qtrue)
+    {
+        rb_cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
+    }
+
+    return Qnil;
+}
 
 static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
 
@@ -311,13 +482,16 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
     VALUE backtrace = Qnil;
 
     Data_Get_Struct(self, ContextInfo, context_info);
+    Isolate* isolate = context_info->isolate_info->isolate;
+
+
 
     {
-	Locker lock(context_info->isolate);
-	Isolate::Scope isolate_scope(context_info->isolate);
-	HandleScope handle_scope(context_info->isolate);
+	Locker lock(isolate);
+	Isolate::Scope isolate_scope(isolate);
+	HandleScope handle_scope(isolate);
 
-	Local<String> eval = String::NewFromUtf8(context_info->isolate, RSTRING_PTR(str),
+	Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
 						  NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
 
 	eval_params.context_info = context_info;
@@ -335,15 +509,15 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
 	rb_thread_call_without_gvl(nogvl_context_eval, &eval_params, unblock_eval, &eval_params);
 
 	if (eval_result.message != NULL) {
-	    Local<Value> tmp = Local<Value>::New(context_info->isolate, *eval_result.message);
-	    message = convert_v8_to_ruby(context_info->isolate, tmp);
+	    Local<Value> tmp = Local<Value>::New(isolate, *eval_result.message);
+	    message = convert_v8_to_ruby(isolate, tmp);
 	    eval_result.message->Reset();
 	    delete eval_result.message;
 	}
 
 	if (eval_result.backtrace != NULL) {
-	    Local<Value> tmp = Local<Value>::New(context_info->isolate, *eval_result.backtrace);
-	    backtrace = convert_v8_to_ruby(context_info->isolate, tmp);
+	    Local<Value> tmp = Local<Value>::New(isolate, *eval_result.backtrace);
+	    backtrace = convert_v8_to_ruby(isolate, tmp);
 	    eval_result.backtrace->Reset();
 	    delete eval_result.backtrace;
 	}
@@ -377,19 +551,25 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
 	}
     }
 
-    // New scope for return value
+    // New scope for return value, must release GVL which
     {
-	Locker lock(context_info->isolate);
-	Isolate::Scope isolate_scope(context_info->isolate);
-	HandleScope handle_scope(context_info->isolate);
+	Locker lock(isolate);
+	Isolate::Scope isolate_scope(isolate);
+	HandleScope handle_scope(isolate);
 
-	Local<Value> tmp = Local<Value>::New(context_info->isolate, *eval_result.value);
-	result = convert_v8_to_ruby(context_info->isolate, tmp);
+	Local<Value> tmp = Local<Value>::New(isolate, *eval_result.value);
+	result = convert_v8_to_ruby(isolate, tmp);
 
 	eval_result.value->Reset();
 	delete eval_result.value;
     }
 
+    if (rb_funcall(result, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
+	// TODO try to recover stack trace from the conversion error
+	rb_raise(rb_eScriptRuntimeError, "Error converting JS object to Ruby object");
+    }
+
+
     return result;
 }
 
@@ -424,7 +604,7 @@ void*
 gvl_ruby_callback(void* data) {
 
     FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
-    VALUE* ruby_args;
+    VALUE* ruby_args = NULL;
     int length = args->Length();
     VALUE callback;
     VALUE result;
@@ -456,8 +636,14 @@ gvl_ruby_callback(void* data) {
     callback_data.args = ruby_args;
     callback_data.failed = false;
 
-    result = rb_rescue((VALUE(*)(...))&protected_callback, (VALUE)(&callback_data),
-			(VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data));
+    if ((bool)args->GetIsolate()->GetData(1) == true) {
+	args->GetIsolate()->ThrowException(String::NewFromUtf8(args->GetIsolate(), "Terminated execution during tansition from Ruby to JS"));
+	V8::TerminateExecution(args->GetIsolate());
+	return NULL;
+    }
+
+    result = rb_rescue2((VALUE(*)(...))&protected_callback, (VALUE)(&callback_data),
+			(VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data), rb_eException, (VALUE)0);
 
     if(callback_data.failed) {
 	VALUE parent = rb_iv_get(self, "@parent");
@@ -474,11 +660,23 @@ gvl_ruby_callback(void* data) {
 	xfree(ruby_args);
     }
 
+    if ((bool)args->GetIsolate()->GetData(1) == true) {
+      Isolate* isolate = args->GetIsolate();
+      V8::TerminateExecution(isolate);
+    }
+
     return NULL;
 }
 
 static void ruby_callback(const FunctionCallbackInfo<Value>& args) {
-    rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
+
+    bool has_gvl = (bool)args.GetIsolate()->GetData(0);
+
+    if(has_gvl) {
+	gvl_ruby_callback((void*)&args);
+    } else {
+	rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
+    }
 }
 
 
@@ -495,16 +693,17 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
     bool attach_error = false;
 
     Data_Get_Struct(parent, ContextInfo, context_info);
+    Isolate* isolate = context_info->isolate_info->isolate;
 
     {
-	Locker lock(context_info->isolate);
-	Isolate::Scope isolate_scope(context_info->isolate);
-	HandleScope handle_scope(context_info->isolate);
+	Locker lock(isolate);
+	Isolate::Scope isolate_scope(isolate);
+	HandleScope handle_scope(isolate);
 
-	Local<Context> context = context_info->context->Get(context_info->isolate);
+	Local<Context> context = context_info->context->Get(isolate);
 	Context::Scope context_scope(context);
 
-	Local<String> v8_str = String::NewFromUtf8(context_info->isolate, RSTRING_PTR(name),
+	Local<String> v8_str = String::NewFromUtf8(isolate, RSTRING_PTR(name),
 						  NewStringType::kNormal, (int)RSTRING_LEN(name)).ToLocalChecked();
 
 	// copy self so we can access from v8 external
@@ -512,13 +711,13 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 	Data_Get_Struct(self, VALUE, self_copy);
 	*self_copy = self;
 
-	Local<Value> external = External::New(context_info->isolate, self_copy);
+	Local<Value> external = External::New(isolate, self_copy);
 
 	if (parent_object == Qnil) {
-	    context->Global()->Set(v8_str, FunctionTemplate::New(context_info->isolate, ruby_callback, external)->GetFunction());
+	    context->Global()->Set(v8_str, FunctionTemplate::New(isolate, ruby_callback, external)->GetFunction());
 	} else {
 
-	    Local<String> eval = String::NewFromUtf8(context_info->isolate, RSTRING_PTR(parent_object_eval),
+	    Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(parent_object_eval),
 						      NewStringType::kNormal, (int)RSTRING_LEN(parent_object_eval)).ToLocalChecked();
 
 	    MaybeLocal<Script> parsed_script = Script::Compile(context, eval);
@@ -531,7 +730,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 		if (!maybe_value.IsEmpty()) {
 		    Local<Value> value = maybe_value.ToLocalChecked();
 		    if (value->IsObject()){
-			value.As<Object>()->Set(v8_str, FunctionTemplate::New(context_info->isolate, ruby_callback, external)->GetFunction());
+			value.As<Object>()->Set(v8_str, FunctionTemplate::New(isolate, ruby_callback, external)->GetFunction());
 			attach_error = false;
 		    }
 		}
@@ -551,71 +750,120 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
     return Qnil;
 }
 
-void deallocate(void * data) {
-    ContextInfo* context_info = (ContextInfo*)data;
-    {
-	Locker lock(context_info->isolate);
+void maybe_free_isolate_info(IsolateInfo* isolate_info) {
+    // an isolate can only be freed if no Isolate or Context (ruby) object
+    // still need it
+    if (isolate_info == NULL || isolate_info->refs_count > 0) {
+        return;
     }
 
-    {
-	context_info->context->Reset();
-	delete context_info->context;
+    if (isolate_info->isolate) {
+	    Locker lock(isolate_info->isolate);
     }
 
-    {
-	if (context_info->interrupted) {
-	    fprintf(stderr, "WARNING: V8 isolate was interrupted by Ruby, it can not be disposed and memory will not be reclaimed till the Ruby process exits.");
-	} else {
-	    context_info->isolate->Dispose();
-	}
+    if (isolate_info->isolate) {
+        if (isolate_info->interrupted) {
+            fprintf(stderr, "WARNING: V8 isolate was interrupted by Ruby, it can not be disposed and memory will not be reclaimed till the Ruby process exits.");
+        } else {
+
+            isolate_info->isolate->Dispose();
+        }
+        isolate_info->isolate = NULL;
+    }
+
+    if (isolate_info->startup_data) {
+        delete[] isolate_info->startup_data->data;
+        delete isolate_info->startup_data;
+    }
+
+    delete isolate_info->allocator;
+    xfree(isolate_info);
+}
+
+void deallocate_isolate(void* data) {
+    IsolateInfo* isolate_info = (IsolateInfo*) data;
+
+    isolate_info->refs_count--;
+
+    maybe_free_isolate_info(isolate_info);
+}
+
+void deallocate(void* data) {
+    ContextInfo* context_info = (ContextInfo*)data;
+    IsolateInfo* isolate_info = context_info->isolate_info;
+
+    if (context_info->context && isolate_info && isolate_info->isolate) {
+        Locker lock(isolate_info->isolate);
+        v8::Isolate::Scope isolate_scope(isolate_info->isolate);
+        context_info->context->Reset();
+        delete context_info->context;
     }
 
-    delete context_info->allocator;
-    xfree(context_info);
+    if (isolate_info) {
+        isolate_info->refs_count--;
+        maybe_free_isolate_info(isolate_info);
+    }
 }
 
 void deallocate_external_function(void * data) {
     xfree(data);
 }
 
+void deallocate_snapshot(void * data) {
+    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
+
+    delete[] snapshot_info->data;
+
+    xfree(snapshot_info);
+}
+
 VALUE allocate_external_function(VALUE klass) {
     VALUE* self = ALLOC(VALUE);
     return Data_Wrap_Struct(klass, NULL, deallocate_external_function, (void*)self);
 }
 
 VALUE allocate(VALUE klass) {
-    init_v8();
-
     ContextInfo* context_info = ALLOC(ContextInfo);
-    context_info->allocator = new ArrayBufferAllocator();
-    context_info->interrupted = false;
-    Isolate::CreateParams create_params;
-    create_params.array_buffer_allocator = context_info->allocator;
+    context_info->isolate_info = NULL;
+    context_info->context = NULL;
 
-    context_info->isolate = Isolate::New(create_params);
+    return Data_Wrap_Struct(klass, NULL, deallocate, (void*)context_info);
+}
 
-    Locker lock(context_info->isolate);
-    Isolate::Scope isolate_scope(context_info->isolate);
-    HandleScope handle_scope(context_info->isolate);
+VALUE allocate_snapshot(VALUE klass) {
+    SnapshotInfo* snapshot_info = ALLOC(SnapshotInfo);
+    snapshot_info->data = NULL;
+    snapshot_info->raw_size = 0;
 
-    Local<Context> context = Context::New(context_info->isolate);
+    return Data_Wrap_Struct(klass, NULL, deallocate_snapshot, (void*)snapshot_info);
+}
 
-    context_info->context = new Persistent<Context>();
-    context_info->context->Reset(context_info->isolate, context);
+VALUE allocate_isolate(VALUE klass) {
+    IsolateInfo* isolate_info = ALLOC(IsolateInfo);
 
-    if (Qnil == rb_cDateTime && rb_funcall(rb_cObject, rb_intern("const_defined?"), 1, rb_str_new2("DateTime")) == Qtrue)
-    {
-        rb_cDateTime = rb_const_get(rb_cObject, rb_intern("DateTime"));
-    }
+    isolate_info->isolate = NULL;
+    isolate_info->allocator = NULL;
+    isolate_info->startup_data = NULL;
+    isolate_info->interrupted = false;
+    isolate_info->refs_count = 0;
 
-    return Data_Wrap_Struct(klass, NULL, deallocate, (void*)context_info);
+    return Data_Wrap_Struct(klass, NULL, deallocate_isolate, (void*)isolate_info);
 }
 
 static VALUE
 rb_context_stop(VALUE self) {
+
     ContextInfo* context_info;
     Data_Get_Struct(self, ContextInfo, context_info);
-    V8::TerminateExecution(context_info->isolate);
+
+    Isolate* isolate = context_info->isolate_info->isolate;
+
+    // flag for termination
+    isolate->SetData(1, (void*)true);
+
+    V8::TerminateExecution(isolate);
+    rb_funcall(self, rb_intern("stop_attached"), 0);
+
     return Qnil;
 }
 
@@ -625,20 +873,38 @@ extern "C" {
     {
 	VALUE rb_mMiniRacer = rb_define_module("MiniRacer");
 	VALUE rb_cContext = rb_define_class_under(rb_mMiniRacer, "Context", rb_cObject);
+	VALUE rb_cSnapshot = rb_define_class_under(rb_mMiniRacer, "Snapshot", rb_cObject);
+	VALUE rb_cIsolate = rb_define_class_under(rb_mMiniRacer, "Isolate", rb_cObject);
+	VALUE rb_cPlatform = rb_define_class_under(rb_mMiniRacer, "Platform", rb_cObject);
 
 	VALUE rb_eEvalError = rb_define_class_under(rb_mMiniRacer, "EvalError", rb_eStandardError);
 	rb_eScriptTerminatedError = rb_define_class_under(rb_mMiniRacer, "ScriptTerminatedError", rb_eEvalError);
 	rb_eParseError = rb_define_class_under(rb_mMiniRacer, "ParseError", rb_eEvalError);
 	rb_eScriptRuntimeError = rb_define_class_under(rb_mMiniRacer, "RuntimeError", rb_eEvalError);
 	rb_cJavaScriptFunction = rb_define_class_under(rb_mMiniRacer, "JavaScriptFunction", rb_cObject);
+	rb_eSnapshotError = rb_define_class_under(rb_mMiniRacer, "SnapshotError", rb_eStandardError);
+	rb_ePlatformAlreadyInitializedError = rb_define_class_under(rb_mMiniRacer, "PlatformAlreadyInitialized", rb_eStandardError);
+	rb_cFailedV8Conversion = rb_define_class_under(rb_mMiniRacer, "FailedV8Conversion", rb_cObject);
 
 	VALUE rb_cExternalFunction = rb_define_class_under(rb_cContext, "ExternalFunction", rb_cObject);
 	rb_define_method(rb_cContext, "stop", (VALUE(*)(...))&rb_context_stop, 0);
 	rb_define_alloc_func(rb_cContext, allocate);
+	rb_define_alloc_func(rb_cSnapshot, allocate_snapshot);
+	rb_define_alloc_func(rb_cIsolate, allocate_isolate);
 
 	rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 1);
+	rb_define_private_method(rb_cContext, "init_with_isolate",(VALUE(*)(...))&rb_context_init_with_isolate, 1);
 	rb_define_private_method(rb_cExternalFunction, "notify_v8", (VALUE(*)(...))&rb_external_function_notify_v8, 0);
 	rb_define_alloc_func(rb_cExternalFunction, allocate_external_function);
+
+	rb_define_method(rb_cSnapshot, "size", (VALUE(*)(...))&rb_snapshot_size, 0);
+	rb_define_method(rb_cSnapshot, "warmup!", (VALUE(*)(...))&rb_snapshot_warmup, 1);
+	rb_define_private_method(rb_cSnapshot, "load", (VALUE(*)(...))&rb_snapshot_load, 1);
+
+	rb_define_method(rb_cIsolate, "idle_notification", (VALUE(*)(...))&rb_isolate_idle_notification, 1);
+	rb_define_private_method(rb_cIsolate, "init_with_snapshot",(VALUE(*)(...))&rb_isolate_init_with_snapshot, 1);
+
+	rb_define_singleton_method(rb_cPlatform, "set_flag_as_str!", (VALUE(*)(...))&rb_platform_set_flag_as_str, 1);
     }
 
 }

data/lib/mini_racer.rb

@@ -7,6 +7,15 @@ module MiniRacer
   class EvalError < StandardError; end
   class ScriptTerminatedError < EvalError; end
   class ParseError < EvalError; end
+  class SnapshotError < StandardError; end
+  class PlatformAlreadyInitialized < StandardError; end
+
+  class FailedV8Conversion
+    attr_reader :info
+    def initialize(info)
+      @info = info
+    end
+  end
 
   class RuntimeError < EvalError
     def initialize(message)
@@ -38,6 +47,53 @@ module MiniRacer
     end
   end
 
+  class Isolate
+    def initialize(snapshot = nil)
+      unless snapshot.nil? || snapshot.is_a?(Snapshot)
+        raise ArgumentError, "snapshot must be a Snapshot object, passed a #{snapshot.inspect}"
+      end
+
+      @lock = Mutex.new
+
+      # defined in the C class
+      init_with_snapshot(snapshot)
+    end
+
+    def with_lock
+      @lock.synchronize { yield }
+    end
+  end
+
+  class Platform
+    class << self
+      def set_flags!(*args, **kwargs)
+        flags_to_strings([args, kwargs]).each do |flag|
+          # defined in the C class
+          set_flag_as_str!(flag)
+        end
+      end
+
+    private
+
+      def flags_to_strings(flags)
+        flags.flatten.map { |flag| flag_to_string(flag) }.flatten
+      end
+
+      # normalize flags to strings, and adds leading dashes if needed
+      def flag_to_string(flag)
+        if flag.is_a?(Hash)
+          flag.map do |key, value|
+            "#{flag_to_string(key)} #{value}"
+          end
+        else
+          str = flag.to_s
+          str = "--#{str}" unless str.start_with?('--')
+          str
+        end
+      end
+    end
+  end
+
   # eval is defined in the C class
   class Context
 
@@ -74,14 +130,27 @@ module MiniRacer
       end
     end
 
+    attr_reader :isolate
+
     def initialize(options = nil)
+      options ||= {}
+
+      check_init_options!(options)
+
       @functions = {}
-      @lock = Mutex.new
       @timeout = nil
       @current_exception = nil
+      @timeout = options[:timeout]
+      @isolate = options[:isolate] || Isolate.new(options[:snapshot])
+
+      @callback_mutex = Mutex.new
+      @callback_running = false
+      @thread_raise_called = false
+      @eval_thread = nil
 
-      if options
-        @timeout = options[:timeout]
+      isolate.with_lock do
+        # defined in the C class
+        init_with_isolate(@isolate)
       end
     end
 
@@ -91,19 +160,102 @@ module MiniRacer
     end
 
     def eval(str)
-      @lock.synchronize do
+      @eval_thread = Thread.current
+      isolate.with_lock do
         @current_exception = nil
-        eval_unsafe(str)
+        timeout do
+          eval_unsafe(str)
+        end
       end
+    ensure
+      @eval_thread = nil
     end
 
+
     def attach(name, callback)
-      @lock.synchronize do
-        external = ExternalFunction.new(name, callback, self)
+
+      wrapped = lambda do |*args|
+        begin
+          @callback_mutex.synchronize{
+            @callback_running = true
+          }
+
+          callback.call(*args)
+        ensure
+          @callback_mutex.synchronize {
+            @callback_running = false
+
+            # this is some odd code, but it is required
+            # if we raised on this thread we better wait for it
+            # otherwise we may end up raising in an unsafe spot
+            if @thread_raise_called
+              sleep 0.1
+            end
+            @thread_raise_called = false
+          }
+        end
+      end
+
+      isolate.with_lock do
+        external = ExternalFunction.new(name, wrapped, self)
         @functions["#{name}"] = external
       end
     end
 
+  private
+
+    def stop_attached
+      @callback_mutex.synchronize{
+        if @callback_running
+          @eval_thread.raise ScriptTerminatedError, "Terminated during callback"
+          @thread_raise_called = true
+        end
+      }
+    end
+
+    def timeout(&blk)
+      return blk.call unless @timeout
+
+      _,wp = IO.pipe
+
+      Thread.new do
+        begin
+          result = IO.select([wp],[],[],(@timeout/1000.0))
+          if !result
+            stop
+          end
+        rescue
+          STDERR.puts "FAILED TO TERMINATE DUE TO TIMEOUT"
+        end
+      end
+
+      rval = blk.call
+      wp.write("done")
+
+      rval
+    end
+
+    def check_init_options!(options)
+      assert_option_is_nil_or_a('isolate', options[:isolate], Isolate)
+      assert_option_is_nil_or_a('snapshot', options[:snapshot], Snapshot)
+
+      if options[:isolate] && options[:snapshot]
+        raise ArgumentError, 'can only pass one of isolate and snapshot options'
+      end
+    end
+
+    def assert_option_is_nil_or_a(option_name, object, klass)
+      unless object.nil? || object.is_a?(klass)
+        raise ArgumentError, "#{option_name} must be a #{klass} object, passed a #{object.inspect}"
+      end
+    end
   end
 
+  # `size` and `warmup!` public methods are defined in the C class
+  class Snapshot
+    def initialize(str = '')
+      # defined in the C class
+      load(str)
+    end
+  end
 end

data/lib/mini_racer/version.rb

@@ -1,3 +1,3 @@
 module MiniRacer
-  VERSION = "0.1.4"
+  VERSION = "0.1.5.pre.0"
 end

data/mini_racer.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "rake-compiler"
 
-  spec.add_dependency 'libv8', '~> 5.0', '< 5.1.11'
+  spec.add_dependency 'libv8', '~> 5.3'
   spec.require_paths = ["lib", "ext"]
 
   spec.extensions = ["ext/mini_racer_extension/extconf.rb"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5.pre.0
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-06-15 00:00:00.000000000 Z
+date: 2016-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -72,20 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 5.1.11
+        version: '5.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.0'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: 5.1.11
+        version: '5.3'
 description: Minimal embedded v8 engine for Ruby
 email:
 - sam.saffron@gmail.com
@@ -125,9 +119,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '2.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.5.1