concurrent-ruby 0.0.1 → 0.1.0

data/lib/concurrent/defer.rb

@@ -0,0 +1,69 @@
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  IllegalMethodCallError = Class.new(StandardError)
+
+  class Defer
+
+    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
+      else
+        self.go
+      end
+    end
+
+    def then(&block)
+      raise IllegalMethodCallError.new('a callback has already been provided') unless @callback.nil?
+      raise IllegalMethodCallError.new('the defer is already running') if @running
+      raise ArgumentError.new('no block given') unless block_given?
+      @callback = block
+      return self
+    end
+
+    def rescue(&block)
+      raise IllegalMethodCallError.new('a errorback has already been provided') unless @errorback.nil?
+      raise IllegalMethodCallError.new('the defer is already running') if @running
+      raise ArgumentError.new('no block given') unless block_given?
+      @errorback = block
+      return self
+    end
+    alias_method :catch, :rescue
+    alias_method :on_error, :rescue
+
+    def go
+      return nil if @running
+      @running = true
+      $GLOBAL_THREAD_POOL.post { fulfill }
+      return nil
+    end
+
+    private
+
+    # @private
+    def fulfill # :nodoc:
+      result = @operation.call
+      @callback.call(result) unless @callback.nil?
+    rescue Exception => ex
+      @errorback.call(ex) unless @errorback.nil?
+    end
+  end
+end
+
+module Kernel
+
+  def defer(*args, &block)
+    return Concurrent::Defer.new(*args, &block)
+  end
+  module_function :defer
+end

data/lib/concurrent/event.rb

@@ -0,0 +1,60 @@
+require 'thread'
+require 'timeout'
+
+module Concurrent
+
+  class Event
+
+    def initialize
+      @set = false
+      @notifier = Queue.new
+      @mutex = Mutex.new
+      @waiting = 0
+    end
+
+    def set?
+      return @set == true
+    end
+
+    def set(pulse = false)
+      return true if set?
+      @mutex.synchronize {
+        @set = true
+        while @waiting > 0
+          @notifier << :set
+          @waiting -= 1
+        end
+        @set = ! pulse
+      }
+      return true
+    end
+
+    def reset
+      @mutex.synchronize {
+        @set = false
+      }
+      return true
+    end
+
+    def pulse
+      return set(true)
+    end
+
+    def wait(timeout = nil)
+      return true if set?
+
+      if timeout.nil?
+        @waiting += 1
+        @notifier.pop
+      else
+        Timeout::timeout(timeout) do
+          @waiting += 1
+          @notifier.pop
+        end
+      end
+      return true
+    rescue Timeout::Error
+      return false
+    end
+  end
+end

data/lib/concurrent/event_machine_defer_proxy.rb

@@ -0,0 +1,23 @@
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  class EventMachineDeferProxy
+    behavior(:global_thread_pool)
+
+    def post(*args, &block)
+      if args.empty?
+        EventMachine.defer(block)
+      else
+        new_block = proc{ block.call(*args) }
+        EventMachine.defer(new_block)
+      end
+      return true
+    end
+
+    def <<(block)
+      EventMachine.defer(block)
+      return self
+    end
+  end
+end

data/lib/concurrent/fixed_thread_pool.rb

@@ -0,0 +1,89 @@
+require 'thread'
+
+require 'concurrent/thread_pool'
+require 'concurrent/event'
+
+module Concurrent
+
+  def self.new_fixed_thread_pool(size)
+    return FixedThreadPool.new(size)
+  end
+
+  class FixedThreadPool < ThreadPool
+    behavior(:thread_pool)
+
+    MIN_POOL_SIZE = 1
+    MAX_POOL_SIZE = 1024
+
+    def initialize(size)
+      super()
+      if size < MIN_POOL_SIZE || size > MAX_POOL_SIZE
+        raise ArgumentError.new("size must be between #{MIN_POOL_SIZE} and #{MAX_POOL_SIZE}")
+      end
+
+      @pool = size.times.collect{ create_worker_thread }
+      collect_garbage
+    end
+
+    def kill
+      @status = :killed
+      @pool.each{|t| Thread.kill(t) }
+    end
+
+    def size
+      if running?
+        return @pool.length
+      else
+        return 0
+      end
+    end
+
+    def post(*args, &block)
+      raise ArgumentError.new('no block given') unless block_given?
+      if running?
+        @queue << [args, block]
+        return true
+      else
+        return false
+      end
+    end
+
+    # @private
+    def status # :nodoc:
+      @pool.collect{|t| t.status }
+    end
+
+    private
+
+    # @private
+    def create_worker_thread # :nodoc:
+      Thread.new do
+        loop do
+          task = @queue.pop
+          if task == :stop
+            break
+          else
+            task.last.call(*task.first)
+          end
+        end
+        @pool.delete(Thread.current)
+        if @pool.empty?
+          @termination.set
+          @status = :shutdown unless killed?
+        end
+      end
+    end
+
+    # @private
+    def collect_garbage # :nodoc:
+      @collector = Thread.new do
+        sleep(1)
+        @pool.size.times do |i|
+          if @pool[i].status.nil?
+            @pool[i] = create_worker_thread
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/future.rb

@@ -0,0 +1,42 @@
+require 'thread'
+
+require 'concurrent/obligation'
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  class Future
+    include Obligation
+    behavior(:future)
+
+    def initialize(*args)
+
+      unless block_given?
+        @state = :fulfilled
+      else
+        @value = nil
+        @state = :pending
+        $GLOBAL_THREAD_POOL.post do
+          semaphore.synchronize do
+            Thread.pass
+            begin
+              @value = yield(*args)
+              @state = :fulfilled
+            rescue Exception => ex
+              @state = :rejected
+              @reason = ex
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module Kernel
+
+  def future(*args, &block)
+    return Concurrent::Future.new(*args, &block)
+  end
+  module_function :future
+end

data/lib/concurrent/global_thread_pool.rb

@@ -0,0 +1,3 @@
+require 'concurrent/cached_thread_pool'
+
+$GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new

data/lib/concurrent/goroutine.rb

@@ -0,0 +1,25 @@
+require 'thread'
+
+require 'concurrent/global_thread_pool'
+
+module Kernel
+
+  # Post the given agruments and block to the Global Thread Pool.
+  #
+  # @param args [Array] zero or more arguments for the block
+  # @param block [Proc] operation to be performed concurrently
+  #
+  # @return [true,false] success/failre of thread creation
+  #
+  # @note Althought based on Go's goroutines and Erlang's spawn/1,
+  # Ruby has a vastly different runtime. Threads aren't nearly as
+  # efficient in Ruby. Use this function appropriately.
+  #
+  # @see http://golang.org/doc/effective_go.html#goroutines
+  # @see https://gobyexample.com/goroutines
+  def go(*args, &block)
+    return false unless block_given?
+    $GLOBAL_THREAD_POOL.post(*args, &block)
+  end
+  module_function :go
+end

data/lib/concurrent/obligation.rb

@@ -0,0 +1,121 @@
+require 'thread'
+require 'timeout'
+
+require 'functional/behavior'
+
+behavior_info(:future,
+              state: 0,
+              value: -1,
+              reason: 0,
+              pending?: 0,
+              fulfilled?: 0,
+              rejected?: 0)
+
+behavior_info(:promise,
+              state: 0,
+              value: -1,
+              reason: 0,
+              pending?: 0,
+              fulfilled?: 0,
+              rejected?: 0,
+              then: 0,
+              rescue: -1)
+
+module Concurrent
+
+  module Obligation
+
+    attr_reader :state
+    attr_reader :reason
+
+    # Has the obligation been fulfilled?
+    # @return [Boolean]
+    def fulfilled?() return(@state == :fulfilled); end
+    alias_method :realized?, :fulfilled?
+
+    # Is obligation completion still pending?
+    # @return [Boolean]
+    def pending?() return(!(fulfilled? || rejected?)); end
+
+    def value(timeout = nil)
+      if !pending? || timeout == 0
+        return @value
+      elsif timeout.nil?
+        return semaphore.synchronize { @value }
+      else
+        begin
+          return Timeout::timeout(timeout.to_f) {
+            semaphore.synchronize { @value }
+          }
+        rescue Timeout::Error => ex
+          return nil
+        end
+      end
+    end
+    alias_method :deref, :value
+
+    # Has the promise been rejected?
+    # @return [Boolean]
+    def rejected?() return(@state == :rejected); end
+
+    protected
+
+    def semaphore
+      @semaphore ||= Mutex.new
+    end
+  end
+end
+
+module Kernel
+
+  def deref(obligation, timeout = nil)
+    if obligation.respond_to?(:deref)
+      return obligation.deref(timeout)
+    elsif obligation.respond_to?(:value)
+      return obligation.deref(timeout)
+    else
+      return nil
+    end
+  end
+  module_function :deref
+
+  def pending?(obligation)
+    if obligation.respond_to?(:pending?)
+      return obligation.pending?
+    else
+      return false
+    end
+  end
+  module_function :pending?
+
+  def fulfilled?(obligation)
+    if obligation.respond_to?(:fulfilled?)
+      return obligation.fulfilled?
+    elsif obligation.respond_to?(:realized?)
+      return obligation.realized?
+    else
+      return false
+    end
+  end
+  module_function :fulfilled?
+
+  def realized?(obligation)
+    if obligation.respond_to?(:realized?)
+      return obligation.realized?
+    elsif obligation.respond_to?(:fulfilled?)
+      return obligation.fulfilled?
+    else
+      return false
+    end
+  end
+  module_function :realized?
+
+  def rejected?(obligation)
+    if obligation.respond_to?(:rejected?)
+      return obligation.rejected?
+    else
+      return false
+    end
+  end
+  module_function :rejected?
+end

data/lib/concurrent/promise.rb

@@ -0,0 +1,194 @@
+require 'thread'
+
+require 'concurrent/obligation'
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  class Promise
+    include Obligation
+    behavior(:future)
+    behavior(:promise)
+
+    # 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
+
+      @mutex = Mutex.new
+      @handler = block || Proc.new{|result| result }
+      @state = :pending
+      @value = nil
+      @reason = nil
+      @children = []
+      @rescuers = []
+
+      realize(*args) if root?
+    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 = @mutex.synchronize do
+        block = Proc.new{|result| result } unless block_given?
+        @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 = Exception, &block)
+      @mutex.synchronize do
+        @rescuers << Rescuer.new(clazz, block) if block_given?
+      end
+      return self
+    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)
+
+    # @private
+    def root # :nodoc:
+      current = self
+      current = current.parent until current.root?
+      return current
+    end
+
+    # @private
+    def root? # :nodoc:
+      @parent.nil?
+    end
+
+    # @private
+    def push(promise) # :nodoc:
+      if root?
+        @chain << promise
+      else
+        @parent.push(promise)
+      end
+    end
+
+    # @private
+    def on_fulfill(value) # :nodoc:
+      @mutex.synchronize do
+        if pending?
+          @value = @handler.call(value)
+          @state = :fulfilled
+          @reason = nil
+        end
+      end
+      return @value
+    end
+
+    # @private
+    def on_reject(reason) # :nodoc:
+      @mutex.synchronize do
+        if pending?
+          @state = :rejected
+          @reason = reason
+          self.try_rescue(reason)
+          @value = nil
+        end
+        @children.each{|child| child.on_reject(reason) }
+      end
+    end
+
+    # @private
+    def try_rescue(ex) # :nodoc:
+      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
+      rescuer.block.call(ex) if rescuer
+    rescue Exception => e
+      # supress
+    end
+
+    # @private
+    def realize(*args) # :nodoc:
+      $GLOBAL_THREAD_POOL.post(@chain, @mutex, args) do |chain, mutex, args|
+        result = args.length == 1 ? args.first : args
+        index = 0
+        loop do
+          Thread.pass
+          current = mutex.synchronize{ chain[index] }
+          unless current.rejected?
+            current.semaphore.synchronize do
+              begin
+                result = current.on_fulfill(result)
+              rescue Exception => ex
+                current.on_reject(ex)
+              end
+            end
+          end
+          index += 1
+          sleep while index >= chain.length
+        end
+      end
+    end
+  end
+end
+
+module Kernel
+
+  # 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 passes to each of its children when the child resolves. When
+  # a promise is rejected all its children will be summarily rejected.
+  # A promise added to a rejected promise will immediately be 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 Promise
+  # @see http://wiki.commonjs.org/wiki/Promises/A
+  def promise(*args, &block)
+    return Concurrent::Promise.new(*args, &block)
+  end
+  module_function :promise
+end