concurrent-ruby 0.7.0.rc1-x64-mingw32 → 0.7.0.rc2-x64-mingw32

data/lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -9,7 +9,7 @@ module Concurrent
     include Concurrent::AtomicDirectUpdate
     include Concurrent::AtomicNumericCompareAndSetWrapper
 
-    # @!macro atomic_reference_method_initialize
+    # @!macro [attach] atomic_reference_method_initialize
     def initialize(value = nil)
       @mutex = Mutex.new
       @value = value

data/lib/concurrent/atomic_reference/ruby.rb

@@ -14,5 +14,20 @@ 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
 end

data/lib/concurrent/atomics.rb

@@ -8,3 +8,4 @@ require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'
 require 'concurrent/atomic/thread_local_var'
+require 'concurrent/atomic/synchronization'

data/lib/concurrent/channel/unbuffered_channel.rb

@@ -12,6 +12,7 @@ module Concurrent
     end
 
     def push(value)
+      # TODO set_unless_assigned define on IVar as #set_state? or #try_set_state
       until @probe_set.take.set_unless_assigned(value, self)
       end
     end
@@ -31,4 +32,4 @@ module Concurrent
     end
 
   end
-end
+end

data/lib/concurrent/configuration.rb

@@ -2,6 +2,7 @@ require 'thread'
 require 'concurrent/delay'
 require 'concurrent/errors'
 require 'concurrent/atomic'
+require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
 require 'concurrent/utility/processor_count'
@@ -18,9 +19,10 @@ module Concurrent
 
     # Create a new configuration object.
     def initialize
-      @global_task_pool      = Delay.new { new_task_pool }
-      @global_operation_pool = Delay.new { new_operation_pool }
-      @global_timer_set      = Delay.new { Concurrent::TimerSet.new }
+      immediate_executor     = ImmediateExecutor.new
+      @global_task_pool      = Delay.new(executor: immediate_executor) { new_task_pool }
+      @global_operation_pool = Delay.new(executor: immediate_executor) { new_operation_pool }
+      @global_timer_set      = Delay.new(executor: immediate_executor) { Concurrent::TimerSet.new }
       @logger                = no_logger
     end
 
@@ -154,5 +156,6 @@ module Concurrent
     self.finalize_executor(self.configuration.global_timer_set)
     self.finalize_executor(self.configuration.global_task_pool)
     self.finalize_executor(self.configuration.global_operation_pool)
+    # TODO may break other test suites using concurrent-ruby, terminates before test is run
   end
 end

data/lib/concurrent/dataflow.rb

@@ -61,17 +61,34 @@ module Concurrent
   # @raise [ArgumentError] if no block is given
   # @raise [ArgumentError] if any of the inputs are not `IVar`s
   def dataflow(*inputs, &block)
-    dataflow_with(Concurrent.configuration.global_task_pool, *inputs, &block)
+    dataflow_with(Concurrent.configuration.global_operation_pool, *inputs, &block)
   end
   module_function :dataflow
 
   def dataflow_with(executor, *inputs, &block)
+    call_dataflow(:value, executor, *inputs, &block)
+  end
+  module_function :dataflow_with
+  
+  def dataflow!(*inputs, &block)
+    dataflow_with!(Concurrent.configuration.global_task_pool, *inputs, &block)
+  end
+  module_function :dataflow!
+
+  def dataflow_with!(executor, *inputs, &block)
+    call_dataflow(:value!, executor, *inputs, &block)
+  end
+  module_function :dataflow_with!
+
+  private 
+
+  def call_dataflow(method, executor, *inputs, &block)
     raise ArgumentError.new('an executor must be provided') if executor.nil?
     raise ArgumentError.new('no block given') unless block_given?
     raise ArgumentError.new('not all dependencies are IVars') unless inputs.all? { |input| input.is_a? IVar }
 
     result = Future.new(executor: executor) do
-      values = inputs.map { |input| input.value }
+      values = inputs.map { |input| input.send(method) }
       block.call(*values)
     end
 
@@ -87,5 +104,5 @@ module Concurrent
 
     result
   end
-  module_function :dataflow_with
+  module_function :call_dataflow
 end

data/lib/concurrent/delay.rb

@@ -1,5 +1,6 @@
 require 'thread'
 require 'concurrent/obligation'
+require 'concurrent/options_parser'
 
 module Concurrent
 
@@ -51,32 +52,13 @@ module Concurrent
       @state = :pending
       @task  = block
       set_deref_options(opts)
+      @task_executor = OptionsParser.get_task_executor_from(opts)
+      @computing     = false
     end
 
-    # Return the (possibly memoized) value of the delayed operation.
-    # 
-    # If the state is `:pending` then the calling thread will block while the
-    # operation is performed. All other threads simultaneously calling `#value`
-    # will block as well. Once the operation is complete (either `:fulfilled` or
-    # `:rejected`) all waiting threads will unblock and the new value will be
-    # returned.
-    #
-    # If the state is not `:pending` when `#value` is called the (possibly memoized)
-    # value will be returned without blocking and without performing the operation
-    # again.
-    #
-    # Regardless of the final disposition all `Dereferenceable` options set during
-    # object construction will be honored.
-    #
-    # @return [Object] the (possibly memoized) result of the block operation
-    #
-    # @see Concurrent::Dereferenceable
-    def value
-      mutex.lock
+    def wait(timeout)
       execute_task_once
-      apply_deref_options(@value)
-    ensure
-      mutex.unlock
+      super timeout
     end
 
     # reconfigures the block returning the value if still #incomplete?
@@ -85,7 +67,7 @@ module Concurrent
     def reconfigure(&block)
       mutex.lock
       raise ArgumentError.new('no block given') unless block_given?
-      if @state == :pending
+      unless @computing
         @task = block
         true
       else
@@ -98,13 +80,23 @@ module Concurrent
     private
 
     def execute_task_once
-      if @state == :pending
-        begin
-          @value = @task.call
-          @state = :fulfilled
-        rescue => ex
-          @reason = ex
-          @state  = :rejected
+      mutex.lock
+      execute = @computing = true unless @computing
+      task    = @task
+      mutex.unlock
+
+      if execute
+        @task_executor.post do
+          begin
+            result  = task.call
+            success = true
+          rescue => ex
+            reason = ex
+          end
+          mutex.lock
+          set_state success, result, reason
+          event.set
+          mutex.unlock
         end
       end
     end

data/lib/concurrent/executor/executor.rb

@@ -250,8 +250,13 @@ module Concurrent
       end
 
       # @!macro executor_method_wait_for_termination
-      def wait_for_termination(timeout)
-        @executor.awaitTermination(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+      def wait_for_termination(timeout = nil)
+        if timeout.nil?
+          ok = @executor.awaitTermination(60, java.util.concurrent.TimeUnit::SECONDS) until ok
+          true
+        else
+          @executor.awaitTermination(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+        end
       end
 
       # @!macro executor_method_shutdown

data/lib/concurrent/executor/timer_set.rb

@@ -23,7 +23,7 @@ module Concurrent
     #   this executor rather than the global thread pool (overrides :operation)
     def initialize(opts = {})
       @queue = PriorityQueue.new(order: :min)
-      @task_executor = OptionsParser::get_executor_from(opts)
+      @task_executor = OptionsParser::get_executor_from(opts) || Concurrent.configuration.global_task_pool
       @timer_executor = SingleThreadExecutor.new
       @condition = Condition.new
       init_executor

data/lib/concurrent/future.rb

@@ -1,6 +1,7 @@
 require 'thread'
 
 require 'concurrent/options_parser'
+require 'concurrent/ivar'
 require 'concurrent/executor/safe_task_executor'
 
 module Concurrent
@@ -61,7 +62,7 @@ module Concurrent
       super(IVar::NO_VALUE, opts)
       @state = :unscheduled
       @task = block
-      @executor = OptionsParser::get_executor_from(opts)
+      @executor = OptionsParser::get_executor_from(opts) || Concurrent.configuration.global_operation_pool
     end
 
     # Execute an `:unscheduled` `Future`. Immediately sets the state to `:pending` and

data/lib/concurrent/lazy_register.rb

@@ -0,0 +1,58 @@
+require 'concurrent/atomic'
+require 'concurrent/delay'
+
+
+module Concurrent
+  # Allows to store lazy evaluated values under keys. Uses `Delay`s.
+  # @example
+  #     register = Concurrent::LazyRegister.new
+  #     #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @data=#<Concurrent::Atomic:0x007fd7ecd5e1e0>>
+  #     register[:key]
+  #     #=> nil
+  #     register.add(:key) { Concurrent::Actor.spawn!(Actor::AdHoc, :ping) { -> message { message } } }
+  #     #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @data=#<Concurrent::Atomic:0x007fd7ecd5e1e0>>
+  #     register[:key]
+  #     #=> #<Concurrent::Actor::Reference /ping (Concurrent::Actor::AdHoc)>
+  class LazyRegister
+    def initialize
+      @data = Atomic.new Hash.new
+    end
+
+    # @param [Object] key
+    # @return value stored under the key
+    # @raise Exception when the initialization block fails
+    def [](key)
+      delay = @data.get[key]
+      delay.value! if delay
+    end
+
+    # @param [Object] key
+    # @return [true, false] if the key is registered
+    def registered?(key)
+      @data.get.key? key
+    end
+
+    alias_method :key?, :registered?
+
+    # @param [Object] key
+    # @yield the object to store under the key
+    # @return self
+    def register(key, &block)
+      delay = Delay.new(&block)
+      @data.update { |h| h.merge key => delay }
+      self
+    end
+
+    alias_method :add, :register
+
+    # Un-registers the object under key, realized or not
+    # @return self
+    # @param [Object] key
+    def unregister(key)
+      @data.update { |h| h.dup.tap { |h| h.delete(key) } }
+      self
+    end
+
+    alias_method :remove, :unregister
+  end
+end

data/lib/concurrent/options_parser.rb

@@ -10,14 +10,16 @@ module Concurrent
     # @option opts [Boolean] :operation (`false`) when true use the global operation pool
     # @option opts [Boolean] :task (`true`) when true use the global task pool
     #
-    # @return [Executor] the requested thread pool (default: global task pool)
+    # @return [Executor, nil] the requested thread pool, or nil when no option specified
     def get_executor_from(opts = {})
       if opts[:executor]
         opts[:executor]
       elsif opts[:operation] == true || opts[:task] == false
         Concurrent.configuration.global_operation_pool
-      else
+      elsif opts[:operation] == false || opts[:task] == true
         Concurrent.configuration.global_task_pool
+      else
+        nil
       end
     end
 

data/lib/concurrent/promise.rb

@@ -5,6 +5,7 @@ require 'concurrent/options_parser'
 
 module Concurrent
 
+  # TODO unify promise and future to single class, with dataflow
   class Promise
     include Obligation
 
@@ -32,7 +33,7 @@ module Concurrent
     def initialize(opts = {}, &block)
       opts.delete_if { |k, v| v.nil? }
 
-      @executor = OptionsParser::get_executor_from(opts)
+      @executor = OptionsParser::get_executor_from(opts) || Concurrent.configuration.global_operation_pool
       @parent = opts.fetch(:parent) { nil }
       @on_fulfill = opts.fetch(:on_fulfill) { Proc.new { |result| result } }
       @on_reject = opts.fetch(:on_reject) { Proc.new { |reason| raise reason } }

data/lib/concurrent/scheduled_task.rb

@@ -15,16 +15,17 @@ module Concurrent
       super(NO_VALUE, opts)
 
       self.observers = CopyOnNotifyObserverSet.new
-      @intended_time =  intended_time
-      @state = :unscheduled
-      @task = block
+      @intended_time = intended_time
+      @state         = :unscheduled
+      @task          = block
+      @executor      = OptionsParser::get_executor_from(opts) || Concurrent.configuration.global_operation_pool
     end
 
     # @since 0.5.0
     def execute
       if compare_and_set_state(:pending, :unscheduled)
         @schedule_time = TimerSet.calculate_schedule_time(@intended_time)
-        Concurrent::timer(@schedule_time.to_f - Time.now.to_f, &method(:process_task))
+        Concurrent::timer(@schedule_time.to_f - Time.now.to_f) { @executor.post &method(:process_task) }
         self
       end
     end
@@ -71,7 +72,7 @@ module Concurrent
         end
 
         time = Time.now
-        observers.notify_and_delete_observers{ [time, self.value, reason] }
+        observers.notify_and_delete_observers { [time, self.value, reason] }
       end
     end
   end

data/lib/concurrent/tvar.rb

@@ -1,7 +1,5 @@
 require 'set'
 
-require 'concurrent/atomic/thread_local_var'
-
 module Concurrent
 
   # A `TVar` is a transactional variable - a single-element container that
@@ -97,7 +95,7 @@ module Concurrent
 
       begin
         # Retry loop
-        
+
         loop do
 
           # Create a new transaction
@@ -149,8 +147,6 @@ module Concurrent
 
     ABORTED = Object.new
 
-    CURRENT_TRANSACTION = ThreadLocalVar.new(nil)
-
     ReadLogEntry = Struct.new(:tvar, :version)
     UndoLogEntry = Struct.new(:tvar, :value)
 
@@ -158,8 +154,8 @@ module Concurrent
 
     def initialize
       @write_set = Set.new
-      @read_log = []
-      @undo_log = []
+      @read_log  = []
+      @undo_log  = []
     end
 
     def read(tvar)
@@ -217,7 +213,7 @@ module Concurrent
       end
 
       unlock
-      
+
       true
     end
 
@@ -240,11 +236,11 @@ module Concurrent
     end
 
     def self.current
-      CURRENT_TRANSACTION.value
+      Thread.current[:current_tvar_transaction]
     end
 
     def self.current=(transaction)
-      CURRENT_TRANSACTION.value = transaction
+      Thread.current[:current_tvar_transaction] = transaction
     end
 
   end

data/lib/concurrent/utility/processor_count.rb

@@ -1,12 +1,14 @@
 require 'rbconfig'
 require 'concurrent/delay'
+require 'concurrent/executor/immediate_executor'
 
 module Concurrent
 
   class ProcessorCounter
     def initialize
-      @processor_count          = Delay.new { compute_processor_count }
-      @physical_processor_count = Delay.new { compute_physical_processor_count }
+      immediate_executor        = ImmediateExecutor.new
+      @processor_count          = Delay.new(executor: immediate_executor) { compute_processor_count }
+      @physical_processor_count = Delay.new(executor: immediate_executor) { compute_physical_processor_count }
     end
 
     # Number of processors seen by the OS and used for process scheduling. For performance