sq_mini_racer 0.2.4.sqreen2 → 0.3.1.0.0

data/ext/mini_racer_extension/extconf.rb

@@ -1,33 +1,232 @@
 require 'mkmf'
+
 require 'fileutils'
+require 'net/http'
+require 'json'
+require 'rubygems'
+require 'rubygems/package'
 
-IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 IS_SOLARIS = RUBY_PLATFORM =~ /solaris/
+IS_LINUX_MUSL = RUBY_PLATFORM =~ /linux-musl/
+
+def cppflags_clear_std!
+  $CPPFLAGS.gsub! /-std=[^\s]+/, ''
+end
+
+def cppflags_add_frame_pointer!
+  $CPPFLAGS += " -fno-omit-frame-pointer"
+end
+
+def cppflags_add_cpu_extension!
+  if enable_config('avx2')
+    $CPPFLAGS += " -mavx2"
+  else
+    $CPPFLAGS += " -mssse3"
+  end
+end
+
+def libv8_gem_name
+  'libv8-node'
+end
+
+def libv8_version
+  '14.14.0.0.beta2'
+end
+
+def libv8_basename
+  "#{libv8_gem_name}-#{libv8_version}-#{ruby_platform}"
+end
+
+def libv8_gemspec_no_libc
+  platform_no_libc = ruby_platform.to_s.split('-')[0..1].join('-')
+  "#{libv8_gem_name}-#{libv8_version}-#{platform_no_libc}.gemspec"
+end
+
+def libv8_gemspec
+  "#{libv8_basename}.gemspec"
+end
+
+def libv8_local_path(path=Gem.path)
+  gemspecs = [libv8_gemspec, libv8_gemspec_no_libc].uniq
+  puts "looking for #{gemspecs.join(', ')} in installed gems"
+  candidates = path.product(gemspecs)
+    .map { |(p, gemspec)| File.join(p, 'specifications', gemspec) }
+  p candidates
+  found = candidates.select { |f| File.exist?(f) }.first
+
+  unless found
+    puts "#{gemspecs.join(', ')} not found in installed gems"
+    return
+  end
+
+  puts "found in installed specs: #{found}"
+
+  gemdir = File.basename(found, '.gemspec')
+  dir = File.expand_path(File.join(found, '..', '..', 'gems', gemdir))
+
+  unless Dir.exist?(dir)
+    puts "not found in installed gems: #{dir}"
+    return
+  end
+
+  puts "found in installed gems: #{dir}"
+
+  dir
+end
+
+def vendor_path
+  File.join(Dir.pwd, 'vendor')
+end
+
+def libv8_vendor_path
+  puts "looking for #{libv8_basename} in #{vendor_path}"
+  path = Dir.glob("#{vendor_path}/#{libv8_basename}").first
+
+  unless path
+    puts "#{libv8_basename} not found in #{vendor_path}"
+    return
+  end
+
+  puts "looking for #{libv8_basename}/lib/libv8-node.rb in #{vendor_path}"
+  unless Dir.glob(File.join(vendor_path, libv8_basename, 'lib', 'libv8-node.rb')).first
+    puts "#{libv8_basename}/lib/libv8.rb not found in #{vendor_path}"
+    return
+  end
+
+  path
+end
+
+def parse_platform(str)
+  Gem::Platform.new(str).tap do |p|
+    p.instance_eval { @cpu = 'x86_64' } if str =~ /universal.*darwin/
+  end
+end
+
+def ruby_platform
+  parse_platform(RUBY_PLATFORM)
+end
+
+def http_get(uri)
+  Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+    res = http.get(uri.path)
+
+    abort("HTTP error #{res.code}: #{uri}") unless res.code == '200'
+
+    return res.body
+  end
+end
+
+def libv8_remote_search
+  body = http_get(URI("https://rubygems.org/api/v1/versions/#{libv8_gem_name}.json"))
+  json = JSON.parse(body)
+
+  versions = json.select do |v|
+    Gem::Version.new(v['number']) == Gem::Version.new(libv8_version)
+  end
+  abort(<<-ERROR) if versions.empty?
+  ERROR: could not find #{libv8_gem_name} (version #{libv8_version}) in rubygems.org
+  ERROR
+
+  platform_versions = versions.select do |v|
+    parse_platform(v['platform']) == ruby_platform unless v['platform'] =~ /universal.*darwin/
+  end
+  abort(<<-ERROR) if platform_versions.empty?
+  ERROR: found #{libv8_gem_name}-#{libv8_version}, but no binary for #{ruby_platform}
+         try "gem install #{libv8_gem_name} -v '#{libv8_version}'" to attempt to build libv8 from source
+  ERROR
+
+  platform_versions.first
+end
+
+def libv8_download_uri(name, version, platform)
+  URI("https://rubygems.org/downloads/#{name}-#{version}-#{platform}.gem")
+end
+
+def libv8_downloaded_gem(name, version, platform)
+  "#{name}-#{version}-#{platform}.gem"
+end
+
+def libv8_download(name, version, platform)
+  FileUtils.mkdir_p(vendor_path)
+  body = http_get(libv8_download_uri(name, version, platform))
+  File.open(File.join(vendor_path, libv8_downloaded_gem(name, version, platform)), 'wb') { |f| f.write(body) }
+end
+
+def libv8_install!
+  cmd = "gem install #{libv8_gem_name} --version '#{libv8_version}' --install-dir '#{vendor_path}'"
+  puts "installing #{libv8_gem_name} using `#{cmd}`"
+  rc = system(cmd)
+
+  abort(<<-ERROR) unless rc
+  ERROR: could not install #{libv8_gem_name} #{libv8_version}
+          try "gem install #{libv8_gem_name} -v '#{libv8_version}'" to attempt to build libv8 from source
+  ERROR
+
+  libv8_local_path([vendor_path])
+end
+
+def libv8_vendor!
+  return libv8_install! if Gem::VERSION < '2.0'
+
+  version = libv8_remote_search
+
+  puts "downloading #{libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform'])} to #{vendor_path}"
+  libv8_download(libv8_gem_name, version['number'], version['platform'])
+
+  package = Gem::Package.new(File.join(vendor_path, libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform'])))
+  package.extract_files(File.join(vendor_path, File.basename(libv8_downloaded_gem(libv8_gem_name, version['number'], version['platform']), '.gem')))
+
+  libv8_vendor_path
+end
+
+def ensure_libv8_load_path
+  puts "detected platform #{RUBY_PLATFORM} => #{ruby_platform}"
+
+  libv8_path = libv8_local_path
+  unless ENV['ONLY_INSTALLED_LIBV8_GEM']
+    libv8_path ||= libv8_vendor_path || libv8_vendor!
+  end
+
+  abort(<<-ERROR) unless libv8_path
+  ERROR: could not find #{libv8_gem_name}
+  ERROR
+
+  $LOAD_PATH.unshift(File.join(libv8_path, 'ext'))
+  $LOAD_PATH.unshift(File.join(libv8_path, 'lib'))
+end
+
+ensure_libv8_load_path
+
+require 'libv8-node'
+
+IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 
 have_library('pthread')
 have_library('objc') if IS_DARWIN
-$CPPFLAGS.gsub! /-std=[^\s]+/, ''
+cppflags_clear_std!
 $CPPFLAGS += " -Wall" unless $CPPFLAGS.split.include? "-Wall"
 $CPPFLAGS += " -g" unless $CPPFLAGS.split.include? "-g"
 $CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
 $CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or IS_DARWIN
 $CPPFLAGS += " -std=c++0x"
 $CPPFLAGS += " -fpermissive"
-$CPPFLAGS += " -fno-omit-frame-pointer"
-if enable_config('avx2')
-  $CPPFLAGS += " -mavx2"
-else
-  $CPPFLAGS += " -mssse3"
-end
+$CPPFLAGS += " -DV8_COMPRESS_POINTERS"
+$CPPFLAGS += " -fvisibility=hidden "
+cppflags_add_frame_pointer!
+cppflags_add_cpu_extension!
 
 $CPPFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
 
 $LDFLAGS.insert(0, " -stdlib=libc++ ") if IS_DARWIN
+$LDFLAGS += " -Wl,--no-undefined " unless IS_DARWIN
 
 if ENV['CXX']
   puts "SETTING CXX"
   CONFIG['CXX'] = ENV['CXX']
 end
+# 1.9 has no $CXXFLAGS
+$CPPFLAGS += " #{ENV['CPPFLAGS']}" if ENV['CPPFLAGS']
+$LDFLAGS  += " #{ENV['LDFLAGS']}" if ENV['LDFLAGS']
 
 CXX11_TEST = <<EOS
 #if __cplusplus <= 199711L
@@ -57,94 +256,15 @@ if CONFIG['warnflags']
   CONFIG['warnflags'].gsub!('-Wimplicit-function-declaration', '')
 end
 
-if enable_config('debug')
+if enable_config('debug') || enable_config('asan')
   CONFIG['debugflags'] << ' -ggdb3 -O0'
 end
 
-def fixup_libtinfo
-  dirs = %w[/lib64 /usr/lib64 /lib /usr/lib]
-  found_v5 = dirs.map { |d| "#{d}/libtinfo.so.5" }.find &File.method(:file?)
-  return '' if found_v5
-  found_v6 = dirs.map { |d| "#{d}/libtinfo.so.6" }.find &File.method(:file?)
-  return '' unless found_v6
-  FileUtils.ln_s found_v6, 'gemdir/libtinfo.so.5', :force => true
-  "LD_LIBRARY_PATH='#{File.expand_path('gemdir')}:#{ENV['LD_LIBRARY_PATH']}'"
-end
-
-def libv8_gem_name
-  return "libv8-solaris" if IS_SOLARIS
-
-  is_musl = false
-  begin
-    is_musl = !!(File.read('/proc/self/maps') =~ /ld-musl-x86_64/)
-  rescue; end
-
-  is_musl ? 'libv8-alpine' : 'libv8'
-end
-
-# old rubygem versions prefer source gems to binary ones
-# ... and their --platform switch is broken too, as it leaves the 'ruby'
-# platform in Gem.platforms.
-def force_platform_gem
-  gem_version = `gem --version`
-  return 'gem' unless $?.success?
-
-  return 'gem' if gem_version.to_f.zero? || gem_version.to_f >= 2.3
-  return 'gem' if RUBY_PLATFORM != 'x86_64-linux'
-
-  gem_binary = `which gem`
-  return 'gem' unless $?.success?
-
-  ruby = File.foreach(gem_binary.strip).first.sub(/^#!/, '').strip
-  unless File.file? ruby
-    warn "No valid ruby: #{ruby}"
-    return 'gem'
-  end
-
-  require 'tempfile'
-  file = Tempfile.new('sq_mini_racer')
-  file << <<EOS
-require 'rubygems'
-Gem.platforms.reject! { |it| it == 'ruby' }
-#{IO.read(gem_binary.strip)}
-EOS
-  file.close
-  "#{ruby} '#{file.path}'"
-end
-
-LIBV8_VERSION = '6.7.288.46.1'
-libv8_rb = Dir.glob('**/libv8.rb').first
-FileUtils.mkdir_p('gemdir')
-unless libv8_rb
-  gem_name = libv8_gem_name
-  cmd = "#{fixup_libtinfo} #{force_platform_gem} install --version '= #{LIBV8_VERSION}' --install-dir gemdir #{gem_name}"
-  puts "Will try downloading #{gem_name} gem: #{cmd}"
-  `#{cmd}`
-  unless $?.success?
-    warn <<EOS
-
-WARNING: Could not download a private copy of the libv8 gem. Please make
-sure that you have internet access and that the `gem` binary is available.
-
-EOS
-  end
-
-  libv8_rb = Dir.glob('**/libv8.rb').first
-  unless libv8_rb
-    warn <<EOS
-
-WARNING: Could not find libv8 after the local copy of libv8 having supposedly
-been installed.
-
-EOS
-  end
-end
+Libv8::Node.configure_makefile
 
-if libv8_rb
-  $:.unshift(File.dirname(libv8_rb) + '/../ext')
-  $:.unshift File.dirname(libv8_rb)
+if enable_config('asan')
+  $CPPFLAGS.insert(0, " -fsanitize=address ")
+  $LDFLAGS.insert(0, " -fsanitize=address ")
 end
 
-require 'libv8'
-Libv8.configure_makefile
 create_makefile 'sq_mini_racer_extension'

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -8,12 +8,24 @@
 # undef HAVE_BUILTIN___BUILTIN_CHOOSE_EXPR_CONSTANT_P
 # undef HAVE_BUILTIN___BUILTIN_TYPES_COMPATIBLE_P
 
-#include <ruby.h>
 #include <ruby/version.h>
+
+// workaround for Ruby 2.3.0 on macOS
+#if RUBY_API_VERSION_CODE == 20300
+#ifdef _DARWIN_C_SOURCE
+#ifndef __STDC_LIB_EXT1__
+#undef HAVE_MEMSET_S
+#endif
+#endif
+#endif
+
+#include <ruby.h>
 #if RUBY_API_VERSION_MAJOR > 1
 #include <ruby/thread.h>
 #endif
+#include <ruby/io.h>
 #include <v8.h>
+#include <v8-profiler.h>
 #include <libplatform/libplatform.h>
 #include <ruby/encoding.h>
 #include <pthread.h>
@@ -24,6 +36,8 @@
 #include "compat.hpp"
 #include "simdutf8check.h"
 
+#include <time.h>
+
 using namespace v8;
 
 typedef struct {
@@ -37,6 +51,7 @@ public:
     ArrayBuffer::Allocator* allocator;
     StartupData* startup_data;
     bool interrupted;
+    bool added_gc_cb;
     pid_t pid;
     VALUE mutex;
 
@@ -54,15 +69,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);
 
@@ -139,6 +151,7 @@ typedef struct {
     Local<Function> fun;
     Local<Value> *argv;
     EvalResult result;
+    size_t max_memory;
 } FunctionCall;
 
 enum IsolateFlags {
@@ -164,9 +177,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;
 
@@ -178,6 +196,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;
@@ -201,8 +222,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();
     }
 
@@ -245,15 +266,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;
@@ -277,11 +300,21 @@ static void prepare_result(MaybeLocal<Value> v8res,
                 evalRes.message = new Persistent<Value>();
                 Local<Message> message = trycatch.Message();
                 char buf[1000];
-                int len;
+                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()),
-                               message->GetLineNumber(),
-                               message->GetStartColumn());
+                               *String::Utf8Value(isolate, message->GetScriptResourceName()->ToString(context).ToLocalChecked()),
+                               line,
+                               column);
+
                 if ((size_t) len >= sizeof(buf)) {
                     len = sizeof(buf) - 1;
                     buf[len] = '\0';
@@ -292,12 +325,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(context).IsEmpty()) {
                 evalRes.backtrace = new Persistent<Value>();
-                evalRes.backtrace->Reset(isolate, trycatch.StackTrace(context).ToLocalChecked()->ToString());
+                evalRes.backtrace->Reset(isolate,
+                                         trycatch.StackTrace(context).ToLocalChecked()->ToString(context).ToLocalChecked());
             }
         }
     }
@@ -312,7 +346,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);
@@ -356,7 +391,10 @@ nogvl_context_eval(void* arg) {
         // 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);
@@ -369,6 +407,12 @@ nogvl_context_eval(void* arg) {
     return 0;
 }
 
+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) {
@@ -381,11 +425,11 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
     }
 
     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()) {
@@ -400,8 +444,11 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
       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);
+          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;
           }
@@ -426,31 +473,52 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
         VALUE rb_hash = rb_hash_new();
         TryCatch trycatch(isolate);
 
-        Local<Object> object = value->ToObject();
+        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++) {
-             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
+             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());
 
-             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(""));
+             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);
+             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(isolate, 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,
@@ -547,7 +615,7 @@ treat_as_latin1:
     return v8str.ToLocalChecked();
 }
 
-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);
 
@@ -561,87 +629,87 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, VALUE value)
     VALUE klass;
 
     switch (TYPE(value)) {
-        case T_FIXNUM:
+    case T_FIXNUM:
         {
-            fixnum = NUM2LONG(value);
-            if (fixnum > INT_MAX)
-            {
-                return scope.Escape(Number::New(isolate, (double)fixnum));
-            }
-            return scope.Escape(Integer::New(isolate, (int)fixnum));
+        fixnum = NUM2LONG(value);
+        if (fixnum > INT_MAX)
+        {
+            return scope.Escape(Number::New(isolate, (double)fixnum));
+        }
+        return scope.Escape(Integer::New(isolate, (int)fixnum));
         }
-        case T_FLOAT:
-            return scope.Escape(Number::New(isolate, NUM2DBL(value)));
-        case T_STRING:
+    case T_FLOAT:
+	return scope.Escape(Number::New(isolate, NUM2DBL(value)));
+    case T_STRING:
             return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
-        case T_NIL:
-            return scope.Escape(Null(isolate));
-        case T_TRUE:
-            return scope.Escape(True(isolate));
-        case T_FALSE:
-            return scope.Escape(False(isolate));
-        case T_ARRAY:
+    case T_NIL:
+	return scope.Escape(Null(isolate));
+    case T_TRUE:
+	return scope.Escape(True(isolate));
+    case T_FALSE:
+	return scope.Escape(False(isolate));
+    case T_ARRAY:
         {
-            length = RARRAY_LEN(value);
-            array = Array::New(isolate, (int)length);
-            for(i=0; i<length; i++) {
-                array->Set(i, convert_ruby_to_v8(isolate, rb_ary_entry(value, i)));
-            }
-            return scope.Escape(array);
+	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)));
+	}
+	return scope.Escape(array);
         }
-        case T_HASH:
+    case T_HASH:
         {
-            object = Object::New(isolate);
-            hash_as_array = rb_funcall(value, rb_intern("to_a"), 0);
-            length = RARRAY_LEN(hash_as_array);
-            for(i=0; i<length; i++) {
-                pair = rb_ary_entry(hash_as_array, i);
-                object->Set(convert_ruby_to_v8(isolate, rb_ary_entry(pair, 0)),
-                            convert_ruby_to_v8(isolate, rb_ary_entry(pair, 1)));
-            }
-            return scope.Escape(object);
+	object = Object::New(isolate);
+	hash_as_array = rb_funcall(value, rb_intern("to_a"), 0);
+	length = RARRAY_LEN(hash_as_array);
+	for(i=0; i<length; i++) {
+	    pair = rb_ary_entry(hash_as_array, i);
+            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:
+    case T_SYMBOL:
         {
-            value = rb_funcall(value, rb_intern("to_s"), 0);
+	value = rb_funcall(value, rb_intern("to_s"), 0);
             return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
         }
-        case T_DATA:
+    case T_DATA:
         {
-            klass = rb_funcall(value, rb_intern("class"), 0);
-            if (klass == rb_cTime || klass == rb_cDateTime)
+        klass = rb_funcall(value, rb_intern("class"), 0);
+        if (klass == rb_cTime || klass == rb_cDateTime)
+        {
+            if (klass == rb_cDateTime)
             {
-                if (klass == rb_cDateTime)
-                {
-                    value = rb_funcall(value, rb_intern("to_time"), 0);
-                }
-                value = rb_funcall(value, rb_intern("to_f"), 0);
-                return scope.Escape(Date::New(isolate, NUM2DBL(value) * 1000));
+                value = rb_funcall(value, rb_intern("to_time"), 0);
             }
+            value = rb_funcall(value, rb_intern("to_f"), 0);
+            return scope.Escape(Date::New(context, NUM2DBL(value) * 1000).ToLocalChecked());
+        }
             // break intentionally missing
         }
-        case T_OBJECT:
-        case T_CLASS:
-        case T_ICLASS:
-        case T_MODULE:
-        case T_REGEXP:
-        case T_MATCH:
-        case T_STRUCT:
-        case T_BIGNUM:
-        case T_FILE:
-        case T_UNDEF:
-        case T_NODE:
-        default:
+    case T_OBJECT:
+    case T_CLASS:
+    case T_ICLASS:
+    case T_MODULE:
+    case T_REGEXP:
+    case T_MATCH:
+    case T_STRUCT:
+    case T_BIGNUM:
+    case T_FILE:
+    case T_UNDEF:
+    case T_NODE:
+    default:
         {
             if (rb_respond_to(value, rb_intern("to_s"))) {
                 // TODO: if this throws we're screwed
                 value = rb_funcall(value, rb_intern("to_s"), 0);
                 return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
             }
-            return scope.Escape(String::NewFromUtf8(isolate, "Undefined Conversion"));
+            return scope.Escape(
+                String::NewFromUtf8Literal(isolate, "Undefined Conversion"));
         }
     }
-
 }
 
 static void unblock_eval(void *ptr) {
@@ -649,6 +717,81 @@ static void unblock_eval(void *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);
@@ -667,7 +810,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");
@@ -698,7 +841,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");
@@ -761,6 +904,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);
@@ -877,8 +1043,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(isolate, 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);
@@ -999,6 +1165,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());
@@ -1011,7 +1179,6 @@ gvl_ruby_callback(void* data) {
             return NULL;
         }
 
-        ContextInfo* context_info;
         Data_Get_Struct(parent, ContextInfo, context_info);
 
         if (length > 0) {
@@ -1021,7 +1188,7 @@ gvl_ruby_callback(void* data) {
         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);
+                                           *context_info->context, value);
             rb_ary_push(ruby_args, tmp);
         }
     }
@@ -1034,7 +1201,9 @@ 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()->ThrowException(
+                    String::NewFromUtf8Literal(args->GetIsolate(),
+                                               "Terminated execution during transition from Ruby to JS"));
         args->GetIsolate()->TerminateExecution();
         if (length > 0) {
             rb_ary_clear(ruby_args);
@@ -1048,11 +1217,11 @@ gvl_ruby_callback(void* data) {
 
     if(callback_data.failed) {
         rb_iv_set(parent, "@current_exception", result);
-        args->GetIsolate()->ThrowException(String::NewFromUtf8(args->GetIsolate(), "Ruby exception"));
+        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);
+        Handle<Value> v8_result = convert_ruby_to_v8(args->GetIsolate(), context_info->context->Get(args->GetIsolate()), result);
         args->GetReturnValue().Set(v8_result);
     }
 
@@ -1109,8 +1278,10 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
         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();
+        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;
@@ -1120,24 +1291,38 @@ static VALUE rb_external_function_notify_v8(VALUE 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 {
+            context->Global()->Set(
+                        context,
+                        v8_str,
+                        FunctionTemplate::New(isolate, ruby_callback, external)
+                            ->GetFunction(context)
+                            .ToLocalChecked());
 
-            Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(parent_object_eval),
-                                  NewStringType::kNormal, (int)RSTRING_LEN(parent_object_eval)).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;
+                parse_error = true;
             } else {
-                MaybeLocal<Value> maybe_value = parsed_script.ToLocalChecked()->Run(context);
+                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;
+                    if (value->IsObject()) {
+                        value.As<Object>()->Set(
+                                    context,
+                                    v8_str,
+                                    FunctionTemplate::New(isolate, ruby_callback, external)
+                                        ->GetFunction(context)
+                                        .ToLocalChecked());
+                        attach_error = false;
                     }
                 }
             }
@@ -1167,35 +1352,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");
+            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_info->isolate->Dispose();
+                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;
@@ -1212,6 +1401,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;
 }
 
@@ -1226,22 +1429,17 @@ static void free_context(ContextInfo* context_info) {
 
     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)) {
+        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);
     }
 
-    if (context_info->context && isolate_info && isolate_info->isolate) {
         context_info->context = NULL;
-    }
-
-    if (isolate_info) {
         context_info->isolate_info = NULL;
     }
-}
 
 static void deallocate_isolate(void* data) {
 
@@ -1255,7 +1453,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);
@@ -1270,22 +1468,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;
@@ -1293,7 +1491,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;
@@ -1301,7 +1499,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);
@@ -1340,6 +1538,71 @@ rb_heap_stats(VALUE self) {
     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) {
 
@@ -1392,13 +1655,23 @@ nogvl_context_call(void *args) {
     if (!call) {
         return 0;
     }
-    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);
@@ -1456,6 +1729,13 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
         call_argv = argv + 1;
     }
 
+    call.max_memory = 0;
+    VALUE mem_softlimit = rb_iv_get(self, "@max_memory");
+    if (mem_softlimit != Qnil) {
+        unsigned long sl_int = NUM2ULONG(mem_softlimit);
+        call.max_memory = (size_t)sl_int;
+    }
+
     bool missingFunction = false;
     {
         Locker lock(isolate);
@@ -1467,8 +1747,11 @@ static VALUE 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);
+        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;
@@ -1484,7 +1767,7 @@ static VALUE rb_context_call_unsafe(int argc, VALUE *argv, VALUE self) {
                     return Qnil;
                 }
                 for(int i=0; i < fun_argc; i++) {
-                    call.argv[i] = convert_ruby_to_v8(isolate, call_argv[i]);
+                    call.argv[i] = convert_ruby_to_v8(isolate, context, call_argv[i]);
                 }
             }
     #if RUBY_API_VERSION_MAJOR > 1
@@ -1517,12 +1800,44 @@ static VALUE rb_context_create_isolate_value(VALUE self) {
     return Data_Wrap_Struct(rb_cIsolate, NULL, &deallocate_isolate, 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);
+    }
+}
+
+static VALUE rb_monotime(VALUE self) {
+    struct timespec ts;
+    if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0) {
+        return INT2FIX(-1);
+    }
+
+    return DBL2NUM(
+        (double)ts.tv_sec + (double)ts.tv_nsec / 1000000000.0);
+}
+
 extern "C" {
 
-    void Init_sq_mini_racer_extension ( void )
+    __attribute__((visibility("default"))) void Init_sq_mini_racer_extension ( void )
     {
-        VALUE rb_mSqreen = rb_define_module("Sqreen");
+		ID sqreen_id = rb_intern("Sqreen");
+		VALUE rb_mSqreen;
+		if (rb_const_defined(rb_cObject, sqreen_id)) {
+			rb_mSqreen = rb_const_get(rb_cObject, sqreen_id);
+			if (TYPE(rb_mSqreen) != T_MODULE) {
+				rb_raise(rb_eTypeError, "Sqreen is not a module");
+				return;
+			}
+		} else {
+			rb_mSqreen = rb_define_module("Sqreen");
+		}
         VALUE rb_mMiniRacer = rb_define_module_under(rb_mSqreen, "MiniRacer");
+        rb_define_module_function(rb_mMiniRacer, "monotime", (VALUE(*)(...))&rb_monotime, 0);
         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);
@@ -1548,6 +1863,8 @@ extern "C" {
         rb_define_method(rb_cContext, "dispose_unsafe", (VALUE(*)(...))&rb_context_dispose, 0);
         rb_define_method(rb_cContext, "low_memory_notification", (VALUE(*)(...))&rb_context_low_memory_notification, 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);
@@ -1567,8 +1884,19 @@ extern "C" {
         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;
+            }
+        }
     }
 }