mini_racer 0.3.1 → 0.6.4

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -2,6 +2,7 @@
 #include <ruby.h>
 #include <ruby/thread.h>
 #include <ruby/io.h>
+#include <ruby/version.h>
 #include <v8.h>
 #include <v8-profiler.h>
 #include <libplatform/libplatform.h>
@@ -11,6 +12,15 @@
 #include <mutex>
 #include <atomic>
 #include <math.h>
+#include <errno.h>
+
+/* workaround C Ruby <= 2.x problems w/ clang in C++ mode */
+#if defined(ENGINE_IS_CRUBY) && \
+	RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR <= 6
+#  define MR_METHOD_FUNC(fn) RUBY_METHOD_FUNC(fn)
+#else
+#  define MR_METHOD_FUNC(fn) fn
+#endif
 
 using namespace v8;
 
@@ -115,6 +125,7 @@ typedef struct {
     useconds_t timeout;
     EvalResult* result;
     size_t max_memory;
+    size_t marshal_stackdepth;
 } EvalParams;
 
 typedef struct {
@@ -126,13 +137,152 @@ typedef struct {
     Local<Value> *argv;
     EvalResult result;
     size_t max_memory;
+    size_t marshal_stackdepth;
 } FunctionCall;
 
-enum IsolateFlags {
-    IN_GVL,
-    DO_TERMINATE,
-    MEM_SOFTLIMIT_VALUE,
-    MEM_SOFTLIMIT_REACHED,
+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;
@@ -155,21 +305,44 @@ 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; // guarded by exit_lock
+static std::atomic_int ruby_exiting(0);
+static bool single_threaded = false;
+
+static void mark_context(void *);
+static void deallocate(void *);
+static size_t context_memsize(const void *);
+static const rb_data_type_t context_type = {
+    "mini_racer/context_info",
+    { mark_context, deallocate, context_memsize }
+};
+
+static void deallocate_snapshot(void *);
+static size_t snapshot_memsize(const void *);
+static const rb_data_type_t snapshot_type = {
+    "mini_racer/snapshot_info",
+    { NULL, deallocate_snapshot, snapshot_memsize }
+};
+
+static void mark_isolate(void *);
+static void deallocate_isolate(void *);
+static size_t isolate_memsize(const void *);
+static const rb_data_type_t isolate_type = {
+    "mini_racer/isolate_info",
+    { mark_isolate, deallocate_isolate, isolate_memsize }
+};
 
 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));
-    }
+    Check_Type(flag_as_str, T_STRING);
 
     platform_lock.lock();
 
     if (current_platform == NULL) {
-        V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), (int)RSTRING_LEN(flag_as_str));
+	if (!strcmp(RSTRING_PTR(flag_as_str), "--single_threaded")) {
+	   single_threaded = true;
+	}
+        V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), RSTRING_LENINT(flag_as_str));
     } else {
         platform_already_initialized = true;
     }
@@ -192,7 +365,11 @@ static void init_v8() {
 
     if (current_platform == NULL) {
         V8::InitializeICU();
-        current_platform = platform::NewDefaultPlatform();
+	if (single_threaded) {
+	    current_platform = platform::NewSingleThreadedDefaultPlatform();
+	} else {
+	    current_platform = platform::NewDefaultPlatform();
+	}
         V8::InitializePlatform(current_platform.get());
         V8::Initialize();
     }
@@ -201,16 +378,18 @@ static void init_v8() {
 }
 
 static void gc_callback(Isolate *isolate, GCType type, GCCallbackFlags flags) {
-    if((bool)isolate->GetData(MEM_SOFTLIMIT_REACHED)) return;
+    if (IsolateData::Get(isolate, IsolateData::MEM_SOFTLIMIT_REACHED)) {
+        return;
+    }
 
-    size_t softlimit = *(size_t*) isolate->GetData(MEM_SOFTLIMIT_VALUE);
+    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) {
-        isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)true);
+        IsolateData::Set(isolate, IsolateData::MEM_SOFTLIMIT_REACHED, true);
         isolate->TerminateExecution();
     }
 }
@@ -235,28 +414,32 @@ static void prepare_result(MaybeLocal<Value> v8res,
         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>();
+            MaybeLocal<v8::Value> ml = context->Global()->Get(
+                        context, String::NewFromUtf8Literal(isolate, "JSON"));
 
-            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()) {
+            if (ml.IsEmpty()) { // exception
                 evalRes.executed = false;
             } else {
-                evalRes.json = true;
-                Persistent<Value>* persistent = new Persistent<Value>();
-                persistent->Reset(isolate, json.ToLocalChecked());
-                evalRes.value = persistent;
+                Local<Object> JSON = ml.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);
@@ -307,7 +490,7 @@ static void prepare_result(MaybeLocal<Value> v8res,
     }
 }
 
-void*
+static void*
 nogvl_context_eval(void* arg) {
 
     EvalParams* eval_params = (EvalParams*)arg;
@@ -322,14 +505,15 @@ nogvl_context_eval(void* arg) {
     Context::Scope context_scope(context);
     v8::ScriptOrigin *origin = NULL;
 
-    // in gvl flag
-    isolate->SetData(IN_GVL, (void*)false);
-    // terminate ASAP
-    isolate->SetData(DO_TERMINATE, (void*)false);
-    // Memory softlimit
-    isolate->SetData(MEM_SOFTLIMIT_VALUE, (void*)false);
-    // Memory softlimit hit flag
-    isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)false);
+    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;
 
@@ -355,12 +539,8 @@ nogvl_context_eval(void* arg) {
         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;
-            }
+        if (eval_params->marshal_stackdepth > 0) {
+            StackCounter::SetMax(isolate, eval_params->marshal_stackdepth);
         }
 
         maybe_value = parsed_script.ToLocalChecked()->Run(context);
@@ -368,7 +548,7 @@ nogvl_context_eval(void* arg) {
 
     prepare_result(maybe_value, trycatch, isolate, context, *result);
 
-    isolate->SetData(IN_GVL, (void*)true);
+    IsolateData::Set(isolate, IsolateData::IN_GVL, true);
 
     return NULL;
 }
@@ -386,6 +566,18 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
     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;
     }
@@ -468,13 +660,9 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
 	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")
-	);
+	VALUE str_symbol = rb_utf8_str_new(*symbol_name, symbol_name.length());
 
-	return ID2SYM(rb_intern_str(str_symbol));
+	return rb_str_intern(str_symbol);
     }
 
     MaybeLocal<String> rstr_maybe = value->ToString(context);
@@ -483,7 +671,7 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
 	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"));
+	return rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
     }
 }
 
@@ -528,7 +716,7 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
     case T_FLOAT:
 	return scope.Escape(Number::New(isolate, NUM2DBL(value)));
     case T_STRING:
-	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
+	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, RSTRING_LENINT(value)).ToLocalChecked());
     case T_NIL:
 	return scope.Escape(Null(isolate));
     case T_TRUE:
@@ -539,7 +727,8 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
 	length = RARRAY_LEN(value);
 	array = Array::New(isolate, (int)length);
 	for(i=0; i<length; i++) {
-            array->Set(context, i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, 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:
@@ -548,13 +737,14 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
 	length = RARRAY_LEN(hash_as_array);
 	for(i=0; i<length; i++) {
 	    pair = rb_ary_entry(hash_as_array, i);
-            object->Set(context, convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 0)),
+            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());
+	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, RSTRING_LENINT(value)).ToLocalChecked());
     case T_DATA:
         klass = rb_funcall(value, rb_intern("class"), 0);
         if (klass == rb_cTime || klass == rb_cDateTime)
@@ -629,6 +819,7 @@ create_snapshot_data_blob(const char *embedded_source = nullptr) {
             SnapshotCreator::FunctionCodeHandling::kClear);
     }
 
+static
 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:
@@ -662,21 +853,18 @@ StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
     return result;
 }
 
-static VALUE rb_snapshot_size(VALUE self, VALUE str) {
+static VALUE rb_snapshot_size(VALUE self) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, 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);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
-    if(TYPE(str) != T_STRING) {
-        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
-                rb_obj_class(str));
-    }
+    Check_Type(str, T_STRING);
 
     init_v8();
 
@@ -692,21 +880,18 @@ static VALUE rb_snapshot_load(VALUE self, VALUE str) {
     return Qnil;
 }
 
-static VALUE rb_snapshot_dump(VALUE self, VALUE str) {
+static VALUE rb_snapshot_dump(VALUE self) {
     SnapshotInfo* snapshot_info;
-    Data_Get_Struct(self, SnapshotInfo, snapshot_info);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, 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);
+    TypedData_Get_Struct(self, SnapshotInfo, &snapshot_type, snapshot_info);
 
-    if(TYPE(str) != T_STRING) {
-        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
-                rb_obj_class(str));
-    }
+    Check_Type(str, T_STRING);
 
     init_v8();
 
@@ -748,13 +933,13 @@ void IsolateInfo::init(SnapshotInfo* snapshot_info) {
 
 static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     init_v8();
 
     SnapshotInfo* snapshot_info = nullptr;
     if (!NIL_P(snapshot)) {
-        Data_Get_Struct(snapshot, SnapshotInfo, snapshot_info);
+        TypedData_Get_Struct(snapshot, SnapshotInfo, &snapshot_type, snapshot_info);
     }
 
     isolate_info->init(snapshot_info);
@@ -765,7 +950,7 @@ static VALUE rb_isolate_init_with_snapshot(VALUE self, VALUE snapshot) {
 
 static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -776,7 +961,7 @@ static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
 
 static VALUE rb_isolate_low_memory_notification(VALUE self) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -786,7 +971,7 @@ static VALUE rb_isolate_low_memory_notification(VALUE self) {
 
 static VALUE rb_isolate_pump_message_loop(VALUE self) {
     IsolateInfo* isolate_info;
-    Data_Get_Struct(self, IsolateInfo, isolate_info);
+    TypedData_Get_Struct(self, IsolateInfo, &isolate_type, isolate_info);
 
     if (current_platform == NULL) return Qfalse;
 
@@ -799,7 +984,7 @@ static VALUE rb_isolate_pump_message_loop(VALUE self) {
 
 static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     init_v8();
 
@@ -810,11 +995,11 @@ static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
 
         SnapshotInfo *snapshot_info = nullptr;
         if (!NIL_P(snap) && rb_obj_is_kind_of(snap, rb_cSnapshot)) {
-            Data_Get_Struct(snap, SnapshotInfo, snapshot_info);
+            TypedData_Get_Struct(snap, SnapshotInfo, &snapshot_type, snapshot_info);
         }
         isolate_info->init(snapshot_info);
     } else { // given isolate or snapshot
-        Data_Get_Struct(isolate, IsolateInfo, isolate_info);
+        TypedData_Get_Struct(isolate, IsolateInfo, &isolate_type, isolate_info);
     }
 
     context_info->isolate_info = isolate_info;
@@ -844,7 +1029,7 @@ static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
 static VALUE convert_result_to_ruby(VALUE self /* context */,
                                     EvalResult& result) {
     ContextInfo *context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     Isolate *isolate = context_info->isolate_info->isolate;
     Persistent<Context> *p_ctx = context_info->context;
@@ -871,7 +1056,7 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
     // a v8 scope, if we do the scope is never cleaned up properly and we leak
     if (!result.parsed) {
         if(TYPE(message) == T_STRING) {
-            rb_raise(rb_eParseError, "%s", RSTRING_PTR(message));
+            rb_raise(rb_eParseError, "%" PRIsVALUE, message);
         } else {
             rb_raise(rb_eParseError, "Unknown JavaScript Error during parse");
         }
@@ -880,9 +1065,13 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
     if (!result.executed) {
         VALUE ruby_exception = rb_iv_get(self, "@current_exception");
         if (ruby_exception == Qnil) {
-            bool mem_softlimit_reached = (bool)isolate->GetData(MEM_SOFTLIMIT_REACHED);
+            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 (result.terminated || mem_softlimit_reached) {
+            if (marshal_stack_maxdepth_reached) {
+                ruby_exception = rb_eScriptRuntimeError;
+                message = rb_utf8_str_new_literal("Marshal object depth too deep. Script terminated.");
+            } else if (result.terminated || mem_softlimit_reached) {
                 ruby_exception = mem_softlimit_reached ? rb_eV8OutOfMemoryError : rb_eScriptTerminatedError;
             } else {
                 ruby_exception = rb_eScriptRuntimeError;
@@ -890,15 +1079,17 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
 
             // exception report about what happened
             if (TYPE(backtrace) == T_STRING) {
-                rb_raise(ruby_exception, "%s", RSTRING_PTR(backtrace));
+                rb_raise(ruby_exception, "%" PRIsVALUE, backtrace);
             } else if(TYPE(message) == T_STRING) {
-                rb_raise(ruby_exception, "%s", RSTRING_PTR(message));
+                rb_raise(ruby_exception, "%" PRIsVALUE, message);
             } else {
                 rb_raise(ruby_exception, "Unknown JavaScript Error during execution");
             }
+        } else if (rb_obj_is_kind_of(ruby_exception, rb_eException)) {
+            rb_exc_raise(ruby_exception);
         } 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), "%" PRIsVALUE, rb_str);
         }
     }
 
@@ -914,9 +1105,10 @@ static VALUE convert_result_to_ruby(VALUE self /* context */,
 
         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"));
+            VALUE json_string = rb_utf8_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate));
             ret = rb_funcall(rb_mJSON, rb_intern("parse"), 1, json_string);
         } else {
+            StackCounter::Reset(isolate);
             ret = convert_v8_to_ruby(isolate, *p_ctx, tmp);
         }
 
@@ -939,16 +1131,13 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
     EvalResult eval_result;
     ContextInfo* context_info;
 
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
-    if(TYPE(str) != T_STRING) {
-        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be a string)",
-                rb_obj_class(str));
-    }
-    if(filename != Qnil && TYPE(filename) != T_STRING) {
-        rb_raise(rb_eArgError, "wrong type argument %" PRIsVALUE " (should be nil or a string)",
-                rb_obj_class(filename));
+    Check_Type(str, T_STRING);
+
+    if (!NIL_P(filename)) {
+        Check_Type(filename, T_STRING);
     }
 
     {
@@ -957,13 +1146,13 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
         HandleScope handle_scope(isolate);
 
         Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
-                    NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
+                    NewStringType::kNormal, RSTRING_LENINT(str)).ToLocalChecked();
 
         Local<String> local_filename;
 
         if (filename != Qnil) {
             local_filename = String::NewFromUtf8(isolate, RSTRING_PTR(filename),
-                NewStringType::kNormal, (int)RSTRING_LEN(filename)).ToLocalChecked();
+                NewStringType::kNormal, RSTRING_LENINT(filename)).ToLocalChecked();
             eval_params.filename = &local_filename;
         } else {
             eval_params.filename = NULL;
@@ -974,6 +1163,7 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
         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);
@@ -984,6 +1174,11 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
             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;
 
@@ -1021,7 +1216,7 @@ VALUE rescue_callback(VALUE rdata, VALUE exception) {
     return exception;
 }
 
-void*
+static void*
 gvl_ruby_callback(void* data) {
 
     FunctionCallbackInfo<Value>* args = (FunctionCallbackInfo<Value>*)data;
@@ -1037,7 +1232,7 @@ gvl_ruby_callback(void* data) {
         HandleScope scope(args->GetIsolate());
         Local<External> external = Local<External>::Cast(args->Data());
 
-        self = *(VALUE*)(external->Value());
+        self = (VALUE)(external->Value());
         callback = rb_iv_get(self, "@callback");
 
         parent = rb_iv_get(self, "@parent");
@@ -1045,7 +1240,7 @@ gvl_ruby_callback(void* data) {
             return NULL;
         }
 
-        Data_Get_Struct(parent, ContextInfo, context_info);
+        TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
 
         if (length > 0) {
             ruby_args = rb_ary_tmp_new(length);
@@ -1053,6 +1248,7 @@ gvl_ruby_callback(void* data) {
 
         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);
@@ -1066,20 +1262,22 @@ gvl_ruby_callback(void* data) {
     callback_data.ruby_args = ruby_args;
     callback_data.failed = false;
 
-    if ((bool)args->GetIsolate()->GetData(DO_TERMINATE) == true) {
+    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;
     }
 
-    result = rb_rescue2((VALUE(*)(...))&protected_callback, (VALUE)(&callback_data),
-            (VALUE(*)(...))&rescue_callback, (VALUE)(&callback_data), rb_eException, (VALUE)0);
+    VALUE callback_data_value = (VALUE)&callback_data;
+
+    // TODO: use rb_vrescue2 in Ruby 2.7 and above
+    result = rb_rescue2(MR_METHOD_FUNC(protected_callback), callback_data_value,
+            MR_METHOD_FUNC(rescue_callback), callback_data_value, rb_eException, (VALUE)0);
 
     if(callback_data.failed) {
         rb_iv_set(parent, "@current_exception", result);
@@ -1093,26 +1291,24 @@ gvl_ruby_callback(void* data) {
 
     if (length > 0) {
         rb_ary_clear(ruby_args);
-        rb_gc_force_recycle(ruby_args);
     }
 
-    if ((bool)args->GetIsolate()->GetData(DO_TERMINATE) == true) {
-      Isolate* isolate = args->GetIsolate();
-      isolate->TerminateExecution();
+    if (IsolateData::Get(args->GetIsolate(), IsolateData::DO_TERMINATE)) {
+      args->GetIsolate()->TerminateExecution();
     }
 
     return NULL;
 }
 
 static void ruby_callback(const FunctionCallbackInfo<Value>& args) {
-    bool has_gvl = (bool)args.GetIsolate()->GetData(IN_GVL);
+    bool has_gvl = IsolateData::Get(args.GetIsolate(), IsolateData::IN_GVL);
 
     if(has_gvl) {
         gvl_ruby_callback((void*)&args);
     } else {
-        args.GetIsolate()->SetData(IN_GVL, (void*)true);
+        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, true);
         rb_thread_call_with_gvl(gvl_ruby_callback, (void*)(&args));
-        args.GetIsolate()->SetData(IN_GVL, (void*)false);
+        IsolateData::Set(args.GetIsolate(), IsolateData::IN_GVL, false);
     }
 }
 
@@ -1129,7 +1325,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
     bool parse_error = false;
     bool attach_error = false;
 
-    Data_Get_Struct(parent, ContextInfo, context_info);
+    TypedData_Get_Struct(parent, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     {
@@ -1142,29 +1338,27 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
         Local<String> v8_str =
             String::NewFromUtf8(isolate, RSTRING_PTR(name),
-                                NewStringType::kNormal, (int)RSTRING_LEN(name))
+                                NewStringType::kNormal, RSTRING_LENINT(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);
+        // Note that self (rb_cExternalFunction) is a pure Ruby T_OBJECT,
+        // not a T_DATA type like most other classes in this file
+        Local<Value> external = External::New(isolate, (void *)self);
 
         if (parent_object == Qnil) {
-            context->Global()->Set(
+            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))
+                                    RSTRING_LENINT(parent_object_eval))
                     .ToLocalChecked();
 
             MaybeLocal<Script> parsed_script = Script::Compile(context, eval);
@@ -1178,12 +1372,13 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
                 if (!maybe_value.IsEmpty()) {
                     Local<Value> value = maybe_value.ToLocalChecked();
                     if (value->IsObject()) {
-                        value.As<Object>()->Set(
+                        Maybe<bool> success = value.As<Object>()->Set(
                                     context,
                                     v8_str,
                                     FunctionTemplate::New(isolate, ruby_callback, external)
                                         ->GetFunction(context)
                                         .ToLocalChecked());
+			(void)success;
                     attach_error = false;
                     }
                 }
@@ -1205,7 +1400,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
 static VALUE rb_context_isolate_mutex(VALUE self) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     if (!context_info->isolate_info) {
         rb_raise(rb_eScriptRuntimeError, "Context has no Isolate available anymore");
@@ -1221,11 +1416,16 @@ IsolateInfo::~IsolateInfo() {
                             "it can not be disposed and memory will not be "
                             "reclaimed till the Ruby process exits.\n");
         } else {
-            if (this->pid != getpid()) {
+            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");
+                                "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();
             }
@@ -1256,42 +1456,33 @@ static void free_context_raw(void *arg) {
     if (isolate_info) {
         isolate_info->release();
     }
-
-    xfree(context_info);
 }
 
 static void *free_context_thr(void* arg) {
-    if (pthread_rwlock_tryrdlock(&exit_lock) != 0) {
-        return NULL;
+    if (ruby_exiting.load() == 0) {
+        free_context_raw(arg);
+        xfree(arg);
     }
-    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;
+        ContextInfo* context_info_copy = ALLOC(ContextInfo);
+
+        context_info_copy->isolate_info = context_info->isolate_info;
+        context_info_copy->context = context_info->context;
         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");
+            xfree(context_info_copy);
         }
     } else {
-        free_context_raw(context_info_copy);
+        free_context_raw(context_info);
     }
 
     context_info->context = NULL;
@@ -1310,6 +1501,11 @@ static void mark_isolate(void* data) {
     isolate_info->mark();
 }
 
+static size_t isolate_memsize(const void *ptr) {
+     const IsolateInfo *isolate_info = (const IsolateInfo *)ptr;
+     return sizeof(*isolate_info);
+}
+
 static void deallocate(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
 
@@ -1318,6 +1514,11 @@ static void deallocate(void* data) {
     xfree(data);
 }
 
+static size_t context_memsize(const void *ptr)
+{
+    return sizeof(ContextInfo);
+}
+
 static void mark_context(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
     if (context_info->isolate_info) {
@@ -1325,48 +1526,39 @@ static void mark_context(void* data) {
     }
 }
 
-static void deallocate_external_function(void * data) {
-    xfree(data);
-}
-
 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);
+static size_t snapshot_memsize(const void *data) {
+    SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
+    return sizeof(*snapshot_info) + snapshot_info->raw_size;
 }
 
 static VALUE allocate(VALUE klass) {
-    ContextInfo* context_info = ALLOC(ContextInfo);
-    context_info->isolate_info = NULL;
-    context_info->context = NULL;
-
-    return Data_Wrap_Struct(klass, mark_context, deallocate, (void*)context_info);
+    ContextInfo* context_info;
+    return TypedData_Make_Struct(klass, ContextInfo, &context_type, context_info);
 }
 
 static VALUE allocate_snapshot(VALUE klass) {
-    SnapshotInfo* snapshot_info = ALLOC(SnapshotInfo);
-    snapshot_info->data = NULL;
-    snapshot_info->raw_size = 0;
+    SnapshotInfo* snapshot_info;
 
-    return Data_Wrap_Struct(klass, NULL, deallocate_snapshot, (void*)snapshot_info);
+    return TypedData_Make_Struct(klass, SnapshotInfo, &snapshot_type, snapshot_info);
 }
 
 static VALUE allocate_isolate(VALUE klass) {
     IsolateInfo* isolate_info = new IsolateInfo();
 
-    return Data_Wrap_Struct(klass, mark_isolate, deallocate_isolate, (void*)isolate_info);
+    return TypedData_Wrap_Struct(klass, &isolate_type, isolate_info);
 }
 
 static VALUE
 rb_heap_stats(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate;
     v8::HeapStatistics stats;
 
@@ -1398,7 +1590,9 @@ rb_heap_stats(VALUE self) {
 // https://github.com/bnoordhuis/node-heapdump/blob/master/src/heapdump.cc
 class FileOutputStream : public OutputStream {
  public:
-  FileOutputStream(FILE* stream) : stream_(stream) {}
+  int err;
+
+  FileOutputStream(int fd) : fd(fd) { err = 0; }
 
   virtual int GetChunkSize() {
     return 65536;
@@ -1407,17 +1601,27 @@ class FileOutputStream : public OutputStream {
   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;
+    size_t len = static_cast<size_t>(size);
+
+    while (len) {
+        ssize_t w = write(fd, data, len);
+
+        if (w > 0) {
+            data += w;
+            len -= w;
+        } else if (w < 0) {
+            err = errno;
+            return kAbort;
+        } else { /* w == 0, could be out-of-space */
+            err = -1;
+            return kAbort;
+        }
+    }
+    return kContinue;
   }
 
  private:
-  FILE* stream_;
+  int fd;
 };
 
 
@@ -1430,13 +1634,11 @@ rb_heap_snapshot(VALUE self, VALUE file) {
 
     if (!fptr) return Qfalse;
 
-    FILE* fp;
-    fp = fdopen(fptr->fd, "w");
-    if (fp == NULL) return Qfalse;
-
+    // prepare for unbuffered write(2) below:
+    rb_funcall(file, rb_intern("flush"), 0);
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate;
     isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
 
@@ -1450,13 +1652,14 @@ rb_heap_snapshot(VALUE self, VALUE file) {
 
     const HeapSnapshot* const snap = heap_profiler->TakeHeapSnapshot();
 
-    FileOutputStream stream(fp);
+    FileOutputStream stream(fptr->fd);
     snap->Serialize(&stream, HeapSnapshot::kJSON);
 
-    fflush(fp);
-
     const_cast<HeapSnapshot*>(snap)->Delete();
 
+    /* TODO: perhaps rb_sys_fail here */
+    if (stream.err) return Qfalse;
+
     return Qtrue;
 }
 
@@ -1464,12 +1667,12 @@ static VALUE
 rb_context_stop(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     Isolate* isolate = context_info->isolate_info->isolate;
 
     // flag for termination
-    isolate->SetData(DO_TERMINATE, (void*)true);
+    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, true);
 
     isolate->TerminateExecution();
     rb_funcall(self, rb_intern("stop_attached"), 0);
@@ -1481,7 +1684,7 @@ static VALUE
 rb_context_dispose(VALUE self) {
 
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
 
     free_context(context_info);
 
@@ -1498,18 +1701,20 @@ nogvl_context_call(void *args) {
     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);
+    IsolateData::Set(isolate, IsolateData::IN_GVL, false);
+    IsolateData::Set(isolate, IsolateData::DO_TERMINATE, false);
 
     if (call->max_memory > 0) {
-        isolate->SetData(MEM_SOFTLIMIT_VALUE, &call->max_memory);
-        isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)false);
+        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->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);
@@ -1527,7 +1732,7 @@ nogvl_context_call(void *args) {
     MaybeLocal<v8::Value> res = fun->Call(context, context->Global(), call->argc, call->argv);
     prepare_result(res, trycatch, isolate, context, eval_res);
 
-    isolate->SetData(IN_GVL, (void*)true);
+    IsolateData::Set(isolate, IsolateData::IN_GVL, true);
 
     return NULL;
 }
@@ -1542,7 +1747,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
     FunctionCall call;
     VALUE *call_argv = NULL;
 
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     Isolate* isolate = context_info->isolate_info->isolate;
 
     if (argc < 1) {
@@ -1550,9 +1755,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
     }
 
     VALUE function_name = argv[0];
-    if (TYPE(function_name) != T_STRING) {
-        rb_raise(rb_eTypeError, "first argument should be a String");
-    }
+    Check_Type(function_name, T_STRING);
 
     char *fname = RSTRING_PTR(function_name);
     if (!fname) {
@@ -1575,6 +1778,13 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
         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;
     {
@@ -1596,23 +1806,15 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
         if (val.IsEmpty() || !val.ToLocalChecked()->IsFunction()) {
             missingFunction = true;
         } else {
-
             Local<v8::Function> fun = Local<v8::Function>::Cast(val.ToLocalChecked());
+            VALUE tmp;
             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]);
-                }
+            call.argv = (v8::Local<Value> *)RB_ALLOCV_N(void *, tmp, call.argc);
+            for(int i=0; i < call.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);
-
+            RB_ALLOCV_END(tmp);
         }
     }
 
@@ -1625,7 +1827,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
 
 static VALUE rb_context_create_isolate_value(VALUE self) {
     ContextInfo* context_info;
-    Data_Get_Struct(self, ContextInfo, context_info);
+    TypedData_Get_Struct(self, ContextInfo, &context_type, context_info);
     IsolateInfo *isolate_info = context_info->isolate_info;
 
     if (!isolate_info) {
@@ -1633,22 +1835,18 @@ static VALUE rb_context_create_isolate_value(VALUE self) {
     }
 
     isolate_info->hold();
-    return Data_Wrap_Struct(rb_cIsolate, NULL, &deallocate_isolate, isolate_info);
+    return TypedData_Wrap_Struct(rb_cIsolate, &isolate_type, isolate_info);
 }
 
 static void set_ruby_exiting(VALUE value) {
     (void)value;
 
-    int res = pthread_rwlock_wrlock(&exit_lock);
-    ruby_exiting  = true;
-    if (res == 0) {
-        pthread_rwlock_unlock(&exit_lock);
-    }
+    ruby_exiting.store(1);
 }
 
 extern "C" {
 
-    void Init_mini_racer_extension ( void )
+    __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);
@@ -1688,7 +1886,6 @@ extern "C" {
         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);