concurrent 0.1

data/Rakefile

@@ -0,0 +1,105 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/gempackagetask'
+
+desc "Remove build products"
+task :clean do
+  rm Dir.glob( "lib/**/*.jar" )
+  rm Dir.glob( "lib/**/*.#{ Config::CONFIG['DLEXT'] }" )
+  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
+
+def setup_extension( dir, lib_dir, extension )
+  ext = File.join( "ext", dir )
+  so_name = "#{ extension }.#{ Config::CONFIG['DLEXT'] }"
+  ext_so = File.join( ext, so_name )
+  lib_so = File.join( "lib", lib_dir, so_name )
+  ext_files = FileList[ File.join( ext, "*.{c,h}" ) ]
+  ext_makefile = File.join( ext, "Makefile" )
+  extconf_rb = File.join( ext, "extconf.rb" )
+  
+  file ext_makefile => [ extconf_rb ] do
+    Dir.chdir ext do
+      ruby "extconf.rb"
+    end
+  end
+
+  file ext_so => ext_files + [ ext_makefile ] do
+    Dir.chdir ext do
+      case PLATFORM
+      when /win32/
+        sh 'nmake'
+      else
+        sh 'make'
+      end
+    end
+  end
+
+  file lib_so => [ ext_so ] do
+    cp ext_so, lib_so
+  end
+
+  task :compile => [ lib_so ]
+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'
+      sh 'jar', 'cf', 'concurrent/futures.jar', *Dir.glob( 'concurrent/**/*.class' )
+    end
+    cp 'java/concurrent/futures.jar', 'lib/concurrent/futures.jar'
+  end
+  task :compile => [ "lib/concurrent/futures.jar" ]
+else
+  setup_extension( 'concurrent/futures', 'concurrent', 'futures' )
+end
+
+desc "Compile extensions"
+task :compile
+
+task :test => [ :compile ]
+Rake::TestTask.new do |task|
+  task.libs << 'lib'
+  task.libs << 'test'
+  task.test_files = [ "test/test_all.rb" ]
+  task.verbose = true
+end
+
+gemspec = Gem::Specification.new do |gemspec|
+  gemspec.name = "concurrent"
+  gemspec.version = "0.1"
+  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}',
+                            "lib/**/*.{rb,jar,#{ Config::CONFIG['DLEXT'] }}" ]
+  gemspec.require_paths = [ 'lib' ]
+
+  case RUBY_PLATFORM
+  when /java/
+    gemspec.platform = 'jruby'
+  when /win32/
+    gemspec.platform = Gem::Platform::WIN32
+  else
+    gemspec.platform = Gem::Platform::RUBY
+    gemspec.extensions = FileList[ 'ext/**/extconf.rb' ]
+  end
+end
+
+task :package => [ :clean, :test ]
+Rake::GemPackageTask.new( gemspec ) do |task|
+  task.gem_spec = gemspec
+  task.need_tar = true
+end
+
+task :default => [ :clean, :test ]
+

data/ext/concurrent/futures/extconf.rb

@@ -0,0 +1,2 @@
+require 'mkmf'
+create_makefile('concurrent/futures')

data/ext/concurrent/futures/futures.c

@@ -0,0 +1,153 @@
+/*
+ * concurrent/futures - futures and lazy evaluation for Ruby
+ *
+ * Copyright (C) 2007  MenTaLguY <mental@rydia.net>
+ *
+ * This file is made available under the same terms as Ruby.
+ */
+
+#include "ruby.h"
+#include "rubysig.h"
+#include "intern.h"
+
+static VALUE mConcurrent;
+static VALUE mFutures;
+static VALUE eAsyncError;
+static VALUE cThunk;
+
+static ID value_id;
+static ID inspect_id;
+static ID respond_to_p_id;
+
+typedef struct {
+  VALUE source;
+  VALUE value;
+} Thunk;
+
+static void thunk_copy_atomic(Thunk *to, Thunk const *from) {
+  int saved_critical;
+  saved_critical = rb_thread_critical;
+  rb_thread_critical = 1;
+  *to = *from;
+  rb_thread_critical = saved_critical;
+}
+
+static VALUE thunk_value(VALUE obj, int evaluate) {
+  VALUE original;
+
+  original = obj;
+
+  while ( CLASS_OF(obj) == cThunk ) {
+    Thunk *thunk;
+    Thunk copy;
+
+    Data_Get_Struct(obj, Thunk, thunk);
+    thunk_copy_atomic(&copy, thunk);
+
+    if (RTEST(copy.source)) {
+      if (evaluate) {
+        copy.value = rb_funcall(copy.source, value_id, 0);
+        copy.source = Qnil;
+        thunk_copy_atomic(thunk, &copy);
+      }
+
+      if ( obj != original ) {
+        Thunk *original_thunk;
+        Data_Get_Struct(original, Thunk, original_thunk);
+        thunk_copy_atomic(original_thunk, &copy);
+      }
+
+      if (!evaluate) {
+        break;
+      }
+    }
+
+    obj = copy.value;
+  }
+
+  return obj;
+}
+
+static VALUE thunk_eval(VALUE thunk) {
+  return thunk_value(thunk, 1);
+}
+
+static VALUE thunk_ground(VALUE thunk) {
+  return thunk_value(thunk, 0);
+}
+
+void thunk_mark(Thunk const *thunk) {
+  rb_gc_mark(thunk->source);
+  rb_gc_mark(thunk->value);
+}
+
+void thunk_free(Thunk *thunk) {
+  free(thunk);
+}
+
+static VALUE rb_thunk_new(VALUE klass, VALUE source) {
+  Thunk *thunk;
+
+  thunk = (Thunk *)malloc(sizeof(Thunk));
+
+  thunk->source = source;
+  thunk->value = Qnil;
+
+  return Data_Wrap_Struct(cThunk, thunk_mark, thunk_free, thunk);
+}
+
+static VALUE wrap_exception(VALUE unused, VALUE ex) {
+  rb_exc_raise(rb_funcall(eAsyncError, rb_intern("new"), 1, ex));
+}
+
+static VALUE rb_thunk_method_missing(int argc, VALUE *argv, VALUE self) {
+  ID name;
+
+  name = SYM2ID(argv[0]);
+  self = thunk_ground(self);
+
+  if ( CLASS_OF(self) == cThunk ) {
+    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(">"));
+    } else if ( name == respond_to_p_id && argc == 2 ) {
+      if ( ID2SYM(inspect_id) == argv[1] ||
+           ID2SYM(respond_to_p_id) == argv[1] )
+      {
+        return Qtrue;
+      }
+    }
+  }
+
+  self = rb_rescue2(thunk_eval, self, wrap_exception, Qnil, rb_cObject, 0);
+
+  return rb_funcall3(self, name, argc-1, argv+1);
+}
+
+static VALUE rb_thunk_value(VALUE self, VALUE thunk_v) {
+  return thunk_eval(thunk_v);
+}
+
+void Init_futures() {
+  value_id = rb_intern("value");
+  inspect_id = rb_intern("inspect");
+  respond_to_p_id = rb_intern("respond_to?");
+
+  mConcurrent = rb_define_module("Concurrent");
+  mFutures = rb_define_module_under(mConcurrent, "Futures");
+
+  eAsyncError = rb_define_class_under(mFutures, "AsyncError", rb_eRuntimeError);
+
+  cThunk = rb_class_boot(0); /* not Qnil */
+  rb_singleton_class(cThunk);
+  rb_undef_alloc_func(cThunk);
+  rb_const_set(mFutures, rb_intern("Thunk"), cThunk);
+
+  rb_define_singleton_method(cThunk, "new", rb_thunk_new, 1);
+  rb_define_singleton_method(cThunk, "value", rb_thunk_value, 1);
+  rb_define_private_method(cThunk, "method_missing",
+                           rb_thunk_method_missing, -1);
+}
+

data/java/concurrent/FuturesService.java.rb

@@ -0,0 +1,163 @@
+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
+ * 
+ *  The contents of this file are subject to the Common Public
+ *  License Version 1.0 (the "License"); you may not use this file
+ *  except in compliance with the License. You may obtain a copy of
+ *  the License at http://www.eclipse.org/legal/cpl-v10.html
+ * 
+ *  Software distributed under the License is distributed on an "AS
+ *  IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+ *  implied. See the License for the specific language governing
+ *  rights and limitations under the License.
+ * 
+ *  Copyright (C) 2007 MenTaLguY <mental@rydia.net>
+ *  
+ *  Alternatively, the contents of this file may be used under the terms of
+ *  either of the GNU General Public License Version 2 or later (the "GPL"),
+ *  or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
+ *  in which case the provisions of the GPL or the LGPL are applicable instead
+ *  of those above. If you wish to allow use of your version of this file only
+ *  under the terms of either the GPL or the LGPL, and not to allow others to
+ *  use your version of this file under the terms of the CPL, indicate your
+ *  decision by deleting the provisions above and replace them with the notice
+ *  and other provisions required by the GPL or the LGPL. If you do not delete
+ *  the provisions above, a recipient may use your version of this file under
+ *  the terms of any one of the CPL, the GPL or the LGPL.
+ ***** END LICENSE BLOCK *****/
+
+package concurrent;
+
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyClass;
+import org.jruby.RubyException;
+import org.jruby.exceptions.RaiseException;
+import org.jruby.runtime.Block;
+import org.jruby.runtime.CallbackFactory;
+import org.jruby.runtime.callback.Callback;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.load.BasicLibraryService;
+import org.jruby.runtime.builtin.IRubyObject;
+
+public class FuturesService implements BasicLibraryService {
+    public boolean basicLoad(final Ruby runtime) throws IOException {
+        Thunk.setup(runtime);
+        return true;
+    }
+
+    public static class Thunk implements IRubyObject {
+        private Ruby runtime;
+        private RubyClass klass;
+        private IRubyObject source;
+        private IRubyObject value;
+
+        Thunk(Ruby runtime, RubyClass klass, IRubyObject source) {
+            this.runtime = runtime;
+            this.klass = klass;
+            this.source = source;
+            this.value = null;
+        }
+
+        public static IRubyObject newInstance(IRubyObject recv, IRubyObject source, Block block) {
+            return new Thunk(recv.getRuntime(), (RubyClass)recv, source);
+        }
+
+        public static void setup(final Ruby runtime) throws IOException {
+            RubyClass cThunk = runtime.getOrCreateModule("Concurrent").defineModuleUnder("Futures").defineClassUnder("Thunk", null, ObjectAllocator.NOT_ALLOCATABLE_ALLOCATOR);
+            CallbackFactory cb = runtime.callbackFactory(Thunk.class);
+            cThunk.getMetaClass().defineMethod("new", cb.getSingletonMethod("newInstance", IRubyObject.class));
+            cThunk.defineMethod("value", cb.getSingletonMethod("value", IRubyObject.class));
+        }
+
+        public static IRubyObject thunkValue(IRubyObject obj, boolean evaluate) {
+            IRubyObject original=obj;
+
+            while (obj instanceof Thunk) {
+                Thunk thunk=(Thunk)obj;
+
+                synchronized (thunk) {
+                    if ( thunk.source != null ) {
+                        if (evaluate) {
+                            thunk.value = thunk.source.callMethod(thunk.source.getRuntime().getCurrentContext(), "value");
+                            thunk.source = null;
+                        }
+
+                        if ( obj != original ) {
+                            Thunk original_thunk = (Thunk)original;
+                            synchronized (original_thunk) {
+                                original_thunk.value = thunk.value;
+                            }
+                        }
+
+                        if (!evaluate) {
+                            break;
+                        }
+                    }
+
+                    obj = thunk.value;
+                }
+            }
+
+            return obj;
+        }
+
+        public static IRubyObject evalThunk(IRubyObject obj) {
+            try {
+                return thunkValue(obj, true);
+            } catch (RaiseException e) {
+                RubyClass cAsyncError = obj.getRuntime().getModule("Concurrent").defineModuleUnder("Futures").getClass("AsyncError");
+                RubyException e2 = (RubyException)cAsyncError.callMethod(obj.getRuntime().getCurrentContext(), "new", e.getException());
+                throw new RaiseException(e2);
+            }
+        }
+
+        public static IRubyObject value(IRubyObject recv, IRubyObject obj, Block block) {
+            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(", ") }); 
+        }
+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

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

data/lib/concurrent/actors/actor.rb

@@ -0,0 +1,83 @@
+#
+# concurrent/actors/actor - class representing actors
+#
+# 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.
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+require 'concurrent/core'
+require 'concurrent/actors/mailbox.rb'
+
+module Concurrent
+module Actors
+
+class Actor
+  class << self
+    alias :private_new :new
+    private :private_new
+
+    def spawn(&prc)
+      channel = Core::Channel.new
+      Thread.new do
+        channel << current
+        prc.call
+      end
+      channel.receive
+    end
+    alias :new :spawn
+
+    def current
+      Thread.current[:__current_actor__] ||= private_new(current_mailbox)
+    end
+
+    def current_mailbox
+      Thread.current[:__current_mailbox__] ||= Mailbox.new
+    end
+    private :current_mailbox
+
+    def receive(&prc)
+      current_mailbox.receive(&prc)
+    end
+  end
+
+  def initialize(mailbox)
+    @mailbox = mailbox
+  end
+
+  def <<(value)
+    @mailbox << value
+    self
+  end
+end
+
+end
+end

data/lib/concurrent/actors/mailbox.rb

@@ -0,0 +1,109 @@
+#
+# concurrent/actors/mailbox - mailbox class supporting actor implementation
+#
+# 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.
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+
+require 'concurrent/core'
+
+module Concurrent
+module Actors
+
+class Mailbox
+  def initialize
+    @channel = Core::Channel.new
+    @skipped = []
+  end
+
+  # safe for multiple writers
+  def <<(value)
+    @channel << value
+    self
+  end
+
+  # safe only for a single reader
+  def receive
+    if block_given?
+      filter = Filter.new
+      yield filter
+
+      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
+
+      until action
+        value = @channel.receive
+        action = filter.action_for value
+        @skipped.push value unless action
+      end
+
+      action.call value
+    else
+      unless @skipped.empty?
+        @skipped.shift
+      else
+        @channel.receive
+      end
+    end
+  end
+
+  class Filter
+    def initialize
+      @pairs = []
+    end
+
+    def when(pattern, &action)
+      raise ArgumentError, "no block given" unless action
+      @pairs.push [pattern, action]
+    end
+
+    def action_for(value)
+      pair = @pairs.find { |pattern, action| pattern === value }
+      pair ? pair[1] : nil
+    end
+  end
+end
+
+end
+end

data/lib/concurrent/core.rb

@@ -0,0 +1,33 @@
+# concurrent/core - pi calculus channels and other core bits
+#
+# Copyright 2007  MenTaLguY <mental@rydia.net>
+#
+# This file is made available under the same terms as Ruby.
+#
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+
+module Concurrent
+module Core
+
+# an asynchronous pi calculus channel
+class Channel < Queue
+  alias :receive :shift
+  undef :clear
+  undef :deq
+  undef :empty?
+  undef :enq
+  undef :length
+  undef :num_waiting
+  undef :pop
+  undef :push
+  undef :shift
+  undef :size
+end
+
+end
+end

data/lib/concurrent/futures.rb

@@ -0,0 +1,151 @@
+#
+# concurrent/futures - futures and lazy evaluation for Ruby
+#
+# Copyright (C) 2007  MenTaLguY <mental@rydia.net>
+#
+# This file is made available under the same terms as Ruby.
+#
+
+require 'thread'
+begin
+  require 'fastthread'
+rescue LoadError
+end
+require 'thwait'
+
+module Concurrent
+module Futures
+extend self
+
+Future = self
+
+class AsyncError < RuntimeError
+  attr_reader :reason
+
+  def initialize( reason, desc=nil )
+    super( desc )
+    @reason = reason
+  end
+end
+
+require 'concurrent/futures.so' # provides Thunk
+
+def async( &block )
+  Thunk.new( Thread.new( &block ) )
+end
+alias new async
+alias spawn async
+alias future async
+
+def await( future )
+  Thunk.value future
+end
+
+def await_any( *futures )
+  threads = futures.map { |future| Thread.new { Futures::await future } }
+  begin
+    threads.index ThreadsWait.new( *threads ).wait_next
+  ensure
+    threads.each { |thread| thread.raise RuntimeError }
+  end
+end
+
+AlreadyFulfilledError = Class.new StandardError
+
+class Promise
+  def initialize
+    @lock = Mutex.new
+    @ready = ConditionVariable.new
+  end
+
+  def future
+    @future ||= Thunk.new self
+  end
+
+  def fulfill( value )
+    @lock.synchronize do
+      if defined? @value
+        raise AlreadyFulfilledError, "promise already fulfilled"
+      end
+      @value = value
+      @ready.broadcast
+    end
+    self
+  end
+
+  def fulfilled?
+    @lock.synchronize { defined? @value }
+  end
+
+  def value
+    @lock.synchronize do
+      @ready.wait @lock until defined? @value
+      @value
+    end
+  end
+
+  def fail( ex )
+    @lock.synchronize do
+      @value = Thunk.new( Thread.new { raise ex } )
+    end
+    self
+  end
+end
+
+class Lazy
+  def initialize( &block )
+    @lock = Mutex.new
+  end
+
+  def value
+    @lock.synchronize do
+      if @block
+        Support::TerminateWaitLock.synchronize do
+          @value = Thunk.new Thread.new( &block )
+          @block = nil
+        end
+      end
+      @value
+    end
+  end
+
+  def inspect
+    @lock.synchronize do
+      if @block
+        "#<Lazy pending #{ @block.inspect }>"
+      else
+        "#<Lazy requested #{ @value.inspect }>"
+      end
+    end
+  end
+end
+
+def lazy( &block )
+  Thunk.new( Lazy.new( &block ) )
+end
+
+class Ref
+  def initialize( value=nil )
+    @lock = Mutex.new
+    @value = value
+  end
+
+  def exchange( value )
+    @lock.synchronize do
+      result = @value
+      @value = value
+      result
+    end
+  end
+
+  def modify( &block )
+    @lock.synchronize do
+      value = @value
+      @value = Future.async { block.call value }
+    end
+  end
+end
+
+end
+end
+

data/lib/concurrent/parallel.rb

@@ -0,0 +1,120 @@
+#
+# concurrent/parallel - data-parallel programming for Ruby
+#
+# Copyright (C) 2007  MenTaLguY <mental@rydia.net>
+#
+# This file is made available under the same terms as Ruby.
+#
+
+module Concurrent
+module Parallel
+end
+end
+
+module Enumerable
+  def parallel_each( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.each &block }
+    end.each do |thread|
+      thread.join
+    end
+    self
+  end
+
+  def parallel_map( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.map &block }
+    end.inject( [] ) do |a, thread|
+      a.push *thread.value
+    end
+  end
+
+  def parallel_select( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.select &block }
+    end.inject( [] ) do |a, results|
+      a.push *thread.value
+    end
+  end
+
+  def parallel_reject( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.reject &block }
+    end.inject( [] ) do |a, thread|
+      a.push *thread.value
+    end
+  end
+
+  def parallel_max( n )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.max }
+    end.map { |t| t.value }.max
+  end
+
+  def parallel_min( n )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.min }
+    end.map { |t| t.value }.min
+  end
+
+  def parallel_partition( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.partition &block }
+    end.inject( [ [], [] ] ) do |acc, thread|
+      pair = thread.value
+      acc[0].push *pair[0]
+      acc[1].push *pair[1]
+      acc
+    end
+  end
+
+  def parallel_grep( re, n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.grep( re, &block ) }
+    end.inject( [] ) do |acc, thread|
+      acc.push *thread.value
+    end
+  end
+
+  def parallel_all?( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.all? &block }
+    end.inject( true ) do |acc, thread|
+      acc && thread.value
+    end
+  end
+
+  def parallel_any?( n, &block )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.any? &block }
+    end.inject( false ) do |acc, thread|
+      acc || thread.value
+    end
+  end
+
+  def parallel_include?( n, obj )
+    parallel_subsets( n ).map do |slice|
+      Thread.new { slice.include? obj }
+    end.inject( false ) do |acc, thread|
+      acc || thread.value
+    end
+  end
+
+  def parallel_subsets( n )
+    to_a.parallel_subsets( n )
+  end
+end
+
+class Array
+  def parallel_subsets( n )
+    if n > 1
+      slice_size = size / n
+      (0...(( size.to_f / slice_size ).ceil)).map do |i|
+        self[i*slice_size, slice_size]
+      end
+    else
+      [ self ]
+    end
+  end
+end
+

data/test/test_actors.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'concurrent/actors'
+require 'thread'
+
+include Concurrent::Actors
+
+class TestActors < Test::Unit::TestCase
+  def test_current
+    assert_instance_of Actor, Actor.current
+  end
+end

data/test/test_all.rb

@@ -0,0 +1,3 @@
+require 'test_actors.rb'
+require 'test_futures.rb'
+require 'test_parallel.rb'

data/test/test_futures.rb

@@ -0,0 +1,51 @@
+require 'test/unit'
+require 'concurrent/futures'
+require 'thread'
+
+include Concurrent::Futures
+
+class FuturesTests < Test::Unit::TestCase
+  def test_promise_fulfill
+    promise = Promise.new
+    assert !promise.fulfilled?
+    promise.fulfill 10
+    assert promise.fulfilled?
+    assert_equal 10, promise.future
+  end
+
+  def test_promise_fulfill_twice
+    promise = Promise.new
+    promise.fulfill 10
+    assert_raise( AlreadyFulfilledError ) do
+      promise.fulfill 20
+    end
+  end
+
+  def test_promise_fail
+    promise = Promise.new
+    promise.fail( EOFError.new )
+    value = promise.future
+    assert_raise( EOFError ) do
+      Future.await promise.value
+    end
+    assert_raise( AsyncError ) do
+      value + 1
+    end
+  end
+
+  def test_future
+    f = Future.future { 3 }
+    assert_equal 3, f
+  end
+
+  def test_future_raise
+    f = Future.future { raise EOFError, "blah" }
+    assert_raise( EOFError ) do
+      Future.await f
+    end
+    assert_raise( AsyncError ) do
+      f + 1
+    end
+  end
+end
+

data/test/test_parallel.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'concurrent/parallel'
+require 'thread'
+
+class TestParallel < Test::Unit::TestCase
+  def check_parallel( enum, n, meth, *args, &block )
+    regular = enum.send( meth, *args, &block )
+    parallel = enum.send( "parallel_#{ meth }", n, *args, &block )
+    assert_equal regular, parallel
+  end
+
+  def test_map
+    check_parallel( 0..100, 2, "map" ) { |x| x * 2 }
+  end
+
+  def test_any?
+    check_parallel( 0..100, 2, "any?" ) { |x| ( ( x + 1 ) % 48 ).zero? }
+    check_parallel( 0..100, 2, "any?" )
+    check_parallel( [ false ] * 100, 2, "any?" )
+    check_parallel( [ true ] * 100, 2, "any?" )
+  end
+
+  def test_all?
+    check_parallel( 0..100, 2, "all?" ) { |x| ( ( x + 1 ) % 48 ).zero? }
+    check_parallel( 0..100, 2, "all?" )
+    check_parallel( [ false ] * 100, 2, "all?" )
+    check_parallel( [ true ] * 100, 2, "all?" )
+  end
+
+  def test_include?
+    check_parallel( 0..100, 2, "include?", 5 )
+    check_parallel( 0..100, 2, "include?", 1000 )
+  end
+end

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification 
+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
+summary: Omnibus concurrency library for Ruby
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+- MenTaLguY <mental@rydia.net>
+files: 
+- Rakefile
+- test/test_all.rb
+- test/test_futures.rb
+- test/test_actors.rb
+- test/test_parallel.rb
+- ext/concurrent/futures/futures.c
+- ext/concurrent/futures/extconf.rb
+- java/concurrent/FuturesService.java.rb
+- 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
+test_files: 
+- test/test_all.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: 
+- ext/concurrent/futures/extconf.rb
+requirements: []
+
+dependencies: []
+