concurrent-ruby 0.7.0.rc0-x86-solaris-2.11

data/lib/concurrent/atomic/copy_on_write_observer_set.rb

@@ -0,0 +1,117 @@
+module Concurrent
+
+  # A thread safe observer set implemented using copy-on-write approach:
+  # every time an observer is added or removed the whole internal data structure is
+  # duplicated and replaced with a new one.
+  class CopyOnWriteObserverSet
+
+    def initialize
+      @mutex = Mutex.new
+      @observers = {}
+    end
+
+    # Adds an observer to this set
+    # If a block is passed, the observer will be created by this method and no other params should be passed
+    # @param [Object] observer the observer to add
+    # @param [Symbol] func the function to call on the observer during notification. Default is :update
+    # @return [Object] the added observer
+    def add_observer(observer=nil, func=:update, &block)
+      if observer.nil? && block.nil?
+        raise ArgumentError, 'should pass observer as a first argument or block'
+      elsif observer && block
+        raise ArgumentError.new('cannot provide both an observer and a block')
+      end
+
+      if block
+        observer = block
+        func = :call
+      end
+
+      begin
+        @mutex.lock
+        new_observers = @observers.dup
+        new_observers[observer] = func
+        @observers = new_observers
+        observer
+      ensure
+        @mutex.unlock
+      end
+    end
+
+    # @param [Object] observer the observer to remove
+    # @return [Object] the deleted observer
+    def delete_observer(observer)
+      @mutex.lock
+      new_observers = @observers.dup
+      new_observers.delete(observer)
+      @observers = new_observers
+      observer
+    ensure
+      @mutex.unlock
+    end
+
+    # Deletes all observers
+    # @return [CopyOnWriteObserverSet] self
+    def delete_observers
+      self.observers = {}
+      self
+    end
+
+
+    # @return [Integer] the observers count
+    def count_observers
+      observers.count
+    end
+
+    # Notifies all registered observers with optional args
+    # @param [Object] args arguments to be passed to each observer
+    # @return [CopyOnWriteObserverSet] self
+    def notify_observers(*args, &block)
+      notify_to(observers, *args, &block)
+      self
+    end
+
+    # Notifies all registered observers with optional args and deletes them.
+    #
+    # @param [Object] args arguments to be passed to each observer
+    # @return [CopyOnWriteObserverSet] self
+    def notify_and_delete_observers(*args, &block)
+      old = clear_observers_and_return_old
+      notify_to(old, *args, &block)
+      self
+    end
+
+    private
+
+    def notify_to(observers, *args)
+      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+      observers.each do |observer, function|
+        args = yield if block_given?
+        observer.send(function, *args)
+      end
+    end
+
+    def observers
+      @mutex.lock
+      @observers
+    ensure
+      @mutex.unlock
+    end
+
+    def observers=(new_set)
+      @mutex.lock
+      @observers = new_set
+    ensure
+      @mutex.unlock
+    end
+
+    def clear_observers_and_return_old
+      @mutex.lock
+      old_observers = @observers
+      @observers = {}
+      old_observers
+    ensure
+      @mutex.unlock
+    end
+  end
+end

data/lib/concurrent/atomic/count_down_latch.rb

@@ -0,0 +1,116 @@
+require 'concurrent/atomic/condition'
+
+module Concurrent
+
+  # @!macro [attach] count_down_latch
+  #
+  #   A synchronization object that allows one thread to wait on multiple other threads.
+  #   The thread that will wait creates a `CountDownLatch` and sets the initial value
+  #   (normally equal to the number of other threads). The initiating thread passes the
+  #   latch to the other threads then waits for the other threads by calling the `#wait`
+  #   method. Each of the other threads calls `#count_down` when done with its work.
+  #   When the latch counter reaches zero the waiting thread is unblocked and continues
+  #   with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
+  class MutexCountDownLatch
+
+    # @!macro [attach] count_down_latch_method_initialize
+    #
+    #   Create a new `CountDownLatch` with the initial `count`.
+    #
+    #   @param [Fixnum] count the initial count
+    #
+    #   @raise [ArgumentError] if `count` is not an integer or is less than zero
+    def initialize(count)
+      unless count.is_a?(Fixnum) && count >= 0
+        raise ArgumentError.new('count must be in integer greater than or equal zero')
+      end
+      @mutex = Mutex.new
+      @condition = Condition.new
+      @count = count
+    end
+
+    # @!macro [attach] count_down_latch_method_wait
+    #
+    #   Block on the latch until the counter reaches zero or until `timeout` is reached.
+    #
+    #   @param [Fixnum] timeout the number of seconds to wait for the counter or `nil`
+    #     to block indefinitely
+    #   @return [Boolean] `true` if the `count` reaches zero else false on `timeout`
+    def wait(timeout = nil)
+      @mutex.synchronize do
+
+        remaining = Condition::Result.new(timeout)
+        while @count > 0 && remaining.can_wait?
+          remaining = @condition.wait(@mutex, remaining.remaining_time)
+        end
+
+        @count == 0
+      end
+    end
+
+    # @!macro [attach] count_down_latch_method_count_down
+    #
+    #   Signal the latch to decrement the counter. Will signal all blocked threads when
+    #   the `count` reaches zero.
+    def count_down
+      @mutex.synchronize do
+        @count -= 1 if @count > 0
+        @condition.broadcast if @count == 0
+      end
+    end
+
+    # @!macro [attach] count_down_latch_method_count
+    #
+    #   The current value of the counter.
+    #
+    #   @return [Fixnum] the current value of the counter
+    def count
+      @mutex.synchronize { @count }
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro count_down_latch
+    class JavaCountDownLatch
+
+      # @!macro count_down_latch_method_initialize
+      def initialize(count)
+        unless count.is_a?(Fixnum) && count >= 0
+          raise ArgumentError.new('count must be in integer greater than or equal zero')
+        end
+        @latch = java.util.concurrent.CountDownLatch.new(count)
+      end
+
+      # @!macro count_down_latch_method_wait
+      def wait(timeout = nil)
+        if timeout.nil?
+          @latch.await
+          true
+        else
+          @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+        end
+      end
+
+      # @!macro count_down_latch_method_count_down
+      def count_down
+        @latch.countDown
+      end
+
+      # @!macro count_down_latch_method_count
+      def count
+        @latch.getCount
+      end
+    end
+
+    # @!macro count_down_latch
+    class CountDownLatch < JavaCountDownLatch
+    end
+
+  else
+
+    # @!macro count_down_latch
+    class CountDownLatch < MutexCountDownLatch
+    end
+  end
+end

data/lib/concurrent/atomic/cyclic_barrier.rb

@@ -0,0 +1,106 @@
+module Concurrent
+
+  class CyclicBarrier
+
+    Generation = Struct.new(:status)
+    private_constant :Generation
+
+    # Create a new `CyclicBarrier` that waits for `parties` threads
+    #
+    # @param [Fixnum] parties the number of parties
+    # @yield an optional block that will be executed that will be executed after the last thread arrives and before the others are released
+    #
+    # @raise [ArgumentError] if `parties` is not an integer or is less than zero
+    def initialize(parties, &block)
+      raise ArgumentError.new('count must be in integer greater than or equal zero') if !parties.is_a?(Fixnum) || parties < 1
+      @parties = parties
+      @mutex = Mutex.new
+      @condition = Condition.new
+      @number_waiting = 0
+      @action = block
+      @generation = Generation.new(:waiting)
+    end
+
+    # @return [Fixnum] the number of threads needed to pass the barrier
+    def parties
+      @parties
+    end
+
+    # @return [Fixnum] the number of threads currently waiting on the barrier
+    def number_waiting
+      @number_waiting
+    end
+
+    # Blocks on the barrier until the number of waiting threads is equal to `parties` or until `timeout` is reached or `reset` is called
+    # If a block has been passed to the constructor, it will be executed once by the last arrived thread before releasing the others
+    # @param [Fixnum] timeout the number of seconds to wait for the counter or `nil` to block indefinitely
+    # @return [Boolean] `true` if the `count` reaches zero else false on `timeout` or on `reset` or if the barrier is broken
+    def wait(timeout = nil)
+      @mutex.synchronize do
+
+        return false unless @generation.status == :waiting
+
+        @number_waiting += 1
+
+        if @number_waiting == @parties
+          @action.call if @action
+          set_status_and_restore(:fulfilled)
+          true
+        else
+          wait_for_wake_up(@generation, timeout)
+        end
+      end
+    end
+
+
+
+    # resets the barrier to its initial state
+    # If there is at least one waiting thread, it will be woken up, the `wait` method will return false and the barrier will be broken
+    # If the barrier is broken, this method restores it to the original state
+    #
+    # @return [nil]
+    def reset
+      @mutex.synchronize do
+        set_status_and_restore(:reset)
+      end
+    end
+
+    # A barrier can be broken when:
+    # - a thread called the `reset` method while at least one other thread was waiting
+    # - at least one thread timed out on `wait` method
+    #
+    # A broken barrier can be restored using `reset` it's safer to create a new one
+    # @return [Boolean] true if the barrier is broken otherwise false
+    def broken?
+      @mutex.synchronize { @generation.status != :waiting }
+    end
+
+    private
+
+    def set_status_and_restore(new_status)
+      @generation.status = new_status
+      @condition.broadcast
+      @generation = Generation.new(:waiting)
+      @number_waiting = 0
+    end
+
+    def wait_for_wake_up(generation, timeout)
+      if wait_while_waiting(generation, timeout)
+        generation.status == :fulfilled
+      else
+        generation.status = :broken
+        @condition.broadcast
+        false
+      end
+    end
+
+    def wait_while_waiting(generation, timeout)
+      remaining = Condition::Result.new(timeout)
+      while generation.status == :waiting && remaining.can_wait?
+        remaining = @condition.wait(@mutex, remaining.remaining_time)
+      end
+      remaining.woken_up?
+    end
+
+  end
+end

data/lib/concurrent/atomic/event.rb

@@ -0,0 +1,98 @@
+require 'thread'
+require 'concurrent/atomic/condition'
+
+module Concurrent
+
+  # Old school kernel-style event reminiscent of Win32 programming in C++.
+  #
+  # When an `Event` is created it is in the `unset` state. Threads can choose to
+  # `#wait` on the event, blocking until released by another thread. When one
+  # thread wants to alert all blocking threads it calls the `#set` method which
+  # will then wake up all listeners. Once an `Event` has been set it remains set.
+  # New threads calling `#wait` will return immediately. An `Event` may be
+  # `#reset` at any time once it has been set.
+  #
+  # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
+  class Event
+
+    # Creates a new `Event` in the unset state. Threads calling `#wait` on the
+    # `Event` will block.
+    def initialize
+      @set = false
+      @mutex = Mutex.new
+      @condition = Condition.new
+    end
+
+    # Is the object in the set state?
+    #
+    # @return [Boolean] indicating whether or not the `Event` has been set
+    def set?
+      @mutex.lock
+      @set
+    ensure
+      @mutex.unlock
+    end
+
+    # Trigger the event, setting the state to `set` and releasing all threads
+    # waiting on the event. Has no effect if the `Event` has already been set.
+    #
+    # @return [Boolean] should always return `true`
+    def set
+      @mutex.lock
+      unless @set
+        @set = true
+        @condition.broadcast
+      end
+      true
+    ensure
+      @mutex.unlock
+    end
+
+    def try?
+      @mutex.lock
+
+      if @set
+        false
+      else
+        @set = true
+        @condition.broadcast
+        true
+      end
+
+    ensure
+      @mutex.unlock
+    end
+
+    # Reset a previously set event back to the `unset` state.
+    # Has no effect if the `Event` has not yet been set.
+    #
+    # @return [Boolean] should always return `true`
+    def reset
+      @mutex.lock
+      @set = false
+      true
+    ensure
+      @mutex.unlock
+    end
+
+    # Wait a given number of seconds for the `Event` to be set by another
+    # thread. Will wait forever when no `timeout` value is given. Returns
+    # immediately if the `Event` has already been set.
+    #
+    # @return [Boolean] true if the `Event` was set before timeout else false
+    def wait(timeout = nil)
+      @mutex.lock
+
+      unless @set
+        remaining = Condition::Result.new(timeout)
+        while !@set && remaining.can_wait?
+          remaining = @condition.wait(@mutex, remaining.remaining_time)
+        end
+      end
+
+      @set
+    ensure
+      @mutex.unlock
+    end
+  end
+end

data/lib/concurrent/atomic/thread_local_var.rb

@@ -0,0 +1,117 @@
+module Concurrent
+
+  module ThreadLocalSymbolAllocator
+
+    COUNTER = AtomicFixnum.new
+
+    protected
+
+    def allocate_symbol
+      # Warning: this symbol may never be deallocated
+      @symbol = :"thread_local_symbol_#{COUNTER.increment}"
+    end
+
+  end
+
+  module ThreadLocalOldStorage
+
+    include ThreadLocalSymbolAllocator
+
+    protected
+
+    def allocate_storage
+      allocate_symbol
+    end
+
+    def get
+      Thread.current[@symbol]
+    end
+
+    def set(value)
+      Thread.current[@symbol] = value
+    end
+
+  end
+
+  module ThreadLocalNewStorage
+
+    include ThreadLocalSymbolAllocator
+
+    protected
+
+    def allocate_storage
+      allocate_symbol
+    end
+
+    def get
+      Thread.current.thread_variable_get(@symbol)
+    end
+
+    def set(value)
+      Thread.current.thread_variable_set(@symbol, value)
+    end
+
+  end
+
+  module ThreadLocalJavaStorage
+
+    protected
+
+    def allocate_storage
+      @var = java.lang.ThreadLocal.new
+    end
+
+    def get
+      @var.get
+    end
+
+    def set(value)
+      @var.set(value)
+    end
+
+  end
+
+  class ThreadLocalVar
+
+    NIL_SENTINEL = Object.new
+
+    if RUBY_PLATFORM == 'java'
+      include ThreadLocalJavaStorage
+    elsif Thread.current.respond_to?(:thread_variable_set)
+      include ThreadLocalNewStorage
+    else
+      include ThreadLocalOldStorage
+    end
+
+    def initialize(default = nil)
+      @default = default
+      allocate_storage
+    end
+
+    def value
+      value = get
+
+      if value.nil?
+        @default
+      elsif value == NIL_SENTINEL
+        nil
+      else
+        value
+      end
+    end
+
+    def value=(value)
+      if value.nil?
+        stored_value = NIL_SENTINEL
+      else
+        stored_value = value
+      end
+
+      set stored_value
+
+      value
+    end
+
+  end
+
+end