sq_mini_racer 0.2.5.0.2 → 0.3.1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 124526376fa9a93ba73fd7205e15abca399022b37b91f5f6fd994ecadaf63714
-  data.tar.gz: 5a20fb645e0fbf6f8da6b4bdfbda258f29c05e6d9861928a28c2f2b0311bf7f1
+  metadata.gz: d8cbb749f96b48a2a73449a6d1cd185b52666e06cafde1403b272546febe73f3
+  data.tar.gz: 8f043ac401c8352821c390f8bb77a6f049bef9fd1554bdb999bb176159dedfce
 SHA512:
-  metadata.gz: b2cb15116b9cda7b82245dee09f93f02cb4634911ef29d2606d084436b7d0d284b6940d69cbc8fd8dc83bfb865b586c943f0c4e13513b8c66ed2437116aaa340
-  data.tar.gz: f09c7e9b3ad2c3a34514bca93b5f209e1f49a2d8b873a0edf4f1ec0ba55c16dad035809a71364b7da1a817a8677342ed63cbd6a8bd0c4e588db6ee10b3b035af
+  metadata.gz: 12b21a0d7d26dd3a4ff555322126f2a93d6e3ecfd6a510aff13af9b097334b43709ad2b8fdd8453736f157364eda2ad6f7bfc22de4c97294eefa519bc9cffd74
+  data.tar.gz: e9f45f0ff41d1939ce62acaeeeae6ecf2aa4d1744c87b6067043bac7480bddb94410a99a27a92526cdfdc006a597cd6d0e55bde992a52bfcfb3c49491d7dc7ce

data/.gitignore

@@ -11,3 +11,12 @@ lib/*.so
 /lib/sq_mini_racer/
 /ext/mini_racer_extension/mini_racer.creator.*
 *.bundle
+/mini_racer.config
+/mini_racer.creator
+/mini_racer.creator.user
+/mini_racer.files
+/mini_racer.includes
+/compile_commands.json
+/.vscode/
+/.clangd/
+/.idea/

data/CHANGELOG

@@ -1,3 +1,76 @@
+- Unreleased
+
+  - FIX: on downgrade mkmf was picking the wrong version of libv8, this fix will correct future issues
+
+- 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
+
+  - FIX: ensure thread live cycle is properly accounter for following file descriptor fix
+
+- 0.2.7
+
+- 11-11-2019
+
+  - FIX: release the file descriptor for timeout pipe earlier (this avoids holding too many files open in Ruby 2.7)
+
 - 14-05-2019
 
 - 0.2.6

data/Dockerfile

@@ -20,4 +20,3 @@ RUN bundle exec rake compile
 
 COPY . /code/
 CMD bundle exec irb -rmini_racer
-

data/README.md

@@ -234,12 +234,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:
@@ -277,7 +282,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.
 
@@ -314,6 +319,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:
@@ -451,7 +466,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

@@ -1,75 +1,57 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 require "rake/extensiontask"
+require "shellwords"
+
+class ValgrindTestTask < Rake::TestTask
+  VALGRIND_EXEC = 'valgrind'
+  DEFAULT_VALGRIND_OPTS = %w{
+    --trace-children=yes
+    --partial-loads-ok=yes
+    --error-limit=no
+    --error-exitcode=33
+    --num-callers=100
+    --suppressions=valgrind.supp
+    --gen-suppressions=all
+  }
+
+  attr_accessor :valgrind_args
+
+  def initialize(name=:valgrind_test)
+    @valgrind_args = DEFAULT_VALGRIND_OPTS
+    super
+  end
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList['test/**/*_test.rb']
-end
-
-task :default => [:compile, :test]
-
-gem = Gem::Specification.load( File.dirname(__FILE__) + '/sq_mini_racer.gemspec' )
-Rake::ExtensionTask.new( 'mini_racer_extension', gem ) do |ext|
-  ext.name = 'sq_mini_racer_extension'
-end
-Rake::ExtensionTask.new('prv_ext_loader', gem)
-
-
-# via http://blog.flavorjon.es/2009/06/easily-valgrind-gdb-your-ruby-c.html
-namespace :test do
-  desc "run test suite with Address Sanitizer"
-  task :asan do
-    ENV["CONFIGURE_ARGS"] = [ENV["CONFIGURE_ARGS"], '--enable-asan'].compact.join(' ')
-    Rake::Task['compile'].invoke
-
-    asan_path = `ldconfig -N -p |grep libasan | grep -v 32 | sed 's/.* => \\(.*\\)$/\\1/'`.chomp.split("\n")[-1]
-
-
-    cmdline = "env LD_PRELOAD=\"#{asan_path}\" ruby test/test_leak.rb"
-    puts cmdline
-    system cmdline
-
-    cmdline = "env LD_PRELOAD=\"#{asan_path}\" rake test"
-    puts cmdline
-    system cmdline
+  # see original def in fileutils.rb
+  def ruby(*args, &block)
+    options = (Hash === args.last) ? args.pop : {}
+    if args.length > 1
+      sh(*([VALGRIND_EXEC] + valgrind_args + [RUBY] + args + [options]), &block)
+    else
+      # if the size is 1 it's assumed the arguments are already escaped
+      non_escaped_args = [VALGRIND_EXEC] + valgrind_args + [RUBY]
+      sh("#{non_escaped_args.map { |s| Shellwords.escape(s) }.join(' ')} #{args.first}", options, &block)
   end
-  # partial-loads-ok and undef-value-errors necessary to ignore
-  # spurious (and eminently ignorable) warnings from the ruby
-  # interpreter
-  VALGRIND_BASIC_OPTS = "--num-callers=50 --error-limit=no \
-                         --partial-loads-ok=yes --undef-value-errors=no"
+  end
+end
 
-  desc "run test suite under valgrind with basic ruby options"
-  task :valgrind => :compile do
-    cmdline = "valgrind #{VALGRIND_BASIC_OPTS} ruby test/test_leak.rb"
-    puts cmdline
-    system cmdline
+test_task_cfg = Proc.new do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
   end
 
-  desc "run test suite under valgrind with leak-check=full"
-  task :valgrind_leak_check => :compile do
-    cmdline = "valgrind #{VALGRIND_BASIC_OPTS} --leak-check=full ruby test/test_leak.rb"
-    puts cmdline
-    require 'open3'
-    _, stderr = Open3.capture3(cmdline)
+Rake::TestTask.new(:test, &test_task_cfg)
+ValgrindTestTask.new(:'test:valgrind', &test_task_cfg)
 
-    section = ""
-    stderr.split("\n").each do |line|
+task :default => [:compile, :test]
 
-      if line =~ /==.*==\s*$/
-        if (section =~ /mini_racer|SUMMARY/)
-          puts
-          puts section
-          puts
-        end
-        section = ""
-      else
-        section << line << "\n"
-      end
-    end
-  end
+gem = Gem::Specification.load( File.dirname(__FILE__) + '/mini_racer.gemspec' )
+Rake::ExtensionTask.new( 'mini_racer_loader', gem ) do |ext|
+  ext.name = 'sq_mini_racer_loader'
+end
+Rake::ExtensionTask.new( 'mini_racer_extension', gem ) do |ext|
+  ext.name = 'sq_mini_racer_extension'
 end
 
 desc 'run clang-tidy linter on mini_racer_extension.cc'

data/azure-template.yml

@@ -66,7 +66,7 @@ jobs:
         displayName: Print logs
         condition: failed()
 
-      - script: $(bundle) exec rake test
+      - script: TESTOPTS=--junit $(bundle) exec rake test
         displayName: Run tests
         env:
           ${{ if eq(parameters.with_mini_racer, true) }}:
@@ -74,6 +74,15 @@ jobs:
           ${{ if eq(parameters.with_therubyracer, true) }}:
             LOAD_THERUBYRACER: 1
 
+      - task: PublishTestResults@2
+        displayName: Publish test results
+        condition: succeededOrFailed()
+        inputs:
+          testResultsFormat: 'JUnit'
+          testResultsFiles: '**/report.xml'
+          searchFolder: '$(System.DefaultWorkingDirectory)'
+          mergeTestResults: true
+
       - ${{ if and(eq(parameters.imageName, 'ubuntu-18.04'), eq(parameters.with_mini_racer, false), eq(parameters.with_therubyracer, false)) }}:
         - script: $(bundle) exec rake test:valgrind
           displayName: Run tests w/ valgrind

data/ext/mini_racer_extension/extconf.rb

@@ -26,14 +26,11 @@ def cppflags_add_cpu_extension!
 end
 
 def libv8_gem_name
-  #return "libv8-solaris" if IS_SOLARIS
-  #return "libv8-alpine" if IS_LINUX_MUSL
-
   'libv8-node'
 end
 
 def libv8_requirement
-  '~> 12.18.4.0.beta1'
+  '~> 15.5.1.0.beta1'
 end
 
 def libv8_basename(version)
@@ -207,19 +204,25 @@ $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_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
-$LDFLAGS += " -Wl,-undefined,error " if IS_DARWIN
+# causes problems on some systems
+# $LDFLAGS += " -Wl,--no-undefined " unless IS_DARWIN
+# $LDFLAGS += " -Wl,-undefined,error " if 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

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -34,7 +34,11 @@
 #include <atomic>
 #include <math.h>
 #include "compat.hpp"
+#ifdef __x86_64__
 #include "simdutf8check.h"
+#endif
+
+#include <time.h>
 
 using namespace v8;
 
@@ -49,6 +53,7 @@ public:
     ArrayBuffer::Allocator* allocator;
     StartupData* startup_data;
     bool interrupted;
+    bool added_gc_cb;
     pid_t pid;
     VALUE mutex;
 
@@ -66,15 +71,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);
 
@@ -151,6 +153,7 @@ typedef struct {
     Local<Function> fun;
     Local<Value> *argv;
     EvalResult result;
+    size_t max_memory;
 } FunctionCall;
 
 enum IsolateFlags {
@@ -179,6 +182,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;
 
@@ -190,6 +198,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;
@@ -256,11 +267,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;
@@ -314,7 +327,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()) {
@@ -335,7 +348,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);
@@ -379,7 +393,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);
@@ -392,6 +409,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) {
@@ -423,8 +446,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;
           }
@@ -454,26 +480,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,
@@ -519,11 +566,13 @@ static inline Local<Value> convert_ruby_str_to_v8(
     static const rb_encoding *usascii_enc = rb_usascii_encoding();
     static const rb_encoding *latin1_enc = rb_enc_find("ISO-8859-1");
     assert(latin1_enc != nullptr);
+#ifdef __x86_64__
 #ifndef __AVX2__
 # define validate_utf8 validate_utf8_fast
 #else
     static const (*validate_utf8)(const char *, size_t) =
             best_utf8_validate_func();
+#endif
 #endif
 
     rb_encoding *enc = rb_enc_get(value);
@@ -532,8 +581,12 @@ static inline Local<Value> convert_ruby_str_to_v8(
     if (len < 0 || len > INT_MAX) {
         return Null(isolate);
     }
+#ifdef __x86_64__
     bool is_valid_utf8 = enc == utf8_enc &&
             validate_utf8(str, static_cast<size_t>(len));
+#else
+    bool is_valid_utf8 = false;
+#endif
 
     MaybeLocal<String> v8str;
     int int_len = static_cast<int>(len);
@@ -596,7 +649,11 @@ 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(convert_ruby_str_to_v8(scope, isolate, value));
+//#ifndef __x86_64__
+//	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
+//#else
+	return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
+//#endif
     case T_NIL:
 	return scope.Escape(Null(isolate));
     case T_TRUE:
@@ -608,7 +665,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);
         }
@@ -619,7 +676,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);
@@ -627,7 +684,11 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
     case T_SYMBOL:
         {
 	value = rb_funcall(value, rb_intern("to_s"), 0);
-            return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
+//#ifndef __x86_64__
+//	return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
+//#else
+	return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
+//#endif
         }
     case T_DATA:
         {
@@ -659,10 +720,15 @@ static Local<Value> convert_ruby_to_v8(Isolate* isolate, Local<Context> context,
             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);
+//#ifndef __x86_64__
+//                return scope.Escape(String::NewFromUtf8(isolate, RSTRING_PTR(value), NewStringType::kNormal, (int)RSTRING_LEN(value)).ToLocalChecked());
+//#else
                 return scope.Escape(convert_ruby_str_to_v8(scope, isolate, value));
+//#endif
             }
-      return scope.Escape(String::NewFromUtf8(isolate, "Undefined Conversion"));
-    }
+            return scope.Escape(
+                String::NewFromUtf8Literal(isolate, "Undefined Conversion"));
+        }
     }
 }
 
@@ -675,53 +741,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};
+    Isolate *isolate = Isolate::Allocate();
+
+    // Optionally run a script to embed, and serialize to create a snapshot blob.
+    SnapshotCreator snapshot_creator(isolate);
     {
-        SnapshotCreator snapshot_creator;
-        Isolate *isolate = snapshot_creator.GetIsolate();
-        {
             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) {
@@ -868,6 +924,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);
@@ -1142,7 +1221,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);
@@ -1156,7 +1237,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());
@@ -1231,7 +1312,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());
 
@@ -1244,7 +1327,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);
@@ -1254,11 +1337,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;
                     }
                 }
             }
@@ -1288,35 +1372,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;
@@ -1333,6 +1421,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;
 }
 
@@ -1347,22 +1449,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) {
 
@@ -1376,7 +1473,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);
@@ -1391,22 +1488,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;
@@ -1414,7 +1511,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;
@@ -1422,7 +1519,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);
@@ -1519,6 +1616,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;
@@ -1576,13 +1675,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);
@@ -1640,6 +1749,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);
@@ -1651,8 +1767,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;
@@ -1701,12 +1820,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);
@@ -1753,8 +1904,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);
     }
 }