mini_racer 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bcbf79004383ed09c2b2ceb6821a13a01ef11c36
-  data.tar.gz: d18d5d701d8067a011f2e778c257a076036cb029
+  metadata.gz: 0af151705087d66782e15f8a45952d95e3a7ff80
+  data.tar.gz: 13c8ac7228b49b3c4be26a521ffd01b9cf2b77ee
 SHA512:
-  metadata.gz: fa133304bbbbac7c0a7cd205d19928cc0bfd074a340c0ef18ceef92bff9bc4e3ff4924085c418ee32e14663c84c856837f7f745b09db65d5ecd89241b5081689
-  data.tar.gz: 9bbfa1a279aef49bcfe500583b73796c4766bc5bbbd278f1d3c76bdf8c9ce2df67d292f2c1e25d94e739f532f252356497b7e4d43dc94fab9c0e8d0819b2cd09
+  metadata.gz: 3c0359323d659fe170453a0b0304bc512c0d3d66edc07d991eb4383f354f788b9a54bc7abeec4f7280ae9e1c85bf9652fa2682d0c54ed5e41a3677009fdbb5d7
+  data.tar.gz: 3da5843bd59f285d3fcc3e9eaf92ee6cc823974016f669d01eeeb36a886055c3b9e6038b6f5e6e9ccc9a74eab4a7729ac2da9ed75df9ab388a5e0e34b4d22542

data/CHANGELOG

@@ -1,3 +1,12 @@
+13-07-2017
+
+- 0.1.10
+
+ - Fix leak: memory leak when disposing a context (20 bytes per context)
+ - Feature: added #heap_stats so you can get visibility from context to actual memory usage of isolate
+ - Feature: added #dispose so you reclaim all v8 memory right away as opposed to waiting for GC
+ - Feature: you can now specify filename in an eval eg: eval('a = 1', filename: 'my_awesome.js')
+
 09-03-2017
 
 - 0.1.9

data/README.md

@@ -68,6 +68,19 @@ context.eval 'while(true){}'
 # => exception is raised
 ```
 
+### Rich debugging with "filename" support
+
+```ruby
+
+context = MiniRacer::Context.new
+context.eval('var foo = function() {bar();}', filename: 'a/foo.js')
+context.eval('bar()', filename: 'a/bar.js')
+
+# MiniRacer::RuntimeError is raised containing the filenames you specified for evals in backtrace
+
+```
+
+
 ### Threadsafe
 
 Context usage is threadsafe
@@ -226,6 +239,39 @@ A list of all V8 runtime flags can be found using `node --v8-options`, or else b
 
 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.
 
+Flags:
+
+- :expose_gc : Will expose `gc()` which you can run in JavaScript to issue a gc
+- :max_old_space_size : defaults to 1400 (megs) on 64 bit, you can restric memory usage by limiting this.
+- **NOTE TO READER** our documentation could be awesome we could be properly documenting all the flags, they are hugely useful, if you feel like documenting a few more, PLEASE DO, PRs are welcome.
+
+## Controlling memory
+
+When hosting v8 you may want to keep track of memory usage, use #heap_stats to get memory usage:
+
+```ruby
+context = MiniRacer::Context.new(timeout: 5)
+context.eval("let a='testing';")
+p context.heap_stats
+# {:total_physical_size=>1280640,
+#  :total_heap_size_executable=>4194304,
+#  :total_heap_size=>3100672,
+#  :used_heap_size=>1205376,
+#  :heap_size_limit=>1501560832}
+```
+
+If you wish to dispose of a context before waiting on the GC use
+
+```ruby
+context = MiniRacer::Context.new(timeout: 5)
+context.eval("let a='testing';")
+context.dispose
+context.eval("a = 2")
+# MiniRacer::ContextDisposedError
+
+# nothing works on the context from now on, its a shell waiting to be disposed
+```
+
 ## Performance
 
 The `bench` folder contains benchmark.
@@ -302,14 +348,14 @@ Add this to your .travis.yml file:
 
 ## Similar Projects
 
-###therubyracer
+### therubyracer
 
 - https://github.com/cowboyd/therubyracer
 - Most comprehensive bridge available
 - Provides the ability to "eval" JavaScript
 - Provides the ability to invoke Ruby code from JavaScript
-- Hold refrences to JavaScript objects and methods in your Ruby code
-- Hold refrences to Ruby objects and methods in JavaScript code
+- Hold references to JavaScript objects and methods in your Ruby code
+- Hold references to Ruby objects and methods in JavaScript code
 - Uses libv8, so installation is fast
 - Supports timeouts for JavaScript execution
 - Does not release global interpreter lock, so performance is constrained to a single thread
@@ -317,7 +363,7 @@ Add this to your .travis.yml file:
 - Supports execjs
 
 
-###v8eval
+### v8eval
 
 - https://github.com/sony/v8eval
 - Provides the ability to "eval" JavaScript using the latest V8 engine
@@ -330,7 +376,7 @@ Add this to your .travis.yml file:
 - No support for execjs (can not be used with Rails uglifier and coffeescript gems)
 
 
-###therubyrhino
+### therubyrhino
 
 - https://github.com/cowboyd/therubyrhino
 - API compatible with therubyracer

data/ext/mini_racer_extension/extconf.rb

@@ -32,7 +32,7 @@ WARNING: C++11 support is required for compiling mini_racer. Please make sure
 you are using a compiler that supports at least C++11. Examples of such
 compilers are GCC 4.7+ and Clang 3.2+.
 
-If you are using Travis, consider either migrating your bulid to Ubuntu Trusty or
+If you are using Travis, consider either migrating your build to Ubuntu Trusty or
 installing GCC 4.8. See mini_racer's README.md for more information.
 
 

data/ext/mini_racer_extension/mini_racer_extension.cc

@@ -17,8 +17,12 @@ class ArrayBufferAllocator : public v8::ArrayBuffer::Allocator {
     void* data = AllocateUninitialized(length);
     return data == NULL ? data : memset(data, 0, length);
   }
-  virtual void* AllocateUninitialized(size_t length) { return malloc(length); }
-  virtual void Free(void* data, size_t) { free(data); }
+  virtual void* AllocateUninitialized(size_t length) {
+    return malloc(length);
+  }
+  virtual void Free(void* data, size_t) {
+     free(data);
+  }
 };
 
 typedef struct {
@@ -31,6 +35,7 @@ typedef struct {
     ArrayBufferAllocator* allocator;
     StartupData* startup_data;
     bool interrupted;
+    bool disposed;
     pid_t pid;
 
     // how many references to this isolate exist
@@ -38,7 +43,7 @@ typedef struct {
     // objects, Ruby will destroy ruby objects first, then call the
     // extenstion's deallocators. In this case, that means it would
     // call `deallocate_isolate` _before_ `deallocate`, causing a segfault
-    int refs_count;
+    volatile int refs_count;
 } IsolateInfo;
 
 typedef struct {
@@ -59,6 +64,7 @@ typedef struct {
 typedef struct {
     ContextInfo* context_info;
     Local<String>* eval;
+    Local<String>* filename;
     useconds_t timeout;
     EvalResult* result;
 } EvalParams;
@@ -126,13 +132,25 @@ nogvl_context_eval(void* arg) {
     TryCatch trycatch(isolate);
     Local<Context> context = eval_params->context_info->context->Get(isolate);
     Context::Scope context_scope(context);
+    v8::ScriptOrigin *origin = NULL;
 
     // in gvl flag
     isolate->SetData(0, (void*)false);
     // terminate ASAP
     isolate->SetData(1, (void*)false);
 
-    MaybeLocal<Script> parsed_script = Script::Compile(context, *eval_params->eval);
+    MaybeLocal<Script> parsed_script;
+
+    if (eval_params->filename) {
+	origin = new v8::ScriptOrigin(*eval_params->filename);
+    }
+
+    parsed_script = Script::Compile(context, *eval_params->eval, origin);
+
+    if (origin) {
+	delete origin;
+    }
+
     result->parsed = !parsed_script.IsEmpty();
     result->executed = false;
     result->terminated = false;
@@ -484,14 +502,14 @@ static VALUE rb_context_init_with_isolate(VALUE self, VALUE isolate) {
     isolate_info->refs_count++;
 
     {
-    Locker lock(isolate_info->isolate);
-    Isolate::Scope isolate_scope(isolate_info->isolate);
-    HandleScope handle_scope(isolate_info->isolate);
+	Locker lock(isolate_info->isolate);
+	Isolate::Scope isolate_scope(isolate_info->isolate);
+	HandleScope handle_scope(isolate_info->isolate);
 
-    Local<Context> context = Context::New(isolate_info->isolate);
+	Local<Context> context = Context::New(isolate_info->isolate);
 
-    context_info->context = new Persistent<Context>();
-    context_info->context->Reset(isolate_info->isolate, context);
+	context_info->context = new Persistent<Context>();
+	context_info->context->Reset(isolate_info->isolate, context);
     }
 
     if (Qnil == rb_cDateTime && rb_funcall(rb_cObject, rb_intern("const_defined?"), 1, rb_str_new2("DateTime")) == Qtrue)
@@ -502,7 +520,7 @@ static VALUE rb_context_init_with_isolate(VALUE self, VALUE isolate) {
     return Qnil;
 }
 
-static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
+static VALUE rb_context_eval_unsafe(VALUE self, VALUE str, VALUE filename) {
 
     EvalParams eval_params;
     EvalResult eval_result;
@@ -521,7 +539,17 @@ static VALUE rb_context_eval_unsafe(VALUE self, VALUE str) {
 	HandleScope handle_scope(isolate);
 
 	Local<String> eval = String::NewFromUtf8(isolate, RSTRING_PTR(str),
-						  NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
+				NewStringType::kNormal, (int)RSTRING_LEN(str)).ToLocalChecked();
+
+	Local<String> local_filename;
+
+	if (filename != Qnil) {
+	    local_filename = String::NewFromUtf8(isolate, RSTRING_PTR(filename),
+		    NewStringType::kNormal, (int)RSTRING_LEN(filename)).ToLocalChecked();
+	    eval_params.filename = &local_filename;
+	} else {
+	    eval_params.filename = NULL;
+	}
 
 	eval_params.context_info = context_info;
 	eval_params.eval = &eval;
@@ -786,15 +814,10 @@ static VALUE rb_external_function_notify_v8(VALUE self) {
     return Qnil;
 }
 
-void maybe_free_isolate_info(IsolateInfo* isolate_info) {
-    // an isolate can only be freed if no Isolate or Context (ruby) object
-    // still need it
-    if (isolate_info == NULL || isolate_info->refs_count > 0) {
-        return;
-    }
+void free_isolate(IsolateInfo* isolate_info) {
 
     if (isolate_info->isolate) {
-	    Locker lock(isolate_info->isolate);
+	Locker lock(isolate_info->isolate);
     }
 
     if (isolate_info->isolate) {
@@ -817,18 +840,25 @@ void maybe_free_isolate_info(IsolateInfo* isolate_info) {
     }
 
     delete isolate_info->allocator;
-    xfree(isolate_info);
+    isolate_info->disposed = true;
 }
 
-void deallocate_isolate(void* data) {
-    IsolateInfo* isolate_info = (IsolateInfo*) data;
-
-    isolate_info->refs_count--;
+void maybe_free_isolate(IsolateInfo* isolate_info) {
+    // an isolate can only be freed if no Isolate or Context (ruby) object
+    // still need it
+    //
+    // there is a sequence issue here where Ruby may call the deallocator on the
+    // context object after it calles the dallocator on the isolate
+    if (isolate_info->refs_count != 0 || isolate_info->disposed) {
+        return;
+    }
 
-    maybe_free_isolate_info(isolate_info);
+    free_isolate(isolate_info);
 }
 
-void deallocate(void* data) {
+
+void free_context(void* data) {
+
     ContextInfo* context_info = (ContextInfo*)data;
     IsolateInfo* isolate_info = context_info->isolate_info;
 
@@ -837,23 +867,56 @@ void deallocate(void* data) {
         v8::Isolate::Scope isolate_scope(isolate_info->isolate);
         context_info->context->Reset();
         delete context_info->context;
+	context_info->context = NULL;
     }
+}
+
+void deallocate_context(void* data) {
+
+    ContextInfo* context_info = (ContextInfo*)data;
+    IsolateInfo* isolate_info = context_info->isolate_info;
+
+    free_context(data);
 
     if (isolate_info) {
-        isolate_info->refs_count--;
-        maybe_free_isolate_info(isolate_info);
+	isolate_info->refs_count--;
+	maybe_free_isolate(isolate_info);
     }
 }
 
+void deallocate_isolate(void* data) {
+
+    IsolateInfo* isolate_info = (IsolateInfo*) data;
+
+    isolate_info->refs_count--;
+    maybe_free_isolate(isolate_info);
+
+    if (isolate_info->refs_count == 0) {
+	xfree(isolate_info);
+    }
+}
+
+void deallocate(void* data) {
+    ContextInfo* context_info = (ContextInfo*)data;
+    IsolateInfo* isolate_info = context_info->isolate_info;
+
+    deallocate_context(data);
+
+    if (isolate_info && isolate_info->refs_count == 0) {
+	xfree(isolate_info);
+    }
+
+    xfree(data);
+}
+
+
 void deallocate_external_function(void * data) {
     xfree(data);
 }
 
 void deallocate_snapshot(void * data) {
     SnapshotInfo* snapshot_info = (SnapshotInfo*)data;
-
     delete[] snapshot_info->data;
-
     xfree(snapshot_info);
 }
 
@@ -887,10 +950,44 @@ VALUE allocate_isolate(VALUE klass) {
     isolate_info->interrupted = false;
     isolate_info->refs_count = 0;
     isolate_info->pid = getpid();
+    isolate_info->disposed = false;
 
     return Data_Wrap_Struct(klass, NULL, deallocate_isolate, (void*)isolate_info);
 }
 
+static VALUE
+rb_heap_stats(VALUE self) {
+
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+    Isolate* isolate;
+    v8::HeapStatistics stats;
+
+    isolate = context_info->isolate_info ? context_info->isolate_info->isolate : NULL;
+
+    VALUE rval = rb_hash_new();
+
+    if (!isolate) {
+
+	rb_hash_aset(rval, ID2SYM(rb_intern("total_physical_size")), ULONG2NUM(0));
+	rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size_executable")), ULONG2NUM(0));
+	rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size")), ULONG2NUM(0));
+	rb_hash_aset(rval, ID2SYM(rb_intern("used_heap_size")), ULONG2NUM(0));
+	rb_hash_aset(rval, ID2SYM(rb_intern("heap_size_limit")), ULONG2NUM(0));
+
+    } else {
+	isolate->GetHeapStatistics(&stats);
+
+	rb_hash_aset(rval, ID2SYM(rb_intern("total_physical_size")), ULONG2NUM(stats.total_physical_size()));
+	rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size_executable")), ULONG2NUM(stats.total_heap_size_executable()));
+	rb_hash_aset(rval, ID2SYM(rb_intern("total_heap_size")), ULONG2NUM(stats.total_heap_size()));
+	rb_hash_aset(rval, ID2SYM(rb_intern("used_heap_size")), ULONG2NUM(stats.used_heap_size()));
+	rb_hash_aset(rval, ID2SYM(rb_intern("heap_size_limit")), ULONG2NUM(stats.heap_size_limit()));
+    }
+
+    return rval;
+}
+
 static VALUE
 rb_context_stop(VALUE self) {
 
@@ -908,6 +1005,22 @@ rb_context_stop(VALUE self) {
     return Qnil;
 }
 
+static VALUE
+rb_context_dispose(VALUE self) {
+
+    ContextInfo* context_info;
+    Data_Get_Struct(self, ContextInfo, context_info);
+
+    free_context(context_info);
+
+    if (context_info->isolate_info && context_info->isolate_info->refs_count == 2) {
+	// special case, we only have isolate + context so we can burn the
+	// isolate as well
+	free_isolate(context_info->isolate_info);
+    }
+    return Qnil;
+}
+
 extern "C" {
 
     void Init_mini_racer_extension ( void )
@@ -918,23 +1031,30 @@ extern "C" {
 	VALUE rb_cIsolate = rb_define_class_under(rb_mMiniRacer, "Isolate", rb_cObject);
 	VALUE rb_cPlatform = rb_define_class_under(rb_mMiniRacer, "Platform", rb_cObject);
 
-	VALUE rb_eEvalError = rb_define_class_under(rb_mMiniRacer, "EvalError", rb_eStandardError);
+	VALUE rb_eError = rb_define_class_under(rb_mMiniRacer, "Error", rb_eStandardError);
+
+	VALUE rb_eEvalError = rb_define_class_under(rb_mMiniRacer, "EvalError", rb_eError);
 	rb_eScriptTerminatedError = rb_define_class_under(rb_mMiniRacer, "ScriptTerminatedError", rb_eEvalError);
 	rb_eParseError = rb_define_class_under(rb_mMiniRacer, "ParseError", rb_eEvalError);
 	rb_eScriptRuntimeError = rb_define_class_under(rb_mMiniRacer, "RuntimeError", rb_eEvalError);
+
 	rb_cJavaScriptFunction = rb_define_class_under(rb_mMiniRacer, "JavaScriptFunction", rb_cObject);
-	rb_eSnapshotError = rb_define_class_under(rb_mMiniRacer, "SnapshotError", rb_eStandardError);
-	rb_ePlatformAlreadyInitializedError = rb_define_class_under(rb_mMiniRacer, "PlatformAlreadyInitialized", rb_eStandardError);
+	rb_eSnapshotError = rb_define_class_under(rb_mMiniRacer, "SnapshotError", rb_eError);
+	rb_ePlatformAlreadyInitializedError = rb_define_class_under(rb_mMiniRacer, "PlatformAlreadyInitialized", rb_eError);
 	rb_cFailedV8Conversion = rb_define_class_under(rb_mMiniRacer, "FailedV8Conversion", rb_cObject);
 	rb_mJSON = rb_define_module("JSON");
 
 	VALUE rb_cExternalFunction = rb_define_class_under(rb_cContext, "ExternalFunction", rb_cObject);
+
 	rb_define_method(rb_cContext, "stop", (VALUE(*)(...))&rb_context_stop, 0);
+	rb_define_method(rb_cContext, "dispose_unsafe", (VALUE(*)(...))&rb_context_dispose, 0);
+	rb_define_method(rb_cContext, "heap_stats", (VALUE(*)(...))&rb_heap_stats, 0);
+
 	rb_define_alloc_func(rb_cContext, allocate);
 	rb_define_alloc_func(rb_cSnapshot, allocate_snapshot);
 	rb_define_alloc_func(rb_cIsolate, allocate_isolate);
 
-	rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 1);
+	rb_define_private_method(rb_cContext, "eval_unsafe",(VALUE(*)(...))&rb_context_eval_unsafe, 2);
 	rb_define_private_method(rb_cContext, "init_with_isolate",(VALUE(*)(...))&rb_context_init_with_isolate, 1);
 	rb_define_private_method(rb_cExternalFunction, "notify_v8", (VALUE(*)(...))&rb_external_function_notify_v8, 0);
 	rb_define_alloc_func(rb_cExternalFunction, allocate_external_function);

data/lib/mini_racer/version.rb

@@ -1,3 +1,3 @@
 module MiniRacer
-  VERSION = "0.1.9"
+  VERSION = "0.1.10"
 end

data/lib/mini_racer.rb

@@ -5,11 +5,15 @@ require "json"
 
 module MiniRacer
 
-  class EvalError < StandardError; end
-  class ScriptTerminatedError < EvalError; end
+  class Error < ::StandardError; end
+
+  class ContextDisposedError < Error; end
+  class SnapshotError < Error; end
+  class PlatformAlreadyInitialized < Error; end
+
+  class EvalError < Error; end
   class ParseError < EvalError; end
-  class SnapshotError < StandardError; end
-  class PlatformAlreadyInitialized < StandardError; end
+  class ScriptTerminatedError < EvalError; end
 
   class FailedV8Conversion
     attr_reader :info
@@ -160,18 +164,31 @@ module MiniRacer
       eval(File.read(filename))
     end
 
-    def eval(str)
+    def eval(str, options=nil)
+      raise(ContextDisposedError, 'attempted to call eval on a disposed context!') if @disposed
+
+      filename = options && options[:filename].to_s
+
       @eval_thread = Thread.current
       isolate.with_lock do
         @current_exception = nil
         timeout do
-          eval_unsafe(str)
+          eval_unsafe(str, filename)
         end
       end
     ensure
       @eval_thread = nil
     end
 
+    def dispose
+      if !@disposed
+        isolate.with_lock do
+          dispose_unsafe
+        end
+        @disposed = true
+      end
+    end
+
 
     def attach(name, callback)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mini_racer
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Sam Saffron
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-09 00:00:00.000000000 Z
+date: 2017-07-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler