h8 0.1.4 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7384caa28f422353e348519ea0f56f9869f8243f
-  data.tar.gz: ef389e8693081cf4c7173bbffd31e2127bcf978e
+  metadata.gz: 0d9eec220ddcefcec439cacbc06a3a1aa9df74a4
+  data.tar.gz: ff56274f0e8f976ea5afe8b35ed01259032330db
 SHA512:
-  metadata.gz: ef76e195a1db60ca07987b46e5060830a73221c7e45daaf8e4fa8b8a8ab7540a25ed1f65740421cddeb19936d3abf8cd24f1a5ea5911292402c1f7b90b366875
-  data.tar.gz: 171b71959ebba1159e62c771a8f529d648307667770dbda0c03bfdaa106abb45c293bd5b7781ff9258abf286886d4e300ae20cc09bb875c6001861a033a784bc
+  metadata.gz: 43eecac7e09f262bddbcb68fe49717c82f27778205bc2b6aa2bb0808b1ea6bc2131c7bdb3d808253a7a35134ff8da9c7cb5d92d190b86f6f46b5e39388782f1d
+  data.tar.gz: 9741491ec26a3698b9a431624c4726db9989afa6ece6e09773eec14a7dcc711ca1fd9163467cc27e27ce2a947daa3af74713f99e17edc6407793a956c965e0ac

data/README.md

@@ -8,7 +8,8 @@ This gem was intended to replace therubyracer for many reasons:
 * therubyracer has critical bugs that are not fixed for a long time, under load it produces
 numerous frequent crashes.
 
-* therubyracer still uses antique version of V8, H8 uses the latest 3.31 branch
+* therubyracer still uses antique version of V8, H8 uses the latest 3.31 branch, which, for example,
+has the generators support.
 
 * H8 is designed to provide very tight and effective integration of two allocation systems and
 object models, passing the same objects between different systems wrapping and unwrapping them
@@ -36,11 +37,12 @@ uncaught javascript exceptions raise ruby error in ruby code.
 
 - Integrated CoffeeScript support
 
-## Main difference from therubyracer/features not ready
+- H8 is thread safe (using Lockers) and releases gvl when executing js code (and reqcquires it as
+need), thus other ruby threads can work in parallel with javascript executing threads. Still,
+h8 does not releases Locker when calling ruby code from javascript - for performance considerations.
+
 
-- H8 is thread safe (uses Lockers) but script is executed in the calling ruby thread without
-releasing gvl (other ruby threads can not perform on this core while javascript code runs). We are
-working on it, as simply releasing GVL and reacquring it may degrade performance.
+## Main difference from therubyracer/features not ready
 
 - labmda/proc passed as var to the context **does not receives first (this) argument
 automatically!**
@@ -98,11 +100,7 @@ Install first a valid v8 version. We provide a ready package!
 
     sudo apt-get install libv8-3.31-dev
 
-It should install prerequisites, if not, manually install
-
-    sudo apt-get install libicu-dev
-
-You might also need to install GMP.
+Usually it is all you need. Rarely, You might also need to install GMP.
 
 ### Setting up
 

data/ext/h8/JsCatcher.cpp

@@ -14,7 +14,12 @@ JsCatcher::JsCatcher(H8* h8) : h8(h8), v8::TryCatch(h8->getIsolate()) {}
 
 void JsCatcher::throwIfCaught() {
 	if( HasCaught() ) {
+		if( h8->isInterrupted() ) {
+			puts("INTERRUPTED!");
+			throw JsError(h8, "interrupted");
+		}
 		if( !CanContinue() && HasTerminated() ) {
+//		if( HasTerminated() ) {
 			throw JsTimeoutError(h8);
 		}
 		throw JsError(h8, Message(), Exception());

data/ext/h8/h8.cpp

@@ -4,6 +4,7 @@
 #include <chrono>
 
 #include "h8.h"
+#include <ruby/thread.h>
 #include "ruby_gate.h"
 
 void h8::JsError::raise() {
@@ -61,6 +62,43 @@ void h8::H8::ruby_mark_gc() const {
 		((AllocatedResource*) x)->rb_mark_gc();
 }
 
+struct CallerParams {
+	h8::H8* h8;
+	Handle<Script>& script;
+	Local<Value>& result;
+};
+
+static void* script_caller(void* param) {
+	CallerParams *cp = (CallerParams*) param;
+	cp->h8->setGvlReleased(true);
+	cp->result = cp->script->Run();
+	return NULL;
+}
+
+static void unblock_script(void* param) {
+	h8::H8* h8 = (h8::H8*) param;
+	if( rb_thread_interrupted(rb_thread_current()) ) {
+		printf("UNBLOCK!!!! CALLED!!! Why? %p\n", param);
+		h8->setInterrupted();
+		h8->getIsolate()->TerminateExecution();
+	}
+	else {
+		puts("UBF not interrupted. why?");
+	}
+}
+
+void h8::H8::invoke(v8::Handle<v8::Script> script, Local<Value>& result) {
+#if 1
+	CallerParams cp = { this, script, result };
+	rb_interrupted = false;
+	rb_thread_call_without_gvl(script_caller, &cp, NULL, NULL);
+	setGvlReleased(false);
+#else
+	gvl_released = false;
+	result = script->Run();
+#endif
+}
+
 v8::Handle<v8::Value> h8::H8::eval(const char* script_utf, unsigned max_ms) {
 	v8::EscapableHandleScope escape(isolate);
 	Local<Value> result;
@@ -87,11 +125,11 @@ v8::Handle<v8::Value> h8::H8::eval(const char* script_utf, unsigned max_ms) {
 							isolate->TerminateExecution();
 						}
 					});
-			script->Run();
+			invoke(script, result);
 			cv.notify_all();
 			thr.join();
 		} else {
-			result = script->Run();
+			invoke(script, result);
 		}
 		try_catch.throwIfCaught();
 	}

data/ext/h8/h8.h

@@ -197,10 +197,21 @@ public:
 
 	void ruby_mark_gc() const;
 
+	bool isGvlReleased() const noexcept { return gvl_released; }
+
+	void setGvlReleased(bool state) noexcept { gvl_released = state; }
+
+	void setInterrupted() {
+		rb_interrupted = true;
+	}
+
+	bool isInterrupted() const { return rb_interrupted; }
+
 	virtual ~H8();
 
 private:
 	friend VALUE h8::context_alloc(VALUE klass);
+	void invoke(v8::Handle<v8::Script> script, Local<Value>& result);
 
 	Isolate *isolate;
 	VALUE self;
@@ -208,6 +219,8 @@ private:
 	Persistent<Context> persistent_context;
 
 	bool is_error = false;
+	bool gvl_released = false;
+	bool rb_interrupted = false;
 
 	chain resources;
 };

data/ext/h8/js_gate.cpp

@@ -1,18 +1,45 @@
 #include "h8.h"
 #include "JsCatcher.h"
+#include <ruby/thread.h>
 
 using namespace h8;
 
+struct ApplyParams {
+	Local<Object> object;
+	Local<Value> &result;
+	Local<Value>& self;
+	Local<Value> *js_args;
+	int count;
+	H8* h8;
+};
+
+static inline void* call_without_gvl(void* param) {
+	ApplyParams *ap = (ApplyParams*)param;
+	ap->h8->setGvlReleased(true);
+	ap->result = ap->object->CallAsFunction(ap->self, ap->count, ap->js_args);
+	return NULL;
+}
+
+#define MAX_ARGS (128)
+
 VALUE JsGate::apply(Local<Value> self, VALUE args) const {
 	H8::Scope scope(h8);
-	long count = RARRAY_LEN(args);
-	Local<Value> *js_args = new Local<Value> [count];
+	int count = RARRAY_LEN(args);
+	if( count >= MAX_ARGS )
+		throw JsError(h8, "Too many arguments for the callable");
+//	Local<Value> *js_args = new Local<Value> [count];
+	Local<Value> js_args[MAX_ARGS];
 	for (int i = 0; i < count; i++) {
 		js_args[i] = h8->to_js(rb_ary_entry(args, i));
 	}
 	h8::JsCatcher catcher(h8);
-	Local<Value> result = object()->CallAsFunction(self, count, js_args);
+	Local<Value> result;
+
+	ApplyParams ap = { object(), result, self, js_args, count, h8 };
+	rb_thread_call_without_gvl(call_without_gvl, &ap, NULL, NULL );
+	h8->setGvlReleased(false);
+
 	catcher.throwIfCaught();
-	delete [] js_args;
+//	delete [] js_args;
 	return h8->to_ruby(result);
 }

data/ext/h8/ruby_gate.cpp

@@ -1,9 +1,31 @@
+#include <functional>
 #include "h8.h"
 #include "ruby_gate.h"
 #include <ruby.h>
+#include <ruby/thread.h>
 
 using namespace h8;
 
+static void* unblock_caller(void *param) {
+	const std::function<void(void)>* pblock =
+			(const std::function<void(void)>*) param;
+	(*pblock)();
+	return NULL;
+}
+
+static void with_gvl(RubyGate *gate,
+		const std::function<void(void)> &block) {
+//	v8::Unlocker unlock(gate->isolate());
+	H8 *h8 = gate->getH8();
+	if (h8->isGvlReleased()) {
+		h8->setGvlReleased(false);
+		rb_thread_call_with_gvl(unblock_caller, (void*) &block);
+		h8->setGvlReleased(true);
+	}
+	else
+		block();
+}
+
 h8::RubyGate::RubyGate(H8* _context, VALUE object) :
 		context(_context), ruby_object(object), next(0), prev(0) {
 	v8::HandleScope scope(context->getIsolate());
@@ -15,7 +37,7 @@ h8::RubyGate::RubyGate(H8* _context, VALUE object) :
 	templ->SetCallAsFunctionHandler(&ObjectCallback);
 
 	templ->SetNamedPropertyHandler(RubyGate::mapGet, RubyGate::mapSet);
-	templ->SetIndexedPropertyHandler(RubyGate::indexGet,RubyGate::indexSet);
+	templ->SetIndexedPropertyHandler(RubyGate::indexGet, RubyGate::indexSet);
 
 	v8::Handle<v8::Object> handle = templ->NewInstance();
 	handle->SetAlignedPointerInInternalField(1, RUBYGATE_ID);
@@ -29,8 +51,7 @@ void h8::RubyGate::mapGet(Local<String> name,
 	rg->getProperty(name, info);
 }
 
-void h8::RubyGate::mapSet(Local<String> name,
-		Local<Value> value,
+void h8::RubyGate::mapSet(Local<String> name, Local<Value> value,
 		const PropertyCallbackInfo<Value> &info) {
 	RubyGate *rg = RubyGate::unwrap(info.This());
 	assert(rg != 0);
@@ -44,8 +65,7 @@ void h8::RubyGate::indexGet(uint32_t index,
 	rg->getIndex(index, info);
 }
 
-void h8::RubyGate::indexSet(uint32_t index,
-		Local<Value> value,
+void h8::RubyGate::indexSet(uint32_t index, Local<Value> value,
 		const PropertyCallbackInfo<Value> &info) {
 	RubyGate *rg = RubyGate::unwrap(info.This());
 	assert(rg != 0);
@@ -99,59 +119,66 @@ void h8::RubyGate::rescued_call(VALUE rb_args, VALUE (*call)(VALUE),
 
 void h8::RubyGate::doObjectCallback(
 		const v8::FunctionCallbackInfo<v8::Value>& args) {
-
-	VALUE rb_args = ruby_args(args, 1);
-	rb_ary_push(rb_args, ruby_object);
-	return rescued_call(rb_args, call, [&] (VALUE res) {
-		args.GetReturnValue().Set(context->to_js(res));
+	with_gvl(this, [&] {
+		VALUE rb_args = ruby_args(args, 1);
+		rb_ary_push(rb_args, ruby_object);
+		rescued_call(rb_args, call, [&] (VALUE res) {
+					args.GetReturnValue().Set(context->to_js(res));
+				});
 	});
 }
 
 void h8::RubyGate::getProperty(Local<String> name,
 		const PropertyCallbackInfo<Value> &info) {
-	VALUE rb_args = rb_ary_new2(2);
-	rb_ary_push(rb_args, ruby_object);
-	rb_ary_push(rb_args, context->to_ruby(name));
-	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
-		info.GetReturnValue().Set(context->to_js(res));
-		});
+	with_gvl(this, [&] {
+		VALUE rb_args = rb_ary_new2(2);
+		rb_ary_push(rb_args, ruby_object);
+		rb_ary_push(rb_args, context->to_ruby(name));
+		rescued_call(rb_args, secure_call, [&] (VALUE res) {
+					info.GetReturnValue().Set(context->to_js(res));
+				});
+	});
 }
 
-void h8::RubyGate::setProperty(Local<String> name,
-		Local<Value> value,
+void h8::RubyGate::setProperty(Local<String> name, Local<Value> value,
 		const PropertyCallbackInfo<Value> &info) {
-	VALUE rb_args = rb_ary_new2(3);
-	rb_ary_push(rb_args, context->to_ruby(value));
-	rb_ary_push(rb_args, ruby_object);
-	VALUE method = context->to_ruby(name);
-	method = rb_str_cat2(method, "=");
-	rb_ary_push(rb_args, method);
-	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
-		info.GetReturnValue().Set(context->to_js(res));
-		});
+	with_gvl(this, [&] {
+		VALUE rb_args = rb_ary_new2(3);
+		rb_ary_push(rb_args, context->to_ruby(value));
+		rb_ary_push(rb_args, ruby_object);
+		VALUE method = context->to_ruby(name);
+		method = rb_str_cat2(method, "=");
+		rb_ary_push(rb_args, method);
+		rescued_call(rb_args, secure_call, [&] (VALUE res) {
+					info.GetReturnValue().Set(context->to_js(res));
+				});
+	});
 }
 
 void h8::RubyGate::getIndex(uint32_t index,
 		const PropertyCallbackInfo<Value> &info) {
-	VALUE rb_args = rb_ary_new2(3);
-	rb_ary_push(rb_args, INT2FIX(index));
-	rb_ary_push(rb_args, ruby_object);
-	rb_ary_push(rb_args, rb_str_new2("[]"));
-	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
-		info.GetReturnValue().Set(context->to_js(res));
-		});
+	with_gvl(this, [&] {
+		VALUE rb_args = rb_ary_new2(3);
+		rb_ary_push(rb_args, INT2FIX(index));
+		rb_ary_push(rb_args, ruby_object);
+		rb_ary_push(rb_args, rb_str_new2("[]"));
+		rescued_call(rb_args, secure_call, [&] (VALUE res) {
+					info.GetReturnValue().Set(context->to_js(res));
+				});
+	});
 }
 
-void h8::RubyGate::setIndex(uint32_t index,
-		Local<Value> value,
+void h8::RubyGate::setIndex(uint32_t index, Local<Value> value,
 		const PropertyCallbackInfo<Value> &info) {
-	VALUE rb_args = rb_ary_new2(4);
-	rb_ary_push(rb_args, INT2FIX(index));
-	rb_ary_push(rb_args, context->to_ruby(value));
-	rb_ary_push(rb_args, ruby_object);
-	rb_ary_push(rb_args, rb_str_new2("[]="));
-	return rescued_call(rb_args, secure_call, [&] (VALUE res) {
-		info.GetReturnValue().Set(context->to_js(res));
-		});
+	with_gvl(this, [&] {
+		VALUE rb_args = rb_ary_new2(4);
+		rb_ary_push(rb_args, INT2FIX(index));
+		rb_ary_push(rb_args, context->to_ruby(value));
+		rb_ary_push(rb_args, ruby_object);
+		rb_ary_push(rb_args, rb_str_new2("[]="));
+		rescued_call(rb_args, secure_call, [&] (VALUE res) {
+					info.GetReturnValue().Set(context->to_js(res));
+				});
+	});
 }
 

data/ext/h8/ruby_gate.h

@@ -54,27 +54,35 @@ public:
 	virtual ~RubyGate() {
 	}
 
+	Isolate* isolate() const noexcept {
+		return context->getIsolate();
+	}
+
+	H8* getH8() {
+		return context;
+	}
+
 protected:
 	/**
 	 * Perform rb_rescue call to 'call' callback, and invoke block with value returned by callback
 	 * unless a ruby exception is caught, in which a correct JsError is thrown.
 	 */
-	void rescued_call(VALUE rb_args, VALUE (*call)(VALUE),const std::function<void(VALUE)> &block);
+	void rescued_call(VALUE rb_args, VALUE (*call)(VALUE),
+			const std::function<void(VALUE)> &block);
 
 	/**
 	 * Convert some v8 parameters-like object to ruby arguments array, allocating
 	 * extra slots in array if need
 	 */
-	template <class T>
+	template<class T>
 	VALUE ruby_args(const T& args, unsigned extras = 0) {
 		unsigned n = args.Length();
-		VALUE rb_args = rb_ary_new2(n+extras);
+		VALUE rb_args = rb_ary_new2(n + extras);
 		for (unsigned i = 0; i < n; i++)
 			rb_ary_push(rb_args, context->to_ruby(args[i]));
 		return rb_args;
 	}
 
-
 	/**
 	 * Ruby callable callback for rb_rescue and like. Args [0..-2] are call arguments,
 	 * last arg[-1] should be a callable to perform call with (for performance
@@ -90,28 +98,34 @@ protected:
 	/**
 	 * callback for rb_rescue. Sets last_ruby_error.
 	 */
-	static VALUE rescue_callback(VALUE me,VALUE exception_object);
+	static VALUE rescue_callback(VALUE me, VALUE exception_object);
 
-	void getProperty(Local<String> name, const PropertyCallbackInfo<Value> &info);
-	void setProperty(Local<String> name, Local<Value> value,const PropertyCallbackInfo<Value> &info);
+	void getProperty(Local<String> name,
+			const PropertyCallbackInfo<Value> &info);
+	void setProperty(Local<String> name, Local<Value> value,
+			const PropertyCallbackInfo<Value> &info);
 
 	void getIndex(uint32_t index, const PropertyCallbackInfo<Value> &info);
-	void setIndex(uint32_t index, Local<Value> value,const PropertyCallbackInfo<Value> &info);
+	void setIndex(uint32_t index, Local<Value> value,
+			const PropertyCallbackInfo<Value> &info);
 private:
 
 	void doObjectCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
 
 	static void ObjectCallback(const v8::FunctionCallbackInfo<v8::Value>& args);
 
-	static void mapGet(Local<String> name, const PropertyCallbackInfo<Value> &info);
-	static void mapSet(Local<String> name, Local<Value> value,const PropertyCallbackInfo<Value> &info);
+	static void mapGet(Local<String> name,
+			const PropertyCallbackInfo<Value> &info);
+	static void mapSet(Local<String> name, Local<Value> value,
+			const PropertyCallbackInfo<Value> &info);
 
-	static void indexGet(uint32_t index, const PropertyCallbackInfo<Value> &info);
-	static void indexSet(uint32_t index, Local<Value> value, const PropertyCallbackInfo<Value> &info);
+	static void indexGet(uint32_t index,
+			const PropertyCallbackInfo<Value> &info);
+	static void indexSet(uint32_t index, Local<Value> value,
+			const PropertyCallbackInfo<Value> &info);
 
 	void throw_js();
 
-
 	friend class H8;
 
 	H8 *context;

data/lib/h8/coffee.rb

@@ -25,7 +25,7 @@ module H8
     # Compile coffeescript and return javascript. Keyword parameters are
     # passed to H8::Context#eval - like time limits and so on.
     #
-    # This method IS THREAD SAFE, it shares single
+    # This method IS THREAD SAFE, though it shares single
     # compiler instance across all threads with a mutex.
     def self.compile src, ** kwargs
       @@mutex.synchronize {

data/lib/h8/version.rb

@@ -1,3 +1,3 @@
 module H8
-  VERSION = "0.1.4"
+  VERSION = "0.2.1"
 end

data/spec/context_spec.rb

@@ -4,16 +4,16 @@ require 'h8'
 describe 'context' do
 
   it 'should create' do
-    cxt = H8::Context.new
+    cxt       = H8::Context.new
     cxt[:one] = 1
     cxt.eval("");
     # cxt.eval("'Res: ' + (2+5);")
   end
 
   it 'should gate simple values to JS context' do
-    cxt = H8::Context.new foo: 'hello', bar: 'world'
+    cxt        = H8::Context.new foo: 'hello', bar: 'world'
     cxt[:sign] = '!'
-    res = cxt.eval "foo+' '+bar+sign;"
+    res        = cxt.eval "foo+' '+bar+sign;"
     res.should == 'hello world!'
     cxt.set_all one: 101, real: 1.21
     cxt.eval("one + one;").should == 202
@@ -21,25 +21,25 @@ describe 'context' do
   end
 
   it 'should gate H8::Values back to JS context' do
-    cxt = H8::Context.new
-    obj = cxt.eval "('che bel');"
+    cxt         = H8::Context.new
+    obj         = cxt.eval "('che bel');"
     cxt[:first] = obj
-    res = cxt.eval "first + ' giorno';"
+    res         = cxt.eval "first + ' giorno';"
     res.should == 'che bel giorno'
   end
 
   it 'should not gate H8::Values between contexts' do
-    cxt = H8::Context.new
-    obj = cxt.eval "({res: 'che bel'});"
+    cxt         = H8::Context.new
+    obj         = cxt.eval "({res: 'che bel'});"
     # This should be ok
     cxt[:first] = obj
-    res = cxt.eval "first.res + ' giorno';"
+    res         = cxt.eval "first.res + ' giorno';"
     res.should == 'che bel giorno'
     # And that should fail
     cxt1 = H8::Context.new
-    expect( -> {
+    expect(-> {
       cxt1[:first] = obj
-      res = cxt1.eval "first.res + ' giorno';"
+      res          = cxt1.eval "first.res + ' giorno';"
     }).to raise_error(H8::Error)
   end
 
@@ -54,7 +54,7 @@ describe 'context' do
   end
 
   it 'should limit script execution time' do
-    cxt = H8::Context.new
+    cxt    = H8::Context.new
     # cxt[:print] = -> (*args) { puts args.join(' ')}
     script = <<-End
       var start = new Date();
@@ -67,34 +67,61 @@ describe 'context' do
     End
     # end
     t = Time.now
-    expect( -> {
+    expect(-> {
       c2 = cxt.eval script, max_time: 0.2
     }).to raise_error(H8::TimeoutError)
     (Time.now - t).should < 0.25
     cxt.eval('(last-start)/1000').should < 250
   end
 
+  it 'should have generators' do
+    script = <<-End
+      function* f(base) {
+        var count = base;
+        var end = base +3;
+        print("F is calleed", count);
+        while(count < end) {
+          var r = yield count++;
+          print("yield returned", r);
+        }
+      }
+      var g = f(100);
+      print(g.next().value);
+      print(g.next(1).value);
+    End
+    c         = H8::Context.new
+    c[:print] = -> (*args) { args.join(' ') }
+    c.eval script
+  end
+
   it 'should work in many threads' do
-    sum = 0
-    valid = 0
-    n   = 10
-    contexts = []
-    tt  = n.times.map { |n|
-      valid += (n+1)*100 + 10
-      Thread.start {
-        cxt         = H8::Context.new
-        contexts << cxt
+    # pending
+    sum      = 0
+    mutex = Mutex.new
+    valid    = 0
+    n        = 10
+    tt = []
+    n.times { |n|
+      cxt = nil
+      t = Thread.start {
+        cxt = H8::Context.new
         cxt[:array] = 100024.times.map { |x| x*(n+1) }
-        cxt[:n] = n+1
-        sum         += cxt.eval('result = array[100] + 10')
+        cxt[:n]     = n+1
+        mutex.synchronize {
+          valid += (n+1)*100 + 10
+          sum         += cxt.eval('result = array[100] + 10')
+        }
+        tt << OpenStruct.new({ thread: t, number: n, context: cxt })
       }
     }
-    tt.each &:join
-    sum.should == valid
+    tt.each{ |x| x.thread.join }
+    mutex.synchronize {
+      sum.should == valid
+    }
     GC.start
     # Cross-thread access
-    contexts.each { |cxt|
-      s, n = cxt.eval('data = [result,n]')
+    tt.each { |x|
+      s, n = x.context.eval('data = [result,n]')
       s.should == 100*n + 10
     }
   end

data/spec/ruby_gate_spec.rb

@@ -5,7 +5,9 @@ describe 'ruby gate' do
 
   it 'should gate callables' do
     cxt      = H8::Context.new
+    count = 0
     cxt[:fn] = -> (a, b) {
+      count += 1
       a + b
     }
 
@@ -14,6 +16,7 @@ describe 'ruby gate' do
     cxt = nil
     res = nil
     GC.start
+    count.should == 1
   end
 
   # it 'should gate callables in therubyrace mode' do
@@ -47,7 +50,7 @@ describe 'ruby gate' do
     res.to_i.should == -11
   end
 
-  it 'should gate callables with varargs' do
+  it 'va: should gate callables with varargs' do
     cxt      = H8::Context.new
     cxt[:fn] = -> (*args) {
       args.reduce(0) { |all, x| all+x }

data/spec/threading_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'h8'
+
+describe 'threading' do
+  before do
+    @counter_script = <<-End
+            var count = 0;
+            var endTime = end*1000 + 150;
+            while( new Date().getTime() < endTime ) count++;
+            (count);
+    End
+    @context         = H8::Context.new
+    @context[:print] = -> (*args) {
+      puts "D: #{args.join(',')}"
+    }
+    Thread.pass
+    @end_time      = Time.now.to_i + 1
+    @context[:end] = @end_time
+  end
+
+  it 'without tout: should run JS/ruby threads in parallel' do
+    cnt2 = 0
+    Thread.start {
+      cnt2 += 1 while Time.now.to_i < @end_time
+    }
+    res  = @context.eval @counter_script, timeout: 5000
+    cnt  = cnt2
+    fail "JS thread does not run in parallel" if res < 1
+    fail "JS thread does not run in parallel" if cnt < 1
+    (res / cnt).should < 16
+  end
+
+
+  it 'should run JS callables in threads in parallel' do
+    fn = @context.eval "res = function (end) { #{@counter_script} return count; }"
+    cnt2 = 0
+    Thread.start {
+      cnt2 += 1 while Time.now.to_i < @end_time
+    }
+    res  = fn.call(@end_time)
+    cnt  = cnt2
+    fail "JS thread does not run in parallel" if res < 1
+    fail "JS thread does not run in parallel" if cnt < 1
+    (res / cnt).should < 16
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: h8
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.1
 platform: ruby
 authors:
 - sergeych
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-30 00:00:00.000000000 Z
+date: 2015-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -113,6 +113,7 @@ files:
 - spec/js_gate_spec.rb
 - spec/ruby_gate_spec.rb
 - spec/spec_helper.rb
+- spec/threading_spec.rb
 homepage: https://github.com/sergeych/hybrid8
 licenses:
 - MIT
@@ -134,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Minimalistic and fast Ruby <--> V8 integration
@@ -144,3 +145,4 @@ test_files:
 - spec/js_gate_spec.rb
 - spec/ruby_gate_spec.rb
 - spec/spec_helper.rb
+- spec/threading_spec.rb