concurrent-ruby 0.4.1 → 0.5.0.pre.1

data/lib/concurrent/ivar.rb

@@ -0,0 +1,78 @@
+require 'thread'
+
+require 'concurrent/obligation'
+require 'concurrent/copy_on_write_observer_set'
+
+module Concurrent
+
+  MultipleAssignmentError = Class.new(StandardError)
+
+  class IVar
+    include Obligation
+
+    NO_VALUE = Object.new
+
+    # Create a new +Ivar+ in the +:pending+ state with the (optional) initial value.
+    #
+    # @param [Object] value the initial value
+    # @param [Hash] opts the options to create a message with
+    # @option opts [String] :dup_on_deref (false) call +#dup+ before returning the data
+    # @option opts [String] :freeze_on_deref (false) call +#freeze+ before returning the data
+    # @option opts [String] :copy_on_deref (nil) call the given +Proc+ passing the internal value and
+    #   returning the value returned from the proc
+    def initialize(value = NO_VALUE, opts = {})
+      init_obligation
+      @observers = CopyOnWriteObserverSet.new
+      set_deref_options(opts)
+
+      if value == NO_VALUE
+        @state = :pending
+      else
+        set(value)
+      end
+    end
+
+    # Add an observer on this object that will receive notification on update.
+    #
+    # Upon completion the +IVar+ will notify all observers in a thread-say way. The +func+
+    # method of the observer will be called with three arguments: the +Time+ at which the
+    # +Future+ completed the asynchronous operation, the final +value+ (or +nil+ on rejection),
+    # and the final +reason+ (or +nil+ on fulfillment).
+    #
+    # @param [Object] observer the object that will be notified of changes
+    # @param [Symbol] func symbol naming the method to call when this +Observable+ has changes`
+    def add_observer(observer, func = :update)
+      direct_notification = false
+
+      mutex.synchronize do
+        if event.set?
+          direct_notification = true
+        else
+          @observers.add_observer(observer, func)
+        end
+      end
+
+      observer.send(func, Time.now, self.value, reason) if direct_notification
+      func
+    end
+
+    def set(value)
+      complete(true, value, nil)
+    end
+
+    def fail(reason = nil)
+      complete(false, nil, reason)
+    end
+
+    def complete(success, value, reason)
+      mutex.synchronize do
+        raise MultipleAssignmentError.new('multiple assignment') if [:fulfilled, :rejected].include? @state
+        set_state(success, value, reason)
+        event.set
+      end
+
+      time = Time.now
+      @observers.notify_and_delete_observers{ [time, self.value, reason] }
+    end
+  end
+end

data/lib/concurrent/mvar.rb

@@ -0,0 +1,154 @@
+require 'concurrent/dereferenceable'
+require 'concurrent/event'
+
+module Concurrent
+
+  class MVar
+
+    include Dereferenceable
+
+    EMPTY = Object.new
+    TIMEOUT = Object.new
+
+    def initialize(value = EMPTY, opts = {})
+      @value = value
+      @mutex = Mutex.new
+      @empty_condition = Condition.new
+      @full_condition = Condition.new
+      set_deref_options(opts)
+    end
+
+    def take(timeout = nil)
+      @mutex.synchronize do
+        wait_for_full(timeout)
+
+        # If we timed out we'll still be empty
+        if unlocked_full?
+          value = @value
+          @value = EMPTY
+          @empty_condition.signal
+          apply_deref_options(value)
+        else
+          TIMEOUT
+        end
+      end
+    end
+
+    def put(value, timeout = nil)
+      @mutex.synchronize do
+        wait_for_empty(timeout)
+
+        # If we timed out we won't be empty
+        if unlocked_empty?
+          @value = value
+          @full_condition.signal
+          apply_deref_options(value)
+        else
+          TIMEOUT
+        end
+      end
+    end
+
+    def modify(timeout = nil)
+      raise ArgumentError.new('no block given') unless block_given?
+
+      @mutex.synchronize do
+        wait_for_full(timeout)
+
+        # If we timed out we'll still be empty
+        if unlocked_full?
+          value = @value
+          @value = yield value
+          @full_condition.signal
+          apply_deref_options(value)
+        else
+          TIMEOUT
+        end
+      end
+    end
+
+    def try_take!
+      @mutex.synchronize do
+        if unlocked_full?
+          value = @value
+          @value = EMPTY
+          @empty_condition.signal
+          apply_deref_options(value)
+        else
+          EMPTY
+        end
+      end
+    end
+
+    def try_put!(value)
+      @mutex.synchronize do
+        if unlocked_empty?
+          @value = value
+          @full_condition.signal
+          true
+        else
+          false
+        end
+      end
+    end
+
+    def set!(value)
+      @mutex.synchronize do
+        old_value = @value
+        @value = value
+        @full_condition.signal
+        apply_deref_options(old_value)
+      end
+    end
+
+    def modify!
+      raise ArgumentError.new('no block given') unless block_given?
+
+      @mutex.synchronize do
+        value = @value
+        @value = yield value
+        if unlocked_empty?
+          @empty_condition.signal
+        else
+          @full_condition.signal
+        end
+        apply_deref_options(value)
+      end
+    end
+
+    def empty?
+      @mutex.synchronize { @value == EMPTY }
+    end
+
+    def full?
+      not empty?
+    end
+
+    private
+
+    def unlocked_empty?
+      @value == EMPTY
+    end
+
+    def unlocked_full?
+      ! unlocked_empty?
+    end
+
+    def wait_for_full(timeout)
+      wait_while(@full_condition, timeout) { unlocked_empty? }
+    end
+
+    def wait_for_empty(timeout)
+      wait_while(@empty_condition, timeout) { unlocked_full? }
+    end
+
+    def wait_while(condition, timeout)
+      remaining = Condition::Result.new(timeout)
+      while yield && remaining.can_wait?
+        remaining = condition.wait(@mutex, remaining.remaining_time)
+      end
+    end
+
+  end
+
+end

data/lib/concurrent/obligation.rb

@@ -9,31 +9,116 @@ module Concurrent
   module Obligation
     include Dereferenceable
 
-    attr_reader :state
-    attr_reader :reason
-
     # Has the obligation been fulfilled?
     # @return [Boolean]
-    def fulfilled?() return(@state == :fulfilled); end
+    def fulfilled?
+      state == :fulfilled
+    end
     alias_method :realized?, :fulfilled?
 
     # Has the obligation been rejected?
     # @return [Boolean]
-    def rejected?() return(@state == :rejected); end
+    def rejected?
+      state == :rejected
+    end
 
     # Is obligation completion still pending?
     # @return [Boolean]
-    def pending?() return(@state == :pending); end
+    def pending?
+      state == :pending
+    end
+
+    # Is the obligation still unscheduled?
+    # @return [Boolean]
+    def unscheduled?
+      state == :unscheduled
+    end
+
+    def completed?
+      [:fulfilled, :rejected].include? state
+    end
+
+    def incomplete?
+      [:unscheduled, :pending].include? state
+    end
 
     def value(timeout = nil)
-      event.wait(timeout) unless timeout == 0 || @state != :pending
+      event.wait(timeout) if timeout != 0 && incomplete?
       super()
     end
 
+    def state
+      mutex.synchronize { @state }
+    end
+
+    def reason
+      mutex.synchronize { @reason }
+    end
+
     protected
 
-    def event
-      @event ||= Event.new
+    # @!visibility private
+    def init_obligation # :nodoc:
+      init_mutex
+      @event = Event.new
+    end
+
+    # @!visibility private
+    def event # :nodoc:
+      @event
+    end
+
+    # @!visibility private
+    def set_state(success, value, reason) # :nodoc:
+      if success
+        @value = value
+        @state = :fulfilled
+      else
+        @reason = reason
+        @state = :rejected
+      end
+    end
+
+    # @!visibility private
+    def state=(value) # :nodoc:
+      mutex.synchronize { @state = value }
+    end
+
+    # atomic compare and set operation
+    # state is set to next_state only if current state is == expected_current
+    #
+    # @param [Symbol] next_state
+    # @param [Symbol] expected_current
+    # 
+    # @return [Boolean] true is state is changed, false otherwise
+    #
+    # @!visibility private
+    def compare_and_set_state(next_state, expected_current) # :nodoc:
+      mutex.synchronize do
+        if @state == expected_current
+          @state = next_state
+          true
+        else
+          false
+        end
+      end
+    end
+
+    # executes the block within mutex if current state is included in expected_states
+    #
+    # @return block value if executed, false otherwise
+    #
+    # @!visibility private
+    def if_state(*expected_states) # :nodoc:
+      raise ArgumentError.new('no block given') unless block_given?
+
+      mutex.synchronize do
+        if expected_states.include? @state
+          yield
+        else
+          false
+        end
+      end
     end
   end
 end

data/lib/concurrent/postable.rb

@@ -1,3 +1,5 @@
+require 'concurrent/event'
+
 module Concurrent
 
   module Postable
@@ -37,20 +39,20 @@ module Concurrent
       raise ArgumentError.new('empty message') if message.empty?
       return false unless ready?
       queue.push(Package.new(message))
-      return queue.length
+      true
     end
 
     def <<(message)
       post(*message)
-      return self
+      self
     end
 
     def post?(*message)
       raise ArgumentError.new('empty message') if message.empty?
       return nil unless ready?
-      contract = Contract.new
-      queue.push(Package.new(message, contract))
-      return contract
+      ivar = IVar.new
+      queue.push(Package.new(message, ivar))
+      ivar
     end
 
     def post!(seconds, *message)
@@ -77,20 +79,20 @@ module Concurrent
       raise ArgumentError.new('empty message') if message.empty?
       return false unless ready?
       queue.push(Package.new(message, receiver))
-      return queue.length
+      queue.length
     end
 
     def ready?
       if self.respond_to?(:running?) && ! running?
-        return false
+        false
       else
-        return true
+        true
       end
     end
 
     private
 
-    # @private
+    # @!visibility private
     def queue # :nodoc:
       @queue ||= Queue.new
     end

data/lib/concurrent/promise.rb

@@ -9,163 +9,137 @@ module Concurrent
     include Obligation
     include UsesGlobalThreadPool
 
-    # Creates a new promise object. "A promise represents the eventual
-    # value returned from the single completion of an operation."
-    # Promises can be chained in a tree structure where each promise
-    # has zero or more children. Promises are resolved asynchronously
-    # in the order they are added to the tree. Parents are guaranteed
-    # to be resolved before their children. The result of each promise
-    # is passed to each of its children upon resolution. When
-    # a promise is rejected all its children will be summarily rejected.
-    # A promise that is neither resolved or rejected is pending.
-    #
-    # @param args [Array] zero or more arguments for the block
-    # @param block [Proc] the block to call when attempting fulfillment
-    #
     # @see http://wiki.commonjs.org/wiki/Promises/A
     # @see http://promises-aplus.github.io/promises-spec/
-    def initialize(*args, &block)
-      if args.first.is_a?(Promise)
-        @parent = args.first
-      else
-        @parent = nil
-        @chain = [self]
-      end
+    def initialize(options = {}, &block)
+      options.delete_if {|k, v| v.nil?}
+
+      @parent = options.fetch(:parent) { nil }
+      @on_fulfill = options.fetch(:on_fulfill) { Proc.new{ |result| result } }
+      @on_reject = options.fetch(:on_reject) { Proc.new{ |reason| raise reason } }
 
-      @lock = Mutex.new
-      @handler = block || Proc.new{|result| result }
-      @state = :pending
-      @value = nil
-      @reason = nil
-      @rescued = false
+      @promise_body = block || Proc.new{|result| result }
+      @state = :unscheduled
       @children = []
-      @rescuers = []
 
-      init_mutex
-      realize(*args) if root?
+      init_obligation
     end
 
-    def rescued?
-      return @rescued
+    # @return [Promise]
+    def self.fulfill(value)
+      Promise.new.tap { |p| p.send(:synchronized_set_state!, true, value, nil) }
     end
 
-    # Create a new child Promise. The block argument for the child will
-    # be the result of fulfilling its parent. If the child will
-    # immediately be rejected if the parent has already been rejected.
-    #
-    # @param block [Proc] the block to call when attempting fulfillment
-    #
-    # @return [Promise] the new promise
-    def then(&block)
-      child = @lock.synchronize do
-        block = Proc.new{|result| result } if block.nil?
-        @children << Promise.new(self, &block)
-        @children.last.on_reject(@reason) if rejected?
-        push(@children.last)
-        @children.last
-      end
-      return child
-    end
-
-    # Add a rescue handler to be run if the promise is rejected (via raised
-    # exception). Multiple rescue handlers may be added to a Promise.
-    # Rescue blocks will be checked in order and the first one with a
-    # matching Exception class will be processed. The block argument
-    # will be the exception that caused the rejection.
-    #
-    # @param clazz [Class] The class of exception to rescue
-    # @param block [Proc] the block to call if the rescue is matched
-    #
-    # @return [self] so that additional chaining can occur
-    def rescue(clazz = nil, &block)
-      return self if fulfilled? || rescued? || block.nil?
-      @lock.synchronize do
-        rescuer = Rescuer.new(clazz, block)
-        if pending?
-          @rescuers << rescuer
-        else
-          try_rescue(reason, rescuer)
+
+    # @return [Promise]
+    def self.reject(reason)
+      Promise.new.tap { |p| p.send(:synchronized_set_state!, false, nil, reason) }
+    end
+
+    # @return [Promise]
+    # @since 0.5.0
+    def execute
+      if root?
+        if compare_and_set_state(:pending, :unscheduled)
+          set_pending
+          realize(@promise_body)
         end
+      else
+        @parent.execute
       end
-      return self
+      self
+    end
+
+    # @since 0.5.0
+    def self.execute(&block)
+      new(&block).execute
+    end
+
+
+    # @return [Promise] the new promise
+    def then(rescuer = nil, &block)
+      raise ArgumentError.new('rescuers and block are both missing') if rescuer.nil? && !block_given?
+      block = Proc.new{ |result| result } if block.nil?
+      child = Promise.new(parent: self, on_fulfill: block, on_reject: rescuer)
+
+      mutex.synchronize do
+        child.state = :pending if @state == :pending
+        child.on_fulfill(apply_deref_options(@value)) if @state == :fulfilled
+        child.on_reject(@reason) if @state == :rejected
+        @children << child
+      end
+
+      child
+    end
+
+    # @return [Promise]
+    def on_success(&block)
+      raise ArgumentError.new('no block given') unless block_given?
+      self.then &block
+    end
+
+    # @return [Promise]
+    def rescue(&block)
+      self.then(block)
     end
     alias_method :catch, :rescue
     alias_method :on_error, :rescue
 
     protected
 
-    attr_reader :parent
-    attr_reader :handler
-    attr_reader :rescuers
-
-    # @private
-    Rescuer = Struct.new(:clazz, :block)
+    def set_pending
+      mutex.synchronize do
+        @state = :pending
+        @children.each { |c| c.set_pending }
+      end
+    end
 
-    # @private
+    # @!visibility private
     def root? # :nodoc:
       @parent.nil?
     end
 
-    # @private
-    def push(promise) # :nodoc:
-      if root?
-        @chain << promise
-      else
-        @parent.push(promise)
-      end
+    # @!visibility private
+    def on_fulfill(result)
+      realize Proc.new{ @on_fulfill.call(result) }
+      nil
     end
 
-    # @private
-    def on_fulfill(result) # :nodoc:
-      @lock.synchronize do
-        @value = @handler.call(result)
-        @state = :fulfilled
-        @reason = nil
-      end
-      return self.value
+    # @!visibility private
+    def on_reject(reason)
+      realize Proc.new{ @on_reject.call(reason) }
+      nil
     end
 
-    # @private
-    def on_reject(reason) # :nodoc:
-      @value = nil
-      @state = :rejected
-      @reason = reason
-      try_rescue(reason)
-      @children.each{|child| child.on_reject(reason) }
+    def notify_child(child)
+      if_state(:fulfilled) { child.on_fulfill(apply_deref_options(@value)) }
+      if_state(:rejected) { child.on_reject(@reason) }
     end
 
-    # @private
-    def try_rescue(ex, *rescuers) # :nodoc:
-      rescuers = @rescuers if rescuers.empty?
-      rescuer = rescuers.find{|r| r.clazz.nil? || ex.is_a?(r.clazz) }
-      if rescuer
-        rescuer.block.call(ex)
-        @rescued = true
-      end
-    rescue Exception => ex
-      # supress
-    end
-
-    # @private
-    def realize(*args) # :nodoc:
-      Promise.thread_pool.post(@chain, @lock, args) do |chain, lock, args|
-        result = args.length == 1 ? args.first : args
-        index = 0
-        loop do
-          current = lock.synchronize{ chain[index] }
-          unless current.rejected?
-            begin
-              result = current.on_fulfill(result)
-            rescue Exception => ex
-              current.on_reject(ex)
-            ensure
-              event.set
-            end
-          end
-          index += 1
-          Thread.pass while index >= chain.length
+    # @!visibility private
+    def realize(task)
+      Promise.thread_pool.post do
+        success, value, reason = SafeTaskExecutor.new( task ).execute
+
+        children_to_notify = mutex.synchronize do
+          set_state!(success, value, reason)
+          @children.dup
         end
+
+        children_to_notify.each{ |child| notify_child(child) }
       end
     end
+
+    def set_state!(success, value, reason)
+      set_state(success, value, reason)
+      event.set
+    end
+
+    def synchronized_set_state!(success, value, reason)
+      mutex.synchronize do
+        set_state!(success, value, reason)
+      end
+    end
+
   end
 end