concurrent-ruby 0.1.1.pre.5 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d466fea03aa4bbc40ea569433ab79bccd946e175
-  data.tar.gz: f2e0bab0869b00f0da3ca079eea4055bd45412a7
+  metadata.gz: ace46fc451714785036604e4174b57f81ff2f3c6
+  data.tar.gz: f5278235efdd0cc59ae6645aace41c35ef61c8ef
 SHA512:
-  metadata.gz: 51b483f1cdafc31484283d9e294b4a927170b781b289a02b0ffca6aeb0d92ffebe34ea3e391c0a8bb948aa886d68dea61f030d00651fd4e56c54611bb0eaaf72
-  data.tar.gz: 4c5b7114bade4f3627a735d4ed8e1fbd83636609f67805c23de691167f0dfc9658114d1c3380daa348ed5eb6c848b87605174bd324f4cb0492c161c6288db034
+  metadata.gz: 48569321a92ec1304c60d425af98412f56dad24ce4fa6c17b149fa18cf40221df320a95ed806196a017a8f521c3d935433b02b626901ec28de5bac5ddcf92332
+  data.tar.gz: f5731e01e2a559c25d92d11f9c9693fafd8219aa681711962dc8d777a46198fb3e3c0d97e26461d4e4d05e3aad8c8cf8b6aee17fbb31441c83fb36bcc91da920

data/README.md

@@ -55,7 +55,6 @@ Several features from Erlang, Go, Clojure, Java, and JavaScript have been implem
 * Go inspired [Goroutine](https://github.com/jdantonio/concurrent-ruby/blob/master/md/goroutine.md)
 * JavaScript inspired [Promise](https://github.com/jdantonio/concurrent-ruby/blob/master/md/promise.md)
 * Java inspired [Thread Pools](https://github.com/jdantonio/concurrent-ruby/blob/master/md/thread_pool.md)
-* Scheduled task execution with the [Executor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/executor.md) service
 
 ### Is it any good?
 
@@ -63,11 +62,7 @@ Several features from Erlang, Go, Clojure, Java, and JavaScript have been implem
 
 ### Supported Ruby versions
 
-MRI 1.9.2, 1.9.3, and 2.0. This library is pure Ruby and has minimal gem dependencies. It should be
-fully compatible with any Ruby interpreter that is 1.9.x compliant. I simply don't know enough
-about JRuby, Rubinius, or the others to fully support them. I can promise good karma and
-attribution on this page to anyone wishing to take responsibility for verifying compaitibility
-with any Ruby other than MRI.
+Optimized for and tested under MRI Ruby 1.9.x and 2.0.
 
 ### Install
 
@@ -89,25 +84,6 @@ Once you've installed the gem you must `require` it in your project:
 require 'concurrent'
 ```
 
-### Kernel Methods
-
-Many Ruby developers consider it bad form to add function to the global (Kernel) namespace.
-I don't necessarily agree. If the function acts like a low-level feature of the language
-I think it is OK to add the method to the `Kernel` module. To support my personal programming
-style I have chosen to implement `Kernel` methods to instance many of the objects in this
-library. Out of respect for the larger Ruby community I have made these methods optional.
-They are not imported with the normal `require 'concurrent'` directive. To import these
-functions you must import the `concurrent/functions` library.
-
-```ruby
-require 'concurrent'
-score = agent(10) #=> NoMethodError: undefined method `agent' for main:Object
-
-require 'concurrent/functions'
-score = agent(10) #=> #<Concurrent::Agent:0x35b2b28 ...
-score.value #=> 10
-```
-
 ### Examples
 
 For complete examples, see the specific documentation linked above. Below are a few examples to whet your appetite.
@@ -127,7 +103,6 @@ sleep(0.1)
 
 ```ruby
 require 'concurrent'
-require 'concurrent/functions'
 
 score = agent(10)
 score.value #=> 10
@@ -149,7 +124,6 @@ score.value #=> 170
 
 ```ruby
 require 'concurrent'
-require 'concurrent/functions'
 
 Concurrent::Defer.new{ "Jerry D'Antonio" }.
                   then{|result| puts "Hello, #{result}!" }.
@@ -171,7 +145,6 @@ sleep(0.1)
 
 ```ruby
 require 'concurrent'
-require 'concurrent/functions'
 
 count = future{ sleep(1); 10 }
 count.state #=> :pending
@@ -184,7 +157,6 @@ deref count #=> 10
 
 ```ruby
 require 'concurrent'
-require 'concurrent/functions'
 
 p = promise("Jerry", "D'Antonio"){|a, b| "#{a} #{b}" }.
     then{|result| "Hello #{result}." }.
@@ -218,25 +190,6 @@ sleep(1)
 @expected #=> 30
 ```
 
-#### Executor
-
-```ruby
-require 'concurrent'
-
-ec = Concurrent::Executor.run('Foo'){ puts 'Boom!' }
-
-ec.name               #=> "Foo"
-ec.execution_interval #=> 60 == Concurrent::Executor::EXECUTION_INTERVAL
-ec.timeout_interval   #=> 30 == Concurrent::Executor::TIMEOUT_INTERVAL
-ec.status             #=> "sleep"
-
-# wait 60 seconds...
-#=> 'Boom!'
-#=> ' INFO (2013-08-02 23:20:15) Foo: execution completed successfully'
-
-ec.kill #=> true
-```
-
 ## Contributing
 
 1. Fork it

data/lib/concurrent.rb

@@ -6,21 +6,15 @@ require 'concurrent/event'
 
 require 'concurrent/agent'
 require 'concurrent/defer'
-require 'concurrent/executor'
 require 'concurrent/future'
 require 'concurrent/goroutine'
 require 'concurrent/promise'
 require 'concurrent/obligation'
 require 'concurrent/utilities'
 
-require 'concurrent/reactor'
-require 'concurrent/reactor/drb_async_demux'
-require 'concurrent/reactor/tcp_sync_demux'
-
 require 'concurrent/thread_pool'
 require 'concurrent/cached_thread_pool'
 require 'concurrent/fixed_thread_pool'
-require 'concurrent/null_thread_pool'
 
 require 'concurrent/global_thread_pool'
 

data/lib/concurrent/agent.rb

@@ -14,7 +14,6 @@ module Concurrent
   # A good example of an agent is a shared incrementing counter, such as the score in a video game.
   class Agent
     include Observable
-    include UsesGlobalThreadPool
 
     TIMEOUT = 5
 
@@ -27,20 +26,15 @@ module Concurrent
       @rescuers = []
       @validator = nil
       @queue = Queue.new
-      @mutex = Mutex.new
 
-      Agent.thread_pool.post{ work }
+      $GLOBAL_THREAD_POOL << proc{ work }
     end
 
     def value(timeout = 0) return @value; end
     alias_method :deref, :value
 
     def rescue(clazz = Exception, &block)
-      if block_given?
-        @mutex.synchronize do
-          @rescuers << Rescuer.new(clazz, block)
-        end
-      end
+      @rescuers << Rescuer.new(clazz, block) if block_given?
       return self
     end
     alias_method :catch, :rescue
@@ -56,10 +50,10 @@ module Concurrent
 
     def post(&block)
       return @queue.length unless block_given?
-      return @mutex.synchronize do
+      return atomic {
         @queue << block
         @queue.length
-      end
+      }
     end
 
     def <<(block)
@@ -68,7 +62,7 @@ module Concurrent
     end
 
     def length
-      return @queue.length
+      @queue.length
     end
     alias_method :size, :length
     alias_method :count, :length
@@ -82,9 +76,7 @@ module Concurrent
 
     # @private
     def try_rescue(ex) # :nodoc:
-      rescuer = @mutex.synchronize do
-        @rescuers.find{|r| ex.is_a?(r.clazz) }
-      end
+      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
       rescuer.block.call(ex) if rescuer
     rescue Exception => e
       # supress
@@ -93,17 +85,18 @@ module Concurrent
     # @private
     def work # :nodoc:
       loop do
+        Thread.pass
         handler = @queue.pop
         begin
-          result = Timeout.timeout(@timeout) do
+          result = Timeout.timeout(@timeout){
             handler.call(@value)
-          end
+          }
           if @validator.nil? || @validator.call(result)
-            @mutex.synchronize do
+            atomic {
               @value = result
               changed
-              notify_observers(Time.now, @value)
-            end
+            }
+            notify_observers(Time.now, @value)
           end
         rescue Exception => ex
           try_rescue(ex)
@@ -112,3 +105,31 @@ module Concurrent
     end
   end
 end
+
+module Kernel
+
+  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
+    return Concurrent::Agent.new(initial, timeout)
+  end
+  module_function :agent
+
+  def deref(agent, timeout = nil)
+    if agent.respond_to?(:deref)
+      return agent.deref(timeout)
+    elsif agent.respond_to?(:value)
+      return agent.deref(timeout)
+    else
+      return nil
+    end
+  end
+  module_function :deref
+
+  def post(agent, &block)
+    if agent.respond_to?(:post)
+      return agent.post(&block)
+    else
+      return nil
+    end
+  end
+  module_function :deref
+end

data/lib/concurrent/cached_thread_pool.rb

@@ -24,11 +24,12 @@ module Concurrent
       @thread_idletime = (opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME).freeze
       super()
       @working = 0
+      @mutex = Mutex.new
     end
 
     def kill
       @status = :killed
-      mutex.synchronize do
+      @mutex.synchronize do
         @pool.each{|t| Thread.kill(t.thread) }
       end
     end
@@ -41,7 +42,7 @@ module Concurrent
       raise ArgumentError.new('no block given') unless block_given?
       if running?
         collect_garbage if @pool.empty?
-        mutex.synchronize do
+        @mutex.synchronize do
           if @working >= @pool.length
             create_worker_thread
           end
@@ -55,7 +56,7 @@ module Concurrent
 
     # @private
     def status # :nodoc:
-      mutex.synchronize do
+      @mutex.synchronize do
         @pool.collect do |worker|
           [
             worker.status,
@@ -79,31 +80,31 @@ module Concurrent
         loop do
           task = @queue.pop
 
-          mutex.synchronize do
+          atomic {
             @working += 1
             me.status = :working
-          end
+          }
 
           if task == :stop
             me.status = :stopping
             break
           else
             task.last.call(*task.first)
-            mutex.synchronize do
+            atomic {
               @working -= 1
               me.status = :idle
               me.idletime = timestamp
-            end
+            }
           end
         end
 
-        mutex.synchronize do
+        atomic {
           @pool.delete(me)
           if @pool.empty?
             @termination.set
             @status = :shutdown unless killed?
           end
-        end
+        }
       end
 
       @pool << worker
@@ -114,7 +115,7 @@ module Concurrent
       @collector = Thread.new do
         loop do
           sleep(@gc_interval)
-          mutex.synchronize do
+          @mutex.synchronize do
             @pool.reject! do |worker|
               worker.thread.status.nil? ||
                 (worker.status == :idle && @thread_idletime >= delta(worker.idletime, timestamp))

data/lib/concurrent/defer.rb

@@ -7,18 +7,14 @@ module Concurrent
   IllegalMethodCallError = Class.new(StandardError)
 
   class Defer
-    include UsesGlobalThreadPool
-
-    def initialize(opts = {}, &block)
-      operation = opts[:op] || opts[:operation]
-      @callback = opts[:cback] || opts[:callback]
-      @errorback = opts[:eback] || opts[:error] || opts[:errorback]
-      thread_pool = opts[:pool] || opts[:thread_pool]
 
+    def initialize(operation = nil, callback = nil, errorback = nil, &block)
       raise ArgumentError.new('no operation given') if operation.nil? && ! block_given?
       raise ArgumentError.new('two operations given') if ! operation.nil? && block_given?
 
       @operation = operation || block
+      @callback = callback
+      @errorback = errorback
 
       if operation.nil?
         @running = false
@@ -48,7 +44,7 @@ module Concurrent
     def go
       return nil if @running
       @running = true
-      Defer.thread_pool.post { fulfill }
+      $GLOBAL_THREAD_POOL.post { Thread.pass; fulfill }
       return nil
     end
 
@@ -63,3 +59,11 @@ module Concurrent
     end
   end
 end
+
+module Kernel
+
+  def defer(*args, &block)
+    return Concurrent::Defer.new(*args, &block)
+  end
+  module_function :defer
+end

data/lib/concurrent/fixed_thread_pool.rb

@@ -26,10 +26,8 @@ module Concurrent
     end
 
     def kill
-      mutex.synchronize do
-        @status = :killed
-        @pool.each{|t| Thread.kill(t) }
-      end
+      @status = :killed
+      @pool.each{|t| Thread.kill(t) }
     end
 
     def size
@@ -52,9 +50,7 @@ module Concurrent
 
     # @private
     def status # :nodoc:
-      mutex.synchronize do
-        @pool.collect{|t| t.status }
-      end
+      @pool.collect{|t| t.status }
     end
 
     private
@@ -82,11 +78,9 @@ module Concurrent
     def collect_garbage # :nodoc:
       @collector = Thread.new do
         sleep(1)
-        mutex.synchronize do
-          @pool.size.times do |i|
-            if @pool[i].status.nil?
-              @pool[i] = create_worker_thread
-            end
+        @pool.size.times do |i|
+          if @pool[i].status.nil?
+            @pool[i] = create_worker_thread
           end
         end
       end

data/lib/concurrent/future.rb

@@ -8,17 +8,17 @@ module Concurrent
 
   class Future
     include Obligation
-    include UsesGlobalThreadPool
-
     behavior(:future)
 
     def initialize(*args, &block)
+
       unless block_given?
         @state = :fulfilled
       else
         @value = nil
         @state = :pending
-        Future.thread_pool.post(*args) do
+        $GLOBAL_THREAD_POOL.post do
+          Thread.pass
           work(*args, &block)
         end
       end
@@ -28,15 +28,27 @@ module Concurrent
 
     # @private
     def work(*args) # :nodoc:
-      mutex.synchronize do
+      semaphore.synchronize do
         begin
-          @value = yield(*args)
-          @state = :fulfilled
+          atomic {
+            @value = yield(*args)
+            @state = :fulfilled
+          }
         rescue Exception => ex
-          @state = :rejected
-          @reason = ex
+          atomic {
+            @state = :rejected
+            @reason = ex
+          }
         end
       end
     end
   end
 end
+
+module Kernel
+
+  def future(*args, &block)
+    return Concurrent::Future.new(*args, &block)
+  end
+  module_function :future
+end