therubyracer 0.9.0 → 0.9.1beta1

data/.gitignore

@@ -8,9 +8,6 @@ v8.so
 *.rbc
 *.log
 *~
-docs/cpp/html/*
-
-ext/v8/upstream/build
-
 pkg/
-tmp/
+tmp/
+.yardoc/

data/.yardopts

@@ -0,0 +1 @@
+ lib/**/*.rb ext/**/*.cpp

data/ext/v8/v8_handle.cpp

@@ -4,28 +4,72 @@
 
 using namespace v8;
 
+/**
+* Creates a new Persistent storage cell for `handle`
+* so that we can reference it from Ruby.
+*/
 v8_handle::v8_handle(Handle<void> handle) : handle(Persistent<void>::New(handle)) {
   this->weakref_callback = Qnil;
   this->weakref_callback_parameters = Qnil;
   this->dead = false;
 }
 
-v8_handle::~v8_handle() {
-  handle.Dispose();
-  handle.Clear();
-  dead = true;
-}
+v8_handle::~v8_handle() {}
 
 namespace {
+  /**
+  * Holds dead references, that are no longer being held in Ruby, so that they can be garbage collected
+  * inside of V8
+  */
+  VALUE handle_queue;
+
+  /**
+  * Invoked by the Ruby garbage collector whenever it determines that this handle is
+  * still reachable. We in turn, mark our weak callback parameters, so that it knows
+  * they are reachable too.
+  */
   void v8_handle_mark(v8_handle* handle) {
     rb_gc_mark(handle->weakref_callback);
     rb_gc_mark(handle->weakref_callback_parameters);
   }
 
+  /**
+  * Deallocates this handle. This function is invoked on Zombie handles after they have
+  * been released from V8 and finally
+  */
   void v8_handle_free(v8_handle* handle) {
     delete handle;
   }
 
+  /**
+  * Whenver a V8::C::Handle becomes garbage collected, we do not free it immediately.
+  * instead, we put them into a "zombie" queue, where its corresponding V8 storage cell
+  * can be released safely while the V8 engine is running. A zombie Ruby object is 
+  * created to wrap it so that it can be stored in the queue.
+  */
+  void v8_handle_enqueue(v8_handle* handle) {
+    handle->dead = true;
+    VALUE zombie = Data_Wrap_Struct(rr_v8_handle_class(), 0, v8_handle_free, handle);
+    rb_ary_unshift(handle_queue, zombie);
+  }
+
+  /**
+  * Drains the dead handle queue, and releases them from V8
+  *
+  * This implements the V8 `GCPrologueCallback` and is registered to run before
+  * each invocation of the V8 garbage collector. It empties the queue of dead handles
+  * and disposes of them. It is important to do this operations inside V8 so that
+  * Ruby garbage collection is never locked, and never touches V8.
+  */
+  void v8_handle_dequeue(GCType type, GCCallbackFlags flags) {
+    for (VALUE handle = rb_ary_pop(handle_queue); RTEST(handle); handle = rb_ary_pop(handle_queue)) {
+      v8_handle* dead = NULL;
+      Data_Get_Struct(handle, struct v8_handle, dead);
+      dead->handle.Dispose();
+      dead->handle.Clear();
+    }
+  }
+
   VALUE New(VALUE self, VALUE handle) {
     if (RTEST(handle)) {
       Persistent<void> that = rr_v8_handle<void>(handle);
@@ -101,11 +145,15 @@ void rr_init_handle() {
   rr_define_method(HandleClass, "ClearWeak", ClearWeak, 0);
   rr_define_method(HandleClass, "IsNearDeath", IsNearDeath, 0);
   rr_define_method(HandleClass, "IsWeak", IsWeak, 0);
+
+  handle_queue = rb_ary_new();
+  rb_gc_register_address(&handle_queue);
+  V8::AddGCPrologueCallback(v8_handle_dequeue);
 }
 
 VALUE rr_v8_handle_new(VALUE klass, v8::Handle<void> handle) {
   v8_handle* new_handle = new v8_handle(handle);
-  return Data_Wrap_Struct(klass, v8_handle_mark, v8_handle_free, new_handle);
+  return Data_Wrap_Struct(klass, v8_handle_mark, v8_handle_enqueue, new_handle);
 }
 
 VALUE rr_v8_handle_class() {

data/ext/v8/v8_handle.h

@@ -4,6 +4,10 @@
 #include <v8.h>
 #include "ruby.h"
 
+/**
+* Holds a reference to a V8 heap object. This serves as the base
+* class for all of the low-level proxies that reference into V8
+*/
 struct v8_handle  {
   v8_handle(v8::Handle<void> object);
   virtual ~v8_handle();

data/ext/v8/v8_locker.cpp

@@ -4,38 +4,136 @@
 using namespace v8;
 
 namespace {
-  VALUE Lock(VALUE self) {
-    Locker locker;
-    return rb_yield(Qnil);
+  namespace Lock {
+
+    /**
+    * Document-method: V8::C::Locker#new
+    *
+    * Allocates and returns a new `v8::Locker` object. The thread that instantiated
+    * this object will hold the V8 interpreter lock until it is released with a
+    * corresponding call to {#delete}.
+    *
+    * It critical that you call {#delete} to deallocate it, preferably within the same method.
+    * If you don't, two bad things will happen:
+    *
+    * 1. You'll leak the underlying C++ object
+    * 1. Worse, you'll leave the V8 vm locked to this thread forever
+    *
+    * It's dangerous! Be sure to `ensure`.
+    *
+    * for detailed semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    *
+    * @return [V8::C::Locker] the new locker
+    */
+
+    VALUE New(VALUE LockerClass) {
+      Locker* locker = new Locker();
+      return Data_Wrap_Struct(LockerClass, 0, 0, (void*)locker);
+    }
+
+    /**
+    * Document-method: V8::C::Locker#delete
+    *
+    * Pop this lock off the stack for this thread. For a full run down of V8 locking
+    * semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    * @return nil
+    */
+    VALUE Delete(VALUE self) {
+      Locker* locker = 0;
+      Data_Get_Struct(self, class Locker, locker);
+      delete locker;
+    }
   }
-  VALUE Unlock(VALUE self) {
-    Unlocker unlocker;
-    return rb_yield(Qnil);
+
+  namespace Unlock {
+    /**
+    * Document-method: V8::C::Unlocker#new
+    *
+    * Allocates and returns a new `v8::UnLocker` object, temporarily releasing any locks that
+    * this thread is holding. It will reaquire all of the locksto {#delete}.
+    *
+    * This is a great thing to do when you want to call out to some code that might do some
+    * waiting, sleeping, and you want to politely let other threads use this VM.
+    *
+    * It critical that you call {#delete} to deallocate it, preferably within the same method.
+    * If you don't, two bad things will happen:
+    *
+    * 1. You'll leak the underlying C++ object
+    * 1. You won't restore the locks to your current thread, and will mess things up horribly
+    *
+    * It's dangerous! Be sure to `ensure`.
+    *
+    * For details on V8 locking semantics, see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    * @return [V8::C::Unocker] the new locker
+    */
+    VALUE New(VALUE UnlockerClass) {
+      Unlocker* unlocker = new Unlocker();
+      return Data_Wrap_Struct(UnlockerClass, 0, 0, (void*)unlocker);
+    }
+
+    /**
+    * Document-method: V8::C::Unlocker#delete
+    *
+    * Restore any locks to the stack that were temporarily removed by this `Unlocker`.
+    * For a full run down, see semantics see the locking {API http://izs.me/v8-docs/classv8_1_1Unlocker.html}
+    * @return nil
+    */
+    VALUE Delete(VALUE self) {
+      Unlocker* unlocker;
+      Data_Get_Struct(self, class Unlocker, unlocker);
+      delete unlocker;
+    }
   }
-  VALUE StartPreemption(VALUE self, VALUE thread_id) {
-    Locker::StartPreemption(NUM2INT(rb_to_int(thread_id)));
+
+  /**
+  * Document-method: V8::C::Locker#StartPreemption
+  * Start preemption.
+  * When preemption is started, a timer is fired every n milli seconds that will switch between
+  * multiple threads that are in contention for the V8 lock.
+  *
+  * @param [Integer] every_n_ms
+  * @return nil
+  */
+  VALUE StartPreemption(VALUE self, VALUE every_n_ms) {
+    Locker::StartPreemption(NUM2INT(rb_to_int(every_n_ms)));
     return Qnil;
   }
+
+  /**
+  * Document-method: V8::C::Locker#StartPreemption
+  * Stop preemption
+  */
   VALUE StopPreemption(VALUE self) {
     Locker::StopPreemption();
     return Qnil;
   }
+
+  /**
+  * Document-method: V8::C::Locker#IsLocked
+  * Returns whether or not the locker is locked by the current thread.
+  */
   VALUE IsLocked(VALUE self) {
     return rr_v82rb(Locker::IsLocked());
   }
+
+  /**
+  * Document-method: V8::C::Locker#IsActive
+  * Returns whether v8::Locker is being used by this V8 instance.
+  */
   VALUE IsActive(VALUE self) {
     return rr_v82rb(Locker::IsActive());
   }
 }
 
 void rr_init_v8_locker() {
-  VALUE V8 = rb_define_module("V8");
-  VALUE V8_C = rb_define_module_under(V8, "C");
-  VALUE LockerModule = rb_define_module_under(V8_C, "Locker");
-  rr_define_singleton_method(V8_C, "Locker", Lock, 0);
-  rr_define_singleton_method(V8_C, "Unlocker", Unlock, 0);
-  rr_define_singleton_method(LockerModule, "StartPreemption", StartPreemption, 1);
-  rr_define_singleton_method(LockerModule, "StopPreemption", StopPreemption, 0);
-  rr_define_singleton_method(LockerModule, "IsLocked", IsLocked, 0);
-  rr_define_singleton_method(LockerModule, "IsActive", IsActive, 0);
+  VALUE LockerClass = rr_define_class("Locker");
+  VALUE UnlockerClass = rr_define_class("Unlocker");
+  rr_define_singleton_method(LockerClass, "new", Lock::New, 0);
+  rr_define_method(LockerClass, "delete", Lock::Delete, 0);
+  rr_define_singleton_method(UnlockerClass, "new", Unlock::New, 0);
+  rr_define_method(UnlockerClass, "delete", Unlock::Delete, 0);
+  rr_define_singleton_method(LockerClass, "StartPreemption", StartPreemption, 1);
+  rr_define_singleton_method(LockerClass, "StopPreemption", StopPreemption, 0);
+  rr_define_singleton_method(LockerClass, "IsLocked", IsLocked, 0);
+  rr_define_singleton_method(LockerClass, "IsActive", IsActive, 0);
 }

data/lib/v8.rb

@@ -4,6 +4,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 module V8
   require 'v8/version'
   require 'v8/v8' #native glue
+  require 'v8/c/locker'
   require 'v8/portal'
   require 'v8/portal/caller'
   require 'v8/portal/proxies'

data/lib/v8/c/locker.rb

@@ -0,0 +1,18 @@
+module V8
+  module C
+    # Shim to support the old style locking syntax. We don't currently
+    # deprecate this because it might make a comeback at some point.
+    #
+    # to synchronize access to V8, and to associate V8 with this thread:
+    #
+    #     Locker() do
+    #       #... interact with v8
+    #     end
+    def self.Locker
+      lock = Locker.new
+      yield
+    ensure
+      lock.delete
+    end
+  end
+end

data/lib/v8/portal/proxies.rb

@@ -43,7 +43,6 @@ module V8
         @js_proxies_js2rb[proxy] = target
         @js_proxies_rb2js[target] = proxy
         proxy.MakeWeak(nil, @clear_js_proxy)
-        V8::C::V8::AdjustAmountOfExternalAllocatedMemory(16 * 1024)
       end
 
       # Lookup the JavaScript proxy for a natively Ruby object
@@ -66,7 +65,6 @@ module V8
         @rb_proxies_rb2js[proxy.object_id] = target
         @rb_proxies_js2rb[target] = proxy.object_id
         ObjectSpace.define_finalizer(proxy, @clear_rb_proxy)
-        V8::C::V8::AdjustAmountOfExternalAllocatedMemory(8 * 1024)
       end
 
       # Looks up the Ruby proxy for an object that is natively JavaScript
@@ -115,7 +113,6 @@ module V8
           rb = @js2rb[proxy]
           @js2rb.delete(proxy)
           @rb2js.delete(rb)
-          V8::C::V8::AdjustAmountOfExternalAllocatedMemory(-16 * 1024)
         end
       end
 
@@ -146,7 +143,6 @@ module V8
           if js = @rb2js[proxy_id]
             @rb2js.delete(proxy_id)
             @js2rb.delete(js)
-            V8::C::V8::AdjustAmountOfExternalAllocatedMemory(-8 * 1024)
           end
         end
       end

data/lib/v8/version.rb

@@ -1,3 +1,3 @@
 module V8
-  VERSION = "0.9.0"
+  VERSION = "0.9.1beta1"
 end

data/specthread/spec_helper.rb

@@ -0,0 +1,2 @@
+require Pathname(__FILE__).dirname.join('../spec/spec_helper')
+

data/specthread/threading_spec.rb

@@ -0,0 +1,13 @@
+
+require 'spec_helper'
+
+describe "using v8 from multiple threads" do
+  
+  it "is possible" do
+    Thread.new do
+      require 'v8'
+      V8::Context.new
+    end.join
+    V8::Context.new
+  end
+end

metadata

@@ -1,8 +1,8 @@
 --- !ruby/object:Gem::Specification 
 name: therubyracer
 version: !ruby/object:Gem::Version 
-  prerelease: 
-  version: 0.9.0
+  prerelease: 5
+  version: 0.9.1beta1
 platform: ruby
 authors: 
 - Charles Lowell
@@ -11,7 +11,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-10 00:00:00 -05:00
+date: 2011-06-15 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -70,6 +70,7 @@ files:
 - .gitignore
 - .gitmodules
 - .rspec
+- .yardopts
 - Changelog.md
 - Gemfile
 - README.md
@@ -120,6 +121,7 @@ files:
 - lib/v8.rb
 - lib/v8/access.rb
 - lib/v8/array.rb
+- lib/v8/c/locker.rb
 - lib/v8/cli.rb
 - lib/v8/context.rb
 - lib/v8/error.rb
@@ -150,6 +152,8 @@ files:
 - specmem/object_memspec.rb
 - specmem/proxies_memspec.rb
 - specmem/spec_helper.rb
+- specthread/spec_helper.rb
+- specthread/threading_spec.rb
 - therubyracer.gemspec
 - spec/redjs/.gitignore
 - spec/redjs/README.txt
@@ -170,19 +174,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -3759778087038355586
+      hash: -227927920256907833
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: -3759778087038355586
-      segments: 
-      - 0
-      version: "0"
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: therubyracer