mini_racer 0.2.10 → 0.2.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a50c6aea93635efc351ce95def252df6edb3fbede6a0372272f8c9cd58f9aaed
-  data.tar.gz: b01cd6a98eca13db18d539ed259e4acd968eb073582979ff06f78a5df54a4207
+  metadata.gz: 359264fa5fcef999d505e7a76075d98d08310e88c4bdc983c9e3ce87122a990c
+  data.tar.gz: 46444c7126d86d41a78a8c44c97f31433eff7e4c7551ba46a7b19e7f2b64100c
 SHA512:
-  metadata.gz: cac0258ac9f1f93245b00b313d004504d770e9dce3eb5ac9a8d547a1b24cd3649ec9039d9c7429ff7871f9f8d3c07e260997d86647905ba433688f361bd72611
-  data.tar.gz: b054a38013e7bcffe689c3732d7d95abbaf61c350dab275ff7e04e667bc5f15ae9863a706beb2848681b8d69cc1194c0bb87014a4c49e2f49d14a4289b1f6436
+  metadata.gz: 6c682ae187454565667c71132a39eed4b179b642d34cf9e48d9a9333973394dbf368000758b89dc721ee3e264708e44cc6812f5530afc3c0aad976697a7fe9a7
+  data.tar.gz: cc032e45e917c57ac329813344dd241dc12ba95b02b5088d0d945a0bf15ea0db8feb9bb147caf1efc8795d1abfec6e321cc16798ea1c554789d26ee9d44cd389

data/CHANGELOG

@@ -1,3 +1,36 @@
+- 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

data/README.md

@@ -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:
@@ -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:

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -156,6 +156,10 @@ 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; // guarded by exit_lock
+
 static VALUE rb_platform_set_flag_as_str(VALUE _klass, VALUE flag_as_str) {
     bool platform_already_initialized = false;
 
@@ -765,6 +769,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);
@@ -1205,7 +1232,7 @@ void free_isolate(IsolateInfo* isolate_info) {
     delete isolate_info->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;
@@ -1222,6 +1249,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;
 }
 
@@ -1235,22 +1276,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) {
@@ -1408,6 +1444,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;
@@ -1582,6 +1620,16 @@ 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 )
@@ -1632,8 +1680,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;
+            }
+        }
     }
 }

data/lib/mini_racer.rb

@@ -130,21 +130,29 @@ module MiniRacer
       end
     end
 
-    def initialize(options = nil)
+    def initialize(max_memory: nil, timeout: nil, isolate: nil, ensure_gc_after_idle: nil, snapshot: nil)
       options ||= {}
 
-      check_init_options!(options)
+      check_init_options!(isolate: isolate, snapshot: snapshot, max_memory: max_memory, ensure_gc_after_idle: ensure_gc_after_idle, timeout: timeout)
 
       @functions = {}
       @timeout = nil
       @max_memory = nil
       @current_exception = nil
-      @timeout = options[:timeout]
-      if options[:max_memory].is_a?(Numeric) && options[:max_memory] > 0
-        @max_memory = options[:max_memory]
-      end
+      @timeout = timeout
+      @max_memory = max_memory
+
       # false signals it should be fetched if requested
-      @isolate = options[:isolate] || false
+      @isolate = isolate || false
+
+      @ensure_gc_after_idle = ensure_gc_after_idle
+
+      if @ensure_gc_after_idle
+        @last_eval = nil
+        @ensure_gc_thread = nil
+        @ensure_gc_mutex = Mutex.new
+      end
+
       @disposed = false
 
       @callback_mutex = Mutex.new
@@ -153,7 +161,7 @@ module MiniRacer
       @eval_thread = nil
 
       # defined in the C class
-      init_unsafe(options[:isolate], options[:snapshot])
+      init_unsafe(isolate, snapshot)
     end
 
     def isolate
@@ -203,6 +211,7 @@ module MiniRacer
       end
     ensure
       @eval_thread = nil
+      ensure_gc_thread if @ensure_gc_after_idle
     end
 
     def call(function_name, *arguments)
@@ -216,15 +225,17 @@ module MiniRacer
       end
     ensure
       @eval_thread = nil
+      ensure_gc_thread if @ensure_gc_after_idle
     end
 
     def dispose
       return if @disposed
       isolate_mutex.synchronize do
+        return if @disposed
         dispose_unsafe
+        @disposed = true
+        @isolate = nil # allow it to be garbage collected, if set
       end
-      @disposed = true
-      @isolate = nil # allow it to be garbage collected, if set
     end
 
 
@@ -273,6 +284,38 @@ module MiniRacer
 
   private
 
+    def ensure_gc_thread
+      @last_eval = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @ensure_gc_mutex.synchronize do
+        @ensure_gc_thread = nil if !@ensure_gc_thread&.alive?
+        @ensure_gc_thread ||= Thread.new do
+          ensure_gc_after_idle_seconds = @ensure_gc_after_idle / 1000.0
+          done = false
+          while !done
+            now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+            if @disposed
+              @ensure_gc_thread = nil
+              break
+            end
+
+            if !@eval_thread && ensure_gc_after_idle_seconds < now - @last_eval
+              @ensure_gc_mutex.synchronize do
+                isolate_mutex.synchronize do
+                  if !@eval_thread
+                    isolate.low_memory_notification if !@disposed
+                    @ensure_gc_thread = nil
+                    done = true
+                  end
+                end
+              end
+            end
+            sleep ensure_gc_after_idle_seconds if !done
+          end
+        end
+      end
+    end
+
     def stop_attached
       @callback_mutex.synchronize{
         if @callback_running
@@ -326,15 +369,29 @@ module MiniRacer
       rp.close if rp
     end
 
-    def check_init_options!(options)
-      assert_option_is_nil_or_a('isolate', options[:isolate], Isolate)
-      assert_option_is_nil_or_a('snapshot', options[:snapshot], Snapshot)
+    def check_init_options!(isolate:, snapshot:, max_memory:, ensure_gc_after_idle:, timeout:)
+      assert_option_is_nil_or_a('isolate', isolate, Isolate)
+      assert_option_is_nil_or_a('snapshot', snapshot, Snapshot)
+
+      assert_numeric_or_nil('max_memory', max_memory, min_value: 10_000)
+      assert_numeric_or_nil('ensure_gc_after_idle', ensure_gc_after_idle, min_value: 1)
+      assert_numeric_or_nil('timeout', timeout, min_value: 1)
 
-      if options[:isolate] && options[:snapshot]
+      if isolate && snapshot
         raise ArgumentError, 'can only pass one of isolate and snapshot options'
       end
     end
 
+    def assert_numeric_or_nil(option_name, object, min_value:)
+      if object.is_a?(Numeric) && object < min_value
+        raise ArgumentError, "#{option_name} must be larger than #{min_value}"
+      end
+
+      if !object.nil? && !object.is_a?(Numeric)
+        raise ArgumentError, "#{option_name} must be a number, passed a #{object.inspect}"
+      end
+    end
+
     def assert_option_is_nil_or_a(option_name, object, klass)
       unless object.nil? || object.is_a?(klass)
         raise ArgumentError, "#{option_name} must be a #{klass} object, passed a #{object.inspect}"

data/lib/mini_racer/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module MiniRacer
-  VERSION = "0.2.10"
+  VERSION = "0.2.15"
 end

data/mini_racer.gemspec

@@ -27,9 +27,10 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake", ">= 12.3.3"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "m"
 
   spec.add_dependency 'libv8', '> 7.3'
   spec.require_paths = ["lib", "ext"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.2.15
 platform: ruby
 authors:
 - Sam Saffron
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-04-22 00:00:00.000000000 Z
+date: 2020-06-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,16 +28,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -66,6 +66,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: libv8
   requirement: !ruby/object:Gem::Requirement
@@ -108,10 +122,10 @@ licenses:
 - MIT
 metadata:
   bug_tracker_uri: https://github.com/discourse/mini_racer/issues
-  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.2.10/CHANGELOG
-  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.2.10
-  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.2.10
-post_install_message: 
+  changelog_uri: https://github.com/discourse/mini_racer/blob/v0.2.15/CHANGELOG
+  documentation_uri: https://www.rubydoc.info/gems/mini_racer/0.2.15
+  source_code_uri: https://github.com/discourse/mini_racer/tree/v0.2.15
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -128,7 +142,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Minimal embedded v8 for Ruby
 test_files: []