concurrent 0.1 → 0.2.1

data/Rakefile

@@ -2,6 +2,8 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/gempackagetask'
 
+GEM_VERSION = "0.2.1"
+
 desc "Remove build products"
 task :clean do
   rm Dir.glob( "lib/**/*.jar" )
@@ -9,9 +11,10 @@ task :clean do
   rm Dir.glob( "ext/**/Makefile" )
   rm Dir.glob( "ext/**/*.{o,#{ Config::CONFIG['DLEXT'] }}" )
   rm Dir.glob( "java/**/*.{class,jar}" )
-  rm Dir.glob( "java/concurrent/FuturesService.java" )
 end
 
+task :clobber => [ :clean ]
+
 def setup_extension( dir, lib_dir, extension )
   ext = File.join( "ext", dir )
   so_name = "#{ extension }.#{ Config::CONFIG['DLEXT'] }"
@@ -47,9 +50,6 @@ end
 
 case RUBY_PLATFORM
 when /java/
-  file 'java/concurrent/FuturesService.java' => [ 'java/concurrent/FuturesService.java.rb' ] do
-    sh File.join( ENV['JRUBY_HOME'], 'bin/jruby' ), 'java/concurrent/FuturesService.java.rb', 'java/concurrent/FuturesService.java'
-  end
   file 'lib/concurrent/futures.jar' => [ 'java/concurrent/FuturesService.java' ] do
     Dir.chdir( 'java' ) do
       sh 'javac', '-classpath', File.join( ENV['JRUBY_HOME'], 'lib/jruby.jar' ), 'concurrent/FuturesService.java'
@@ -67,6 +67,7 @@ task :compile
 
 task :test => [ :compile ]
 Rake::TestTask.new do |task|
+  task.ruby_opts << '-rrubygems'
   task.libs << 'lib'
   task.libs << 'test'
   task.test_files = [ "test/test_all.rb" ]
@@ -75,14 +76,15 @@ end
 
 gemspec = Gem::Specification.new do |gemspec|
   gemspec.name = "concurrent"
-  gemspec.version = "0.1"
+  gemspec.version = GEM_VERSION
   gemspec.author = "MenTaLguY <mental@rydia.net>"
   gemspec.summary = "Omnibus concurrency library for Ruby"
   gemspec.test_file = 'test/test_all.rb'
   gemspec.files = FileList[ 'Rakefile', 'test/*.rb', 'ext/**/*.{c,h,rb}',
-                            'java/**/*.{java,rb}',
+                            'java/**/*.java',
                             "lib/**/*.{rb,jar,#{ Config::CONFIG['DLEXT'] }}" ]
   gemspec.require_paths = [ 'lib' ]
+  gemspec.add_dependency 'scheduler', '>= 0.1'
 
   case RUBY_PLATFORM
   when /java/

data/ext/concurrent/futures/futures.c

@@ -103,6 +103,10 @@ static VALUE wrap_exception(VALUE unused, VALUE ex) {
 static VALUE rb_thunk_method_missing(int argc, VALUE *argv, VALUE self) {
   ID name;
 
+  if ( argc < 1 ) {
+    rb_raise(rb_eArgError, "Too few arguments (0 for 1)");
+  }
+
   name = SYM2ID(argv[0]);
   self = thunk_ground(self);
 
@@ -110,8 +114,12 @@ static VALUE rb_thunk_method_missing(int argc, VALUE *argv, VALUE self) {
     if ( name == inspect_id && argc == 1 ) {
       Thunk *thunk;
       Data_Get_Struct(self, Thunk, thunk);
-      /* FIXME: thunk->source might be nil by the time we get here */
-      return rb_str_plus(rb_str_plus(rb_str_new2("#<Thunk "), rb_funcall(thunk->source, inspect_id, 0)), rb_str_new2(">"));
+      rb_thread_critical = 1;
+      VALUE source = thunk->source;
+      rb_thread_critical = 0;
+      if (RTEST(source)) {
+        return rb_str_plus(rb_str_plus(rb_str_new2("#<Thunk "), rb_funcall(source, inspect_id, 0)), rb_str_new2(">"));
+      }
     } else if ( name == respond_to_p_id && argc == 2 ) {
       if ( ID2SYM(inspect_id) == argv[1] ||
            ID2SYM(respond_to_p_id) == argv[1] )

data/java/concurrent/{FuturesService.java.rb → FuturesService.java}

@@ -1,8 +1,3 @@
-require 'java'
-
-begin
-File.open(ARGV[0], "w") do |stream|
-stream.print <<EOS
 /***** BEGIN LICENSE BLOCK *****
  *  Version: CPL 1.0/GPL 2.0/LGPL 2.1
  * 
@@ -38,6 +33,7 @@ import java.io.IOException;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyException;
+import org.jruby.RubyObject;
 import org.jruby.exceptions.RaiseException;
 import org.jruby.runtime.Block;
 import org.jruby.runtime.CallbackFactory;
@@ -52,15 +48,12 @@ public class FuturesService implements BasicLibraryService {
         return true;
     }
 
-    public static class Thunk implements IRubyObject {
-        private Ruby runtime;
-        private RubyClass klass;
+    public static class Thunk extends RubyObject {
         private IRubyObject source;
         private IRubyObject value;
 
         Thunk(Ruby runtime, RubyClass klass, IRubyObject source) {
-            this.runtime = runtime;
-            this.klass = klass;
+            super(runtime, klass, false);
             this.source = source;
             this.value = null;
         }
@@ -70,10 +63,13 @@ public class FuturesService implements BasicLibraryService {
         }
 
         public static void setup(final Ruby runtime) throws IOException {
-            RubyClass cThunk = runtime.getOrCreateModule("Concurrent").defineModuleUnder("Futures").defineClassUnder("Thunk", null, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+            RubyClass cThunk = RubyClass.createBootstrapMetaClass(runtime, null, null, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR, null);
+            cThunk.setMetaClass(runtime.getClass("Class"));
+            runtime.getOrCreateModule("Concurrent").defineModuleUnder("Futures").setConstant("Thunk", cThunk);
             CallbackFactory cb = runtime.callbackFactory(Thunk.class);
-            cThunk.getMetaClass().defineMethod("new", cb.getSingletonMethod("newInstance", IRubyObject.class));
-            cThunk.defineMethod("value", cb.getSingletonMethod("value", IRubyObject.class));
+            cThunk.getSingletonClass().defineMethod("new", cb.getSingletonMethod("newInstance", IRubyObject.class));
+            cThunk.getSingletonClass().defineMethod("value", cb.getSingletonMethod("value", IRubyObject.class));
+            cThunk.defineMethod("method_missing", cb.getOptMethod("methodMissing"));
         }
 
         public static IRubyObject thunkValue(IRubyObject obj, boolean evaluate) {
@@ -122,42 +118,37 @@ public class FuturesService implements BasicLibraryService {
             return thunkValue(obj, true);
         }
 
-        /*** Generated wrapper methods ***/
-EOS
-
-def demangle( type )
-  case type
-  when /^\[L(.*);$/
-    "#{ demangle( $1 ) }[]"
-  else
-    type
-  end
-end
-
-Modifier = java.lang.reflect.Modifier
-
-c = java.lang.Class.for_name("org.jruby.runtime.builtin.IRubyObject")
-c.get_declared_methods.each do |method|
-    parameter_types = method.get_parameter_types.map { |t| demangle( t.to_s ) }
-    parameter_names = (0...(parameter_types.length)).map { |i| "p#{i}" }
-    return_type = demangle( method.get_return_type.to_s )
-    stream.print <<EOS
-
-        #{ Modifier.to_string( method.get_modifiers & ~Modifier::ABSTRACT ) } #{ return_type } #{ method.get_name }(#{ parameter_types.zip( parameter_names ).map { |t, n| "#{t} #{n}" }.join(", ")}) {
-            #{ return_type == "void" ? "" : "return" } evalThunk(this).#{ method.get_name }(#{ parameter_names.join(", ") }); 
+        public IRubyObject methodMissing(IRubyObject args[], Block block) {
+            if (args.length < 1) {
+                throw getRuntime().newArgumentError("Too few arguments (0 for 1)");
+            }
+
+            String name = args[0].asSymbol();
+            IRubyObject self = thunkValue(this, false);
+
+            if ( self instanceof Thunk ) {
+                if ( name == "inspect" && args.length == 1 ) {
+                    Thunk thunk = (Thunk)self;
+                    IRubyObject source;
+                    synchronized (thunk) {
+                        source = thunk.source;
+                    }
+                    if ( source != null ) {
+                        Ruby runtime = getRuntime();
+                        return runtime.newString("#<Thunk " + source.callMethod(runtime.getCurrentContext(), "inspect").asString().toString() + ">");
+                    }
+                } else if ( name == "respond_to?" && args.length == 2 ) {
+                    if ( args[1].asSymbol() == "inspect" || args[1].asSymbol() == "respond_to?" ) {
+                        return getRuntime().getTrue();
+                    }
+                }
+            }
+
+            IRubyObject[] args2 = new IRubyObject[args.length-1];
+            for ( int i = 0 ; i < args2.length ; i++ ) {
+                args2[i] = args[i+1];
+            }
+            return evalThunk(this).callMethod(getRuntime().getCurrentContext(), name, args2, block);
         }
-EOS
-end
-        
-stream.print <<EOS
     }
 }
-EOS
-end
-rescue Exception => e
-  begin
-    File.unlink(ARGV[0])
-  rescue Errno::ENOENT
-  end
-  raise e
-end

data/lib/concurrent/actors.rb

@@ -1,2 +1,3 @@
 require 'concurrent/actors/mailbox'
 require 'concurrent/actors/actor'
+require 'concurrent/actors/case'

data/lib/concurrent/actors/actor.rb

@@ -64,8 +64,8 @@ class Actor
     end
     private :current_mailbox
 
-    def receive(&prc)
-      current_mailbox.receive(&prc)
+    def receive(timeout=nil, &prc)
+      current_mailbox.receive(timeout, &prc)
     end
   end
 

data/lib/concurrent/actors/case.rb

@@ -0,0 +1,45 @@
+# concurrent/actors/case - pattern-matchable Struct
+#
+# Copyright 2007  MenTaLguY <mental@rydia.net>
+#
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+# * Redistributions of source code must retain the above copyright notice,
+#   thi slist of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice
+#   this list of conditions and the following disclaimer in the documentatio
+#   and/or other materials provided with the distribution.
+# * Neither the name of the Evan Phoenix nor the names of its contributors
+#   may be used to endorse or promote products derived from this software
+#   without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+
+module Concurrent
+module Actors
+
+class Case < Struct
+  def ===(other)
+    return false unless self.class == other.class
+    zip(other) do |a, b|
+      return false unless a === b
+    end
+    true
+  end
+end
+
+end
+end

data/lib/concurrent/actors/mailbox.rb

@@ -36,13 +36,23 @@ rescue LoadError
 end
 
 require 'concurrent/core'
+require 'scheduler'
 
 module Concurrent
 module Actors
 
+Channel = Core::Channel
+
+class TimeoutError < RuntimeError
+end
+
+class Actor
 class Mailbox
+  class Timeout < Exception #:nodoc:
+  end
+
   def initialize
-    @channel = Core::Channel.new
+    @channel = Channel.new
     @skipped = []
   end
 
@@ -53,39 +63,62 @@ class Mailbox
   end
 
   # safe only for a single reader
-  def receive
+  def receive(timeout=nil)
+    filter = Filter.new
     if block_given?
-      filter = Filter.new
       yield filter
+      raise ArgumentError, "Empty filter" if filter.empty?
+    else
+      filter.when(Object) { |m| m }
+    end
+
+    value = nil
+    action = nil
+
+    found_at = nil
+    @skipped.each_with_index do |obj, index|
+      action = filter.action_for obj
+      if action
+        value = obj
+        found_at = index
+        break
+      end
+    end
+    @skipped.delete_at found_at if found_at
 
-      value = nil
-      action = nil
+    unless action
+      timeout_instance = nil
+      timeout_event = nil
 
-      found_at = nil
-      @skipped.each_with_index do |obj, index|
-        action = filter.action_for obj
-        if action
-          value = obj
-          found_at = index
-          break
+      if timeout
+        timeout_instance = Timeout.new
+        if timeout > 0
+          timeout_event = Scheduler.after_delay!(timeout) do
+            @channel << timeout_instance
+          end
+        else
+          @channel << timeout_instance
         end
       end
-      @skipped.delete_at found_at if found_at
 
       until action
         value = @channel.receive
+        if Timeout === value
+          if value == timeout_instance
+            raise TimeoutError, "Receive timed out"
+          else
+            # Timeout left over from previous call
+            next
+          end
+        end
         action = filter.action_for value
         @skipped.push value unless action
       end
 
-      action.call value
-    else
-      unless @skipped.empty?
-        @skipped.shift
-      else
-        @channel.receive
-      end
+      timeout_event.cancel if timeout_event
     end
+
+    action.call value
   end
 
   class Filter
@@ -102,8 +135,13 @@ class Mailbox
       pair = @pairs.find { |pattern, action| pattern === value }
       pair ? pair[1] : nil
     end
+
+    def empty?
+      @pairs.empty?
+    end
   end
 end
+end
 
 end
 end

data/lib/concurrent/futures.rb

@@ -15,9 +15,10 @@ require 'thwait'
 
 module Concurrent
 module Futures
-extend self
 
-Future = self
+module Future
+  extend Futures
+end
 
 class AsyncError < RuntimeError
   attr_reader :reason
@@ -33,7 +34,6 @@ require 'concurrent/futures.so' # provides Thunk
 def async( &block )
   Thunk.new( Thread.new( &block ) )
 end
-alias new async
 alias spawn async
 alias future async
 

data/test/test_actors.rb

@@ -5,7 +5,40 @@ require 'thread'
 include Concurrent::Actors
 
 class TestActors < Test::Unit::TestCase
+  class A ; end
+  class B ; end
+
   def test_current
     assert_instance_of Actor, Actor.current
   end
+
+  def test_spawn
+    c = Channel.new
+    child = Actor.spawn { c << Actor.current }
+    assert_equal child, c.receive
+  end
+
+  def test_receive_filter
+    c = Channel.new
+    child = Actor.spawn do
+      Actor.receive do |f|
+        f.when( B ) { |m| c << m }
+      end
+      Actor.receive do |f|
+        f.when( A ) { |m| c << m }
+      end
+    end
+    a = A.new
+    b = B.new
+    child << a
+    child << b
+    assert_equal b, c.receive
+    assert_equal a, c.receive
+  end
+
+  def test_receive_empty_filter
+    assert_raise ArgumentError do
+      Actor.receive {}
+    end
+  end
 end

data/test/test_futures.rb

@@ -47,5 +47,26 @@ class FuturesTests < Test::Unit::TestCase
       f + 1
     end
   end
+
+  def test_thunk_inspect
+    t = Thunk.new Object.new
+    t.inspect # should not try to call #value
+  end
+
+  def test_thunk_respond_to?
+    t = Thunk.new Object.new
+    assert t.respond_to?( :respond_to? )
+    assert t.respond_to?( :inspect )
+    assert_raise( AsyncError ) do
+      t.respond_to?( :arbitrary )
+    end
+  end
+
+  def test_thunk_method_missing_short_args
+    t = Thunk.new Object.new
+    assert_raise( ArgumentError ) do
+      t.method_missing
+    end
+  end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: concurrent
 version: !ruby/object:Gem::Version 
-  version: "0.1"
-date: 2007-05-24 00:00:00 -04:00
+  version: 0.2.1
+date: 2007-05-28 00:00:00 -04:00
 summary: Omnibus concurrency library for Ruby
 require_paths: 
 - lib
@@ -35,13 +35,14 @@ files:
 - test/test_parallel.rb
 - ext/concurrent/futures/futures.c
 - ext/concurrent/futures/extconf.rb
-- java/concurrent/FuturesService.java.rb
+- java/concurrent/FuturesService.java
 - lib/concurrent/actors.rb
 - lib/concurrent/futures.rb
 - lib/concurrent/parallel.rb
 - lib/concurrent/core.rb
 - lib/concurrent/actors/actor.rb
 - lib/concurrent/actors/mailbox.rb
+- lib/concurrent/actors/case.rb
 test_files: 
 - test/test_all.rb
 rdoc_options: []
@@ -54,5 +55,13 @@ extensions:
 - ext/concurrent/futures/extconf.rb
 requirements: []
 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: scheduler
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0.1"
+    version: