concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/lib/concurrent/channel/blocking_ring_buffer.rb

@@ -0,0 +1,60 @@
+module Concurrent
+  class BlockingRingBuffer
+
+    def initialize(capacity)
+      @buffer = RingBuffer.new(capacity)
+      @first = @last = 0
+      @count = 0
+      @mutex = Mutex.new
+      @condition = Condition.new
+    end
+
+    def capacity
+      @mutex.synchronize { @buffer.capacity }
+    end
+
+    def count
+      @mutex.synchronize { @buffer.count }
+    end
+
+    def full?
+      @mutex.synchronize { @buffer.full? }
+    end
+
+    def empty?
+      @mutex.synchronize { @buffer.empty? }
+    end
+
+    def put(value)
+      @mutex.synchronize do
+        wait_while_full
+        @buffer.offer(value)
+        @condition.signal
+      end
+    end
+
+    def take
+      @mutex.synchronize do
+        wait_while_empty
+        result = @buffer.poll
+        @condition.signal
+        result
+      end
+    end
+
+    def peek
+      @mutex.synchronize { @buffer.peek }
+    end
+
+    private
+
+    def wait_while_full
+      @condition.wait(@mutex) while @buffer.full?
+    end
+
+    def wait_while_empty
+      @condition.wait(@mutex) while @buffer.empty?
+    end
+
+  end
+end

data/lib/concurrent/channel/buffered_channel.rb

@@ -0,0 +1,83 @@
+require_relative 'waitable_list'
+
+module Concurrent
+  class BufferedChannel
+
+    def initialize(size)
+      @mutex = Mutex.new
+      @condition = Condition.new
+      @buffer_condition = Condition.new
+
+      @probe_set = WaitableList.new
+      @buffer = RingBuffer.new(size)
+    end
+
+    def probe_set_size
+      @probe_set.size
+    end
+
+    def buffer_queue_size
+      @mutex.synchronize { @buffer.count }
+    end
+
+    def push(value)
+      until set_probe_or_push_into_buffer(value)
+      end
+    end
+
+    def pop
+      probe = Probe.new
+      select(probe)
+      probe.value
+    end
+
+    def select(probe)
+      @mutex.synchronize do
+
+        if @buffer.empty?
+          @probe_set.put(probe)
+          true
+        else
+          shift_buffer if probe.set_unless_assigned peek_buffer
+        end
+
+      end
+    end
+
+    def remove_probe(probe)
+      @probe_set.delete(probe)
+    end
+
+    private
+
+    def push_into_buffer(value)
+      @buffer_condition.wait(@mutex) while @buffer.full?
+      @buffer.offer value
+      @buffer_condition.broadcast
+    end
+
+    def peek_buffer
+      @buffer_condition.wait(@mutex) while @buffer.empty?
+      @buffer.peek
+    end
+
+    def shift_buffer
+      @buffer_condition.wait(@mutex) while @buffer.empty?
+      result = @buffer.poll
+      @buffer_condition.broadcast
+      result
+    end
+
+    def set_probe_or_push_into_buffer(value)
+      @mutex.synchronize do
+        if @probe_set.empty?
+          push_into_buffer(value)
+          true
+        else
+          @probe_set.take.set_unless_assigned(value)
+        end
+      end
+    end
+
+  end
+end

data/lib/concurrent/channel/channel.rb

@@ -0,0 +1,11 @@
+module Concurrent
+  class Channel
+    def self.select(*channels)
+      probe = Probe.new
+      channels.each { |channel| channel.select(probe) }
+      result = probe.value
+      channels.each { |channel| channel.remove_probe(probe) }
+      result
+    end
+  end
+end

data/lib/concurrent/channel/probe.rb

@@ -0,0 +1,19 @@
+module Concurrent
+  class Probe < IVar
+
+    def initialize(value = NO_VALUE, opts = {})
+      super(value, opts)
+    end
+
+    def set_unless_assigned(value)
+      mutex.synchronize do
+        return false if [:fulfilled, :rejected].include? @state
+
+        set_state(true, value, nil)
+        event.set
+        true
+      end
+
+    end
+  end
+end

data/lib/concurrent/channel/ring_buffer.rb

@@ -0,0 +1,54 @@
+module Concurrent
+
+  # not thread safe buffer
+  class RingBuffer
+
+    def initialize(capacity)
+      @buffer = Array.new(capacity)
+      @first = @last = 0
+      @count = 0
+    end
+
+    def capacity
+      @buffer.size
+    end
+
+    def count
+      @count
+    end
+
+    def empty?
+      @count == 0
+    end
+
+    def full?
+      @count == capacity
+    end
+
+    # @param [Object] value
+    # @return [Boolean] true if value has been inserted, false otherwise
+    def offer(value)
+      return false if full?
+
+      @buffer[@last] = value
+      @last = (@last + 1) % @buffer.size
+      @count += 1
+      true
+    end
+
+    # @return [Object] the first available value and removes it from the buffer. If buffer is empty returns nil
+    def poll
+      result = @buffer[@first]
+      @buffer[@first] = nil
+      @first = (@first + 1) % @buffer.size
+      @count -= 1
+      result
+    end
+
+    # @return [Object] the first available value and without removing it from the buffer. If buffer is empty returns nil
+    def peek
+      @buffer[@first]
+    end
+
+  end
+end

data/lib/concurrent/channel/unbuffered_channel.rb

@@ -0,0 +1,34 @@
+require_relative 'waitable_list'
+
+module Concurrent
+  class UnbufferedChannel
+
+    def initialize
+      @probe_set = WaitableList.new
+    end
+
+    def probe_set_size
+      @probe_set.size
+    end
+
+    def push(value)
+      until @probe_set.take.set_unless_assigned(value)
+      end
+    end
+
+    def pop
+      probe = Probe.new
+      select(probe)
+      probe.value
+    end
+
+    def select(probe)
+      @probe_set.put(probe)
+    end
+
+    def remove_probe(probe)
+      @probe_set.delete(probe)
+    end
+
+  end
+end

data/lib/concurrent/channel/waitable_list.rb

@@ -0,0 +1,38 @@
+module Concurrent
+  class WaitableList
+
+    def initialize
+      @mutex = Mutex.new
+      @condition = Condition.new
+
+      @list = []
+    end
+
+    def size
+      @mutex.synchronize { @list.size }
+    end
+
+    def empty?
+      @mutex.synchronize { @list.empty? }
+    end
+
+    def put(value)
+      @mutex.synchronize do
+        @list << value
+        @condition.signal
+      end
+    end
+
+    def delete(value)
+      @mutex.synchronize { @list.delete(value) }
+    end
+
+    def take
+      @mutex.synchronize do
+        @condition.wait(@mutex) while @list.empty?
+        @list.shift
+      end
+    end
+
+  end
+end

data/lib/concurrent/configuration.rb

@@ -0,0 +1,92 @@
+require 'thread'
+require 'concurrent/thread_pool_executor'
+require 'concurrent/processor_count'
+
+module Concurrent
+
+  ConfigurationError = Class.new(StandardError)
+
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    (@mutex ||= Mutex.new).synchronize do
+      yield(configuration)
+    end
+  end
+
+  class Configuration
+    attr_accessor :global_task_pool
+    attr_accessor :global_operation_pool
+
+    def initialize
+      @cores ||= Concurrent::processor_count
+    end
+
+    def global_task_pool
+      @global_task_pool ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: [2, @cores].max,
+        max_threads: [20, @cores * 15].max,
+        idletime: 2 * 60,                   # 2 minutes
+        max_queue: 0,                       # unlimited
+        overflow_policy: :abort             # raise an exception
+      )
+    end
+
+    def global_operation_pool
+      @global_operation_pool ||= Concurrent::ThreadPoolExecutor.new(
+        min_threads: [2, @cores].max,
+        max_threads: [2, @cores].max,
+        idletime: 10 * 60,                  # 10 minutes
+        max_queue: [20, @cores * 15].max,
+        overflow_policy: :abort             # raise an exception
+      )
+    end
+
+    def global_task_pool=(executor)
+      raise ConfigurationError.new('global task pool was already set') unless @global_task_pool.nil?
+      @global_task_pool = executor
+    end
+
+    def global_operation_pool=(executor)
+      raise ConfigurationError.new('global operation pool was already set') unless @global_operation_pool.nil?
+      @global_operation_pool = executor
+    end
+  end
+
+  module OptionsParser
+
+    def get_executor_from(opts = {})
+      if opts[:executor]
+        opts[:executor]
+      elsif opts[:operation] == true || opts[:task] == false
+        Concurrent.configuration.global_operation_pool
+      else
+        Concurrent.configuration.global_task_pool
+      end
+    end
+  end
+
+  private
+
+  def self.finalize_executor(executor)
+    return if executor.nil?
+    if executor.respond_to?(:shutdown)
+      executor.shutdown
+    elsif executor.respond_to?(:kill)
+      executor.kill
+    end
+  rescue
+    # suppress
+  end
+
+  # create the default configuration on load
+  self.configuration = Configuration.new
+
+  # set exit hook to shutdown global thread pools
+  at_exit do
+    self.finalize_executor(self.configuration.global_task_pool)
+    self.finalize_executor(self.configuration.global_operation_pool)
+  end
+end

data/lib/concurrent/dataflow.rb

@@ -1,5 +1,6 @@
 require 'concurrent/atomic'
 require 'concurrent/future'
+require 'concurrent/per_thread_executor'
 
 module Concurrent
 
@@ -60,10 +61,16 @@ 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)
+  end
+  module_function :dataflow
+
+  def dataflow_with(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 do
+    result = Future.new(executor: executor) do
       values = inputs.map { |input| input.value }
       block.call(*values)
     end
@@ -80,6 +87,5 @@ module Concurrent
 
     result
   end
-
-  module_function :dataflow
+  module_function :dataflow_with
 end

data/lib/concurrent/delay.rb

@@ -0,0 +1,88 @@
+require 'thread'
+
+module Concurrent
+
+  # Lazy evaluation of a block yielding an immutable result. Useful for expensive
+  # operations that may never be needed.
+  #
+  # A `Delay` is similar to `Future` but solves a different problem.
+  # Where a `Future` schedules an operation for immediate execution and
+  # performs the operation asynchronously, a `Delay` (as the name implies)
+  # delays execution of the operation until the result is actually needed.
+  # 
+  # When a `Delay` is created its state is set to `pending`. The value and
+  # reason are both `nil`. The first time the `#value` method is called the
+  # enclosed opration will be run and the calling thread will block. Other
+  # threads attempting to call `#value` will block as well. Once the operation
+  # is complete the *value* will be set to the result of the operation or the
+  # *reason* will be set to the raised exception, as appropriate. All threads
+  # blocked on `#value` will return. Subsequent calls to `#value` will immediately
+  # return the cached value. The operation will only be run once. This means that
+  # any side effects created by the operation will only happen once as well.
+  #
+  # `Delay` includes the `Concurrent::Dereferenceable` mixin to support thread
+  # safety of the reference returned by `#value`.
+  #
+  # @since 0.6.0
+  #
+  # @see Concurrent::Dereferenceable
+  #
+  # @see http://clojuredocs.org/clojure_core/clojure.core/delay
+  # @see http://aphyr.com/posts/306-clojure-from-the-ground-up-state
+  class Delay
+    include Obligation
+
+    # Create a new +Delay+ in the +:pending+ state.
+    #
+    # @yield the delayed operation to perform
+    #
+    # @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
+    #
+    # @raise [ArgumentError] if no block is given
+    def initialize(opts = {}, &block)
+      raise ArgumentError.new('no block given') unless block_given?
+
+      init_obligation
+      @state = :pending
+      @task = block
+      set_deref_options(opts)
+    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.synchronize do
+        if @state == :pending
+          begin
+            @value = @task.call
+            @state = :fulfilled
+          rescue => ex
+            @reason = ex
+            @state = :rejected
+          end
+        end
+        return apply_deref_options(@value)
+      end
+    end
+  end
+end