mini_racer 0.2.8 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f6c48eedae322fc66e7dc1f816d63d8d093a18a02167a16cada1cd04a34e821
-  data.tar.gz: 0b4de89162986b4d729abff697c04de4f54216bb1a94c5d7737b7cf011fca85e
+  metadata.gz: e73ac3193df3f33b51463ba1125ac4eee312caecd47833c545e098ba91d11ece
+  data.tar.gz: d6d754829b36953d239ba85e84d2fc88c0af3ccbadd3f8d2e4cd9759bd24fab2
 SHA512:
-  metadata.gz: ce21ef957f04319ed5109e6f5ddbc2c17be7f657d9beed5941950ccf57d36054341c5f6685c790ab217d8445e1af1758e7d16c1745d47955042453c6294784c3
-  data.tar.gz: 4e58fdfde4f8f78ade9c470510296cb8dcd30e3c02a8827f4c4ba68ee49e41dee66de5419938c52c98d9df41d1dd02433b5b0d5389f0d0664da100f5087e0db1
+  metadata.gz: 52a0799d84be10bb03774789b3d12d4f0fe2d4159d310b9c6a1ae3dcf878a99cd6b7c786fae813f29754a894ecf5fcc6b7e07834c0aba994a16da5c54d75595b
+  data.tar.gz: bc478bdb582d7b786d28754200063d7ef185396e0da23840f006679bc1af6707f54c7a719918360afa9b24c2b4ab083ca081e2b2d6853095ecd5949a9482ecbd

data/.dockerignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+lib/mini_racer_extension.so
+lib/mini_racer_loader.so
+*.bundle

data/.github/workflows/ci.yml

@@ -0,0 +1,80 @@
+name: Test
+on:
+  - push
+
+jobs:
+  test-darwin:
+    strategy:
+      fail-fast: false
+      matrix:
+        os:
+          - '10.15'
+          - '11.0'
+        platform:
+          - x86_64
+          # arm64
+    name: Test (darwin)
+    runs-on: macos-${{ matrix.os }}
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Bundle
+        run: bundle install
+      - name: Compile
+        run: bundle exec rake compile
+      - name: Test
+        run: bundle exec rake test
+  test-linux:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby:
+          - '2.4'
+          - '2.5'
+          - '2.6'
+          - '2.7'
+          - '3.0'
+        platform:
+          - amd64
+          - arm64
+          # arm
+          # ppc64le
+          # s390x
+        libc:
+          - gnu
+          - musl
+    name: Test (linux)
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Enable ${{ matrix.platform }} platform
+        id: qemu
+        if: ${{ matrix.platform != 'amd64' }}
+        run: |
+          docker run --privileged --rm tonistiigi/binfmt:latest --install ${{ matrix.platform }} | tee platforms.json
+          echo "::set-output name=platforms::$(cat platforms.json)"
+      - name: Start container
+        id: container
+        run: |
+          case ${{ matrix.libc }} in
+            gnu)
+              echo 'ruby:${{ matrix.ruby }}'
+              ;;
+            musl)
+              echo 'ruby:${{ matrix.ruby }}-alpine'
+              ;;
+          esac > container_image
+          echo "::set-output name=image::$(cat container_image)"
+          docker run --rm -d -v "${PWD}":"${PWD}" -w "${PWD}" --platform linux/${{ matrix.platform }} $(cat container_image) /bin/sleep 64d | tee container_id
+          docker exec -w "${PWD}" $(cat container_id) uname -a
+          echo "::set-output name=id::$(cat container_id)"
+      - name: Install Alpine system dependencies
+        if: ${{ matrix.libc == 'musl' }}
+        run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} apk add --no-cache build-base linux-headers bash python2 python3 git curl tar clang binutils-gold
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Bundle
+        run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} bundle install
+      - name: Compile
+        run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} bundle exec rake compile
+      - name: Test
+        run: docker exec -w "${PWD}" ${{ steps.container.outputs.id }} bundle exec rake test

data/.gitignore

@@ -8,4 +8,5 @@ Gemfile.lock
 /spec/reports/
 /tmp/
 lib/mini_racer_extension.so
+lib/mini_racer_loader.so
 *.bundle

data/.travis.yml

@@ -1,23 +1,30 @@
 language: ruby
+os: linux
 rvm:
-  - 2.3
   - 2.4
   - 2.5
   - 2.6
+  - 2.7
+  - 3.0
   - ruby-head
-matrix:
+arch:
+  - amd64
+  - arm64
+jobs:
   include:
-    - rvm: 2.5.1
+    - rvm: 2.5
       os: osx
       osx_image: xcode9.4
-    - rvm: 2.4.0
+    - rvm: 2.6
       os: osx
-      osx_image: xcode8.3
-    - rvm: 2.4.0
+      osx_image: xcode11.3
+    - rvm: 2.6
       os: osx
-      osx_image: xcode7.3
-dist: trusty
-sudo: true
+      osx_image: xcode12.2
+    - rvm: 2.7
+      os: osx
+      osx_image: xcode12.2
+dist: xenial
 before_install:
   - gem update --system
   - gem install bundler -v 1.16.2

data/CHANGELOG

@@ -1,3 +1,74 @@
+- 11-04-2021
+
+- 0.4.0
+
+  - FEATURE: upgrade to libv8 node 15.14.0 (v8 8.6.395.17)
+  - Promote 0.4.0.beta1 to release, using libv8-node release path
+
+- 08-04-2021
+
+- 0.4.0.beta1
+
+  - FIX: on downgrade mkmf was picking the wrong version of libv8, this fix will correct future issues
+  - FEATURE: upgraded libv8 to use node libv8 build which supports M1 and various ARM builds v8 moved to (8.6.395.17)
+
+- 23-07-2020
+
+- 0.3.1
+
+  - FIX: specify that libv8 must be larger than 8.4.255 but smaller than 8.5, this avoids issues going forward
+
+- 22-07-2020
+
+- 0.3.0
+
+  - FEATURE: upgraded to libv8 version 8.4.255.0
+
+- 29-06-2020
+
+- 0.2.15
+
+  - FEATURE: basic wasm support via pump_message_loop
+
+- 15-05-2020
+
+- 0.2.14
+
+  - FIX: ensure_gc_after_idle should take in milliseconds like the rest of the APIs not seconds
+  - FEATURE: strict params on MiniRacer::Context.new
+
+- 15-05-2020
+
+- 0.2.13
+
+   - FIX: edge case around ensure_gc_after_idle possibly firing when context is not idle
+
+- 15-05-2020
+
+- 0.2.12
+
+  - FEATURE: isolate.low_memory_notification which can force a full GC
+  - FEATURE: MiniRacer::Context.new(ensure_gc_after_idle: 2) - to force full GC 2 seconds after context is idle, this allows you to conserve memory on isolates
+
+- 14-05-2020
+
+- 0.2.11
+
+  - FIX: dumping heap snapshots was not flushing the file leading to corrupt snapshots
+  - FIX: a use-after-free shutdown crash
+
+- 0.2.10
+
+- 22-04-2020
+
+  - FEATURE: memory softlimit support for nogvl_context_call
+
+- 0.2.9
+
+- 09-01-2020
+
+  - FIX: correct segfault when JS returns a Symbol and properly cast to ruby symbol
+
 - 0.2.8
 
 - 11-11-2019

data/Dockerfile

@@ -0,0 +1,21 @@
+ARG RUBY_VERSION=2.7
+FROM ruby:${RUBY_VERSION}
+
+RUN test ! -f /etc/alpine-release || apk add --no-cache build-base git
+
+# without this `COPY .git`, we get the following error:
+#   fatal: not a git repository (or any of the parent directories): .git
+# but with it we need the full gem just to compile the extension because
+# of gemspec's `git --ls-files`
+# COPY .git /code/.git
+COPY Gemfile mini_racer.gemspec /code/
+COPY lib/mini_racer/version.rb /code/lib/mini_racer/version.rb
+WORKDIR /code
+RUN bundle install
+
+COPY Rakefile /code/
+COPY ext /code/ext/
+RUN bundle exec rake compile
+
+COPY . /code/
+CMD bundle exec irb -rmini_racer

data/README.md

@@ -1,6 +1,6 @@
 # MiniRacer
 
-[![Build Status](https://travis-ci.org/discourse/mini_racer.svg?branch=master)](https://travis-ci.org/discourse/mini_racer)
+[![Build Status](https://travis-ci.org/rubyjs/mini_racer.svg?branch=master)](https://travis-ci.org/rubyjs/mini_racer)
 
 Minimal, modern embedded V8 for Ruby.
 
@@ -230,12 +230,17 @@ context = MiniRacer::Context.new(isolate: isolate)
 # give up to 100ms for V8 garbage collection
 isolate.idle_notification(100)
 
+# force V8 to perform a full GC
+isolate.low_memory_notification
+
 ```
 
 This can come in handy to force V8 GC runs for example in between requests if you use MiniRacer on a web application.
 
 Note that this method maps directly to [`v8::Isolate::IdleNotification`](http://bespin.cz/~ondras/html/classv8_1_1Isolate.html#aea16cbb2e351de9a3ae7be2b7cb48297), and that in particular its return value is the same (true if there is no further garbage to collect, false otherwise) and the same caveats apply, in particular that `there is no guarantee that the [call will return] within the time limit.`
 
+Additionally you may automate this process on a context by defining it with `MiniRacer::Content.new(ensure_gc_after_idle: 1000)`. Using this will ensure V8 will run a full GC using `context.isolate.low_memory_notification` 1 second after the last eval on the context. Low memory notification is both slower and more aggressive than an idle_notification and will ensure long living isolates use minimal amounts of memory.
+
 ### V8 Runtime flags
 
 It is possible to set V8 Runtime flags:
@@ -244,7 +249,7 @@ It is possible to set V8 Runtime flags:
 MiniRacer::Platform.set_flags! :noconcurrent_recompilation, max_inlining_levels: 10
 ```
 
-This can come in handy if you want to use MiniRacer with Unicorn, which doesn't seem to alwatys appreciate V8's liberal use of threading:
+This can come in handy if you want to use MiniRacer with Unicorn, which doesn't seem to always appreciate V8's liberal use of threading:
 ```ruby
 MiniRacer::Platform.set_flags! :noconcurrent_recompilation, :noconcurrent_sweeping
 ```
@@ -273,7 +278,7 @@ context.eval js
 The same code without the harmony runtime flag results in a `MiniRacer::RuntimeError: RangeError: Maximum call stack size exceeded` exception.
 Please refer to http://node.green/ as a reference on other harmony features.
 
-A list of all V8 runtime flags can be found using `node --v8-options`, or else by perusing [the V8 source code for flags (make sure to use the right version of V8)](https://github.com/v8/v8/blob/master/src/flag-definitions.h).
+A list of all V8 runtime flags can be found using `node --v8-options`, or else by perusing [the V8 source code for flags (make sure to use the right version of V8)](https://github.com/v8/v8/blob/master/src/flags/flag-definitions.h).
 
 Note that runtime flags must be set before any other operation (e.g. creating a context, a snapshot or an isolate), otherwise an exception will be thrown.
 
@@ -310,6 +315,16 @@ context.eval("a = 2")
 # nothing works on the context from now on, its a shell waiting to be disposed
 ```
 
+A MiniRacer context can also be dumped in a heapsnapshot file using `#write_heap_snapshot(file_or_io)`
+
+```ruby
+context = MiniRacer::Context.new(timeout: 5)
+context.eval("let a='testing';")
+context.write_heap_snapshot("test.heapsnapshot")
+```
+
+This file can then be loaded in the memory tab of the chrome dev console.
+
 ### Function call
 
 This calls the function passed as first argument:
@@ -447,7 +462,7 @@ Add this to your .travis.yml file:
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/discourse/mini_racer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+Bug reports and pull requests are welcome on GitHub at https://github.com/rubyjs/mini_racer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
 
 ## License

data/Rakefile

@@ -11,6 +11,7 @@ end
 task :default => [:compile, :test]
 
 gem = Gem::Specification.load( File.dirname(__FILE__) + '/mini_racer.gemspec' )
+Rake::ExtensionTask.new( 'mini_racer_loader', gem )
 Rake::ExtensionTask.new( 'mini_racer_extension', gem )
 
 

data/ext/mini_racer_extension/extconf.rb

@@ -1,5 +1,7 @@
 require 'mkmf'
-require 'libv8'
+require_relative '../../lib/mini_racer/version'
+gem 'libv8-node', MiniRacer::LIBV8_NODE_VERSION
+require 'libv8-node'
 
 IS_DARWIN = RUBY_PLATFORM =~ /darwin/
 
@@ -11,11 +13,17 @@ $CPPFLAGS += " -rdynamic" unless $CPPFLAGS.split.include? "-rdynamic"
 $CPPFLAGS += " -fPIC" unless $CPPFLAGS.split.include? "-rdynamic" or IS_DARWIN
 $CPPFLAGS += " -std=c++0x"
 $CPPFLAGS += " -fpermissive"
+$CPPFLAGS += " -DV8_COMPRESS_POINTERS"
+$CPPFLAGS += " -fvisibility=hidden "
 
 $CPPFLAGS += " -Wno-reserved-user-defined-literal" if IS_DARWIN
 
 $LDFLAGS.insert(0, " -stdlib=libc++ ") if IS_DARWIN
 
+# check for missing symbols at link time
+# $LDFLAGS += " -Wl,--no-undefined " unless IS_DARWIN
+# $LDFLAGS += " -Wl,-undefined,error " if IS_DARWIN
+
 if ENV['CXX']
   puts "SETTING CXX"
   CONFIG['CXX'] = ENV['CXX']
@@ -53,7 +61,7 @@ if enable_config('debug') || enable_config('asan')
   CONFIG['debugflags'] << ' -ggdb3 -O0'
 end
 
-Libv8.configure_makefile
+Libv8::Node.configure_makefile
 
 if enable_config('asan')
   $CPPFLAGS.insert(0, " -fsanitize=address ")

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -25,6 +25,7 @@ public:
     ArrayBuffer::Allocator* allocator;
     StartupData* startup_data;
     bool interrupted;
+    bool added_gc_cb;
     pid_t pid;
     VALUE mutex;
 
@@ -42,15 +43,12 @@ public:
 
 
     IsolateInfo() : isolate(nullptr), allocator(nullptr), startup_data(nullptr),
-        interrupted(false), pid(getpid()), refs_count(0) {
+        interrupted(false), added_gc_cb(false), pid(getpid()), refs_count(0) {
         VALUE cMutex = rb_const_get(rb_cThread, rb_intern("Mutex"));
         mutex = rb_class_new_instance(0, nullptr, cMutex);
     }
 
-    ~IsolateInfo() {
-        void free_isolate(IsolateInfo*);
-        free_isolate(this);
-    }
+    ~IsolateInfo();
 
     void init(SnapshotInfo* snapshot_info = nullptr);
 
@@ -127,6 +125,7 @@ typedef struct {
     Local<Function> fun;
     Local<Value> *argv;
     EvalResult result;
+    size_t max_memory;
 } FunctionCall;
 
 enum IsolateFlags {
@@ -155,6 +154,11 @@ static VALUE rb_cDateTime = Qnil;
 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;
 
@@ -166,6 +170,9 @@ static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
     platform_lock.lock();
 
     if (current_platform == NULL) {
+	if (!strcmp(RSTRING_PTR(flag_as_str), "--single_threaded")) {
+	   single_threaded = true;
+	}
         V8::SetFlagsFromString(RSTRING_PTR(flag_as_str), (int)RSTRING_LEN(flag_as_str));
     } else {
         platform_already_initialized = true;
@@ -232,11 +239,13 @@ 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(String::NewFromUtf8(isolate, "JSON"))
-              ->ToObject(context).ToLocalChecked();
+            Local<Object> JSON = context->Global()->Get(
+                        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(context).ToLocalChecked();
             const unsigned argc = 1;
@@ -290,7 +299,7 @@ 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()) {
@@ -307,7 +316,8 @@ nogvl_context_eval(void* arg) {
 
     EvalParams* eval_params = (EvalParams*)arg;
     EvalResult* result = eval_params->result;
-    Isolate* isolate = eval_params->context_info->isolate_info->isolate;
+    IsolateInfo* isolate_info = eval_params->context_info->isolate_info;
+    Isolate* isolate = isolate_info->isolate;
 
     Isolate::Scope isolate_scope(isolate);
     HandleScope handle_scope(isolate);
@@ -351,7 +361,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);
@@ -364,6 +377,12 @@ nogvl_context_eval(void* arg) {
     return NULL;
 }
 
+static VALUE new_empty_failed_conv_obj() {
+    // TODO isolate code that translates execption to ruby
+    // exception so we can properly return it
+    return rb_funcall(rb_cFailedV8Conversion, rb_intern("new"), 1, rb_str_new2(""));
+}
+
 // assumes isolate locking is in place
 static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> context,
                                 Local<Value> value) {
@@ -395,8 +414,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,26 +448,47 @@ static VALUE convert_v8_to_ruby(Isolate* isolate, Local<Context> 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(context).ToLocalChecked();
-    return rb_enc_str_new(*String::Utf8Value(isolate, rstr), rstr->Utf8Length(isolate), 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,
@@ -500,7 +543,7 @@ 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(i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
+            array->Set(context, i, convert_ruby_to_v8(isolate, context, rb_ary_entry(value, i)));
 	}
 	return scope.Escape(array);
     case T_HASH:
@@ -509,7 +552,7 @@ 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(convert_ruby_to_v8(isolate, context, rb_ary_entry(pair, 0)),
+            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);
@@ -539,9 +582,9 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
     case T_UNDEF:
     case T_NODE:
     default:
-      return scope.Escape(String::NewFromUtf8(isolate, "Undefined Conversion"));
+      return scope.Escape(String::NewFromUtf8Literal(isolate, "Undefined Conversion"));
+    }
     }
-}
 
 static void unblock_eval(void *ptr) {
     EvalParams* eval = (EvalParams*)ptr;
@@ -552,53 +595,43 @@ static void unblock_eval(void *ptr) {
  * 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.
  */
-bool run_extra_code(Isolate *isolate, Local<v8::Context> context,
+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,
-                             NewStringType::kNormal)
-             .ToLocal(&source_string)) {
+    if (!String::NewFromUtf8(isolate, utf8_source).ToLocal(&source_string)) {
         return false;
     }
-    Local<v8::String> resource_name =
-        String::NewFromUtf8(isolate, name, NewStringType::kNormal)
-            .ToLocalChecked();
+    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;
-    // CHECK(!try_catch.HasCaught());
+    if (script->Run(context).IsEmpty()) return false;
     return true;
 }
 
-StartupData
+static StartupData
 create_snapshot_data_blob(const char *embedded_source = nullptr) {
-    // Create a new isolate and a new context from scratch, optionally run
-    // a script to embed, and serialize to create a snapshot blob.
-    StartupData result = {nullptr, 0};
-    {
-        SnapshotCreator snapshot_creator;
-        Isolate *isolate = snapshot_creator.GetIsolate();
+    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<Context> context = Context::New(isolate);
+        Local<v8::Context> context = v8::Context::New(isolate);
             if (embedded_source != nullptr &&
-                !run_extra_code(isolate, context, embedded_source,
-                                "<embedded>")) {
-                return result;
+                !run_extra_code(isolate, context, embedded_source, "<embedded>")) {
+           return {};
             }
             snapshot_creator.SetDefaultContext(context);
         }
-        result = snapshot_creator.CreateBlob(
+    return snapshot_creator.CreateBlob(
             SnapshotCreator::FunctionCodeHandling::kClear);
     }
-    return result;
-}
 
 StartupData warm_up_snapshot_data_blob(StartupData cold_snapshot_blob,
                                        const char *warmup_source) {
@@ -745,6 +778,29 @@ static VALUE rb_isolate_idle_notification(VALUE self, VALUE idle_time_in_ms) {
     return isolate_info->isolate->IdleNotificationDeadline(now + duration) ? Qtrue : Qfalse;
 }
 
+static VALUE rb_isolate_low_memory_notification(VALUE self) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    if (current_platform == NULL) return Qfalse;
+
+    isolate_info->isolate->LowMemoryNotification();
+    return Qnil;
+}
+
+static VALUE rb_isolate_pump_message_loop(VALUE self) {
+    IsolateInfo* isolate_info;
+    Data_Get_Struct(self, IsolateInfo, isolate_info);
+
+    if (current_platform == NULL) return Qfalse;
+
+    if (platform::PumpMessageLoop(current_platform.get(), isolate_info->isolate)){
+	return Qtrue;
+    } else {
+	return Qfalse;
+    }
+}
+
 static VALUE rb_context_init_unsafe(VALUE self, VALUE isolate, VALUE snap) {
     ContextInfo* context_info;
     Data_Get_Struct(self, ContextInfo, context_info);
@@ -1015,7 +1071,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);
@@ -1029,7 +1087,7 @@ 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());
@@ -1100,7 +1158,9 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
         if (parent_object == Qnil) {
             context->Global()->Set(
-                v8_str, FunctionTemplate::New(isolate, ruby_callback, external)
+                        context,
+                        v8_str,
+                        FunctionTemplate::New(isolate, ruby_callback, external)
                             ->GetFunction(context)
                             .ToLocalChecked());
 
@@ -1113,7 +1173,7 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
 
             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);
@@ -1123,11 +1183,12 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
                     Local<Value> value = maybe_value.ToLocalChecked();
                     if (value->IsObject()) {
                         value.As<Object>()->Set(
-                            v8_str, FunctionTemplate::New(
-                                        isolate, ruby_callback, external)
+                                    context,
+                                    v8_str,
+                                    FunctionTemplate::New(isolate, ruby_callback, external)
                                         ->GetFunction(context)
                                         .ToLocalChecked());
-                        attach_error = false;
+                    attach_error = false;
                     }
                 }
             }
@@ -1157,35 +1218,39 @@ static VALUE rb_context_isolate_mutex(VALUE self) {
     return context_info->isolate_info->mutex;
 }
 
-void free_isolate(IsolateInfo* isolate_info) {
-
-    if (isolate_info->isolate) {
-        Locker lock(isolate_info->isolate);
-    }
-
-    if (isolate_info->isolate) {
-        if (isolate_info->interrupted) {
-            fprintf(stderr, "WARNING: V8 isolate was interrupted by Ruby, it can not be disposed and memory will not be reclaimed till the Ruby process exits.\n");
+IsolateInfo::~IsolateInfo() {
+    if (isolate) {
+        if (this->interrupted) {
+            fprintf(stderr, "WARNING: V8 isolate was interrupted by Ruby, "
+                            "it can not be disposed and memory will not be "
+                            "reclaimed till the Ruby process exits.\n");
         } else {
-            
-            if (isolate_info->pid != getpid()) {
-                fprintf(stderr, "WARNING: V8 isolate was forked, it can not be disposed and memory will not be reclaimed till the Ruby process exits.\n");
+            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;
@@ -1202,6 +1267,20 @@ static void *free_context_raw(void* arg) {
     }
 
     xfree(context_info);
+}
+
+static void *free_context_thr(void* arg) {
+    if (pthread_rwlock_tryrdlock(&exit_lock) != 0) {
+        return NULL;
+    }
+    if (ruby_exiting) {
+        return NULL;
+    }
+
+    free_context_raw(arg);
+
+    pthread_rwlock_unlock(&exit_lock);
+
     return NULL;
 }
 
@@ -1215,22 +1294,17 @@ static void free_context(ContextInfo* context_info) {
     context_info_copy->context = context_info->context;
 
     if (isolate_info && isolate_info->refs() > 1) {
-    pthread_t free_context_thread;
-    if (pthread_create(&free_context_thread, NULL, free_context_raw, (void*)context_info_copy)) {
-        fprintf(stderr, "WARNING failed to release memory in MiniRacer, thread to release could not be created, process will leak memory\n");
-    }
-
+        pthread_t free_context_thread;
+        if (pthread_create(&free_context_thread, thread_attr_p,
+                           free_context_thr, (void*)context_info_copy)) {
+            fprintf(stderr, "WARNING failed to release memory in MiniRacer, thread to release could not be created, process will leak memory\n");
+        }
     } else {
         free_context_raw(context_info_copy);
     }
 
-    if (context_info->context && isolate_info && isolate_info->isolate) {
-        context_info->context = NULL;
-    }
-
-    if (isolate_info) {
-        context_info->isolate_info = NULL;
-    }
+    context_info->context = NULL;
+    context_info->isolate_info = NULL;
 }
 
 static void deallocate_isolate(void* data) {
@@ -1245,7 +1319,7 @@ static void mark_isolate(void* data) {
     isolate_info->mark();
 }
 
-void deallocate(void* data) {
+static void deallocate(void* data) {
     ContextInfo* context_info = (ContextInfo*)data;
 
     free_context(context_info);
@@ -1260,22 +1334,22 @@ static void mark_context(void* data) {
     }
 }
 
-void deallocate_external_function(void * data) {
+static void deallocate_external_function(void * data) {
     xfree(data);
 }
 
-void deallocate_snapshot(void * data) {
+static void deallocate_snapshot(void * data) {
     SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
     delete[] snapshot_info->data;
     xfree(snapshot_info);
 }
 
-VALUE allocate_external_function(VALUE klass) {
+static VALUE allocate_external_function(VALUE klass) {
     VALUE* self = ALLOC(VALUE);
     return Data_Wrap_Struct(klass, NULL, deallocate_external_function, (void*)self);
 }
 
-VALUE allocate(VALUE klass) {
+static VALUE allocate(VALUE klass) {
     ContextInfo* context_info = ALLOC(ContextInfo);
     context_info->isolate_info = NULL;
     context_info->context = NULL;
@@ -1283,7 +1357,7 @@ VALUE allocate(VALUE klass) {
     return Data_Wrap_Struct(klass, mark_context, deallocate, (void*)context_info);
 }
 
-VALUE allocate_snapshot(VALUE klass) {
+static VALUE allocate_snapshot(VALUE klass) {
     SnapshotInfo* snapshot_info = ALLOC(SnapshotInfo);
     snapshot_info->data = NULL;
     snapshot_info->raw_size = 0;
@@ -1291,7 +1365,7 @@ VALUE allocate_snapshot(VALUE klass) {
     return Data_Wrap_Struct(klass, NULL, deallocate_snapshot, (void*)snapshot_info);
 }
 
-VALUE allocate_isolate(VALUE klass) {
+static VALUE allocate_isolate(VALUE klass) {
     IsolateInfo* isolate_info = new IsolateInfo();
 
     return Data_Wrap_Struct(klass, mark_isolate, deallocate_isolate, (void*)isolate_info);
@@ -1388,6 +1462,8 @@ rb_heap_snapshot(VALUE self, VALUE file) {
     FileOutputStream stream(fp);
     snap->Serialize(&stream, HeapSnapshot::kJSON);
 
+    fflush(fp);
+
     const_cast<HeapSnapshot*>(snap)->Delete();
 
     return Qtrue;
@@ -1428,13 +1504,23 @@ nogvl_context_call(void *args) {
     if (!call) {
         return NULL;
     }
-    Isolate* isolate = call->context_info->isolate_info->isolate;
+    IsolateInfo *isolate_info = call->context_info->isolate_info;
+    Isolate* isolate = isolate_info->isolate;
 
     // in gvl flag
     isolate->SetData(IN_GVL, (void*)false);
     // terminate ASAP
     isolate->SetData(DO_TERMINATE, (void*)false);
 
+    if (call->max_memory > 0) {
+        isolate->SetData(MEM_SOFTLIMIT_VALUE, &call->max_memory);
+        isolate->SetData(MEM_SOFTLIMIT_REACHED, (void*)false);
+        if (!isolate_info->added_gc_cb) {
+        isolate->AddGCEpilogueCallback(gc_callback);
+            isolate_info->added_gc_cb = true;
+    }
+    }
+
     Isolate::Scope isolate_scope(isolate);
     EscapableHandleScope handle_scope(isolate);
     TryCatch trycatch(isolate);
@@ -1492,6 +1578,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);
@@ -1503,8 +1596,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;
@@ -1549,9 +1645,20 @@ 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);
+    }
+}
+
 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);
@@ -1599,8 +1706,23 @@ 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;
+            }
+        }
+        auto on_fork_for_child = []() {
+            exit_lock = PTHREAD_RWLOCK_INITIALIZER;
+        };
+        pthread_atfork(nullptr, nullptr, on_fork_for_child);
     }
 }