concurrent-ruby-edge 0.1.0.pre2

data/lib/concurrent/channel/buffered_channel.rb

@@ -0,0 +1,87 @@
+require 'concurrent/channel/waitable_list'
+
+module Concurrent
+  module Channel
+
+    # @api Channel
+    # @!macro edge_warning
+    class BufferedChannel
+
+      def initialize(size)
+        @mutex = Mutex.new
+        @buffer_condition = ConditionVariable.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.try_set([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.try_set([value, self])
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/concurrent/channel/channel.rb

@@ -0,0 +1,19 @@
+require 'concurrent/ivar'
+
+module Concurrent
+  
+  # @api Channel
+  # @!macro edge_warning
+  module Channel
+
+    Probe = IVar
+
+    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/ring_buffer.rb

@@ -0,0 +1,65 @@
+module Concurrent
+  module Channel
+
+    # non-thread safe buffer
+    #
+    # @api Channel
+    # @!macro edge_warning
+    class RingBuffer
+
+      def initialize(capacity)
+        @buffer = Array.new(capacity)
+        @first = @last = 0
+        @count = 0
+      end
+
+
+      # @return [Integer] the capacity of the buffer
+      def capacity
+        @buffer.size
+      end
+
+      # @return [Integer] the number of elements currently in the buffer
+      def count
+        @count
+      end
+
+      # @return [Boolean] true if buffer is empty, false otherwise
+      def empty?
+        @count == 0
+      end
+
+      # @return [Boolean] true if buffer is full, false otherwise
+      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
+end

data/lib/concurrent/channel/unbuffered_channel.rb

@@ -0,0 +1,39 @@
+require 'concurrent/channel/waitable_list'
+
+module Concurrent
+  module Channel
+
+    # @api Channel
+    # @!macro edge_warning
+    class UnbufferedChannel
+
+      def initialize
+        @probe_set = WaitableList.new
+      end
+
+      def probe_set_size
+        @probe_set.size
+      end
+
+      def push(value)
+        until @probe_set.take.try_set([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
+end

data/lib/concurrent/channel/waitable_list.rb

@@ -0,0 +1,48 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Channel
+
+    # @api Channel
+    # @!macro edge_warning
+    class WaitableList < Synchronization::Object
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      def size
+        synchronize { @list.size }
+      end
+
+      def empty?
+        synchronize { @list.empty? }
+      end
+
+      def put(value)
+        synchronize do
+          @list << value
+          ns_signal
+        end
+      end
+
+      def delete(value)
+        synchronize { @list.delete(value) }
+      end
+
+      def take
+        synchronize do
+          ns_wait_until { !@list.empty? }
+          @list.shift
+        end
+      end
+
+      protected
+
+      def ns_initialize
+        @list = []
+      end
+    end
+  end
+end

data/lib/concurrent/edge/atomic_markable_reference.rb

@@ -0,0 +1,184 @@
+module Concurrent
+  module Edge
+
+    # @!macro [attach] atomic_markable_reference
+    #
+    #   An atomic reference which maintains an object reference along with a mark bit
+    #   that can be updated atomically.
+    #
+    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicMarkableReference.html java.util.concurrent.atomic.AtomicMarkableReference
+    #
+    #   @api Edge
+    class AtomicMarkableReference < ::Concurrent::Synchronization::Object
+
+      # @!macro [attach] atomic_markable_reference_method_initialize
+      def initialize(value = nil, mark = false)
+        super()
+        @Reference = AtomicReference.new ImmutableArray[value, mark]
+        ensure_ivar_visibility!
+      end
+
+      # @!macro [attach] atomic_markable_reference_method_compare_and_set
+      #
+      #   Atomically sets the value and mark to the given updated value and
+      #   mark given both:
+      #     - the current value == the expected value &&
+      #     - the current mark == the expected mark
+      #
+      #   @param [Object] expected_val the expected value
+      #   @param [Object] new_val the new value
+      #   @param [Boolean] expected_mark the expected mark
+      #   @param [Boolean] new_mark the new mark
+      #
+      #   @return [Boolean] `true` if successful. A `false` return indicates
+      #   that the actual value was not equal to the expected value or the
+      #   actual mark was not equal to the expected mark
+      def compare_and_set(expected_val, new_val, expected_mark, new_mark)
+        # Memoize a valid reference to the current AtomicReference for
+        # later comparison.
+        current = @Reference.get
+        curr_val, curr_mark = current
+
+        # Ensure that that the expected marks match.
+        return false unless expected_mark == curr_mark
+
+        if expected_val.is_a? Numeric
+          # If the object is a numeric, we need to ensure we are comparing
+          # the numerical values
+          return false unless expected_val == curr_val
+        else
+          # Otherwise, we need to ensure we are comparing the object identity.
+          # Theoretically, this could be incorrect if a user monkey-patched
+          # `Object#equal?`, but they should know that they are playing with
+          # fire at that point.
+          return false unless expected_val.equal? curr_val
+        end
+
+        prospect = ImmutableArray[new_val, new_mark]
+
+        @Reference.compare_and_set current, prospect
+      end
+      alias_method :compare_and_swap, :compare_and_set
+
+      # @!macro [attach] atomic_markable_reference_method_get
+      #
+      #   Gets the current reference and marked values.
+      #
+      #   @return [ImmutableArray] the current reference and marked values
+      def get
+        @Reference.get
+      end
+
+      # @!macro [attach] atomic_markable_reference_method_value
+      #
+      #   Gets the current value of the reference
+      #
+      #   @return [Object] the current value of the reference
+      def value
+        @Reference.get[0]
+      end
+
+      # @!macro [attach] atomic_markable_reference_method_mark
+      #
+      #   Gets the current marked value
+      #
+      #   @return [Boolean] the current marked value
+      def mark
+        @Reference.get[1]
+      end
+      alias_method :marked?, :mark
+
+      # @!macro [attach] atomic_markable_reference_method_set
+      #
+      #   _Unconditionally_ sets to the given value of both the reference and
+      #   the mark.
+      #
+      #   @param [Object] new_val the new value
+      #   @param [Boolean] new_mark the new mark
+      #
+      #   @return [ImmutableArray] both the new value and the new mark
+      def set(new_val, new_mark)
+        @Reference.set ImmutableArray[new_val, new_mark]
+      end
+
+      # @!macro [attach] atomic_markable_reference_method_update
+      #
+      # Pass the current value and marked state to the given block, replacing it
+      # with the block's results. May retry if the value changes during the
+      # block's execution.
+      #
+      # @yield [Object] Calculate a new value and marked state for the atomic
+      #   reference using given (old) value and (old) marked
+      # @yieldparam [Object] old_val the starting value of the atomic reference
+      # @yieldparam [Boolean] old_mark the starting state of marked
+      #
+      # @return [ImmutableArray] the new value and new mark
+      def update
+        loop do
+          old_val, old_mark = @Reference.get
+          new_val, new_mark = yield old_val, old_mark
+
+          if compare_and_set old_val, new_val, old_mark, new_mark
+            return ImmutableArray[new_val, new_mark]
+          end
+        end
+      end
+
+      # @!macro [attach] atomic_markable_reference_method_try_update!
+      #
+      # Pass the current value to the given block, replacing it
+      # with the block's result. Raise an exception if the update
+      # fails.
+      #
+      # @yield [Object] Calculate a new value and marked state for the atomic
+      #   reference using given (old) value and (old) marked
+      # @yieldparam [Object] old_val the starting value of the atomic reference
+      # @yieldparam [Boolean] old_mark the starting state of marked
+      #
+      # @return [ImmutableArray] the new value and marked state
+      #
+      # @raise [Concurrent::ConcurrentUpdateError] if the update fails
+      def try_update!
+        old_val, old_mark = @Reference.get
+        new_val, new_mark = yield old_val, old_mark
+
+        unless compare_and_set old_val, new_val, old_mark, new_mark
+          fail ::Concurrent::ConcurrentUpdateError,
+               'AtomicMarkableReference: Update failed due to race condition.',
+               'Note: If you would like to guarantee an update, please use ' \
+               'the `AtomicMarkableReference#update` method.'
+        end
+
+        ImmutableArray[new_val, new_mark]
+      end
+
+      # @!macro [attach] atomic_markable_reference_method_try_update
+      #
+      # Pass the current value to the given block, replacing it with the
+      # block's result. Simply return nil if update fails.
+      #
+      # @yield [Object] Calculate a new value and marked state for the atomic
+      #   reference using given (old) value and (old) marked
+      # @yieldparam [Object] old_val the starting value of the atomic reference
+      # @yieldparam [Boolean] old_mark the starting state of marked
+      #
+      # @return [ImmutableArray] the new value and marked state, or nil if
+      # the update failed
+      def try_update
+        old_val, old_mark = @Reference.get
+        new_val, new_mark = yield old_val, old_mark
+
+        return unless compare_and_set old_val, new_val, old_mark, new_mark
+
+        ImmutableArray[new_val, new_mark]
+      end
+
+      # Internal/private ImmutableArray for representing pairs
+      class ImmutableArray < Array
+        def self.new(*args)
+          super(*args).freeze
+        end
+      end
+    end
+  end
+end