mini_racer 0.1.0 → 0.5.0

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -1,35 +1,108 @@
 #include <stdio.h>
 #include <ruby.h>
 #include <ruby/thread.h>
-#include <include/v8.h>
-#include <include/libplatform/libplatform.h>
+#include <ruby/io.h>
+#include <v8.h>
+#include <v8-profiler.h>
+#include <libplatform/libplatform.h>
 #include <ruby/encoding.h>
 #include <pthread.h>
 #include <unistd.h>
+#include <mutex>
+#include <atomic>
+#include <math.h>
 
 using namespace v8;
 
-class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
- public:
-  virtual void* Allocate(size_t length) {
-    void* data = AllocateUninitialized(length);
-    return data == NULL ? data : memset(data, 0, length);
-  }
-  virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
-  virtual void Free(void* data, size_t) { free(data); }
+typedef struct {
+    const char* data;
+    int raw_size;
+} SnapshotInfo;
+
+class IsolateInfo {
+public:
+    Isolate* isolate;
+    ArrayBuffer::Allocator* allocator;
+    StartupData* startup_data;
+    bool interrupted;
+    bool added_gc_cb;
+    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), added_gc_cb(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 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;
+        }
+    }
+
+    int refs() {
+        return refs_count;
+    }
+
+    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 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 {
-    Isolate* isolate;
+    IsolateInfo* isolate_info;
     Persistent<Context>* context;
-    ArrayBufferAllocator* allocator;
-    bool interrupted;
 } ContextInfo;
 
 typedef struct {
     bool parsed;
     bool executed;
     bool terminated;
+    bool json;
     Persistent<Value>* value;
     Persistent<Value>* message;
     Persistent<Value>* backtrace;
@@ -38,168 +111,575 @@ typedef struct {
 typedef struct {
     ContextInfo* context_info;
     Local<String>* eval;
+    Local<String>* filename;
     useconds_t timeout;
     EvalResult* result;
+    size_t max_memory;
+    size_t marshal_stackdepth;
 } EvalParams;
 
+typedef struct {
+    ContextInfo *context_info;
+    char *function_name;
+    int argc;
+    bool error;
+    Local<Function> fun;
+    Local<Value> *argv;
+    EvalResult result;
+    size_t max_memory;
+    size_t marshal_stackdepth;
+} FunctionCall;
+
+class IsolateData {
+public:
+    enum Flag {
+        // first flags are bitfield
+        //  max count: sizeof(uintptr_t) * 8
+        IN_GVL, // whether we are inside of ruby gvl or not
+        DO_TERMINATE, // terminate as soon as possible
+        MEM_SOFTLIMIT_REACHED, // we've hit the memory soft limit
+        MEM_SOFTLIMIT_MAX, // maximum memory value
+        MARSHAL_STACKDEPTH_REACHED, // we've hit our max stack depth
+        MARSHAL_STACKDEPTH_VALUE, // current stackdepth
+        MARSHAL_STACKDEPTH_MAX, // maximum stack depth during marshal
+    };
+
+    static void Init(Isolate *isolate) {
+        // zero out all fields in the bitfield
+        isolate->SetData(0, 0);
+    }
+
+    static uintptr_t Get(Isolate *isolate, Flag flag) {
+        Bitfield u = { reinterpret_cast<uint64_t>(isolate->GetData(0)) };
+        switch (flag) {
+            case IN_GVL: return u.IN_GVL;
+            case DO_TERMINATE: return u.DO_TERMINATE;
+            case MEM_SOFTLIMIT_REACHED: return u.MEM_SOFTLIMIT_REACHED;
+            case MEM_SOFTLIMIT_MAX: return static_cast<uintptr_t>(u.MEM_SOFTLIMIT_MAX) << 10;
+            case MARSHAL_STACKDEPTH_REACHED: return u.MARSHAL_STACKDEPTH_REACHED;
+            case MARSHAL_STACKDEPTH_VALUE: return u.MARSHAL_STACKDEPTH_VALUE;
+            case MARSHAL_STACKDEPTH_MAX: return u.MARSHAL_STACKDEPTH_MAX;
+        }
+
+	// avoid compiler warning
+	return u.IN_GVL;
+    }
+
+    static void Set(Isolate *isolate, Flag flag, uintptr_t value) {
+        Bitfield u = { reinterpret_cast<uint64_t>(isolate->GetData(0)) };
+        switch (flag) {
+            case IN_GVL: u.IN_GVL = value; break;
+            case DO_TERMINATE: u.DO_TERMINATE = value; break;
+            case MEM_SOFTLIMIT_REACHED: u.MEM_SOFTLIMIT_REACHED = value; break;
+            // drop least significant 10 bits 'store memory amount in kb'
+            case MEM_SOFTLIMIT_MAX: u.MEM_SOFTLIMIT_MAX = value >> 10; break;
+            case MARSHAL_STACKDEPTH_REACHED: u.MARSHAL_STACKDEPTH_REACHED = value; break;
+            case MARSHAL_STACKDEPTH_VALUE: u.MARSHAL_STACKDEPTH_VALUE = value; break;
+            case MARSHAL_STACKDEPTH_MAX: u.MARSHAL_STACKDEPTH_MAX = value; break;
+        }
+        isolate->SetData(0, reinterpret_cast<void*>(u.dataPtr));
+    }
+
+private:
+    struct Bitfield {
+        // WARNING: this would explode on platforms below 64 bit ptrs
+        //  compiler will fail here, making it clear for them.
+        //  Additionally, using the other part of the union to reinterpret the
+        //  memory is undefined behavior according to spec, but is / has been stable
+        //  across major compilers for decades.
+        static_assert(sizeof(uintptr_t) >= sizeof(uint64_t), "mini_racer not supported on this platform. ptr size must be at least 64 bit.");
+        union {
+            uint64_t dataPtr: 64;
+            // order in this struct matters. For cpu performance keep larger subobjects
+            //  aligned on their boundaries (8 16 32), try not to straddle
+            struct {
+                size_t MEM_SOFTLIMIT_MAX:22;
+                bool IN_GVL:1;
+                bool DO_TERMINATE:1;
+                bool MEM_SOFTLIMIT_REACHED:1;
+                bool MARSHAL_STACKDEPTH_REACHED:1;
+                uint8_t :0; // align to next 8bit bound
+                size_t MARSHAL_STACKDEPTH_VALUE:10;
+                uint8_t :0; // align to next 8bit bound
+                size_t MARSHAL_STACKDEPTH_MAX:10;
+            };
+        };
+    };
+};
+
+struct StackCounter {
+    static void Reset(Isolate* isolate) {
+        if (IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX) > 0) {
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, 0);
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, false);
+        }
+    }
+
+    static void SetMax(Isolate* isolate, size_t marshalMaxStackDepth) {
+        if (marshalMaxStackDepth > 0) {
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX, marshalMaxStackDepth);
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, 0);
+            IsolateData::Set(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, false);
+        }
+    }
+
+    StackCounter(Isolate* isolate) {
+        this->isActive = IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_MAX) > 0;
+
+        if (this->isActive) {
+            this->isolate = isolate;
+            this->IncDepth(1);
+        }
+    }
+
+    bool IsTooDeep() {
+        if (!this->IsActive()) {
+            return false;
+        }
+
+        size_t depth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE);
+        size_t maxDepth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_MAX);
+        if (depth > maxDepth) {
+            IsolateData::Set(this->isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED, true);
+            return true;
+        }
+
+        return false;
+    }
+
+    bool IsActive() {
+        return this->isActive && !IsolateData::Get(this->isolate, IsolateData::DO_TERMINATE);
+    }
+
+    ~StackCounter() {
+        if (this->IsActive()) {
+            this->IncDepth(-1);
+        }
+    }
+
+private: 
+    Isolate* isolate;
+    bool isActive;
+
+    void IncDepth(int direction) {
+        int inc = direction > 0 ? 1 : -1;
+
+        size_t depth = IsolateData::Get(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE);
+
+        // don't decrement past 0
+        if (inc > 0 || depth > 0) {
+            depth += inc;
+        }
+
+        IsolateData::Set(this->isolate, IsolateData::MARSHAL_STACKDEPTH_VALUE, depth);
+    }
+};
+
+static VALUE rb_cContext;
+static VALUE rb_cSnapshot;
+static VALUE rb_cIsolate;
+
 static VALUE rb_eScriptTerminatedError;
+static VALUE rb_eV8OutOfMemoryError;
 static VALUE rb_eParseError;
 static VALUE rb_eScriptRuntimeError;
 static VALUE rb_cJavaScriptFunction;
+static VALUE rb_eSnapshotError;
+static VALUE rb_ePlatformAlreadyInitializedError;
+static VALUE rb_mJSON;
+
+static VALUE rb_cFailedV8Conversion;
+static VALUE rb_cDateTime = Qnil;
 
-static Platform* current_platform = NULL;
+static std::unique_ptr<Platform> current_platform = NULL;
+static std::mutex platform_lock;
+
+static pthread_attr_t *thread_attr_p;
+static pthread_rwlock_t exit_lock = PTHREAD_RWLOCK_INITIALIZER;
+static bool ruby_exiting = false; // guarded by exit_lock
+static bool single_threaded = false;
+
+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) {
+	if (!strcmp(RSTRING_PTR(flag_as_str), "--single_threaded")) {
+	   single_threaded = true;
+	}
+        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;
+}
 
 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();
+        V8::InitializeICU();
+        current_platform = platform::NewDefaultPlatform();
+        V8::InitializePlatform(current_platform.get());
+        V8::Initialize();
+    }
+
+    platform_lock.unlock();
+}
+
+static void gc_callback(Isolate *isolate, GCType type, GCCallbackFlags flags) {
+    if (IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_REACHED)) {
+        return;
+    }
+
+    size_t softlimit = IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_MAX);
+
+    HeapStatistics stats;
+    isolate->GetHeapStatistics(&stats);
+    size_t used = stats.used_heap_size();
+
+    if(used > softlimit) {
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_REACHED, true);
+        isolate->TerminateExecution();
     }
 }
 
-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;
+// 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(
+                        context, String::NewFromUtf8Literal(isolate, "JSON"))
+                    .ToLocalChecked().As<Object>();
+
+            Local<Function> stringify = JSON->Get(
+                        context, v8::String::NewFromUtf8Literal(isolate, "stringify"))
+                    .ToLocalChecked().As<Function>();
+
+            Local<Object> object = local_value->ToObject(context).ToLocalChecked();
+            const unsigned argc = 1;
+            Local<Value> argv[argc] = { object };
+            MaybeLocal<Value> json = stringify->Call(context, 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, line, column;
+
+                if (!message->GetLineNumber(context).To(&line)) {
+                  line = 0;
+                }
+
+                if (!message->GetStartColumn(context).To(&column)) {
+                  column = 0;
+                }
+
+                len = snprintf(buf, sizeof(buf), "%s at %s:%i:%i", *String::Utf8Value(isolate, message->Get()),
+                               *String::Utf8Value(isolate, message->GetScriptResourceName()->ToString(context).ToLocalChecked()),
+                               line,
+                               column);
+
+                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::NewFromUtf8Literal(isolate, "JavaScript was terminated (either by timeout or explicitly)");
+                evalRes.message->Reset(isolate, tmp);
+            }
+            if (!trycatch.StackTrace(context).IsEmpty()) {
+                evalRes.backtrace = new Persistent<Value>();
+                evalRes.backtrace->Reset(isolate,
+                                         trycatch.StackTrace(context).ToLocalChecked()->ToString(context).ToLocalChecked());
+            }
+        }
+    }
 }
 
 void*
 nogvl_context_eval(void* arg) {
+
     EvalParams* eval_params = (EvalParams*)arg;
     EvalResult* result = eval_params->result;
-    Isolate* isolate = eval_params->context_info->isolate;
+    IsolateInfo* isolate_info = eval_params->context_info->isolate_info;
+    Isolate* isolate = 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);
+    v8::ScriptOrigin *origin = NULL;
+
+    IsolateData::Init(isolate);
+
+    if (eval_params->max_memory > 0) {
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_MAX, eval_params->max_memory);
+        if (!isolate_info->added_gc_cb) {
+            isolate->AddGCEpilogueCallback(gc_callback);
+            isolate_info->added_gc_cb = true;
+        }
+    }
+
+    MaybeLocal<Script> parsed_script;
+
+    if (eval_params->filename) {
+        origin = new v8::ScriptOrigin(*eval_params->filename);
+    }
+
+    parsed_script = Script::Compile(context, *eval_params->eval, origin);
+
+    if (origin) {
+        delete origin;
+    }
 
-    MaybeLocal<Script> parsed_script = Script::Compile(context, *eval_params->eval);
     result->parsed = !parsed_script.IsEmpty();
     result->executed = false;
     result->terminated = false;
+    result->json = false;
     result->value = NULL;
 
+    MaybeLocal<Value> maybe_value;
     if (!result->parsed) {
-	result->message = new Persistent<Value>();
-	result->message->Reset(isolate, trycatch.Exception());
+        result->message = new Persistent<Value>();
+        result->message->Reset(isolate, trycatch.Exception());
     } else {
+        // parsing successful
+        if (eval_params->marshal_stackdepth > 0) {
+            StackCounter::SetMax(isolate, eval_params->marshal_stackdepth);
+        }
 
-	pthread_t breaker_thread;
-
-	if (eval_params->timeout > 0) {
-	   pthread_create(&breaker_thread, NULL, breaker, (void*)eval_params);
-	}
+        maybe_value = parsed_script.ToLocalChecked()->Run(context);
+    }
 
-	MaybeLocal<Value> maybe_value = parsed_script.ToLocalChecked()->Run(context);
+    prepare_result(maybe_value, trycatch, isolate, context, *result);
 
-	if (eval_params->timeout > 0) {
-	    pthread_cancel(breaker_thread);
-	    pthread_join(breaker_thread, NULL);
-	}
-
-	result->executed = !maybe_value.IsEmpty();
-
-	if (!result->executed) {
-	    if (trycatch.HasCaught()) {
-		if (!trycatch.Exception()->IsNull()) {
-		    result->message = new Persistent<Value>();
-		    result->message->Reset(isolate, trycatch.Exception()->ToString());
-		} 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());
-		}
-	    }
-	} else {
-	    Persistent<Value>* persistent = new Persistent<Value>();
-	    persistent->Reset(isolate, maybe_value.ToLocalChecked());
-	    result->value = persistent;
-	}
-    }
+    IsolateData::Set(isolate, IsolateData::IN_GVL, true);
 
     return NULL;
 }
 
-static VALUE convert_v8_to_ruby(Isolate* isolate, Handle<Value> &value) {
+static VALUE new_empty_failed_conv_obj() {
+    // 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(""));
+}
+
+// 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);
 
+    StackCounter stackCounter(isolate);
+
+    if (IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED)) {
+        return Qnil;
+    }
+
+    if (stackCounter.IsTooDeep()) {
+        IsolateData::Set(isolate, IsolateData::DO_TERMINATE, true);
+        isolate->TerminateExecution();
+        return Qnil;
+    }
+
     if (value->IsNull() || value->IsUndefined()){
-	return Qnil;
+        return Qnil;
     }
 
     if (value->IsInt32()) {
-     return INT2FIX(value->Int32Value());
+        return INT2FIX(value->Int32Value(context).ToChecked());
     }
 
     if (value->IsNumber()) {
-      return rb_float_new(value->NumberValue());
+        return rb_float_new(value->NumberValue(context).ToChecked());
     }
 
     if (value->IsTrue()) {
-      return Qtrue;
+        return Qtrue;
     }
 
     if (value->IsFalse()) {
-      return Qfalse;
+        return Qfalse;
     }
 
     if (value->IsArray()) {
       VALUE rb_array = rb_ary_new();
       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);
+          MaybeLocal<Value> element = arr->Get(context, i);
+          if (element.IsEmpty()) {
+              continue;
+          }
+          VALUE rb_elem = convert_v8_to_ruby(isolate, context, element.ToLocalChecked());
+          if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
+            return rb_elem;
+          }
           rb_ary_push(rb_array, rb_elem);
       }
       return rb_array;
     }
 
     if (value->IsFunction()){
-	return rb_funcall(rb_cJavaScriptFunction, rb_intern("new"), 0);
+        return rb_funcall(rb_cJavaScriptFunction, rb_intern("new"), 0);
+    }
+
+    if (value->IsDate()){
+        double ts = Local<Date>::Cast(value)->ValueOf();
+        double secs = ts/1000;
+        long nanos = round((secs - floor(secs)) * 1000000);
+
+        return rb_time_new(secs, nanos);
     }
 
     if (value->IsObject()) {
-	VALUE rb_hash = rb_hash_new();
-	Local<Context> context = Context::New(isolate);
-	Local<Object> object = value->ToObject();
-	MaybeLocal<Array> 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_value = convert_v8_to_ruby(isolate, value);
-	     rb_hash_aset(rb_hash, rb_key, rb_value);
-	    }
-	}
-	return rb_hash;
+        VALUE rb_hash = rb_hash_new();
+        TryCatch trycatch(isolate);
+
+        Local<Object> object = value->ToObject(context).ToLocalChecked();
+        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++) {
+             MaybeLocal<Value> key = props->Get(context, i);
+             if (key.IsEmpty()) {
+                return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
+             }
+             VALUE rb_key = convert_v8_to_ruby(isolate, context, key.ToLocalChecked());
+
+             MaybeLocal<Value> prop_value = object->Get(context, key.ToLocalChecked());
+             // this may have failed due to Get raising
+             if (prop_value.IsEmpty() || trycatch.HasCaught()) {
+                 return new_empty_failed_conv_obj();
+             }
+
+             VALUE rb_value = convert_v8_to_ruby(
+                         isolate, context, prop_value.ToLocalChecked());
+             rb_hash_aset(rb_hash, rb_key, rb_value);
+            }
+        }
+        return rb_hash;
     }
 
-    Local<String> rstr = value->ToString();
-    return rb_enc_str_new(*v8::String::Utf8Value(rstr), rstr->Utf8Length(), rb_enc_find("utf-8"));
+    if (value->IsSymbol()) {
+	v8::String::Utf8Value symbol_name(isolate,
+	    Local<Symbol>::Cast(value)->Name());
+
+	VALUE str_symbol = rb_enc_str_new(
+	    *symbol_name,
+	    symbol_name.length(),
+	    rb_enc_find("utf-8")
+	);
+
+	return rb_str_intern(str_symbol);
+    }
+
+    MaybeLocal<String> rstr_maybe = value->ToString(context);
+
+    if (rstr_maybe.IsEmpty()) {
+	return Qnil;
+    } else {
+	Local<String> rstr = rstr_maybe.ToLocalChecked();
+	return rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate), 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, Local<Context> context, VALUE value) {
     EscapableHandleScope scope(isolate);
 
+    Local<Array> array;
+    Local<Object> object;
+    VALUE hash_as_array;
+    VALUE pair;
+    int i;
+    long length;
+    long fixnum;
+    VALUE klass;
+
     switch (TYPE(value)) {
     case T_FIXNUM:
-	return scope.Escape(Integer::New(isolate, NUM2INT(value)));
+        fixnum = NUM2LONG(value);
+        if (fixnum > INT_MAX)
+        {
+            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)));
     case T_STRING:
@@ -210,144 +690,495 @@ static Handle<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
 	return scope.Escape(True(isolate));
     case T_FALSE:
 	return scope.Escape(False(isolate));
+    case T_ARRAY:
+	length = RARRAY_LEN(value);
+	array = Array::New(isolate, (int)length);
+	for(i=0; i<length; i++) {
+            Maybe<bool> success = array->Set(context, i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
+	    (void)(success);
+	}
+	return scope.Escape(array);
+    case T_HASH:
+	object = Object::New(isolate);
+	hash_as_array = rb_funcall(value, rb_intern("to_a"), 0);
+	length = RARRAY_LEN(hash_as_array);
+	for(i=0; i<length; i++) {
+	    pair = rb_ary_entry(hash_as_array, i);
+            Maybe<bool> success = object->Set(context, convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 0)),
+                  convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 1)));
+	    (void)(success);
+	}
+	return scope.Escape(object);
+    case T_SYMBOL:
+	value = rb_funcall(value, rb_intern("to_s"), 0);
+	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
     case T_DATA:
+        klass = rb_funcall(value, rb_intern("class"), 0);
+        if (klass == rb_cTime || klass == rb_cDateTime)
+        {
+            if (klass == rb_cDateTime)
+            {
+                value = rb_funcall(value, rb_intern("to_time"), 0);
+            }
+            value = rb_funcall(value, rb_intern("to_f"), 0);
+            return scope.Escape(Date::New(context, NUM2DBL(value) * 1000).ToLocalChecked());
+        }
     case T_OBJECT:
     case T_CLASS:
     case T_ICLASS:
     case T_MODULE:
     case T_REGEXP:
     case T_MATCH:
-    case T_ARRAY:
-    case T_HASH:
     case T_STRUCT:
     case T_BIGNUM:
     case T_FILE:
-    case T_SYMBOL:
     case T_UNDEF:
     case T_NODE:
     default:
-     // rb_warn("unknown conversion to V8 for: %s", RSTRING_PTR(rb_inspect(value)));
-      return scope.Escape(String::NewFromUtf8(isolate, "Undefined Conversion"));
+      return scope.Escape(String::NewFromUtf8Literal(isolate, "Undefined Conversion"));
+    }
     }
-
-}
 
 static void unblock_eval(void *ptr) {
     EvalParams* eval = (EvalParams*)ptr;
-    eval->context_info->interrupted = true;
+    eval->context_info->isolate_info->interrupted = true;
 }
 
+/*
+ * The implementations of the run_extra_code(), create_snapshot_data_blob() and
+ * warm_up_snapshot_data_blob() functions have been derived from V8's test suite.
+ */
+static bool run_extra_code(Isolate *isolate, Local<v8::Context> context,
+                    const char *utf8_source, const char *name) {
+    Context::Scope context_scope(context);
+    TryCatch try_catch(isolate);
+    Local<String> source_string;
+    if (!String::NewFromUtf8(isolate, utf8_source).ToLocal(&source_string)) {
+        return false;
+    }
+    Local<String> resource_name =
+            String::NewFromUtf8(isolate, name).ToLocalChecked();
+    ScriptOrigin origin(resource_name);
+    ScriptCompiler::Source source(source_string, origin);
+    Local<Script> script;
+    if (!ScriptCompiler::Compile(context, &source).ToLocal(&script))
+        return false;
+    if (script->Run(context).IsEmpty()) return false;
+    return true;
+}
 
-static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
+static StartupData
+create_snapshot_data_blob(const char *embedded_source = nullptr) {
+    Isolate *isolate = Isolate::Allocate();
+
+    // Optionally run a script to embed, and serialize to create a snapshot blob.
+    SnapshotCreator snapshot_creator(isolate);
+        {
+            HandleScope scope(isolate);
+        Local<v8::Context> context = v8::Context::New(isolate);
+            if (embedded_source != nullptr &&
+                !run_extra_code(isolate, context, embedded_source, "<embedded>")) {
+           return {};
+            }
+            snapshot_creator.SetDefaultContext(context);
+        }
+    return snapshot_creator.CreateBlob(
+            SnapshotCreator::FunctionCodeHandling::kClear);
+    }
 
-    EvalParams eval_params;
-    EvalResult eval_result;
-    ContextInfo* context_info;
-    VALUE result;
+StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
+                                       const char *warmup_source) {
+    // Use following steps to create a warmed up snapshot blob from a cold one:
+    //  - Create a new isolate from the cold snapshot.
+    //  - Create a new context to run the warmup script. This will trigger
+    //    compilation of executed functions.
+    //  - Create a new context. This context will be unpolluted.
+    //  - Serialize the isolate and the second context into a new snapshot blob.
+    StartupData result = {nullptr, 0};
+
+    if (cold_snapshot_blob.raw_size > 0 && cold_snapshot_blob.data != nullptr &&
+        warmup_source != NULL) {
+        SnapshotCreator snapshot_creator(nullptr, &cold_snapshot_blob);
+        Isolate *isolate = snapshot_creator.GetIsolate();
+        {
+            HandleScope scope(isolate);
+            Local<Context> context = Context::New(isolate);
+            if (!run_extra_code(isolate, context, warmup_source, "<warm-up>")) {
+                return result;
+            }
+        }
+        {
+            HandleScope handle_scope(isolate);
+            isolate->ContextDisposedNotification(false);
+            Local<Context> context = Context::New(isolate);
+            snapshot_creator.SetDefaultContext(context);
+        }
+        result = snapshot_creator.CreateBlob(
+            SnapshotCreator::FunctionCodeHandling::kKeep);
+    }
+    return result;
+}
 
-    VALUE message = Qnil;
-    VALUE backtrace = Qnil;
+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);
+
+    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 = create_snapshot_data_blob(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_dump(VALUE self, VALUE str) {
+    SnapshotInfo* snapshot_info;
+    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+
+    return rb_str_new(snapshot_info->data, snapshot_info->raw_size);
+}
+
+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};
+    StartupData warm_startup_data = warm_up_snapshot_data_blob(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;
+}
+
+void IsolateInfo::init(SnapshotInfo* snapshot_info) {
+    allocator = v8::ArrayBuffer::Allocator::NewDefaultAllocator();
+
+    Isolate::CreateParams create_params;
+    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, raw_size);
+
+        startup_data = new StartupData;
+        startup_data->data = data;
+        startup_data->raw_size = raw_size;
+
+        create_params.snapshot_blob = startup_data;
+    }
+
+    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;
+}
+
+static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    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_isolate_low_memory_notification(VALUE self) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    if (current_platform == NULL) return Qfalse;
+
+    isolate_info->isolate->LowMemoryNotification();
+    return Qnil;
+}
+
+static VALUE rb_isolate_pump_message_loop(VALUE self) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    if (current_platform == NULL) return Qfalse;
+
+    if (platform::PumpMessageLoop(current_platform.get(), isolate_info->isolate)){
+	return Qtrue;
+    } else {
+	return Qfalse;
+    }
+}
+
+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;
+
+    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->hold();
+
     {
-	Locker lock(context_info->isolate);
-	Isolate::Scope isolate_scope(context_info->isolate);
-	HandleScope handle_scope(context_info->isolate);
-
-	Local<String> eval = String::NewFromUtf8(context_info->isolate, RSTRING_PTR(str),
-						  NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
-
-	eval_params.context_info = context_info;
-	eval_params.eval = &eval;
-	eval_params.result = &eval_result;
-	eval_params.timeout = 0;
-	VALUE timeout = rb_iv_get(self, "@timeout");
-	if (timeout != Qnil) {
-	    eval_params.timeout = (useconds_t)NUM2LONG(timeout);
-	}
+        // 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);
 
-	eval_result.message = NULL;
-	eval_result.backtrace = NULL;
+        Local<Context> context = Context::New(isolate_info->isolate);
 
-	rb_thread_call_without_gvl(nogvl_context_eval, &eval_params, unblock_eval, &eval_params);
+        context_info->context = new Persistent<Context>();
+        context_info->context->Reset(isolate_info->isolate, context);
+    }
 
-	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);
-	    eval_result.message->Reset();
-	    delete eval_result.message;
-	}
+    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"));
+    }
 
-	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);
-	    eval_result.backtrace->Reset();
-	    delete eval_result.backtrace;
-	}
+    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 (!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 (!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) {
-	    ruby_exception = eval_result.terminated ? rb_eScriptTerminatedError : rb_eScriptRuntimeError;
-	    // exception report about what happened
-	    if(TYPE(message) == T_STRING && TYPE(backtrace) == T_STRING) {
-		rb_raise(ruby_exception, "%s/n%s", RSTRING_PTR(message), 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 {
+    if (!result.executed) {
+        VALUE ruby_exception = rb_iv_get(self, "@current_exception");
+        if (ruby_exception == Qnil) {
+            bool mem_softlimit_reached = IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_REACHED);
+            bool marshal_stack_maxdepth_reached = IsolateData::Get(isolate, IsolateData::MARSHAL_STACKDEPTH_REACHED);
+            // If we were terminated or have the memory softlimit flag set
+            if (marshal_stack_maxdepth_reached) {
+                ruby_exception = rb_eScriptRuntimeError;
+                std::string msg = std::string("Marshal object depth too deep. Script terminated.");
+                message = rb_enc_str_new(msg.c_str(), msg.length(), rb_enc_find("utf-8"));
+            } else 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));
-	}
+            rb_raise(CLASS_OF(ruby_exception), "%s", RSTRING_PTR(rb_str));
+        }
     }
 
+    VALUE ret = Qnil;
+
     // New scope for return value
     {
-	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(isolate, *result.value);
+
+        if (result.json) {
+            Local<String> rstr = tmp->ToString(p_ctx->Get(isolate)).ToLocalChecked();
+            VALUE json_string = rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate), rb_enc_find("utf-8"));
+            ret = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
+        } else {
+            StackCounter::Reset(isolate);
+            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;
+
+    Data_Get_Struct(self, ContextInfo, context_info);
+    Isolate* isolate = context_info->isolate_info->isolate;
 
-	Local<Value> tmp = Local<Value>::New(context_info->isolate, *eval_result.value);
-	result = convert_v8_to_ruby(context_info->isolate, tmp);
+    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));
+    }
 
-	eval_result.value->Reset();
-	delete eval_result.value;
+    {
+        Locker lock(isolate);
+        Isolate::Scope isolate_scope(isolate);
+        HandleScope handle_scope(isolate);
+
+        Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
+                    NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
+
+        Local<String> local_filename;
+
+        if (filename != Qnil) {
+            local_filename = String::NewFromUtf8(isolate, RSTRING_PTR(filename),
+                NewStringType::kNormal, (int)RSTRING_LEN(filename)).ToLocalChecked();
+            eval_params.filename = &local_filename;
+        } else {
+            eval_params.filename = NULL;
+        }
+
+        eval_params.context_info = context_info;
+        eval_params.eval = &eval;
+        eval_params.result = &eval_result;
+        eval_params.timeout = 0;
+        eval_params.max_memory = 0;
+        eval_params.marshal_stackdepth = 0;
+        VALUE timeout = rb_iv_get(self, "@timeout");
+        if (timeout != Qnil) {
+            eval_params.timeout = (useconds_t)NUM2LONG(timeout);
+        }
+
+        VALUE mem_softlimit = rb_iv_get(self, "@max_memory");
+        if (mem_softlimit != Qnil) {
+            eval_params.max_memory = (size_t)NUM2ULONG(mem_softlimit);
+        }
+
+        VALUE stack_depth = rb_iv_get(self, "@marshal_stack_depth");
+        if (stack_depth != Qnil) {
+            eval_params.marshal_stackdepth = (size_t)NUM2ULONG(stack_depth);
+        }
+
+        eval_result.message = NULL;
+        eval_result.backtrace = NULL;
+
+        rb_thread_call_without_gvl(nogvl_context_eval, &eval_params, unblock_eval, &eval_params);
     }
 
-    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;
 
-static
-VALUE protected_callback(VALUE rdata) {
+static VALUE protected_callback(VALUE rdata) {
     protected_callback_data* data = (protected_callback_data*)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);
+        result = rb_funcall(data->callback, rb_intern("call"), 0);
     }
     return result;
 }
@@ -363,61 +1194,98 @@ void*
 gvl_ruby_callback(void* data) {
 
     FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
-    VALUE* ruby_args;
+    VALUE ruby_args = Qnil;
     int length = args->Length();
     VALUE callback;
     VALUE result;
     VALUE self;
+    VALUE parent;
+    ContextInfo* context_info;
 
     {
-	HandleScope scope(args->GetIsolate());
-	Handle<External> external = Handle<External>::Cast(args->Data());
-
-	VALUE* self_pointer = (VALUE*)(external->Value());
-	self = *self_pointer;
-	callback = rb_iv_get(self, "@callback");
-
-	if (length > 0) {
-	    ruby_args = ALLOC_N(VALUE, 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);
-	}
+        HandleScope scope(args->GetIsolate());
+        Local<External> external = Local<External>::Cast(args->Data());
+
+        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;
+        }
+
+        Data_Get_Struct(parent, ContextInfo, context_info);
+
+        if (length > 0) {
+            ruby_args = rb_ary_tmp_new(length);
+        }
+
+        for (int i = 0; i < length; i++) {
+            Local<Value> value = ((*args)[i]).As<Value>();
+            StackCounter::Reset(args->GetIsolate());
+            VALUE tmp = convert_v8_to_ruby(args->GetIsolate(),
+                                           *context_info->context, value);
+            rb_ary_push(ruby_args, tmp);
+        }
     }
 
     // may raise exception stay clear of handle scope
     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;
 
-    result = rb_rescue((VALUE(*)(...))&protected_callback, (VALUE)(&callback_data),
-			(VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data));
+    if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
+        args->GetIsolate()->ThrowException(
+                    String::NewFromUtf8Literal(args->GetIsolate(),
+                                               "Terminated execution during transition from Ruby to JS"));
+        args->GetIsolate()->TerminateExecution();
+        if (length > 0) {
+            rb_ary_clear(ruby_args);
+            rb_gc_force_recycle(ruby_args);
+        }
+        return NULL;
+    }
+
+    VALUE callback_data_value = (VALUE)&callback_data;
+
+    // TODO: use rb_vrescue2 in Ruby 2.7 and above
+    result = rb_rescue2(RUBY_METHOD_FUNC(protected_callback), callback_data_value,
+            RUBY_METHOD_FUNC(rescue_callback), callback_data_value, 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"));
+        rb_iv_set(parent, "@current_exception", result);
+        args->GetIsolate()->ThrowException(String::NewFromUtf8Literal(args->GetIsolate(), "Ruby exception"));
     }
     else {
-	HandleScope scope(args->GetIsolate());
-	Handle<Value> v8_result = convert_ruby_to_v8(args->GetIsolate(), result);
-	args->GetReturnValue().Set(v8_result);
+        HandleScope scope(args->GetIsolate());
+        Handle<Value> v8_result = convert_ruby_to_v8(args->GetIsolate(), context_info->context->Get(args->GetIsolate()), result);
+        args->GetReturnValue().Set(v8_result);
     }
 
     if (length > 0) {
-	xfree(ruby_args);
+        rb_ary_clear(ruby_args);
+        rb_gc_force_recycle(ruby_args);
+    }
+
+    if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
+      args->GetIsolate()->TerminateExecution();
     }
 
     return NULL;
 }
 
 static void ruby_callback(const FunctionCallbackInfo<Value>& args) {
-    rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
+    bool has_gvl = IsolateData::Get(args.GetIsolate(), IsolateData::IN_GVL);
+
+    if(has_gvl) {
+        gvl_ruby_callback((void*)&args);
+    } else {
+        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, true);
+        rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
+        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, false);
+    }
 }
 
 
@@ -427,114 +1295,613 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
     VALUE parent = rb_iv_get(self, "@parent");
     VALUE name = rb_iv_get(self, "@name");
+    VALUE parent_object = rb_iv_get(self, "@parent_object");
+    VALUE parent_object_eval = rb_iv_get(self, "@parent_object_eval");
+
+    bool parse_error = false;
+    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(isolate);
+        Context::Scope context_scope(context);
+
+        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
+        VALUE* self_copy;
+        Data_Get_Struct(self, VALUE, self_copy);
+        *self_copy = self;
+
+        Local<Value> external = External::New(isolate, self_copy);
+
+        if (parent_object == Qnil) {
+            Maybe<bool> success = context->Global()->Set(
+                        context,
+                        v8_str,
+                        FunctionTemplate::New(isolate, ruby_callback, external)
+                            ->GetFunction(context)
+                            .ToLocalChecked());
+	    (void)success;
+
+        } else {
+            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);
+            if (parsed_script.IsEmpty()) {
+            parse_error = true;
+            } else {
+                MaybeLocal<Value> maybe_value =
+                    parsed_script.ToLocalChecked()->Run(context);
+                attach_error = true;
+
+                if (!maybe_value.IsEmpty()) {
+                    Local<Value> value = maybe_value.ToLocalChecked();
+                    if (value->IsObject()) {
+                        Maybe<bool> success = value.As<Object>()->Set(
+                                    context,
+                                    v8_str,
+                                    FunctionTemplate::New(isolate, ruby_callback, external)
+                                        ->GetFunction(context)
+                                        .ToLocalChecked());
+			(void)success;
+                    attach_error = false;
+                    }
+                }
+            }
+        }
+    }
 
-    Local<Context> context = context_info->context->Get(context_info->isolate);
-    Context::Scope context_scope(context);
+    // always raise out of V8 context
+    if (parse_error) {
+        rb_raise(rb_eParseError, "Invalid object %" PRIsVALUE, parent_object);
+    }
 
-    Local<String> v8_str = String::NewFromUtf8(context_info->isolate, RSTRING_PTR(name),
-					      NewStringType::kNormal, (int)RSTRING_LEN(name)).ToLocalChecked();
+    if (attach_error) {
+        rb_raise(rb_eParseError, "Was expecting %" PRIsVALUE" to be an object", parent_object);
+    }
 
+    return Qnil;
+}
 
-    // copy self so we can access from v8 external
-    VALUE* self_copy;
-    Data_Get_Struct(self, VALUE, self_copy);
-    *self_copy = self;
+static VALUE rb_context_isolate_mutex(VALUE self) {
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
 
-    Local<Value> external = External::New(context_info->isolate, self_copy);
-    context->Global()->Set(v8_str, FunctionTemplate::New(context_info->isolate, ruby_callback, external)->GetFunction());
+    if (!context_info->isolate_info) {
+        rb_raise(rb_eScriptRuntimeError, "Context has no Isolate available anymore");
+    }
 
-    return Qnil;
+    return context_info->isolate_info->mutex;
 }
 
-void deallocate(void * data) {
-    ContextInfo* context_info = (ContextInfo*)data;
-    {
-	Locker lock(context_info->isolate);
+IsolateInfo::~IsolateInfo() {
+    if (isolate) {
+        if (this->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.\n");
+        } else {
+            if (this->pid != getpid() && !single_threaded) {
+                fprintf(stderr, "WARNING: V8 isolate was forked, "
+                                "it can not be disposed and "
+                                "memory will not be reclaimed "
+                                "till the Ruby process exits.\n"
+				"It is VERY likely your process will hang.\n"
+				"If you wish to use v8 in forked environment "
+				"please ensure the platform is initialized with:\n"
+				"MiniRacer::Platform.set_flags! :single_threaded\n"
+				);
+            } else {
+                isolate->Dispose();
+            }
+        }
+        isolate = nullptr;
     }
 
-    {
-	context_info->context->Reset();
-	delete context_info->context;
+    if (startup_data) {
+        delete[] startup_data->data;
+        delete startup_data;
     }
 
-    {
-	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();
-	}
+    delete allocator;
+}
+
+static void free_context_raw(void *arg) {
+    ContextInfo* context_info = (ContextInfo*)arg;
+    IsolateInfo* isolate_info = context_info->isolate_info;
+    Persistent<Context>* context = context_info->context;
+
+    if (context && isolate_info && isolate_info->isolate) {
+        Locker lock(isolate_info->isolate);
+        v8::Isolate::Scope isolate_scope(isolate_info->isolate);
+        context->Reset();
+        delete context;
+    }
+
+    if (isolate_info) {
+        isolate_info->release();
     }
 
-    delete context_info->allocator;
     xfree(context_info);
 }
 
-void deallocate_external_function(void * data) {
+static void *free_context_thr(void* arg) {
+    if (pthread_rwlock_tryrdlock(&exit_lock) != 0) {
+        return NULL;
+    }
+    if (ruby_exiting) {
+        return NULL;
+    }
+
+    free_context_raw(arg);
+
+    pthread_rwlock_unlock(&exit_lock);
+
+    return NULL;
+}
+
+// destroys everything except freeing the ContextInfo struct (see deallocate())
+static void free_context(ContextInfo* context_info) {
+
+    IsolateInfo* isolate_info = context_info->isolate_info;
+
+    ContextInfo* context_info_copy = ALLOC(ContextInfo);
+    context_info_copy->isolate_info = context_info->isolate_info;
+    context_info_copy->context = context_info->context;
+
+    if (isolate_info && isolate_info->refs() > 1) {
+        pthread_t free_context_thread;
+        if (pthread_create(&free_context_thread, thread_attr_p,
+                           free_context_thr, (void*)context_info_copy)) {
+            fprintf(stderr, "WARNING failed to release memory in MiniRacer, thread to release could not be created, process will leak memory\n");
+        }
+    } else {
+        free_context_raw(context_info_copy);
+    }
+
+    context_info->context = NULL;
+    context_info->isolate_info = NULL;
+}
+
+static void deallocate_isolate(void* data) {
+
+    IsolateInfo* isolate_info = (IsolateInfo*) data;
+
+    isolate_info->release();
+}
+
+static void mark_isolate(void* data) {
+    IsolateInfo* isolate_info = (IsolateInfo*) data;
+    isolate_info->mark();
+}
+
+static void deallocate(void* data) {
+    ContextInfo* context_info = (ContextInfo*)data;
+
+    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();
+    }
+}
+
+static void deallocate_external_function(void * data) {
     xfree(data);
 }
 
-VALUE allocate_external_function(VALUE klass) {
+static void deallocate_snapshot(void * data) {
+    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
+    delete[] snapshot_info->data;
+    xfree(snapshot_info);
+}
+
+static 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();
-
+static VALUE allocate(VALUE klass) {
     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, mark_context, deallocate, (void*)context_info);
+}
 
-    Locker lock(context_info->isolate);
-    Isolate::Scope isolate_scope(context_info->isolate);
-    HandleScope handle_scope(context_info->isolate);
+static 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);
+static VALUE allocate_isolate(VALUE klass) {
+    IsolateInfo* isolate_info = new IsolateInfo();
 
-    return Data_Wrap_Struct(klass, NULL, deallocate, (void*)context_info);
+    return Data_Wrap_Struct(klass, mark_isolate, deallocate_isolate, (void*)isolate_info);
+}
+
+static VALUE
+rb_heap_stats(VALUE self) {
+
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+    Isolate* isolate;
+    v8::HeapStatistics stats;
+
+    isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
+
+    VALUE rval = rb_hash_new();
+
+    if (!isolate) {
+
+        rb_hash_aset(rval, ID2SYM(rb_intern("total_physical_size")), ULONG2NUM(0));
+        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size_executable")), ULONG2NUM(0));
+        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size")), ULONG2NUM(0));
+        rb_hash_aset(rval, ID2SYM(rb_intern("used_heap_size")), ULONG2NUM(0));
+        rb_hash_aset(rval, ID2SYM(rb_intern("heap_size_limit")), ULONG2NUM(0));
+
+    } else {
+        isolate->GetHeapStatistics(&stats);
+
+        rb_hash_aset(rval, ID2SYM(rb_intern("total_physical_size")), ULONG2NUM(stats.total_physical_size()));
+        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size_executable")), ULONG2NUM(stats.total_heap_size_executable()));
+        rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size")), ULONG2NUM(stats.total_heap_size()));
+        rb_hash_aset(rval, ID2SYM(rb_intern("used_heap_size")), ULONG2NUM(stats.used_heap_size()));
+        rb_hash_aset(rval, ID2SYM(rb_intern("heap_size_limit")), ULONG2NUM(stats.heap_size_limit()));
+    }
+
+    return rval;
+}
+
+// https://github.com/bnoordhuis/node-heapdump/blob/master/src/heapdump.cc
+class FileOutputStream : public OutputStream {
+ public:
+  FileOutputStream(FILE* stream) : stream_(stream) {}
+
+  virtual int GetChunkSize() {
+    return 65536;
+  }
+
+  virtual void EndOfStream() {}
+
+  virtual WriteResult WriteAsciiChunk(char* data, int size) {
+    const size_t len = static_cast<size_t>(size);
+    size_t off = 0;
+
+    while (off < len && !feof(stream_) && !ferror(stream_))
+      off += fwrite(data + off, 1, len - off, stream_);
+
+    return off == len ? kContinue : kAbort;
+  }
+
+ private:
+  FILE* stream_;
+};
+
+
+static VALUE
+rb_heap_snapshot(VALUE self, VALUE file) {
+
+    rb_io_t *fptr;
+
+    fptr = RFILE(file)->fptr;
+
+    if (!fptr) return Qfalse;
+
+    FILE* fp;
+    fp = fdopen(fptr->fd, "w");
+    if (fp == NULL) return Qfalse;
+
+
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+    Isolate* isolate;
+    isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
+
+    if (!isolate) return Qfalse;
+
+    Locker lock(isolate);
+    Isolate::Scope isolate_scope(isolate);
+    HandleScope handle_scope(isolate);
+
+    HeapProfiler* heap_profiler = isolate->GetHeapProfiler();
+
+    const HeapSnapshot* const snap = heap_profiler->TakeHeapSnapshot();
+
+    FileOutputStream stream(fp);
+    snap->Serialize(&stream, HeapSnapshot::kJSON);
+
+    fflush(fp);
+
+    const_cast<HeapSnapshot*>(snap)->Delete();
+
+    return Qtrue;
 }
 
 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
+    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, true);
+
+    isolate->TerminateExecution();
+    rb_funcall(self, rb_intern("stop_attached"), 0);
+
     return Qnil;
 }
 
-extern "C" {
+static VALUE
+rb_context_dispose(VALUE self) {
+
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+
+    free_context(context_info);
+
+    return Qnil;
+}
+
+static void*
+nogvl_context_call(void *args) {
+
+    FunctionCall *call = (FunctionCall *) args;
+    if (!call) {
+        return NULL;
+    }
+    IsolateInfo *isolate_info = call->context_info->isolate_info;
+    Isolate* isolate = isolate_info->isolate;
+
+    IsolateData::Set(isolate, IsolateData::IN_GVL, false);
+    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, false);
+
+    if (call->max_memory > 0) {
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_MAX, call->max_memory);
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_REACHED, false);
+        if (!isolate_info->added_gc_cb) {
+            isolate->AddGCEpilogueCallback(gc_callback);
+            isolate_info->added_gc_cb = true;
+        }
+    }
+ 
+    if (call->marshal_stackdepth > 0) {
+        StackCounter::SetMax(isolate, call->marshal_stackdepth);
+    }
+
+    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);
+
+    IsolateData::Set(isolate, IsolateData::IN_GVL, 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;
 
-    void Init_mini_racer_extension ( void )
+    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;
+    }
+
+    call.max_memory = 0;
+    VALUE mem_softlimit = rb_iv_get(self, "@max_memory");
+    if (mem_softlimit != Qnil) {
+        unsigned long sl_int = NUM2ULONG(mem_softlimit);
+        call.max_memory = (size_t)sl_int;
+    }
+ 
+    call.marshal_stackdepth = 0;
+    VALUE marshal_stackdepth = rb_iv_get(self, "@marshal_stack_depth");
+    if (marshal_stackdepth != Qnil) {
+        unsigned long sl_int = NUM2ULONG(marshal_stackdepth);
+        call.marshal_stackdepth = (size_t)sl_int;
+    }
+
+    bool missingFunction = false;
     {
-	VALUE rb_mMiniRacer = rb_define_module("MiniRacer");
-	VALUE rb_cContext = rb_define_class_under(rb_mMiniRacer, "Context", rb_cObject);
+        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
+        MaybeLocal<String> fname = String::NewFromUtf8(isolate, call.function_name);
+        MaybeLocal<v8::Value> val;
+        if (!fname.IsEmpty()) {
+            val = context->Global()->Get(context, fname.ToLocalChecked());
+        }
+
+        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, context, 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");
+    }
 
-	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);
+    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);
+}
+
+static void set_ruby_exiting(VALUE value) {
+    (void)value;
 
-	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);
+    int res = pthread_rwlock_wrlock(&exit_lock);
 
-	rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 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);
+    ruby_exiting  = true;
+    if (res == 0) {
+        pthread_rwlock_unlock(&exit_lock);
     }
+}
 
+extern "C" {
+
+    __attribute__((visibility("default"))) void Init_mini_racer_extension ( void )
+    {
+        VALUE rb_mMiniRacer = rb_define_module("MiniRacer");
+        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);
+
+        VALUE rb_eEvalError = rb_define_class_under(rb_mMiniRacer, "EvalError", rb_eError);
+        rb_eScriptTerminatedError = rb_define_class_under(rb_mMiniRacer, "ScriptTerminatedError", rb_eEvalError);
+        rb_eV8OutOfMemoryError = rb_define_class_under(rb_mMiniRacer, "V8OutOfMemoryError", 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_eError);
+        rb_ePlatformAlreadyInitializedError = rb_define_class_under(rb_mMiniRacer, "PlatformAlreadyInitialized", rb_eError);
+        rb_cFailedV8Conversion = rb_define_class_under(rb_mMiniRacer, "FailedV8Conversion", rb_cObject);
+        rb_mJSON = rb_define_module("JSON");
+
+        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_method(rb_cContext, "dispose_unsafe", (VALUE(*)(...))&rb_context_dispose, 0);
+        rb_define_method(rb_cContext, "heap_stats", (VALUE(*)(...))&rb_heap_stats, 0);
+	rb_define_method(rb_cContext, "write_heap_snapshot_unsafe", (VALUE(*)(...))&rb_heap_snapshot, 1);
+
+        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_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, "dump", (VALUE(*)(...))&rb_snapshot_dump, 0);
+        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);
+        rb_define_method(rb_cIsolate, "low_memory_notification", (VALUE(*)(...))&rb_isolate_low_memory_notification, 0);
+        rb_define_method(rb_cIsolate, "pump_message_loop", (VALUE(*)(...))&rb_isolate_pump_message_loop, 0);
+        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);
+
+        rb_set_end_proc(set_ruby_exiting, Qnil);
+
+        static pthread_attr_t attr;
+        if (pthread_attr_init(&attr) == 0) {
+            if (pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED) == 0) {
+                thread_attr_p = &attr;
+            }
+        }
+        auto on_fork_for_child = []() {
+            exit_lock = PTHREAD_RWLOCK_INITIALIZER;
+        };
+        pthread_atfork(nullptr, nullptr, on_fork_for_child);
+    }
 }