concurrent-ruby 0.7.0-java

data/lib/concurrent/atomics.rb

@@ -0,0 +1,11 @@
+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'
+require 'concurrent/atomic/synchronization'

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,35 @@
+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)
+      # TODO set_unless_assigned define on IVar as #set_state? or #try_set_state
+      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

data/lib/concurrent/collection/priority_queue.rb

@@ -0,0 +1,305 @@
+module Concurrent
+
+  # @!macro [attach] priority_queue
+  #
+  #   A queue collection in which the elements are sorted based on their
+  #   comparison (spaceship) operator `<=>`. Items are added to the queue
+  #   at a position relative to their priority. On removal the element
+  #   with the "highest" priority is removed. By default the sort order is
+  #   from highest to lowest, but a lowest-to-highest sort order can be
+  #   set on construction.
+  #
+  #   The API is based on the `Queue` class from the Ruby standard library.
+  #
+  #   The pure Ruby implementation, `MutexPriorityQueue` uses a heap algorithm
+  #   stored in an array. The algorithm is based on the work of Robert Sedgewick
+  #   and Kevin Wayne.
+  #
+  #   The JRuby native implementation is a thin wrapper around the standard
+  #   library `java.util.PriorityQueue`.
+  #
+  #   When running under JRuby the class `PriorityQueue` extends `JavaPriorityQueue`.
+  #   When running under all other interpreters it extends `MutexPriorityQueue`.
+  #
+  #   @note This implementation is *not* thread safe and performs no blocking.
+  #
+  #   @see http://en.wikipedia.org/wiki/Priority_queue
+  #   @see http://ruby-doc.org/stdlib-2.0.0/libdoc/thread/rdoc/Queue.html
+  #
+  #   @see http://algs4.cs.princeton.edu/24pq/index.php#2.6
+  #   @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
+  #
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
+  class MutexPriorityQueue
+
+    # @!macro [attach] priority_queue_method_initialize
+    #
+    #   Create a new priority queue with no items.
+    #  
+    #   @param [Hash] opts the options for creating the queue
+    #   @option opts [Symbol] :order (:max) dictates the order in which items are
+    #     stored: from highest to lowest when `:max` or `:high`; from lowest to
+    #     highest when `:min` or `:low`
+    def initialize(opts = {})
+      order = opts.fetch(:order, :max)
+      @comparator = [:min, :low].include?(order) ? -1 : 1
+      clear
+    end
+
+    # @!macro [attach] priority_queue_method_clear
+    #
+    #   Removes all of the elements from this priority queue.
+    def clear
+      @queue = [nil]
+      @length = 0
+      true
+    end
+
+    # @!macro [attach] priority_queue_method_delete
+    #
+    #   Deletes all items from `self` that are equal to `item`.
+    #  
+    #   @param [Object] item the item to be removed from the queue
+    #   @return [Object] true if the item is found else false
+    def delete(item)
+      original_length = @length
+      k = 1
+      while k <= @length
+        if @queue[k] == item
+          swap(k, @length)
+          @length -= 1
+          sink(k)
+          @queue.pop
+        else
+          k += 1
+        end
+      end
+      @length != original_length
+    end
+
+    # @!macro [attach] priority_queue_method_empty
+    #  
+    #   Returns `true` if `self` contains no elements.
+    #  
+    #   @return [Boolean] true if there are no items in the queue else false
+    def empty?
+      size == 0
+    end
+
+    # @!macro [attach] priority_queue_method_include
+    #
+    #   Returns `true` if the given item is present in `self` (that is, if any
+    #   element == `item`), otherwise returns false.
+    #  
+    #   @param [Object] item the item to search for
+    #  
+    #   @return [Boolean] true if the item is found else false
+    def include?(item)
+      @queue.include?(item)
+    end
+    alias_method :has_priority?, :include?
+
+    # @!macro [attach] priority_queue_method_length
+    #  
+    #   The current length of the queue.
+    #  
+    #   @return [Fixnum] the number of items in the queue
+    def length
+      @length
+    end
+    alias_method :size, :length
+
+    # @!macro [attach] priority_queue_method_peek
+    #  
+    #   Retrieves, but does not remove, the head of this queue, or returns `nil`
+    #   if this queue is empty.
+    #   
+    #   @return [Object] the head of the queue or `nil` when empty
+    def peek
+      @queue[1]
+    end
+
+    # @!macro [attach] priority_queue_method_pop
+    #  
+    #   Retrieves and removes the head of this queue, or returns `nil` if this
+    #   queue is empty.
+    #   
+    #   @return [Object] the head of the queue or `nil` when empty
+    def pop
+      max = @queue[1]
+      swap(1, @length)
+      @length -= 1
+      sink(1)
+      @queue.pop
+      max
+    end
+    alias_method :deq, :pop
+    alias_method :shift, :pop
+
+    # @!macro [attach] priority_queue_method_push
+    #  
+    #   Inserts the specified element into this priority queue.
+    #  
+    #   @param [Object] item the item to insert onto the queue
+    def push(item)
+      @length += 1
+      @queue << item
+      swim(@length)
+      true
+    end
+    alias_method :<<, :push
+    alias_method :enq, :push
+
+    # @!macro [attach] priority_queue_method_from_list
+    #  
+    #   Create a new priority queue from the given list.
+    #  
+    #   @param [Enumerable] list the list to build the queue from
+    #   @param [Hash] opts the options for creating the queue
+    #  
+    #   @return [PriorityQueue] the newly created and populated queue
+    def self.from_list(list, opts = {})
+      queue = new(opts)
+      list.each{|item| queue << item }
+      queue
+    end
+
+    protected
+
+    # Exchange the values at the given indexes within the internal array.
+    # 
+    # @param [Integer] x the first index to swap
+    # @param [Integer] y the second index to swap
+    # 
+    # @!visibility private
+    def swap(x, y)
+      temp = @queue[x]
+      @queue[x] = @queue[y]
+      @queue[y] = temp
+    end
+
+    # Are the items at the given indexes ordered based on the priority
+    # order specified at construction?
+    #
+    # @param [Integer] x the first index from which to retrieve a comparable value
+    # @param [Integer] y the second index from which to retrieve a comparable value
+    #
+    # @return [Boolean] true if the two elements are in the correct priority order
+    #   else false
+    # 
+    # @!visibility private
+    def ordered?(x, y)
+      (@queue[x] <=> @queue[y]) == @comparator
+    end
+
+    # Percolate down to maintain heap invariant.
+    # 
+    # @param [Integer] k the index at which to start the percolation
+    # 
+    # @!visibility private
+    def sink(k)
+      while (j = (2 * k)) <= @length do
+        j += 1 if j < @length && ! ordered?(j, j+1)
+        break if ordered?(k, j)
+        swap(k, j)
+        k = j
+      end
+    end
+
+    # Percolate up to maintain heap invariant.
+    # 
+    # @param [Integer] k the index at which to start the percolation
+    # 
+    # @!visibility private
+    def swim(k)
+      while k > 1 && ! ordered?(k/2, k) do
+        swap(k, k/2)
+        k = k/2
+      end
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro priority_queue
+    class JavaPriorityQueue
+
+      # @!macro priority_queue_method_initialize
+      def initialize(opts = {})
+        order = opts.fetch(:order, :max)
+        if [:min, :low].include?(order)
+          @queue = java.util.PriorityQueue.new(11) # 11 is the default initial capacity
+        else
+          @queue = java.util.PriorityQueue.new(11, java.util.Collections.reverseOrder())
+        end
+      end
+
+      # @!macro priority_queue_method_clear
+      def clear
+        @queue.clear
+        true
+      end
+
+      # @!macro priority_queue_method_delete
+      def delete(item)
+        found = false
+        while @queue.remove(item) do
+          found = true
+        end
+        found
+      end
+
+      # @!macro priority_queue_method_empty
+      def empty?
+        @queue.size == 0
+      end
+
+      # @!macro priority_queue_method_include
+      def include?(item)
+        @queue.contains(item)
+      end
+      alias_method :has_priority?, :include?
+
+      # @!macro priority_queue_method_length
+      def length
+        @queue.size
+      end
+      alias_method :size, :length
+
+      # @!macro priority_queue_method_peek
+      def peek
+        @queue.peek
+      end
+
+      # @!macro priority_queue_method_pop
+      def pop
+        @queue.poll
+      end
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+
+      # @!macro priority_queue_method_push
+      def push(item)
+        @queue.add(item)
+      end
+      alias_method :<<, :push
+      alias_method :enq, :push
+
+      # @!macro priority_queue_method_from_list
+      def self.from_list(list, opts = {})
+        queue = new(opts)
+        list.each{|item| queue << item }
+        queue
+      end
+    end
+
+    # @!macro priority_queue
+    class PriorityQueue < JavaPriorityQueue
+    end
+  else
+
+    # @!macro priority_queue
+    class PriorityQueue < MutexPriorityQueue
+    end
+  end
+end