mini_racer 0.2.4 → 0.4.0

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -1,7 +1,9 @@
 #include <stdio.h>
 #include <ruby.h>
 #include <ruby/thread.h>
+#include <ruby/io.h>
 #include <v8.h>
+#include <v8-profiler.h>
 #include <libplatform/libplatform.h>
 #include <ruby/encoding.h>
 #include <pthread.h>
@@ -23,6 +25,7 @@ public:
     ArrayBuffer::Allocator* allocator;
     StartupData* startup_data;
     bool interrupted;
+    bool added_gc_cb;
     pid_t pid;
     VALUE mutex;
 
@@ -40,15 +43,12 @@ public:
 
 
     IsolateInfo() : isolate(nullptr), allocator(nullptr), startup_data(nullptr),
-        interrupted(false), pid(getpid()), refs_count(0) {
+        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 free_isolate(IsolateInfo*);
-        free_isolate(this);
-    }
+    ~IsolateInfo();
 
     void init(SnapshotInfo* snapshot_info = nullptr);
 
@@ -71,7 +71,7 @@ public:
     }
 
     int refs() {
-	return refs_count;
+        return refs_count;
     }
 
     static void* operator new(size_t size) {
@@ -125,6 +125,7 @@ typedef struct {
     Local<Function> fun;
     Local<Value> *argv;
     EvalResult result;
+    size_t max_memory;
 } FunctionCall;
 
 enum IsolateFlags {
@@ -150,9 +151,14 @@ 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;
 
@@ -164,6 +170,9 @@ static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE 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;
@@ -187,8 +196,8 @@ static void init_v8() {
 
     if (current_platform == NULL) {
         V8::InitializeICU();
-        current_platform = platform::CreateDefaultPlatform();
-        V8::InitializePlatform(current_platform);
+        current_platform = platform::NewDefaultPlatform();
+        V8::InitializePlatform(current_platform.get());
         V8::Initialize();
     }
 
@@ -200,9 +209,9 @@ static void gc_callback(Isolate *isolate, GCType type, GCCallbackFlags flags) {
 
     size_t softlimit = *(size_t*) isolate->GetData(MEM_SOFTLIMIT_VALUE);
 
-    HeapStatistics* stats = new HeapStatistics();
-    isolate->GetHeapStatistics(stats);
-    size_t used = stats->used_heap_size();
+    HeapStatistics stats;
+    isolate->GetHeapStatistics(&stats);
+    size_t used = stats.used_heap_size();
 
     if(used > softlimit) {
         isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)true);
@@ -231,15 +240,17 @@ static void prepare_result(MaybeLocal<Value> v8res,
         if ((local_value->IsObject() || local_value->IsArray()) &&
                 !local_value->IsDate() && !local_value->IsFunction()) {
             Local<Object> JSON = context->Global()->Get(
-                        String::NewFromUtf8(isolate, "JSON"))->ToObject();
+                        context, String::NewFromUtf8Literal(isolate, "JSON"))
+                    .ToLocalChecked().As<Object>();
 
-            Local<Function> stringify = JSON->Get(v8::String::NewFromUtf8(isolate, "stringify"))
-                    .As<Function>();
+            Local<Function> stringify = JSON->Get(
+                        context, v8::String::NewFromUtf8Literal(isolate, "stringify"))
+                    .ToLocalChecked().As<Function>();
 
-            Local<Object> object = local_value->ToObject();
+            Local<Object> object = local_value->ToObject(context).ToLocalChecked();
             const unsigned argc = 1;
             Local<Value> argv[argc] = { object };
-            MaybeLocal<Value> json = stringify->Call(JSON, argc, argv);
+            MaybeLocal<Value> json = stringify->Call(context, JSON, argc, argv);
 
             if (json.IsEmpty()) {
                 evalRes.executed = false;
@@ -263,11 +274,21 @@ static void prepare_result(MaybeLocal<Value> v8res,
                 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());
+                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';
@@ -278,12 +299,13 @@ static void prepare_result(MaybeLocal<Value> v8res,
             } 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)");
+                Local<String> tmp = String::NewFromUtf8Literal(isolate, "JavaScript was terminated (either by timeout or explicitly)");
                 evalRes.message->Reset(isolate, tmp);
             }
-            if (!trycatch.StackTrace().IsEmpty()) {
+            if (!trycatch.StackTrace(context).IsEmpty()) {
                 evalRes.backtrace = new Persistent<Value>();
-                evalRes.backtrace->Reset(isolate, trycatch.StackTrace()->ToString());
+                evalRes.backtrace->Reset(isolate,
+                                         trycatch.StackTrace(context).ToLocalChecked()->ToString(context).ToLocalChecked());
             }
         }
     }
@@ -294,7 +316,8 @@ nogvl_context_eval(void* arg) {
 
     EvalParams* eval_params = (EvalParams*)arg;
     EvalResult* result = eval_params->result;
-    Isolate* isolate = eval_params->context_info->isolate_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);
@@ -315,13 +338,13 @@ nogvl_context_eval(void* arg) {
     MaybeLocal<Script> parsed_script;
 
     if (eval_params->filename) {
-	origin = new v8::ScriptOrigin(*eval_params->filename);
+        origin = new v8::ScriptOrigin(*eval_params->filename);
     }
 
     parsed_script = Script::Compile(context, *eval_params->eval, origin);
 
     if (origin) {
-	delete origin;
+        delete origin;
     }
 
     result->parsed = !parsed_script.IsEmpty();
@@ -332,13 +355,16 @@ nogvl_context_eval(void* arg) {
 
     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->max_memory > 0) {
             isolate->SetData(MEM_SOFTLIMIT_VALUE, &eval_params->max_memory);
+            if (!isolate_info->added_gc_cb) {
             isolate->AddGCEpilogueCallback(gc_callback);
+                isolate_info->added_gc_cb = true;
+            }
         }
 
         maybe_value = parsed_script.ToLocalChecked()->Run(context);
@@ -351,6 +377,12 @@ nogvl_context_eval(void* arg) {
     return NULL;
 }
 
+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) {
@@ -359,41 +391,44 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
     HandleScope scope(isolate);
 
     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, context, element);
-	  if (rb_funcall(rb_elem, rb_intern("class"), 0) == rb_cFailedV8Conversion) {
-	    return rb_elem;
-	  }
+          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()){
@@ -405,34 +440,55 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
     }
 
     if (value->IsObject()) {
-	VALUE rb_hash = rb_hash_new();
-	TryCatch trycatch(isolate);
-
-	Local<Object> object = value->ToObject();
-	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, context, key);
-	     Local<Value> prop_value = object->Get(key);
-	     // this may have failed due to Get raising
-
-	     if (trycatch.HasCaught()) {
-		 // TODO isolate code that translates execption to ruby
-		 // exception so we can properly return it
-		 return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
-	     }
-
-	     VALUE rb_value = convert_v8_to_ruby(isolate, context, prop_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(*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 ID2SYM(rb_intern_str(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 VALUE convert_v8_to_ruby(Isolate* isolate,
@@ -453,7 +509,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate,
                               Local<Value>::New(isolate, value));
 }
 
-static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
+static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context, VALUE value) {
     EscapableHandleScope scope(isolate);
 
     Local<Array> array;
@@ -487,7 +543,7 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
 	length = RARRAY_LEN(value);
 	array = Array::New(isolate, (int)length);
 	for(i=0; i<length; i++) {
-	    array->Set(i, convert_ruby_to_v8(isolate, rb_ary_entry(value, i)));
+            array->Set(context, i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
 	}
 	return scope.Escape(array);
     case T_HASH:
@@ -496,8 +552,8 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
 	length = RARRAY_LEN(hash_as_array);
 	for(i=0; i<length; i++) {
 	    pair = rb_ary_entry(hash_as_array, i);
-	    object->Set(convert_ruby_to_v8(isolate, rb_ary_entry(pair, 0)),
-			convert_ruby_to_v8(isolate, rb_ary_entry(pair, 1)));
+            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)));
 	}
 	return scope.Escape(object);
     case T_SYMBOL:
@@ -512,7 +568,7 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
                 value = rb_funcall(value, rb_intern("to_time"), 0);
             }
             value = rb_funcall(value, rb_intern("to_f"), 0);
-            return scope.Escape(Date::New(isolate, NUM2DBL(value) * 1000));
+            return scope.Escape(Date::New(context, NUM2DBL(value) * 1000).ToLocalChecked());
         }
     case T_OBJECT:
     case T_CLASS:
@@ -526,16 +582,90 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value) {
     case T_UNDEF:
     case T_NODE:
     default:
-      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->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 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);
+    }
+
+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;
+}
+
 static VALUE rb_snapshot_size(VALUE self, VALUE str) {
     SnapshotInfo* snapshot_info;
     Data_Get_Struct(self, SnapshotInfo, snapshot_info);
@@ -554,7 +684,7 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
 
     init_v8();
 
-    StartupData startup_data = V8::CreateSnapshotDataBlob(RSTRING_PTR(str));
+    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");
@@ -585,7 +715,7 @@ static VALUE rb_snapshot_warmup_unsafe(VALUE self, VALUE str) {
     init_v8();
 
     StartupData cold_startup_data = {snapshot_info->data, snapshot_info->raw_size};
-    StartupData warm_startup_data = V8::WarmUpSnapshotDataBlob(cold_startup_data, RSTRING_PTR(str));
+    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");
@@ -648,6 +778,29 @@ static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
     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);
@@ -675,13 +828,13 @@ static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
         // 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);
+        Isolate::Scope isolate_scope(isolate_info->isolate);
+        HandleScope handle_scope(isolate_info->isolate);
 
-	Local<Context> context = Context::New(isolate_info->isolate);
+        Local<Context> context = Context::New(isolate_info->isolate);
 
-	context_info->context = new Persistent<Context>();
-	context_info->context->Reset(isolate_info->isolate, context);
+        context_info->context = new Persistent<Context>();
+        context_info->context->Reset(isolate_info->isolate, context);
     }
 
     if (Qnil == rb_cDateTime && rb_funcall(rb_cObject, rb_intern("const_defined?"), 1, rb_str_new2("DateTime")) == Qtrue)
@@ -764,8 +917,8 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
         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"));
+            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 {
             ret = convert_v8_to_ruby(isolate, *p_ctx, tmp);
@@ -803,42 +956,42 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
     }
 
     {
-	Locker lock(isolate);
-	Isolate::Scope isolate_scope(isolate);
-	HandleScope handle_scope(isolate);
+        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> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
+                    NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
 
-	Local<String> local_filename;
+        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;
-	}
+        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;
-	VALUE timeout = rb_iv_get(self, "@timeout");
-	if (timeout != Qnil) {
-	    eval_params.timeout = (useconds_t)NUM2LONG(timeout);
-	}
+        eval_params.context_info = context_info;
+        eval_params.eval = &eval;
+        eval_params.result = &eval_result;
+        eval_params.timeout = 0;
+        eval_params.max_memory = 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 mem_softlimit = rb_iv_get(self, "@max_memory");
+        if (mem_softlimit != Qnil) {
+            eval_params.max_memory = (size_t)NUM2ULONG(mem_softlimit);
+        }
 
-	eval_result.message = NULL;
-	eval_result.backtrace = NULL;
+        eval_result.message = NULL;
+        eval_result.backtrace = NULL;
 
-	rb_thread_call_without_gvl(nogvl_context_eval, &eval_params, unblock_eval, &eval_params);
+        rb_thread_call_without_gvl(nogvl_context_eval, &eval_params, unblock_eval, &eval_params);
     }
 
     return convert_result_to_ruby(self, eval_result);
@@ -851,17 +1004,16 @@ typedef struct {
     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,
-			     RARRAY_PTR(data->ruby_args));
-	RB_GC_GUARD(data->ruby_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;
 }
@@ -883,6 +1035,8 @@ gvl_ruby_callback(void* data) {
     VALUE result;
     VALUE self;
     VALUE parent;
+    ContextInfo* context_info;
+
     {
         HandleScope scope(args->GetIsolate());
         Local<External> external = Local<External>::Cast(args->Data());
@@ -895,19 +1049,18 @@ gvl_ruby_callback(void* data) {
             return NULL;
         }
 
-        ContextInfo* context_info;
         Data_Get_Struct(parent, ContextInfo, context_info);
 
-	if (length > 0) {
-	    ruby_args = rb_ary_tmp_new(length);
-	}
+        if (length > 0) {
+            ruby_args = rb_ary_tmp_new(length);
+        }
 
-	for (int i = 0; i < length; i++) {
-	    Local<Value> value = ((*args)[i]).As<Value>();
-	    VALUE tmp = convert_v8_to_ruby(args->GetIsolate(),
-					      *context_info->context, value);
-	    rb_ary_push(ruby_args, tmp);
-	}
+        for (int i = 0; i < length; i++) {
+            Local<Value> value = ((*args)[i]).As<Value>();
+            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
@@ -918,31 +1071,33 @@ gvl_ruby_callback(void* data) {
     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"));
-	args->GetIsolate()->TerminateExecution();
-	if (length > 0) {
-	    rb_ary_clear(ruby_args);
-	    rb_gc_force_recycle(ruby_args);
-	}
-	return NULL;
+        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;
     }
 
     result = rb_rescue2((VALUE(*)(...))&protected_callback, (VALUE)(&callback_data),
-			(VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data), rb_eException, (VALUE)0);
+            (VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data), rb_eException, (VALUE)0);
 
     if(callback_data.failed) {
-	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) {
-	rb_ary_clear(ruby_args);
-	rb_gc_force_recycle(ruby_args);
+        rb_ary_clear(ruby_args);
+        rb_gc_force_recycle(ruby_args);
     }
 
     if ((bool)args->GetIsolate()->GetData(DO_TERMINATE) == true) {
@@ -957,11 +1112,11 @@ 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);
+        gvl_ruby_callback((void*)&args);
     } else {
-	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*)true);
+        rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
+        args.GetIsolate()->SetData(IN_GVL, (void*)false);
     }
 }
 
@@ -982,55 +1137,71 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
     Isolate* isolate = context_info->isolate_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) {
-	    context->Global()->Set(v8_str, FunctionTemplate::New(isolate, ruby_callback, external)->GetFunction());
-	} 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()){
-			value.As<Object>()->Set(v8_str, FunctionTemplate::New(isolate, ruby_callback, external)->GetFunction());
-			attach_error = 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);
+
+        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) {
+            context->Global()->Set(
+                        context,
+                        v8_str,
+                        FunctionTemplate::New(isolate, ruby_callback, external)
+                            ->GetFunction(context)
+                            .ToLocalChecked());
+
+        } 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()) {
+                        value.As<Object>()->Set(
+                                    context,
+                                    v8_str,
+                                    FunctionTemplate::New(isolate, ruby_callback, external)
+                                        ->GetFunction(context)
+                                        .ToLocalChecked());
+                    attach_error = false;
+                    }
+                }
+            }
+        }
     }
 
     // always raise out of V8 context
     if (parse_error) {
-	rb_raise(rb_eParseError, "Invalid object %" PRIsVALUE, parent_object);
+        rb_raise(rb_eParseError, "Invalid object %" PRIsVALUE, parent_object);
     }
 
     if (attach_error) {
-	rb_raise(rb_eParseError, "Was expecting %" PRIsVALUE" to be an object", parent_object);
+        rb_raise(rb_eParseError, "Was expecting %" PRIsVALUE" to be an object", parent_object);
     }
 
     return Qnil;
@@ -1047,35 +1218,39 @@ static VALUE rb_context_isolate_mutex(VALUE self) {
     return context_info->isolate_info->mutex;
 }
 
-void free_isolate(IsolateInfo* isolate_info) {
-
-    if (isolate_info->isolate) {
-	Locker lock(isolate_info->isolate);
-    }
-
-    if (isolate_info->isolate) {
-        if (isolate_info->interrupted) {
-            fprintf(stderr, "WARNING: V8 isolate was interrupted by Ruby, it can not be disposed and memory will not be reclaimed till the Ruby process exits.\n");
+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 (isolate_info->pid != getpid()) {
-		fprintf(stderr, "WARNING: V8 isolate was forked, it can not be disposed and memory will not be reclaimed till the Ruby process exits.\n");
-	    } else {
-		isolate_info->isolate->Dispose();
-	    }
+            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_info->isolate = NULL;
+        isolate = nullptr;
     }
 
-    if (isolate_info->startup_data) {
-        delete[] isolate_info->startup_data->data;
-        delete isolate_info->startup_data;
+    if (startup_data) {
+        delete[] startup_data->data;
+        delete startup_data;
     }
 
-    delete isolate_info->allocator;
+    delete allocator;
 }
 
-static void *free_context_raw(void* arg) {
+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;
@@ -1092,6 +1267,20 @@ static void *free_context_raw(void* arg) {
     }
 
     xfree(context_info);
+}
+
+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;
 }
 
@@ -1105,22 +1294,17 @@ static void free_context(ContextInfo* context_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, NULL, free_context_raw, (void*)context_info_copy)) {
+        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);
+        free_context_raw(context_info_copy);
     }
 
-    if (context_info->context && isolate_info && isolate_info->isolate) {
-	context_info->context = NULL;
-    }
-
-    if (isolate_info) {
-        context_info->isolate_info = NULL;
-    }
+    context_info->context = NULL;
+    context_info->isolate_info = NULL;
 }
 
 static void deallocate_isolate(void* data) {
@@ -1135,7 +1319,7 @@ static void mark_isolate(void* data) {
     isolate_info->mark();
 }
 
-void deallocate(void* data) {
+static void deallocate(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
 
     free_context(context_info);
@@ -1150,22 +1334,22 @@ static void mark_context(void* data) {
     }
 }
 
-void deallocate_external_function(void * data) {
+static void deallocate_external_function(void * data) {
     xfree(data);
 }
 
-void deallocate_snapshot(void * data) {
+static void deallocate_snapshot(void * data) {
     SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
     delete[] snapshot_info->data;
     xfree(snapshot_info);
 }
 
-VALUE allocate_external_function(VALUE klass) {
+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) {
+static VALUE allocate(VALUE klass) {
     ContextInfo* context_info = ALLOC(ContextInfo);
     context_info->isolate_info = NULL;
     context_info->context = NULL;
@@ -1173,7 +1357,7 @@ VALUE allocate(VALUE klass) {
     return Data_Wrap_Struct(klass, mark_context, deallocate, (void*)context_info);
 }
 
-VALUE allocate_snapshot(VALUE klass) {
+static VALUE allocate_snapshot(VALUE klass) {
     SnapshotInfo* snapshot_info = ALLOC(SnapshotInfo);
     snapshot_info->data = NULL;
     snapshot_info->raw_size = 0;
@@ -1181,7 +1365,7 @@ VALUE allocate_snapshot(VALUE klass) {
     return Data_Wrap_Struct(klass, NULL, deallocate_snapshot, (void*)snapshot_info);
 }
 
-VALUE allocate_isolate(VALUE klass) {
+static VALUE allocate_isolate(VALUE klass) {
     IsolateInfo* isolate_info = new IsolateInfo();
 
     return Data_Wrap_Struct(klass, mark_isolate, deallocate_isolate, (void*)isolate_info);
@@ -1201,25 +1385,90 @@ rb_heap_stats(VALUE self) {
 
     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));
+        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);
+        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()));
+        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) {
 
@@ -1255,13 +1504,23 @@ nogvl_context_call(void *args) {
     if (!call) {
         return NULL;
     }
-    Isolate* isolate = call->context_info->isolate_info->isolate;
+    IsolateInfo *isolate_info = call->context_info->isolate_info;
+    Isolate* isolate = isolate_info->isolate;
 
     // in gvl flag
     isolate->SetData(IN_GVL, (void*)false);
     // terminate ASAP
     isolate->SetData(DO_TERMINATE, (void*)false);
 
+    if (call->max_memory > 0) {
+        isolate->SetData(MEM_SOFTLIMIT_VALUE, &call->max_memory);
+        isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)false);
+        if (!isolate_info->added_gc_cb) {
+        isolate->AddGCEpilogueCallback(gc_callback);
+            isolate_info->added_gc_cb = true;
+    }
+    }
+
     Isolate::Scope isolate_scope(isolate);
     EscapableHandleScope handle_scope(isolate);
     TryCatch trycatch(isolate);
@@ -1287,8 +1546,7 @@ static void unblock_function(void *args) {
     call->context_info->isolate_info->interrupted = true;
 }
 
-static VALUE
-rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
+static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
     ContextInfo* context_info;
     FunctionCall call;
     VALUE *call_argv = NULL;
@@ -1320,8 +1578,14 @@ rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
         call_argv = argv + 1;
     }
 
-    bool missingFunction = false;
+    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;
+    }
 
+    bool missingFunction = false;
     {
         Locker lock(isolate);
         Isolate::Scope isolate_scope(isolate);
@@ -1332,35 +1596,37 @@ rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
 
         // 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);
+        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");
+    rb_raise(rb_eScriptRuntimeError, "Unknown JavaScript method invoked");
     }
 
     return convert_result_to_ruby(self, call.result);
@@ -1379,57 +1645,84 @@ static VALUE rb_context_create_isolate_value(VALUE self) {
     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");
-	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);
+static void set_ruby_exiting(VALUE value) {
+    (void)value;
 
-	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");
+    int res = pthread_rwlock_wrlock(&exit_lock);
 
-	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_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);
+    ruby_exiting  = true;
+    if (res == 0) {
+        pthread_rwlock_unlock(&exit_lock);
+    }
+}
 
-	rb_define_method(rb_cIsolate, "idle_notification", (VALUE(*)(...))&rb_isolate_idle_notification, 1);
-	rb_define_private_method(rb_cIsolate, "init_with_snapshot",(VALUE(*)(...))&rb_isolate_init_with_snapshot, 1);
+extern "C" {
 
-	rb_define_singleton_method(rb_cPlatform, "set_flag_as_str!", (VALUE(*)(...))&rb_platform_set_flag_as_str, 1);
+    __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);
     }
-
 }