mini_racer 0.1.15 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d6c94af48c76bdd1d4ce6744e81cf812192498d8
-  data.tar.gz: dd14708bbca74f0845ce37310fb4a7679326e7cb
+SHA256:
+  metadata.gz: b2bb1ce568e44bcf3f6fcc469942ee12bd418cb21faaedbf1ed60a1b89e4ee47
+  data.tar.gz: 4a38af517388189628e22c7f9bf6b8129489847ff1b4d79b741e248b0f88fc6d
 SHA512:
-  metadata.gz: 8982f3a4a7aa6c9f89a581099c48a2e694930f9e4f48beaf88cfaf38f9a21004b32fd5093937ffa0096ac4ebb725c7f99402928a0ab4b54153114fa81267d21b
-  data.tar.gz: f9219565baccdea2ce89be3e50012b204e4482296f83084517db0e996a4a6147050230f6afcebc4ba79e1b127aa3dcbe845962c3087c5dd3ec3b2e16970537f0
+  metadata.gz: 9e8f42aad8b92fc27e9d430edea330fd583743ea7c81c6bbb5097de797af02b2905b87006798559e61e95ab2a0a9fb667e4d0758a3021876c81be138bc890e3d
+  data.tar.gz: 5e17012b06081f0b3f303f549908c348bed54ef9151069c1a6efcfb778708fde80fe2108a6f5f9f9908a9aec52449ad65a85fd2f0ae49892d89dfba59cc568c2

data/.travis.yml

@@ -1,19 +1,23 @@
 language: ruby
 rvm:
-  - 2.1
-  - 2.2
-  - 2.3.3
-  - 2.4.0
+  - 2.3
+  - 2.4
+  - 2.5
+  - ruby-head
 matrix:
   include:
+    - rvm: 2.5.1
+      os: osx
+      osx_image: xcode9.4
     - rvm: 2.4.0
       os: osx
-      osx_image: xcode8.2
+      osx_image: xcode8.3
     - rvm: 2.4.0
       os: osx
       osx_image: xcode7.3
 dist: trusty
 sudo: true
 before_install:
-  - gem install bundler -v 1.12.0
+  - gem update --system
+  - gem install bundler -v 1.16.2
 cache: bundler

data/CHANGELOG

@@ -1,3 +1,12 @@
+- 06-07-2018
+
+- 0.2.0
+  - FEATURE: context#call to allow for cheaper invocation of functions
+  - FIX: rare memory leak when terminating a long running attached function
+  - FIX: rare segfault when terminating a long running attached function
+  - FIX: Reimplement Isolate#idle_notification using idle_notification_deadline, API remains the same @ignisf
+  - Account for changes in the upstream V8 API @ignisf
+  - Support for libv8 6.7
 
 23-08-2017
 

data/README.md

@@ -10,6 +10,12 @@ It was created as an alternative to the excellent [therubyracer](https://github.
 
 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.
 
+### A note about Ruby version Support
+
+MiniRacer only supports non-EOL versions of Ruby. See [Ruby](https://www.ruby-lang.org/en/downloads) to see the list of non-EOL Rubies.
+
+If you require support for older versions of Ruby install an older version of the gem.
+
 ## Features
 
 ### Simple eval for JavaScript
@@ -283,6 +289,22 @@ context.eval("a = 2")
 # nothing works on the context from now on, its a shell waiting to be disposed
 ```
 
+### Function call
+
+This calls the function passed as first argument:
+
+```ruby
+context = MiniRacer::Context.new
+context.eval('function hello(name) { return "Hello, " + name + "!" }')
+context.call('hello', 'George')
+# "Hello, George!"
+```
+
+Performance is slightly better than running `eval('hello("George")')` since:
+
+ - compilation of eval'd string is avoided
+ - function arguments don't need to be converted to JSON
+
 ## Performance
 
 The `bench` folder contains benchmark.

data/ext/mini_racer_extension/extconf.rb

@@ -9,6 +9,7 @@ $CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
 $CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or RUBY_PLATFORM =~ /darwin/
 $CPPFLAGS += " -std=c++0x"
 $CPPFLAGS += " -fpermissive"
+$CPPFLAGS += " -Wno-reserved-user-defined-literal" if RUBY_PLATFORM =~ /darwin/
 
 $LDFLAGS.insert 0, " -stdlib=libstdc++ " if RUBY_PLATFORM =~ /darwin/
 

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -7,6 +7,7 @@
 #include <pthread.h>
 #include <unistd.h>
 #include <mutex>
+#include <atomic>
 #include <math.h>
 
 using namespace v8;
@@ -16,21 +17,77 @@ typedef struct {
     int raw_size;
 } SnapshotInfo;
 
-typedef struct {
+class IsolateInfo {
+public:
     Isolate* isolate;
     ArrayBuffer::Allocator* allocator;
     StartupData* startup_data;
     bool interrupted;
-    bool disposed;
     pid_t pid;
+    VALUE mutex;
+
+    class Lock {
+        VALUE &mutex;
+
+    public:
+        Lock(VALUE &mutex) : mutex(mutex) {
+            rb_mutex_lock(mutex);
+        }
+        ~Lock() {
+            rb_mutex_unlock(mutex);
+        }
+    };
+
+
+    IsolateInfo() : isolate(nullptr), allocator(nullptr), startup_data(nullptr),
+        interrupted(false), pid(getpid()), refs_count(0) {
+        VALUE cMutex = rb_const_get(rb_cThread, rb_intern("Mutex"));
+        mutex = rb_class_new_instance(0, nullptr, cMutex);
+    }
+
+    ~IsolateInfo() {
+        void free_isolate(IsolateInfo*);
+        free_isolate(this);
+    }
+
+    void init(SnapshotInfo* snapshot_info = nullptr);
+
+    void mark() {
+        rb_gc_mark(mutex);
+    }
+
+    Lock createLock() {
+        Lock lock(mutex);
+        return lock;
+    }
+
+    void hold() {
+        refs_count++;
+    }
+    void release() {
+        if (--refs_count <= 0) {
+            delete this;
+        }
+    }
+
+    static void* operator new(size_t size) {
+        return ruby_xmalloc(size);
+    }
 
+    static void operator delete(void *block) {
+        xfree(block);
+    }
+private:
     // 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
-    volatile int refs_count;
-} IsolateInfo;
+    // we can't rely on Ruby's GC for this, because Ruby could destroy the
+    // isolate before destroying the contexts that depend on them. We'd need to
+    // keep a list of linked contexts in the isolate to destroy those first when
+    // isolate destruction was requested. Keeping such a list would require
+    // notification from the context VALUEs when they are constructed and
+    // destroyed. With a ref count, those notifications are still needed, but
+    // we keep a simple int rather than a list of pointers.
+    std::atomic_int refs_count;
+};
 
 typedef struct {
     IsolateInfo* isolate_info;
@@ -56,6 +113,16 @@ typedef struct {
     size_t max_memory;
 } EvalParams;
 
+typedef struct {
+    ContextInfo *context_info;
+    char *function_name;
+    int argc;
+    bool error;
+    Local<Function> fun;
+    Local<Value> *argv;
+    EvalResult result;
+} FunctionCall;
+
 enum IsolateFlags {
     IN_GVL,
     DO_TERMINATE,
@@ -63,6 +130,10 @@ enum IsolateFlags {
     MEM_SOFTLIMIT_REACHED,
 };
 
+static VALUE rb_cContext;
+static VALUE rb_cSnapshot;
+static VALUE rb_cIsolate;
+
 static VALUE rb_eScriptTerminatedError;
 static VALUE rb_eV8OutOfMemoryError;
 static VALUE rb_eParseError;
@@ -81,6 +152,11 @@ static std::mutex platform_lock;
 static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
     bool platform_already_initialized = false;
 
+    if(TYPE(flag_as_str) != T_STRING) {
+        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE" (should be a string)",
+                rb_obj_class(flag_as_str));
+    }
+
     platform_lock.lock();
 
     if (current_platform == NULL) {
@@ -126,7 +202,86 @@ static void gc_callback(Isolate *isolate, GCType type, GCCallbackFlags flags) {
 
     if(used > softlimit) {
         isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)true);
-        V8::TerminateExecution(isolate);
+        isolate->TerminateExecution();
+    }
+}
+
+// to be called with active lock and scope
+static void prepare_result(MaybeLocal<Value> v8res,
+                           TryCatch& trycatch,
+                           Isolate* isolate,
+                           Local<Context> context,
+                           EvalResult& evalRes /* out */) {
+
+    // just don't touch .parsed
+    evalRes.terminated = false;
+    evalRes.json = false;
+    evalRes.value = nullptr;
+    evalRes.message = nullptr;
+    evalRes.backtrace = nullptr;
+    evalRes.executed = !v8res.IsEmpty();
+
+    if (evalRes.executed) {
+        // arrays and objects get converted to json
+        Local<Value> local_value = v8res.ToLocalChecked();
+        if ((local_value->IsObject() || local_value->IsArray()) &&
+                !local_value->IsDate() && !local_value->IsFunction()) {
+            Local<Object> JSON = context->Global()->Get(
+                        String::NewFromUtf8(isolate, "JSON"))->ToObject();
+
+            Local<Function> stringify = JSON->Get(v8::String::NewFromUtf8(isolate, "stringify"))
+                    .As<Function>();
+
+            Local<Object> object = local_value->ToObject();
+            const unsigned argc = 1;
+            Local<Value> argv[argc] = { object };
+            MaybeLocal<Value> json = stringify->Call(JSON, argc, argv);
+
+            if (json.IsEmpty()) {
+                evalRes.executed = false;
+            } else {
+                evalRes.json = true;
+                Persistent<Value>* persistent = new Persistent<Value>();
+                persistent->Reset(isolate, json.ToLocalChecked());
+                evalRes.value = persistent;
+            }
+
+        } else {
+            Persistent<Value>* persistent = new Persistent<Value>();
+            persistent->Reset(isolate, local_value);
+            evalRes.value = persistent;
+        }
+    }
+
+    if (!evalRes.executed || !evalRes.parsed) {
+        if (trycatch.HasCaught()) {
+            if (!trycatch.Exception()->IsNull()) {
+                evalRes.message = new Persistent<Value>();
+                Local<Message> message = trycatch.Message();
+                char buf[1000];
+                int len;
+                len = snprintf(buf, sizeof(buf), "%s at %s:%i:%i", *String::Utf8Value(message->Get()),
+                               *String::Utf8Value(message->GetScriptResourceName()->ToString()),
+                               message->GetLineNumber(),
+                               message->GetStartColumn());
+                if ((size_t) len >= sizeof(buf)) {
+                    len = sizeof(buf) - 1;
+                    buf[len] = '\0';
+                }
+
+                Local<String> v8_message = String::NewFromUtf8(isolate, buf, NewStringType::kNormal, len).ToLocalChecked();
+                evalRes.message->Reset(isolate, v8_message);
+            } else if(trycatch.HasTerminated()) {
+                evalRes.terminated = true;
+                evalRes.message = new Persistent<Value>();
+                Local<String> tmp = String::NewFromUtf8(isolate, "JavaScript was terminated (either by timeout or explicitly)");
+                evalRes.message->Reset(isolate, tmp);
+            }
+            if (!trycatch.StackTrace().IsEmpty()) {
+                evalRes.backtrace = new Persistent<Value>();
+                evalRes.backtrace->Reset(isolate, trycatch.StackTrace()->ToString());
+            }
+        }
     }
 }
 
@@ -171,90 +326,30 @@ nogvl_context_eval(void* arg) {
     result->json = false;
     result->value = NULL;
 
+    MaybeLocal<Value> maybe_value;
     if (!result->parsed) {
 	result->message = new Persistent<Value>();
 	result->message->Reset(isolate, trycatch.Exception());
     } else {
+        // parsing successful
+        if (eval_params->max_memory > 0) {
+            isolate->SetData(MEM_SOFTLIMIT_VALUE, &eval_params->max_memory);
+            isolate->AddGCEpilogueCallback(gc_callback);
+        }
 
-    if(eval_params->max_memory > 0) {
-        isolate->SetData(MEM_SOFTLIMIT_VALUE, &eval_params->max_memory);
-        isolate->AddGCEpilogueCallback(gc_callback);
-    }
-
-	MaybeLocal<Value> maybe_value = parsed_script.ToLocalChecked()->Run(context);
-
-	result->executed = !maybe_value.IsEmpty();
-
-	if (result->executed) {
-
-	    // arrays and objects get converted to json
-	    Local<Value> local_value = maybe_value.ToLocalChecked();
-	    if ((local_value->IsObject() || local_value->IsArray()) &&
-		    !local_value->IsDate() && !local_value->IsFunction()) {
-		Local<Object> JSON = context->Global()->Get(
-		    String::NewFromUtf8(isolate, "JSON"))->ToObject();
-
-		Local<Function> stringify = JSON->Get(v8::String::NewFromUtf8(isolate, "stringify"))
-		     .As<Function>();
-
-		Local<Object> object = local_value->ToObject();
-		const unsigned argc = 1;
-		Local<Value> argv[argc] = { object };
-		MaybeLocal<Value> json = stringify->Call(JSON, argc, argv);
-
-		if (json.IsEmpty()) {
-		    result->executed = false;
-		} else {
-		    result->json = true;
-		    Persistent<Value>* persistent = new Persistent<Value>();
-		    persistent->Reset(isolate, json.ToLocalChecked());
-		    result->value = persistent;
-		}
-
-	    } else {
-		Persistent<Value>* persistent = new Persistent<Value>();
-		persistent->Reset(isolate, local_value);
-		result->value = persistent;
-	    }
-	}
+        maybe_value = parsed_script.ToLocalChecked()->Run(context);
     }
 
-    if (!result->executed || !result->parsed) {
-	if (trycatch.HasCaught()) {
-	    if (!trycatch.Exception()->IsNull()) {
-		result->message = new Persistent<Value>();
-		Local<Message> message = trycatch.Message();
-		char buf[1000];
-		int len;
-		len = snprintf(buf, sizeof(buf), "%s at %s:%i:%i", *String::Utf8Value(message->Get()),
-			           *String::Utf8Value(message->GetScriptResourceName()->ToString()),
-				    message->GetLineNumber(),
-				    message->GetStartColumn());
-
-		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)");
-		result->message->Reset(isolate, tmp);
-	    }
-	    if (!trycatch.StackTrace().IsEmpty()) {
-		result->backtrace = new Persistent<Value>();
-		result->backtrace->Reset(isolate, trycatch.StackTrace()->ToString());
-	    }
-	}
-    }
+    prepare_result(maybe_value, trycatch, isolate, context, *result);
 
     isolate->SetData(IN_GVL, (void*)true);
 
-
     return NULL;
 }
 
-static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
+// assumes isolate locking is in place
+static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
+                                Local<Value> value) {
 
     Isolate::Scope isolate_scope(isolate);
     HandleScope scope(isolate);
@@ -284,7 +379,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
       Local<Array> arr = Local<Array>::Cast(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);
+	  VALUE rb_elem = convert_v8_to_ruby(isolate, context, element);
 	  if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
 	    return rb_elem;
 	  }
@@ -308,16 +403,15 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
     if (value->IsObject()) {
 	VALUE rb_hash = rb_hash_new();
 	TryCatch trycatch(isolate);
-	Local<Context> context = Context::New(isolate);
 
 	Local<Object> object = value->ToObject();
-	MaybeLocal<Array> maybe_props = object->GetOwnPropertyNames(context);
+	auto maybe_props = object->GetOwnPropertyNames(context);
 	if (!maybe_props.IsEmpty()) {
 	    Local<Array> props = maybe_props.ToLocalChecked();
 	    for(uint32_t i=0; i < props->Length(); i++) {
 	     Local<Value> key = props->Get(i);
-	     VALUE rb_key = convert_v8_to_ruby(isolate, key);
-	     Local<Value> value = object->Get(key);
+	     VALUE rb_key = convert_v8_to_ruby(isolate, context, key);
+	     Local<Value> prop_value = object->Get(key);
 	     // this may have failed due to Get raising
 
 	     if (trycatch.HasCaught()) {
@@ -326,7 +420,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
 		 return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
 	     }
 
-	     VALUE rb_value = convert_v8_to_ruby(isolate, value);
+	     VALUE rb_value = convert_v8_to_ruby(isolate, context, prop_value);
 	     rb_hash_aset(rb_hash, rb_key, rb_value);
 	    }
 	}
@@ -337,7 +431,25 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
     return rb_enc_str_new(*String::Utf8Value(rstr), rstr->Utf8Length(), rb_enc_find("utf-8"));
 }
 
-static Handle<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
+static VALUE convert_v8_to_ruby(Isolate* isolate,
+                                const Persistent<Context>& context,
+                                Local<Value> value) {
+    HandleScope scope(isolate);
+    return convert_v8_to_ruby(isolate,
+                              Local<Context>::New(isolate, context),
+                              value);
+}
+
+static VALUE convert_v8_to_ruby(Isolate* isolate,
+                                const Persistent<Context>& context,
+                                const Persistent<Value>& value) {
+    HandleScope scope(isolate);
+    return convert_v8_to_ruby(isolate,
+                              Local<Context>::New(isolate, context),
+                              Local<Value>::New(isolate, value));
+}
+
+static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
     EscapableHandleScope scope(isolate);
 
     Local<Array> array;
@@ -431,6 +543,11 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
     Data_Get_Struct(self, SnapshotInfo, snapshot_info);
 
+    if(TYPE(str) != T_STRING) {
+        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
+                rb_obj_class(str));
+    }
+
     init_v8();
 
     StartupData startup_data = V8::CreateSnapshotDataBlob(RSTRING_PTR(str));
@@ -445,10 +562,15 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
     return Qnil;
 }
 
-static VALUE rb_snapshot_warmup(VALUE self, VALUE str) {
+static VALUE rb_snapshot_warmup_unsafe(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
     Data_Get_Struct(self, SnapshotInfo, snapshot_info);
 
+    if(TYPE(str) != T_STRING) {
+        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
+                rb_obj_class(str));
+    }
+
     init_v8();
 
     StartupData cold_startup_data = {snapshot_info->data, snapshot_info->raw_size};
@@ -466,27 +588,16 @@ static VALUE rb_snapshot_warmup(VALUE self, VALUE str) {
     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 = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
-    isolate_info->interrupted = false;
-    isolate_info->refs_count = 1;
+void IsolateInfo::init(SnapshotInfo* snapshot_info) {
+    allocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
 
     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);
+    create_params.array_buffer_allocator = allocator;
 
+    if (snapshot_info) {
         int raw_size = snapshot_info->raw_size;
         char* data = new char[raw_size];
-        memcpy(data, snapshot_info->data, sizeof(char) * raw_size);
+        memcpy(data, snapshot_info->data, raw_size);
 
         startup_data = new StartupData;
         startup_data->data = data;
@@ -495,8 +606,22 @@ static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
         create_params.snapshot_blob = startup_data;
     }
 
-    isolate_info->startup_data = startup_data;
-    isolate_info->isolate = Isolate::New(create_params);
+    isolate = Isolate::New(create_params);
+}
+
+static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    init_v8();
+
+    SnapshotInfo* snapshot_info = nullptr;
+    if (!NIL_P(snapshot)) {
+        Data_Get_Struct(snapshot, SnapshotInfo, snapshot_info);
+    }
+
+    isolate_info->init(snapshot_info);
+    isolate_info->hold();
 
     return Qnil;
 }
@@ -505,23 +630,40 @@ 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;
+    if (current_platform == NULL) return Qfalse;
+
+    double duration = NUM2DBL(idle_time_in_ms) / 1000.0;
+    double now = current_platform->MonotonicallyIncreasingTime();
+    return isolate_info->isolate->IdleNotificationDeadline(now + duration) ? Qtrue : Qfalse;
 }
 
-static VALUE rb_context_init_with_isolate(VALUE self, VALUE isolate) {
+static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
     ContextInfo* context_info;
     Data_Get_Struct(self, ContextInfo, context_info);
 
     init_v8();
 
     IsolateInfo* isolate_info;
-    Data_Get_Struct(isolate, IsolateInfo, isolate_info);
+
+    if (NIL_P(isolate) || !rb_obj_is_kind_of(isolate, rb_cIsolate)) {
+        isolate_info = new IsolateInfo();
+
+        SnapshotInfo *snapshot_info = nullptr;
+        if (!NIL_P(snap) && rb_obj_is_kind_of(snap, rb_cSnapshot)) {
+            Data_Get_Struct(snap, SnapshotInfo, snapshot_info);
+        }
+        isolate_info->init(snapshot_info);
+    } else { // given isolate or snapshot
+        Data_Get_Struct(isolate, IsolateInfo, isolate_info);
+    }
 
     context_info->isolate_info = isolate_info;
-    isolate_info->refs_count++;
+    isolate_info->hold();
 
     {
-	Locker lock(isolate_info->isolate);
+        // the ruby lock is needed if this isn't a new isolate
+        IsolateInfo::Lock ruby_lock(isolate_info->mutex);
+        Locker lock(isolate_info->isolate);
 	Isolate::Scope isolate_scope(isolate_info->isolate);
 	HandleScope handle_scope(isolate_info->isolate);
 
@@ -539,19 +681,116 @@ static VALUE rb_context_init_with_isolate(VALUE self, VALUE isolate) {
     return Qnil;
 }
 
+static VALUE convert_result_to_ruby(VALUE self /* context */,
+                                    EvalResult& result) {
+    ContextInfo *context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+
+    Isolate *isolate = context_info->isolate_info->isolate;
+    Persistent<Context> *p_ctx = context_info->context;
+
+    VALUE message = Qnil;
+    VALUE backtrace = Qnil;
+    {
+        Locker lock(isolate);
+        if (result.message) {
+            message = convert_v8_to_ruby(isolate, *p_ctx, *result.message);
+            result.message->Reset();
+            delete result.message;
+            result.message = nullptr;
+        }
+
+        if (result.backtrace) {
+            backtrace = convert_v8_to_ruby(isolate, *p_ctx, *result.backtrace);
+            result.backtrace->Reset();
+            delete result.backtrace;
+        }
+    }
+
+    // NOTE: this is very important, we can not do an rb_raise from within
+    // a v8 scope, if we do the scope is never cleaned up properly and we leak
+    if (!result.parsed) {
+        if(TYPE(message) == T_STRING) {
+            rb_raise(rb_eParseError, "%s", RSTRING_PTR(message));
+        } else {
+            rb_raise(rb_eParseError, "Unknown JavaScript Error during parse");
+        }
+    }
+
+    if (!result.executed) {
+        VALUE ruby_exception = rb_iv_get(self, "@current_exception");
+        if (ruby_exception == Qnil) {
+            bool mem_softlimit_reached = (bool)isolate->GetData(MEM_SOFTLIMIT_REACHED);
+            // If we were terminated or have the memory softlimit flag set
+            if (result.terminated || mem_softlimit_reached) {
+                ruby_exception = mem_softlimit_reached ? rb_eV8OutOfMemoryError : rb_eScriptTerminatedError;
+            } else {
+                ruby_exception = rb_eScriptRuntimeError;
+            }
+
+            // exception report about what happened
+            if (TYPE(backtrace) == T_STRING) {
+                rb_raise(ruby_exception, "%s", RSTRING_PTR(backtrace));
+            } else if(TYPE(message) == T_STRING) {
+                rb_raise(ruby_exception, "%s", RSTRING_PTR(message));
+            } else {
+                rb_raise(ruby_exception, "Unknown JavaScript Error during execution");
+            }
+        } else {
+            VALUE rb_str = rb_funcall(ruby_exception, rb_intern("to_s"), 0);
+            rb_raise(CLASS_OF(ruby_exception), "%s", RSTRING_PTR(rb_str));
+        }
+    }
+
+    VALUE ret = Qnil;
+
+    // New scope for return value
+    {
+        Locker lock(isolate);
+        Isolate::Scope isolate_scope(isolate);
+        HandleScope handle_scope(isolate);
+
+        Local<Value> tmp = Local<Value>::New(isolate, *result.value);
+
+        if (result.json) {
+            Local<String> rstr = tmp->ToString();
+            VALUE json_string = rb_enc_str_new(*String::Utf8Value(rstr), rstr->Utf8Length(), rb_enc_find("utf-8"));
+            ret = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
+        } else {
+            ret = convert_v8_to_ruby(isolate, *p_ctx, tmp);
+        }
+
+        result.value->Reset();
+        delete result.value;
+    }
+
+    if (rb_funcall(ret, 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 ret;
+}
+
 static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
 
     EvalParams eval_params;
     EvalResult eval_result;
     ContextInfo* context_info;
-    VALUE result;
-
-    VALUE message = Qnil;
-    VALUE backtrace = Qnil;
 
     Data_Get_Struct(self, ContextInfo, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
+    if(TYPE(str) != T_STRING) {
+        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
+                rb_obj_class(str));
+    }
+    if(filename != Qnil && TYPE(filename) != T_STRING) {
+        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be nil or a string)",
+                rb_obj_class(filename));
+    }
+
     {
 	Locker lock(isolate);
 	Isolate::Scope isolate_scope(isolate);
@@ -589,90 +828,15 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
 	eval_result.backtrace = NULL;
 
 	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(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(isolate, *eval_result.backtrace);
-	    backtrace = convert_v8_to_ruby(isolate, tmp);
-	    eval_result.backtrace->Reset();
-	    delete eval_result.backtrace;
-	}
-    }
-
-    // NOTE: this is very important, we can not do an rb_raise from within
-    // a v8 scope, if we do the scope is never cleaned up properly and we leak
-    if (!eval_result.parsed) {
-	if(TYPE(message) == T_STRING) {
-	    rb_raise(rb_eParseError, "%s", RSTRING_PTR(message));
-	} else {
-	    rb_raise(rb_eParseError, "Unknown JavaScript Error during parse");
-	}
-    }
-
-    if (!eval_result.executed) {
-	VALUE ruby_exception = rb_iv_get(self, "@current_exception");
-	if (ruby_exception == Qnil) {
-		bool mem_softlimit_reached = (bool)isolate->GetData(MEM_SOFTLIMIT_REACHED);
-		// If we were terminated or have the memory softlimit flag set
-		if(eval_result.terminated || mem_softlimit_reached) {
-	    	ruby_exception = mem_softlimit_reached ? rb_eV8OutOfMemoryError : rb_eScriptTerminatedError;
-		} else {
-	    	ruby_exception = rb_eScriptRuntimeError;
-		}
-
-	    // exception report about what happened
-	    if(TYPE(backtrace) == T_STRING) {
-		rb_raise(ruby_exception, "%s", RSTRING_PTR(backtrace));
-	    } else if(TYPE(message) == T_STRING) {
-		rb_raise(ruby_exception, "%s", RSTRING_PTR(message));
-	    } else {
-		rb_raise(ruby_exception, "Unknown JavaScript Error during execution");
-	    }
-	} else {
-            VALUE rb_str = rb_funcall(ruby_exception, rb_intern("to_s"), 0);
-	    rb_raise(CLASS_OF(ruby_exception), "%s", RSTRING_PTR(rb_str));
-	}
-    }
-
-    // New scope for return value
-    {
-	Locker lock(isolate);
-	Isolate::Scope isolate_scope(isolate);
-	HandleScope handle_scope(isolate);
-
-	Local<Value> tmp = Local<Value>::New(isolate, *eval_result.value);
-
-	if (eval_result.json) {
-	    Local<String> rstr = tmp->ToString();
-	    VALUE json_string = rb_enc_str_new(*String::Utf8Value(rstr), rstr->Utf8Length(), rb_enc_find("utf-8"));
-	    result = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
-	} else {
-	    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;
+    return convert_result_to_ruby(self, eval_result);
 }
 
 typedef struct {
     VALUE callback;
     int length;
-    VALUE* args;
+    VALUE ruby_args;
     bool failed;
 } protected_callback_data;
 
@@ -682,7 +846,9 @@ VALUE protected_callback(VALUE rdata) {
     VALUE result;
 
     if (data->length > 0) {
-	result = rb_funcall2(data->callback, rb_intern("call"), data->length, data->args);
+	result = rb_funcall2(data->callback, rb_intern("call"), data->length,
+			     RARRAY_PTR(data->ruby_args));
+	RB_GC_GUARD(data->ruby_args);
     } else {
 	result = rb_funcall(data->callback, rb_intern("call"), 0);
     }
@@ -700,28 +866,36 @@ void*
 gvl_ruby_callback(void* data) {
 
     FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
-    VALUE* ruby_args = NULL;
+    VALUE ruby_args = Qnil;
     int length = args->Length();
     VALUE callback;
     VALUE result;
     VALUE self;
-
+    VALUE parent;
     {
-	HandleScope scope(args->GetIsolate());
-	Handle<External> external = Handle<External>::Cast(args->Data());
+        HandleScope scope(args->GetIsolate());
+        Local<External> external = Local<External>::Cast(args->Data());
 
-	VALUE* self_pointer = (VALUE*)(external->Value());
-	self = *self_pointer;
-	callback = rb_iv_get(self, "@callback");
+        self = *(VALUE*)(external->Value());
+        callback = rb_iv_get(self, "@callback");
+
+        parent = rb_iv_get(self, "@parent");
+        if (NIL_P(parent) || !rb_obj_is_kind_of(parent, rb_cContext)) {
+            return NULL;
+        }
+
+        ContextInfo* context_info;
+        Data_Get_Struct(parent, ContextInfo, context_info);
 
 	if (length > 0) {
-	    ruby_args = ALLOC_N(VALUE, length);
+	    ruby_args = rb_ary_tmp_new(length);
 	}
 
-
 	for (int i = 0; i < length; i++) {
 	    Local<Value> value = ((*args)[i]).As<Value>();
-	    ruby_args[i] = convert_v8_to_ruby(args->GetIsolate(), value);
+	    VALUE tmp = convert_v8_to_ruby(args->GetIsolate(),
+					      *context_info->context, value);
+	    rb_ary_push(ruby_args, tmp);
 	}
     }
 
@@ -729,12 +903,16 @@ gvl_ruby_callback(void* data) {
     protected_callback_data callback_data;
     callback_data.length = length;
     callback_data.callback = callback;
-    callback_data.args = ruby_args;
+    callback_data.ruby_args = ruby_args;
     callback_data.failed = false;
 
     if ((bool)args->GetIsolate()->GetData(DO_TERMINATE) == true) {
 	args->GetIsolate()->ThrowException(String::NewFromUtf8(args->GetIsolate(), "Terminated execution during transition from Ruby to JS"));
-	V8::TerminateExecution(args->GetIsolate());
+	args->GetIsolate()->TerminateExecution();
+	if (length > 0) {
+	    rb_ary_clear(ruby_args);
+	    rb_gc_force_recycle(ruby_args);
+	}
 	return NULL;
     }
 
@@ -742,7 +920,6 @@ gvl_ruby_callback(void* data) {
 			(VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data), rb_eException, (VALUE)0);
 
     if(callback_data.failed) {
-	VALUE parent = rb_iv_get(self, "@parent");
 	rb_iv_set(parent, "@current_exception", result);
 	args->GetIsolate()->ThrowException(String::NewFromUtf8(args->GetIsolate(), "Ruby exception"));
     }
@@ -753,27 +930,27 @@ gvl_ruby_callback(void* data) {
     }
 
     if (length > 0) {
-	xfree(ruby_args);
+	rb_ary_clear(ruby_args);
+	rb_gc_force_recycle(ruby_args);
     }
 
     if ((bool)args->GetIsolate()->GetData(DO_TERMINATE) == true) {
       Isolate* isolate = args->GetIsolate();
-      V8::TerminateExecution(isolate);
+      isolate->TerminateExecution();
     }
 
     return NULL;
 }
 
 static void ruby_callback(const FunctionCallbackInfo<Value>& args) {
-
     bool has_gvl = (bool)args.GetIsolate()->GetData(IN_GVL);
 
     if(has_gvl) {
 	gvl_ruby_callback((void*)&args);
     } else {
-    args.GetIsolate()->SetData(IN_GVL, (void*)true);
+	args.GetIsolate()->SetData(IN_GVL, (void*)true);
 	rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
-    args.GetIsolate()->SetData(IN_GVL, (void*)false);
+	args.GetIsolate()->SetData(IN_GVL, (void*)false);
     }
 }
 
@@ -838,16 +1015,27 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
     // always raise out of V8 context
     if (parse_error) {
-	rb_raise(rb_eParseError, "Invalid object %s", RSTRING_PTR(parent_object));
+	rb_raise(rb_eParseError, "Invalid object %" PRIsVALUE, parent_object);
     }
 
     if (attach_error) {
-	rb_raise(rb_eParseError, "Was expecting %s to be an object", RSTRING_PTR(parent_object));
+	rb_raise(rb_eParseError, "Was expecting %" PRIsVALUE" to be an object", parent_object);
     }
 
     return Qnil;
 }
 
+static VALUE rb_context_isolate_mutex(VALUE self) {
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+
+    if (!context_info->isolate_info) {
+        rb_raise(rb_eScriptRuntimeError, "Context has no Isolate available anymore");
+    }
+
+    return context_info->isolate_info->mutex;
+}
+
 void free_isolate(IsolateInfo* isolate_info) {
 
     if (isolate_info->isolate) {
@@ -874,26 +1062,11 @@ void free_isolate(IsolateInfo* isolate_info) {
     }
 
     delete isolate_info->allocator;
-    isolate_info->disposed = true;
 }
 
-void maybe_free_isolate(IsolateInfo* isolate_info) {
-    // an isolate can only be freed if no Isolate or Context (ruby) object
-    // still need it
-    //
-    // there is a sequence issue here where Ruby may call the deallocator on the
-    // context object after it calles the dallocator on the isolate
-    if (isolate_info->refs_count != 0 || isolate_info->disposed) {
-        return;
-    }
-
-    free_isolate(isolate_info);
-}
-
-
-void free_context(void* data) {
+// destroys everything except freeing the ContextInfo struct (see deallocate())
+static void free_context(ContextInfo* context_info) {
 
-    ContextInfo* context_info = (ContextInfo*)data;
     IsolateInfo* isolate_info = context_info->isolate_info;
 
     if (context_info->context && isolate_info && isolate_info->isolate) {
@@ -903,46 +1076,39 @@ void free_context(void* data) {
         delete context_info->context;
 	context_info->context = NULL;
     }
-}
-
-void deallocate_context(void* data) {
-
-    ContextInfo* context_info = (ContextInfo*)data;
-    IsolateInfo* isolate_info = context_info->isolate_info;
-
-    free_context(data);
 
     if (isolate_info) {
-	isolate_info->refs_count--;
-	maybe_free_isolate(isolate_info);
+        isolate_info->release();
+        context_info->isolate_info = NULL;
     }
 }
 
-void deallocate_isolate(void* data) {
+static void deallocate_isolate(void* data) {
 
     IsolateInfo* isolate_info = (IsolateInfo*) data;
 
-    isolate_info->refs_count--;
-    maybe_free_isolate(isolate_info);
+    isolate_info->release();
+}
 
-    if (isolate_info->refs_count == 0) {
-	xfree(isolate_info);
-    }
+static void mark_isolate(void* data) {
+    IsolateInfo* isolate_info = (IsolateInfo*) data;
+    isolate_info->mark();
 }
 
 void deallocate(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
-    IsolateInfo* isolate_info = context_info->isolate_info;
 
-    deallocate_context(data);
-
-    if (isolate_info && isolate_info->refs_count == 0) {
-	xfree(isolate_info);
-    }
+    free_context(context_info);
 
     xfree(data);
 }
 
+static void mark_context(void* data) {
+    ContextInfo* context_info = (ContextInfo*)data;
+    if (context_info->isolate_info) {
+        context_info->isolate_info->mark();
+    }
+}
 
 void deallocate_external_function(void * data) {
     xfree(data);
@@ -964,7 +1130,7 @@ VALUE allocate(VALUE klass) {
     context_info->isolate_info = NULL;
     context_info->context = NULL;
 
-    return Data_Wrap_Struct(klass, NULL, deallocate, (void*)context_info);
+    return Data_Wrap_Struct(klass, mark_context, deallocate, (void*)context_info);
 }
 
 VALUE allocate_snapshot(VALUE klass) {
@@ -976,17 +1142,9 @@ VALUE allocate_snapshot(VALUE klass) {
 }
 
 VALUE allocate_isolate(VALUE klass) {
-    IsolateInfo* isolate_info = ALLOC(IsolateInfo);
-
-    isolate_info->isolate = NULL;
-    isolate_info->allocator = NULL;
-    isolate_info->startup_data = NULL;
-    isolate_info->interrupted = false;
-    isolate_info->refs_count = 0;
-    isolate_info->pid = getpid();
-    isolate_info->disposed = false;
+    IsolateInfo* isolate_info = new IsolateInfo();
 
-    return Data_Wrap_Struct(klass, NULL, deallocate_isolate, (void*)isolate_info);
+    return Data_Wrap_Struct(klass, mark_isolate, deallocate_isolate, (void*)isolate_info);
 }
 
 static VALUE
@@ -1033,7 +1191,7 @@ rb_context_stop(VALUE self) {
     // flag for termination
     isolate->SetData(DO_TERMINATE, (void*)true);
 
-    V8::TerminateExecution(isolate);
+    isolate->TerminateExecution();
     rb_funcall(self, rb_intern("stop_attached"), 0);
 
     return Qnil;
@@ -1047,22 +1205,148 @@ rb_context_dispose(VALUE self) {
 
     free_context(context_info);
 
-    if (context_info->isolate_info && context_info->isolate_info->refs_count == 2) {
-	// special case, we only have isolate + context so we can burn the
-	// isolate as well
-	free_isolate(context_info->isolate_info);
-    }
     return Qnil;
 }
 
+static void*
+nogvl_context_call(void *args) {
+
+    FunctionCall *call = (FunctionCall *) args;
+    if (!call) {
+        return NULL;
+    }
+    Isolate* isolate = call->context_info->isolate_info->isolate;
+
+    // in gvl flag
+    isolate->SetData(IN_GVL, (void*)false);
+    // terminate ASAP
+    isolate->SetData(DO_TERMINATE, (void*)false);
+
+    Isolate::Scope isolate_scope(isolate);
+    EscapableHandleScope handle_scope(isolate);
+    TryCatch trycatch(isolate);
+
+    Local<Context> context = call->context_info->context->Get(isolate);
+    Context::Scope context_scope(context);
+
+    Local<Function> fun = call->fun;
+
+    EvalResult& eval_res = call->result;
+    eval_res.parsed = true;
+
+    MaybeLocal<v8::Value> res = fun->Call(context, context->Global(), call->argc, call->argv);
+    prepare_result(res, trycatch, isolate, context, eval_res);
+
+    isolate->SetData(IN_GVL, (void*)true);
+
+    return NULL;
+}
+
+static void unblock_function(void *args) {
+    FunctionCall *call = (FunctionCall *) args;
+    call->context_info->isolate_info->interrupted = true;
+}
+
+static VALUE
+rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
+    ContextInfo* context_info;
+    FunctionCall call;
+    VALUE *call_argv = NULL;
+
+    Data_Get_Struct(self, ContextInfo, context_info);
+    Isolate* isolate = context_info->isolate_info->isolate;
+
+    if (argc < 1) {
+        rb_raise(rb_eArgError, "need at least one argument %d", argc);
+    }
+
+    VALUE function_name = argv[0];
+    if (TYPE(function_name) != T_STRING) {
+        rb_raise(rb_eTypeError, "first argument should be a String");
+    }
+
+    char *fname = RSTRING_PTR(function_name);
+    if (!fname) {
+        return Qnil;
+    }
+
+    call.context_info = context_info;
+    call.error = false;
+    call.function_name = fname;
+    call.argc = argc - 1;
+    call.argv = NULL;
+    if (call.argc > 0) {
+        // skip first argument which is the function name
+        call_argv = argv + 1;
+    }
+
+    bool missingFunction = false;
+
+    {
+        Locker lock(isolate);
+        Isolate::Scope isolate_scope(isolate);
+        HandleScope handle_scope(isolate);
+
+        Local<Context> context = context_info->context->Get(isolate);
+        Context::Scope context_scope(context);
+
+        // examples of such usage can be found in
+        // https://github.com/v8/v8/blob/36b32aa28db5e993312f4588d60aad5c8330c8a5/test/cctest/test-api.cc#L15711
+	Local<String> fname = String::NewFromUtf8(isolate, call.function_name);
+	MaybeLocal<v8::Value> val = context->Global()->Get(fname);
+
+	if (val.IsEmpty() || !val.ToLocalChecked()->IsFunction()) {
+	    missingFunction = true;
+	} else {
+
+	    Local<v8::Function> fun = Local<v8::Function>::Cast(val.ToLocalChecked());
+	    call.fun = fun;
+	    int fun_argc = call.argc;
+
+	    if (fun_argc > 0) {
+		call.argv = (v8::Local<Value> *) malloc(sizeof(void *) * fun_argc);
+		if (!call.argv) {
+		    return Qnil;
+		}
+		for(int i=0; i < fun_argc; i++) {
+		    call.argv[i] = convert_ruby_to_v8(isolate, call_argv[i]);
+		}
+	    }
+
+	    rb_thread_call_without_gvl(nogvl_context_call, &call, unblock_function, &call);
+	    free(call.argv);
+
+	}
+    }
+
+    if (missingFunction) {
+	rb_raise(rb_eScriptRuntimeError, "Unknown JavaScript method invoked");
+    }
+
+    return convert_result_to_ruby(self, call.result);
+}
+
+static VALUE rb_context_create_isolate_value(VALUE self) {
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+    IsolateInfo *isolate_info = context_info->isolate_info;
+
+    if (!isolate_info) {
+        return Qnil;
+    }
+
+    isolate_info->hold();
+    return Data_Wrap_Struct(rb_cIsolate, NULL, &deallocate_isolate, isolate_info);
+}
+
 extern "C" {
 
     void Init_mini_racer_extension ( void )
     {
 	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);
+	rb_cContext = rb_define_class_under(rb_mMiniRacer, "Context", rb_cObject);
+	rb_cSnapshot = rb_define_class_under(rb_mMiniRacer, "Snapshot", rb_cObject);
+	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_eError = rb_define_class_under(rb_mMiniRacer, "Error", rb_eStandardError);
@@ -1084,18 +1368,21 @@ extern "C" {
 	rb_define_method(rb_cContext, "stop", (VALUE(*)(...))&rb_context_stop, 0);
 	rb_define_method(rb_cContext, "dispose_unsafe", (VALUE(*)(...))&rb_context_dispose, 0);
 	rb_define_method(rb_cContext, "heap_stats", (VALUE(*)(...))&rb_heap_stats, 0);
+	rb_define_private_method(rb_cContext, "create_isolate_value",(VALUE(*)(...))&rb_context_create_isolate_value, 0);
+	rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 2);
+	rb_define_private_method(rb_cContext, "call_unsafe", (VALUE(*)(...))&rb_context_call_unsafe, -1);
+	rb_define_private_method(rb_cContext, "isolate_mutex", (VALUE(*)(...))&rb_context_isolate_mutex, 0);
+	rb_define_private_method(rb_cContext, "init_unsafe",(VALUE(*)(...))&rb_context_init_unsafe, 2);
 
 	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, 2);
-	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_method(rb_cSnapshot, "warmup_unsafe!", (VALUE(*)(...))&rb_snapshot_warmup_unsafe, 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);