concurrent-ruby 0.7.0.rc0-x86-linux

data/lib/concurrent/atomic_reference/concurrent_update_error.rb

@@ -0,0 +1,7 @@
+module Concurrent
+
+  class ConcurrentUpdateError < ThreadError
+    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
+    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
+  end
+end

data/lib/concurrent/atomic_reference/delegated_update.rb

@@ -0,0 +1,28 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+
+module Concurrent
+
+  # Define update methods that delegate to @ref field
+  class Atomic
+    # Pass the current value to the given block, replacing it
+    # with the block's result. May retry if the value changes
+    # during the block's execution.
+    def update
+      true until @ref.compare_and_set(old_value = @ref.get, new_value = yield(old_value))
+      new_value
+    end
+
+    def try_update
+      old_value = @ref.get
+      new_value = yield old_value
+      unless @ref.compare_and_set(old_value, new_value)
+        if $VERBOSE
+          raise ConcurrentUpdateError, "Update failed"
+        else
+          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+        end
+      end
+      new_value
+    end
+  end
+end

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -0,0 +1,28 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+
+module Concurrent
+
+  # Define update methods that use direct paths
+  module AtomicDirectUpdate
+    # Pass the current value to the given block, replacing it
+    # with the block's result. May retry if the value changes
+    # during the block's execution.
+    def update
+      true until compare_and_set(old_value = get, new_value = yield(old_value))
+      new_value
+    end
+
+    def try_update
+      old_value = get
+      new_value = yield old_value
+      unless compare_and_set(old_value, new_value)
+        if $VERBOSE
+          raise ConcurrentUpdateError, "Update failed"
+        else
+          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
+        end
+      end
+      new_value
+    end
+  end
+end

data/lib/concurrent/atomic_reference/jruby.rb

@@ -0,0 +1,8 @@
+require 'concurrent_ruby_ext'
+require 'concurrent/atomic_reference/direct_update'
+
+module Concurrent
+  class JavaAtomic
+    include Concurrent::AtomicDirectUpdate
+  end
+end

data/lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -0,0 +1,47 @@
+require 'thread'
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # Portable/generic (but not very memory or scheduling-efficient) fallback
+  class MutexAtomic #:nodoc: all
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    def initialize(value = nil)
+      @mutex = Mutex.new
+      @value = value
+    end
+
+    def get
+      @mutex.synchronize { @value }
+    end
+    alias value get
+
+    def set(new_value)
+      @mutex.synchronize { @value = new_value }
+    end
+    alias value= set
+
+    def get_and_set(new_value)
+      @mutex.synchronize do
+        old_value = @value
+        @value = new_value
+        old_value
+      end
+    end
+    alias swap get_and_set
+
+    def _compare_and_set(old_value, new_value)
+      return false unless @mutex.try_lock
+      begin
+        return false unless @value.equal? old_value
+        @value = new_value
+      ensure
+        @mutex.unlock
+      end
+      true
+    end
+  end
+end

data/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -0,0 +1,24 @@
+module Concurrent
+
+  module AtomicNumericCompareAndSetWrapper
+    #alias _compare_and_set compare_and_set
+
+    def compare_and_set(expected, new)
+      if expected.kind_of? Numeric
+        while true
+          old = get
+
+          return false unless old.kind_of? Numeric
+
+          return false unless old == expected
+
+          result = _compare_and_set(old, new)
+          return result if result
+        end
+      else
+        _compare_and_set(expected, new)
+      end
+    end
+    alias compare_and_swap compare_and_set
+  end
+end

data/lib/concurrent/atomic_reference/rbx.rb

@@ -0,0 +1,16 @@
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # extend Rubinius's version adding aliases and numeric logic
+  class RbxAtomic < Rubinius::AtomicReference
+    alias _compare_and_set compare_and_set
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    alias value get
+    alias value= set
+    alias swap get_and_set
+  end
+end

data/lib/concurrent/atomic_reference/ruby.rb

@@ -0,0 +1,16 @@
+begin
+  require 'concurrent_ruby_ext'
+rescue LoadError
+  # may be a Windows cross-compiled native gem
+  require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+end
+
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+  class CAtomic
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+  end
+end

data/lib/concurrent/atomics.rb

@@ -0,0 +1,10 @@
+require 'concurrent/atomic'
+require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/condition'
+require 'concurrent/atomic/copy_on_notify_observer_set'
+require 'concurrent/atomic/copy_on_write_observer_set'
+require 'concurrent/atomic/cyclic_barrier'
+require 'concurrent/atomic/count_down_latch'
+require 'concurrent/atomic/event'
+require 'concurrent/atomic/thread_local_var'

data/lib/concurrent/channel/buffered_channel.rb

@@ -0,0 +1,85 @@
+require 'concurrent/atomic/condition'
+
+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 = Channel::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, self)
+        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, self)
+        end
+      end
+    end
+
+  end
+end

data/lib/concurrent/channel/channel.rb

@@ -0,0 +1,41 @@
+require 'concurrent/ivar'
+
+module Concurrent
+  module Channel
+
+    class Probe < Concurrent::IVar
+
+      def initialize(value = NO_VALUE, opts = {})
+        super(value, opts)
+      end
+
+      def set_unless_assigned(value, channel)
+        mutex.synchronize do
+          return false if [:fulfilled, :rejected].include? @state
+
+          set_state(true, [value, channel], nil)
+          event.set
+          true
+        end
+      end
+
+      alias_method :composite_value, :value
+
+      def value
+        composite_value.nil? ? nil : composite_value[0]
+      end
+
+      def channel
+        composite_value.nil? ? nil : composite_value[1]
+      end
+    end
+
+    def self.select(*channels)
+      probe = Probe.new
+      channels.each { |channel| channel.select(probe) }
+      result = probe.composite_value
+      channels.each { |channel| channel.remove_probe(probe) }
+      result
+    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, self)
+      end
+    end
+
+    def pop
+      probe = Channel::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,40 @@
+require 'concurrent/atomic/condition'
+
+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/channels.rb

@@ -0,0 +1,5 @@
+require 'concurrent/collections'
+
+require 'concurrent/channel/channel'
+require 'concurrent/channel/unbuffered_channel'
+require 'concurrent/channel/buffered_channel'

data/lib/concurrent/collection/blocking_ring_buffer.rb

@@ -0,0 +1,71 @@
+require 'concurrent/atomic/condition'
+
+module Concurrent
+  class BlockingRingBuffer
+
+    def initialize(capacity)
+      @buffer = RingBuffer.new(capacity)
+      @first = @last = 0
+      @count = 0
+      @mutex = Mutex.new
+      @condition = Condition.new
+    end
+
+    # @return [Integer] the capacity of the buffer
+    def capacity
+      @mutex.synchronize { @buffer.capacity }
+    end
+
+    # @return [Integer] the number of elements currently in the buffer
+    def count
+      @mutex.synchronize { @buffer.count }
+    end
+
+    # @return [Boolean] true if buffer is empty, false otherwise
+    def empty?
+      @mutex.synchronize { @buffer.empty? }
+    end
+
+    # @return [Boolean] true if buffer is full, false otherwise
+    def full?
+      @mutex.synchronize { @buffer.full? }
+    end
+
+    # @param [Object] value the value to be inserted
+    # @return [Boolean] true if value has been inserted, false otherwise
+    def put(value)
+      @mutex.synchronize do
+        wait_while_full
+        @buffer.offer(value)
+        @condition.signal
+        true
+      end
+    end
+
+    # @return [Object] the first available value and removes it from the buffer. If buffer is empty it blocks until an element is available
+    def take
+      @mutex.synchronize do
+        wait_while_empty
+        result = @buffer.poll
+        @condition.signal
+        result
+      end
+    end
+
+    # @return [Object] the first available value and without removing it from the buffer. If buffer is empty returns nil
+    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