concurrent-ruby 0.7.0.rc2-x86-solaris-2.11 → 0.7.0-x86-solaris-2.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e851c255a67a6fc45285fa0945f7c15f6aa44cb
-  data.tar.gz: 8a560af27570c136596e05bfbb8b7a05831bc686
+  metadata.gz: 42b5b3581d3c2ecbb9979c3ca259fe23a7e27915
+  data.tar.gz: 5fb76ed4fc1d91b50d0896cb41ae4244c5a0fc13
 SHA512:
-  metadata.gz: f15adb8bf748b1da9d61c604bfb6d9a207d1c074464c4bd4f136d1eda1189911805e93fac577f104b8113bb0d88cf5a91cbaa443585a38f52772e9199568c46d
-  data.tar.gz: 37de66b3c064dbe7e7ed2b7e6dcaf5a21689293eb3a70d88e47aa169c03700b16d6194ea9dec8f7806519c3065d9855713cf0d9def643bb12eccd1310440e76b
+  metadata.gz: 7f2d5e31bf690426ebe5fe3b3f8ec563a11ae2b8469f1a2f1c8caf606793d4795e5b332bd5bf1fe5e18f6355118fc9949f284533e71cd429a0c01a504eb6a7c7
+  data.tar.gz: 84951f036c41be59cc9af5e257d473c6b003b088d60683826898e4d8d8ff2031d8ca388a918e1d63f94983b0c4312311f938b50e0176bf586921b697415cdb1b

data/README.md

@@ -1,5 +1,5 @@
 # Concurrent Ruby
-[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.png)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Coverage Status](https://coveralls.io/repos/ruby-concurrency/concurrent-ruby/badge.png)](https://coveralls.io/r/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.png)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.png)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.png)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![Gitter chat](https://badges.gitter.im/ruby-concurrency/concurrent-ruby.png)](https://gitter.im/ruby-concurrency/concurrent-ruby)
+[![Gem Version](https://badge.fury.io/rb/concurrent-ruby.png)](http://badge.fury.io/rb/concurrent-ruby) [![Build Status](https://travis-ci.org/ruby-concurrency/concurrent-ruby.svg?branch=master)](https://travis-ci.org/ruby-concurrency/concurrent-ruby) [![Coverage Status](https://coveralls.io/repos/ruby-concurrency/concurrent-ruby/badge.png)](https://coveralls.io/r/ruby-concurrency/concurrent-ruby) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby.png)](https://codeclimate.com/github/ruby-concurrency/concurrent-ruby) [![Inline docs](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby.png)](http://inch-ci.org/github/ruby-concurrency/concurrent-ruby) [![Dependency Status](https://gemnasium.com/ruby-concurrency/concurrent-ruby.png)](https://gemnasium.com/ruby-concurrency/concurrent-ruby) [![License](http://img.shields.io/license/MIT.png?color=green)](http://opensource.org/licenses/MIT) [![Gitter chat](https://badges.gitter.im/ruby-concurrency/concurrent-ruby.png)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
 <table>
   <tr>
@@ -35,22 +35,6 @@
   </tr>
 </table>
 
-## Install
-
-```shell
-gem install concurrent-ruby
-```
-
-or add the following line to Gemfile:
-
-```ruby
-gem 'concurrent-ruby'
-```
-
-and run `bundle install` from your shell.
-
-_NOTE: There is an old gem from 2007 called "concurrent" that does not appear to be under active development. That isn't us. Please do not run* `gem install concurrent`*. It is not the droid you are looking for._
-
 ## Features & Documentation
 
 Please see the [Concurrent Ruby Wiki](https://github.com/ruby-concurrency/concurrent-ruby/wiki)
@@ -61,21 +45,27 @@ There are many concurrency abstractions in this library. These abstractions can
 into several general groups:
 
 * Asynchronous concurrency abstractions including
-  [Async](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Async),
-  [Agent](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Agent),
-  [Future](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Future),
-  [Promise](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Promise),
-  [ScheduledTask](https://github.com/ruby-concurrency/concurrent-ruby/wiki/ScheduledTask),
-  and [TimerTask](https://github.com/ruby-concurrency/concurrent-ruby/wiki/TimerTask) 
-* Thread-safe variables including [M-Structures](https://github.com/ruby-concurrency/concurrent-ruby/wiki/MVar-(M-Structure)),
-  [I-Structures](https://github.com/ruby-concurrency/concurrent-ruby/wiki/IVar-(I-Structure)),
-  [thread-local variables](https://github.com/ruby-concurrency/concurrent-ruby/wiki/ThreadLocalVar),
-  atomic counters, and [software transactional memory](https://github.com/ruby-concurrency/concurrent-ruby/wiki/TVar-(STM))
-* Thread synchronization classes and algorithms including [dataflow](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Dataflow), 
-  timeout, condition, countdown latch, dependency counter, and event
-* Java-inspired [thread pools](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Thread%20Pools)
-* New fast light-weighted [Actor model](http://ruby-concurrency.github.io/concurrent-ruby/frames.html#!Concurrent/Actress.html) implementation. 
-* And many more...
+  [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html),
+  [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html),
+  [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html),
+  [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html),
+  [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html),
+  and [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html) 
+* Fast, light-weight [Actor model](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html) implementation. 
+* Thread-safe variables including
+  [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html),
+  [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html),
+  [thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html),
+  and [software transactional memory](https://github.com/ruby-concurrency/concurrent-ruby/wiki/TVar-(STM))
+* Thread synchronization classes and algorithms including
+  [condition](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Condition.html),
+  [countdown latch](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CountDownLatch.html),
+  [dataflow](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Dataflow), 
+  [event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html),
+  [exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html),
+  and [timeout](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timeout-class_method)
+* Java-inspired [executors](https://github.com/ruby-concurrency/concurrent-ruby/wiki/Thread%20Pools) (thread pools and more)
+* [And many more](http://ruby-concurrency.github.io/concurrent-ruby/index.html)...
 
 ### Semantic Versioning
 
@@ -90,7 +80,8 @@ It should be fully compatible with any interpreter that is compliant with Ruby 1
 ### Examples
 
 Many more code examples can be found in the documentation for each class (linked above).
-This one simple example shows some of the power of this gem.
+
+Future and ScheduledTask:
 
 ```ruby    
 require 'concurrent'
@@ -112,18 +103,6 @@ sleep(1)    # do other stuff
 price.value #=> 63.65
 price.state #=> :fulfilled
 
-# Promise
-prices = Concurrent::Promise.new{ puts Ticker.new.get_year_end_closing('AAPL', 2013) }.
-           then{ puts Ticker.new.get_year_end_closing('MSFT', 2013) }.
-           then{ puts Ticker.new.get_year_end_closing('GOOG', 2013) }.
-           then{ puts Ticker.new.get_year_end_closing('AMZN', 2013) }.execute
-prices.state #=> :pending
-sleep(1)     # do other stuff
-#=> 561.02
-#=> 37.41
-#=> 1120.71
-#=> 398.79
-
 # ScheduledTask
 task = Concurrent::ScheduledTask.execute(2){ Ticker.new.get_year_end_closing('INTC', 2013) }
 task.state #=> :pending
@@ -131,6 +110,88 @@ sleep(3)   # do other stuff
 task.value #=> 25.96
 ```
 
+Actor:
+
+```ruby
+class Counter < Concurrent::Actor::Context
+  # Include context of an actor which gives this class access to reference
+  # and other information about the actor
+
+  # use initialize as you wish
+  def initialize(initial_value)
+    @count = initial_value
+  end
+
+  # override on_message to define actor's behaviour
+  def on_message(message)
+    if Integer === message
+      @count += message
+    end
+  end
+end #
+
+# Create new actor naming the instance 'first'.
+# Return value is a reference to the actor, the actual actor is never returned.
+counter = Counter.spawn(:first, 5)
+
+# Tell a message and forget returning self.
+counter.tell(1)
+counter << 1
+# (First counter now contains 7.)
+
+# Send a messages asking for a result.
+counter.ask(0).class
+counter.ask(0).value
+```
+
+## Installing and Building
+
+This gem includes several platform-specific optimizations. To reduce the possibility of
+compilation errors, we provide pre-compiled gem packages for several platforms as well
+as a pure-Ruby build. Installing the gem should be no different than installing any other
+Rubygems-hosted gem.
+
+### Installing
+
+```shell
+gem install concurrent-ruby
+```
+
+or add the following line to Gemfile:
+
+```ruby
+gem 'concurrent-ruby'
+```
+
+and run `bundle install` from your shell.
+
+### Building
+
+Because we provide pre-compiled gem builds, users should never need to build the gem manually.
+The build process for this gem is completely automated using open source tools. All of
+the automation components are available in the [ruby-concurrency/rake-compiler-dev-box](https://github.com/ruby-concurrency/rake-compiler-dev-box)
+GitHub repository.
+
+This gem will compile native C code under MRI and native Java code under JRuby. It is
+also possible to build a pure-Ruby version. All builds have identical functionality.
+The only difference is performance. Additionally, pure-Ruby classes are always available,
+even when using the native optimizations. Please see the [documentation](http://ruby-concurrency.github.io/concurrent-ruby/)
+for more details.
+
+To build and package the gem using MRI or JRuby, install the necessary build dependencies and run:
+
+```shell
+bundle exec rake compile
+bundle exec rake build
+```
+
+To build and package a pure-Ruby gem, on *any* platform and interpreter
+(including MRI and JRuby), run:
+
+```shell
+BUILD_PURE_RUBY='true' bundle exec rake build
+```
+
 ## Maintainers
 
 * [Jerry D'Antonio](https://github.com/jdantonio)
@@ -139,22 +200,6 @@ task.value #=> 25.96
 * [Lucas Allan](https://github.com/lucasallan)
 * [Petr Chalupa](https://github.com/pitr-ch)
 
-### Contributors
-
-* [Bill Dueber](https://github.com/billdueber)
-* [Brian Shirai](https://github.com/brixen)
-* [Chip Miller](https://github.com/chip-miller)
-* [Giuseppe Capizzi](https://github.com/gcapizzi)
-* [Jamie Hodge](https://github.com/jamiehodge)
-* [Justin Lambert](https://github.com/mastfish)
-* [Larry Lv](https://github.com/larrylv)
-* [Maxim Chechel](https://github.com/maximchick)
-* [Ravil Bayramgalin](https://github.com/brainopia)
-* [René Föhring](https://github.com/rrrene)
-* [Shane Wilton](https://github.com/ShaneWilton)
-* [sheaney](https://github.com/sheaney)
-* [Zander Hill](https://github.com/zph)
-
 ### Contributing
 
 1. Fork it

data/ext/concurrent_ruby_ext/atomic_reference.c

@@ -27,18 +27,31 @@ VALUE ir_initialize(int argc, VALUE* argv, VALUE self) {
 }
 
 VALUE ir_get(VALUE self) {
+#if HAVE_GCC_SYNC
+  __sync_synchronize();
+#elif defined _MSC_VER
+  MemoryBarrier();
+#elif __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
+  OSMemoryBarrier();
+#endif
   return (VALUE) DATA_PTR(self);
 }
 
 VALUE ir_set(VALUE self, VALUE new_value) {
   DATA_PTR(self) = (void *) new_value;
+#if HAVE_GCC_SYNC
+  __sync_synchronize();
+#elif defined _MSC_VER
+  MemoryBarrier();
+#elif __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ >= 1050
+  OSMemoryBarrier();
+#endif
   return new_value;
 }
 
 VALUE ir_get_and_set(VALUE self, VALUE new_value) {
-  VALUE old_value;
-  old_value = (VALUE) DATA_PTR(self);
-  DATA_PTR(self) = (void *) new_value;
+  VALUE old_value = ir_get(self);
+  ir_set(self, new_value);
   return old_value;
 }
 

data/ext/concurrent_ruby_ext/extconf.rb

@@ -12,7 +12,7 @@ def create_dummy_makefile
   end
 end
 
-if defined?(JRUBY_VERSION) || ! Concurrent.use_c_extensions? 
+if defined?(JRUBY_VERSION) || ! Concurrent.allow_c_extensions? 
   create_dummy_makefile
   warn 'C optimizations are not supported on this version of Ruby.'
 else
@@ -43,12 +43,11 @@ else
       end
     end
 
-    try_run(<<CODE,$CFLAGS) && ($defs << '-DHAVE_GCC_CAS')
-int main() {
-  int i = 1;
-  __sync_bool_compare_and_swap(&i, 1, 4);
-  return (i != 4);
-}
+    try_run(<<CODE,$CFLAGS) && ($defs << '-DHAVE_GCC_SYNC')
+      int main() {
+        __sync_synchronize();
+        return 0;
+      }
 CODE
 
     create_makefile(EXTENSION_NAME)

data/lib/concurrent/actor.rb

@@ -26,7 +26,7 @@ module Concurrent
 
     require 'concurrent/actor/default_dead_letter_handler'
     require 'concurrent/actor/root'
-    require 'concurrent/actor/ad_hoc'
+    require 'concurrent/actor/utils'
 
     # @return [Reference, nil] current executing actor if any
     def self.current

data/lib/concurrent/actor/behaviour/executes_context.rb

@@ -1,7 +1,7 @@
 module Concurrent
   module Actor
     module Behaviour
-      # Delegates messages nad events to {AbstractContext} instance
+      # Delegates messages and events to {AbstractContext} instance
       class ExecutesContext < Abstract
         def on_envelope(envelope)
           context.on_envelope envelope

data/lib/concurrent/actor/behaviour/supervised.rb

@@ -2,7 +2,7 @@ module Concurrent
   module Actor
     module Behaviour
 
-      # Sets nad holds the supervisor of the actor if any. There is only one or none supervisor
+      # Sets and holds the supervisor of the actor if any. There is at most one supervisor
       # for each actor. Each supervisor is automatically linked.
       class Supervised < Abstract
         attr_reader :supervisor

data/lib/concurrent/actor/behaviour/terminates_children.rb

@@ -4,7 +4,7 @@ module Concurrent
       # Terminates all children when the actor terminates.
       class TerminatesChildren < Abstract
         def on_event(event)
-          children.each { |ch| ch << :terminate! } if event == :terminated
+          children.map { |ch| ch.ask :terminate! }.each(&:wait) if event == :terminated
           super event
         end
       end

data/lib/concurrent/actor/core.rb

@@ -37,7 +37,7 @@ module Concurrent
       # @option opts [true, false] link, atomically link the actor to its parent
       # @option opts [true, false] supervise, atomically supervise the actor by its parent
       # @option opts [Array<Array(Behavior::Abstract, Array<Object>)>] behaviour_definition, array of pairs
-      #   where each pair is behaviour class and its args, see {Behaviour.basic_behaviour}
+      #   where each pair is behaviour class and its args, see {Behaviour.basic_behaviour_definition}
       # @option opts [IVar, nil] initialized, if present it'll be set or failed after {Context} initialization
       # @option opts [Proc, nil] logger a proc accepting (level, progname, message = nil, &block) params,
       #   can be used to hook actor instance to any logging system

data/lib/concurrent/actor/utils.rb

@@ -0,0 +1,10 @@
+module Concurrent
+  module Actor
+    module Utils
+      require 'concurrent/actor/utils/ad_hoc'
+      require 'concurrent/actor/utils/broadcast'
+      require 'concurrent/actor/utils/balancer'
+      require 'concurrent/actor/utils/pool'
+    end
+  end
+end

data/lib/concurrent/actor/utils/ad_hoc.rb

@@ -0,0 +1,21 @@
+module Concurrent
+  module Actor
+    module Utils
+      # Allows quick creation of actors with behaviour defined by blocks.
+      # @example ping
+      #   AdHoc.spawn :forward, an_actor do |where|
+      #     # this block has to return proc defining #on_message behaviour
+      #     -> message { where.tell message  }
+      #   end
+      class AdHoc < Context
+        def initialize(*args, &initializer)
+          @on_message = Type! initializer.call(*args), Proc
+        end
+
+        def on_message(message)
+          instance_exec message, &@on_message
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/actor/utils/balancer.rb

@@ -0,0 +1,40 @@
+module Concurrent
+  module Actor
+    module Utils
+
+      # Distributes messages between subscribed actors. Each actor'll get only one message then
+      # it's unsubscribed. The actor needs to resubscribe when it's ready to receive next message.
+      # @see Pool
+      class Balancer < RestartingContext
+
+        def initialize
+          @receivers = []
+          @buffer    = []
+        end
+
+        def on_message(message)
+          case message
+          when :subscribe
+            @receivers << envelope.sender
+            distribute
+            true
+          when :unsubscribe
+            @receivers.delete envelope.sender
+            true
+          when :subscribed?
+            @receivers.include? envelope.sender
+          else
+            @buffer << message
+            distribute
+          end
+        end
+
+        def distribute
+          while !@receivers.empty? && !@buffer.empty?
+            @receivers.shift << @buffer.shift
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/actor/utils/broadcast.rb

@@ -4,8 +4,20 @@ module Concurrent
   module Actor
     module Utils
 
-      # TODO doc
-      class Broadcast < Context
+      # Allows to build pub/sub easily.
+      # @example news
+      #   news_channel = Concurrent::Actor::Utils::Broadcast.spawn :news
+      #
+      #   2.times do |i|
+      #     Concurrent::Actor::Utils::AdHoc.spawn "listener-#{i}" do
+      #       news_channel << :subscribe
+      #       -> message { puts message }
+      #     end
+      #   end
+      #
+      #   news_channel << 'Ruby rocks!'
+      #   # prints: 'Ruby rocks!' twice
+      class Broadcast < RestartingContext
 
         def initialize
           @receivers = Set.new
@@ -14,11 +26,14 @@ module Concurrent
         def on_message(message)
           case message
           when :subscribe
-            @receivers.add envelope.sender
-            true
+            if envelope.sender.is_a? Reference
+              @receivers.add envelope.sender
+              true
+            else
+              false
+            end
           when :unsubscribe
-            @receivers.delete envelope.sender
-            true
+            !!@receivers.delete(envelope.sender)
           when :subscribed?
             @receivers.include? envelope.sender
           else
@@ -31,6 +46,7 @@ module Concurrent
           @receivers
         end
       end
+
     end
   end
 end

data/lib/concurrent/actor/utils/pool.rb

@@ -0,0 +1,59 @@
+require 'concurrent/actor/utils/balancer'
+
+module Concurrent
+  module Actor
+    module Utils
+
+      # Allows to create a pool of workers and distribute work between them
+      # @param [Integer] size number of workers
+      # @yield [balancer, index] a block spawning an worker instance. called +size+ times.
+      #   The worker should be descendant of AbstractWorker and supervised, see example.
+      # @yieldparam [Balancer] balancer to pass to the worker
+      # @yieldparam [Integer] index of the worker, usually used in its name
+      # @yieldreturn [Reference] the reference of newly created worker
+      # @example
+      #     class Worker < Concurrent::Actor::Utils::AbstractWorker
+      #       def work(message)
+      #         p message * 5
+      #       end
+      #     end
+      #
+      #     pool = Concurrent::Actor::Utils::Pool.spawn! 'pool', 5 do |balancer, index|
+      #       Worker.spawn name: "worker-#{index}", supervise: true, args: [balancer]
+      #     end
+      #
+      #     pool << 'asd' << 2
+      #     # prints:
+      #     # "asdasdasdasdasd"
+      #     # 10
+      class Pool < RestartingContext
+        def initialize(size, &worker_initializer)
+          @balancer = Balancer.spawn name: :balancer, supervise: true
+          @workers  = Array.new(size, &worker_initializer.curry[@balancer])
+          @workers.each { |w| Type! w, Reference }
+        end
+
+        def on_message(message)
+          @balancer << message
+        end
+      end
+
+      class AbstractWorker < RestartingContext
+        def initialize(balancer)
+          @balancer = balancer
+          @balancer << :subscribe
+        end
+
+        def on_message(message)
+          work message
+        ensure
+          @balancer << :subscribe
+        end
+
+        def work(message)
+          raise NotImplementedError
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/atomic.rb

@@ -1,3 +1,17 @@
+#####################################################################
+# Attempt to check for the deprecated ruby-atomic gem and warn the
+# user that they should use the new implementation instead.
+
+if defined?(Atomic)
+  warn <<-RUBY
+[ATOMIC] Detected an `Atomic` class, which may indicate a dependency
+on the ruby-atomic gem. That gem has been deprecated and merged into
+the concurrent-ruby gem. Please use the Concurrent::Atomic class for
+atomic references and not the Atomic class.
+RUBY
+end
+#####################################################################
+
 require 'concurrent/atomic_reference/concurrent_update_error'
 require 'concurrent/atomic_reference/mutex_atomic'
 
@@ -57,41 +71,21 @@ if defined? Concurrent::JavaAtomic
   class Concurrent::Atomic < Concurrent::JavaAtomic
   end
 
-elsif defined? Concurrent::CAtomic
-
-  # @!macro [attach] concurrent_update_error
-  #
-  # This exception may be thrown by methods that have detected concurrent
-  # modification of an object when such modification is not permissible.
-  class Concurrent::Atomic < Concurrent::CAtomic
-  end
-
 elsif defined? Concurrent::RbxAtomic
 
   # @!macro atomic_reference
   class Concurrent::Atomic < Concurrent::RbxAtomic
   end
 
-else
+elsif Concurrent.allow_c_native_class?('CAtomic')
 
   # @!macro atomic_reference
-  class Concurrent::Atomic < Concurrent::MutexAtomic
+  class Concurrent::Atomic < Concurrent::CAtomic
   end
-end
 
-# @!macro atomic_reference
-class Atomic < Concurrent::Atomic
-
-  # @!macro concurrent_update_error
-  ConcurrentUpdateError = Class.new(Concurrent::ConcurrentUpdateError)
+else
 
-  # @!macro [attach] atomic_reference_method_initialize
-  #
-  # Creates a new Atomic reference with null initial value.
-  #
-  # @param [Object] value the initial value
-  def initialize(value)
-    warn "[DEPRECATED] Please use Concurrent::Atomic instead."
-    super
+  # @!macro atomic_reference
+  class Concurrent::Atomic < Concurrent::MutexAtomic
   end
 end

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -1,3 +1,6 @@
+require_relative '../../extension_helper'
+Concurrent.safe_require_c_extensions
+
 module Concurrent
 
   # @!macro [attach] atomic_boolean
@@ -159,7 +162,7 @@ module Concurrent
     class AtomicBoolean < JavaAtomicBoolean
     end
 
-  elsif defined? Concurrent::CAtomicBoolean
+  elsif Concurrent.allow_c_native_class?('CAtomicBoolean')
 
     # @!macro atomic_boolean
     class CAtomicBoolean

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -1,3 +1,6 @@
+require_relative '../../extension_helper'
+Concurrent.safe_require_c_extensions
+
 module Concurrent
 
   # @!macro [attach] atomic_fixnum
@@ -163,7 +166,7 @@ module Concurrent
     class AtomicFixnum < JavaAtomicFixnum
     end
 
-  elsif defined? Concurrent::CAtomicFixnum
+  elsif Concurrent.allow_c_native_class?('CAtomicFixnum')
 
     # @!macro atomic_fixnum
     class CAtomicFixnum

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,10 +1,14 @@
-require 'concurrent_ruby_ext'
-require 'concurrent/atomic_reference/direct_update'
+require_relative '../../extension_helper'
+Concurrent.safe_require_java_extensions
 
-module Concurrent
+if defined?(Concurrent::JavaAtomic)
+  require 'concurrent/atomic_reference/direct_update'
 
-  # @!macro atomic_reference
-  class JavaAtomic
-    include Concurrent::AtomicDirectUpdate
+  module Concurrent
+
+    # @!macro atomic_reference
+    class JavaAtomic
+      include Concurrent::AtomicDirectUpdate
+    end
   end
 end

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,8 +1,12 @@
-begin
-  require 'concurrent_ruby_ext'
-rescue LoadError
-  # may be a Windows cross-compiled native gem
-  require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+require_relative '../../extension_helper'
+
+if Concurrent.allow_c_extensions?
+  begin
+    require 'concurrent_ruby_ext'
+  rescue LoadError
+    # may be a Windows cross-compiled native gem
+    require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+  end
 end
 
 require 'concurrent/atomic_reference/direct_update'
@@ -14,19 +18,19 @@ module Concurrent
   class CAtomic
     include Concurrent::AtomicDirectUpdate
     include Concurrent::AtomicNumericCompareAndSetWrapper
-    
+
     # @!method initialize
     #   @!macro atomic_reference_method_initialize
-    
+
     # @!method get
     #   @!macro atomic_reference_method_get
-    
+
     # @!method set
     #   @!macro atomic_reference_method_set
-    
+
     # @!method get_and_set
     #   @!macro atomic_reference_method_get_and_set
-    
+
     # @!method _compare_and_set
     #   @!macro atomic_reference_method_compare_and_set
   end

data/lib/concurrent/executor/serialized_execution.rb

@@ -1,12 +1,14 @@
 require 'delegate'
 require 'concurrent/executor/executor'
 require 'concurrent/logging'
+require 'concurrent/atomic/synchronization'
 
 module Concurrent
 
   # Ensures passed jobs in a serialized order never running at the same time.
   class SerializedExecution
     include Logging
+    include Synchronization
 
     Job = Struct.new(:executor, :args, :block) do
       def call
@@ -15,9 +17,10 @@ module Concurrent
     end
 
     def initialize
-      @being_executed = false
-      @stash          = []
-      @mutex          = Mutex.new
+      synchronize do
+        @being_executed = false
+        @stash          = []
+      end
     end
 
     # Submit a task to the executor for asynchronous processing.
@@ -33,23 +36,36 @@ module Concurrent
     #
     # @raise [ArgumentError] if no task is given
     def post(executor, *args, &task)
-      return nil if task.nil?
-
-      job = Job.new executor, args, task
-
-      begin
-        @mutex.lock
-        post = if @being_executed
-                 @stash << job
-                 false
-               else
-                 @being_executed = true
-               end
-      ensure
-        @mutex.unlock
+      posts [[executor, args, task]]
+      true
+    end
+
+    # As {#post} but allows to submit multiple tasks at once, it's guaranteed that they will not
+    # be interleaved by other tasks.
+    #
+    # @param [Array<Array(Executor, Array<Object>, Proc)>] posts array of triplets where
+    #   first is a {Executor}, second is array of args for task, third is a task (Proc)
+    def posts(posts)
+      # if can_overflow?
+      #   raise ArgumentError, 'SerializedExecution does not support thread-pools which can overflow'
+      # end
+
+      return nil if posts.empty?
+
+      jobs = posts.map { |executor, args, task| Job.new executor, args, task }
+
+      job_to_post = synchronize do
+        if @being_executed
+          @stash.push(*jobs)
+          nil
+        else
+          @being_executed = true
+          @stash.push(*jobs[1..-1])
+          jobs.first
+        end
       end
 
-      call_job job if post
+      call_job job_to_post if job_to_post
       true
     end
 
@@ -78,11 +94,8 @@ module Concurrent
     def work(job)
       job.call
     ensure
-      begin
-        @mutex.lock
+      synchronize do
         job = @stash.shift || (@being_executed = false)
-      ensure
-        @mutex.unlock
       end
 
       call_job job if job
@@ -98,7 +111,7 @@ module Concurrent
     include SerialExecutor
 
     def initialize(executor)
-      @executor = executor
+      @executor   = executor
       @serializer = SerializedExecution.new
       super(executor)
     end

data/lib/concurrent/tvar.rb

@@ -112,7 +112,7 @@ module Concurrent
             result = Transaction::ABORTED
           rescue => e
             transaction.abort
-            throw e
+            raise e
           end
           # If we can commit, break out of the loop
 

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.7.0.rc2'
+  VERSION = '0.7.0'
 end

data/lib/extension_helper.rb

@@ -1,9 +1,28 @@
-require 'rbconfig'
-
 module Concurrent
-  def self.use_c_extensions?
-    host_os = RbConfig::CONFIG['host_os']
-    ruby_name = RbConfig::CONFIG['ruby_install_name']
-    (ruby_name =~ /^ruby$/i || host_os =~ /mswin32/i || host_os =~ /mingw32/i)
+
+  # @!visibility private
+  def self.allow_c_extensions?
+    defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby'
+  end
+
+  # @!visibility private
+  def self.allow_c_native_class?(clazz)
+    allow_c_extensions? && Concurrent.const_defined?(clazz)
+  rescue
+    false
+  end
+
+  # @!visibility private
+  def self.safe_require_c_extensions
+    require 'concurrent_ruby_ext' if allow_c_extensions?
+  rescue LoadError
+    #warn 'Attempted to load C extensions on unsupported platform. Continuing with pure-Ruby.'
+  end
+
+  # @!visibility private
+  def self.safe_require_java_extensions
+    require 'concurrent_ruby_ext' if RUBY_PLATFORM == 'java'
+  rescue LoadError
+    #warn 'Attempted to load Java extensions on unsupported platform. Continuing with pure-Ruby.'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.0.rc2
+  version: 0.7.0
 platform: x86-solaris-2.11
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-30 00:00:00.000000000 Z
+date: 2014-08-13 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -35,7 +35,6 @@ files:
 - lib/2.0/concurrent_ruby_ext.so
 - lib/concurrent.rb
 - lib/concurrent/actor.rb
-- lib/concurrent/actor/ad_hoc.rb
 - lib/concurrent/actor/behaviour.rb
 - lib/concurrent/actor/behaviour/abstract.rb
 - lib/concurrent/actor/behaviour/awaits.rb
@@ -60,8 +59,11 @@ files:
 - lib/concurrent/actor/reference.rb
 - lib/concurrent/actor/root.rb
 - lib/concurrent/actor/type_check.rb
-- lib/concurrent/actor/utills.rb
+- lib/concurrent/actor/utils.rb
+- lib/concurrent/actor/utils/ad_hoc.rb
+- lib/concurrent/actor/utils/balancer.rb
 - lib/concurrent/actor/utils/broadcast.rb
+- lib/concurrent/actor/utils/pool.rb
 - lib/concurrent/actress.rb
 - lib/concurrent/agent.rb
 - lib/concurrent/async.rb
@@ -154,9 +156,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.2.2

data/lib/concurrent/actor/ad_hoc.rb

@@ -1,19 +0,0 @@
-module Concurrent
-  module Actor
-    # Allows quick creation of actors with behaviour defined by blocks.
-    # @example ping
-    #   AdHoc.spawn :forward, an_actor do |where|
-    #     # this block has to return proc defining #on_message behaviour
-    #     -> message { where.tell message  }
-    #   end
-    class AdHoc < Context
-      def initialize(*args, &initializer)
-        @on_message = Type! initializer.call(*args), Proc
-      end
-
-      def on_message(message)
-        instance_exec message, &@on_message
-      end
-    end
-  end
-end

data/lib/concurrent/actor/utills.rb

@@ -1,7 +0,0 @@
-module Concurrent
-  module Actor
-    module Utils
-      require 'concurrent/actor/utils/broadcast'
-    end
-  end
-end