concurrent-ruby 0.7.0-java

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/synchronization.rb

@@ -0,0 +1,51 @@
+module Concurrent
+
+  # Safe synchronization under JRuby, prevents reading uninitialized @mutex variable.
+  # @note synchronized needs to be called in #initialize for this module to work properly
+  # @example usage
+  #     class AClass
+  #       include Synchronized
+  #
+  #       def initialize
+  #         synchronize do
+  #           # body of the constructor ...
+  #         end
+  #       end
+  #
+  #       def a_method
+  #         synchronize do
+  #           # body of a_method ...
+  #         end
+  #       end
+  #     end
+  module Synchronization
+
+    engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
+
+    case engine
+    when 'jruby'
+      require 'jruby'
+
+      def synchronize
+        JRuby.reference0(self).synchronized { yield }
+      end
+
+    when 'rbx'
+
+      def synchronize
+        Rubinius.lock(self)
+        yield
+      ensure
+        Rubinius.unlock(self)
+      end
+
+    else
+
+      def synchronize
+        @mutex ||= Mutex.new
+        @mutex.synchronize { yield }
+      end
+
+    end
+  end
+end

data/lib/concurrent/atomic/thread_local_var.rb

@@ -0,0 +1,82 @@
+require 'concurrent/atomic'
+
+module Concurrent
+
+  module ThreadLocalRubyStorage
+
+    def allocate_storage
+      @storage = Atomic.new Hash.new
+    end
+
+    def get
+      @storage.get[Thread.current]
+    end
+
+    def set(value)
+      @storage.update { |s| s.merge Thread.current => 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 AbstractThreadLocalVar
+
+    NIL_SENTINEL = Object.new
+
+    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
+
+  class ThreadLocalVar < AbstractThreadLocalVar
+    if RUBY_PLATFORM == 'java'
+      include ThreadLocalJavaStorage
+    else
+      include ThreadLocalRubyStorage
+    end
+  end
+
+end

data/lib/concurrent/atomic_reference/concurrent_update_error.rb

@@ -0,0 +1,8 @@
+module Concurrent
+
+  # @!macro atomic_reference
+  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/direct_update.rb

@@ -0,0 +1,50 @@
+require 'concurrent/atomic_reference/concurrent_update_error'
+
+module Concurrent
+
+  # Define update methods that use direct paths
+  module AtomicDirectUpdate
+
+    # @!macro [attach] atomic_reference_method_update
+    #
+    # 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.
+    # 
+    # @yield [Object] Calculate a new value for the atomic reference using
+    #   given (old) value
+    # @yieldparam [Object] old_value the starting value of the atomic reference
+    #
+    # @return [Object] the new value
+    def update
+      true until compare_and_set(old_value = get, new_value = yield(old_value))
+      new_value
+    end
+
+    # @!macro [attach] atomic_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 for the atomic reference using
+    #   given (old) value
+    # @yieldparam [Object] old_value the starting value of the atomic reference
+    #
+    # @return [Object] the new value
+    #
+    # @raise [Concurrent::ConcurrentUpdateError] if the update fails
+    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,14 @@
+require_relative '../../extension_helper'
+Concurrent.safe_require_java_extensions
+
+if defined?(Concurrent::JavaAtomic)
+  require 'concurrent/atomic_reference/direct_update'
+
+  module Concurrent
+
+    # @!macro atomic_reference
+    class JavaAtomic
+      include Concurrent::AtomicDirectUpdate
+    end
+  end
+end

data/lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -0,0 +1,77 @@
+require 'thread'
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # @!macro atomic_reference
+  class MutexAtomic
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    # @!macro [attach] atomic_reference_method_initialize
+    def initialize(value = nil)
+      @mutex = Mutex.new
+      @value = value
+    end
+
+    # @!macro [attach] atomic_reference_method_get
+    #
+    #   Gets the current value.
+    #
+    #   @return [Object] the current value
+    def get
+      @mutex.synchronize { @value }
+    end
+    alias_method :value, :get
+
+    # @!macro [attach] atomic_reference_method_set
+    #
+    #   Sets to the given value.
+    #
+    #   @param [Object] new_value the new value
+    #
+    #   @return [Object] the new value
+    def set(new_value)
+      @mutex.synchronize { @value = new_value }
+    end
+    alias_method :value=, :set
+
+    # @!macro [attach] atomic_reference_method_get_and_set
+    #
+    #   Atomically sets to the given value and returns the old value.
+    #
+    #   @param [Object] new_value the new value
+    #
+    #   @return [Object] the old value
+    def get_and_set(new_value)
+      @mutex.synchronize do
+        old_value = @value
+        @value = new_value
+        old_value
+      end
+    end
+    alias_method :swap, :get_and_set
+
+    # @!macro [attach] atomic_reference_method_compare_and_set
+    #
+    #   Atomically sets the value to the given updated value if
+    #   the current value == the expected value.
+    #
+    #   @param [Object] old_value the expected value
+    #   @param [Object] new_value the new value
+    #
+    #   @return [Boolean] `true` if successful. A `false` return indicates
+    #   that the actual value was not equal to the expected value.
+    def _compare_and_set(old_value, new_value) #:nodoc:
+      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,25 @@
+module Concurrent
+
+  # Special "compare and set" handling of numeric values.
+  module AtomicNumericCompareAndSetWrapper
+
+    # @!macro atomic_reference_method_compare_and_set
+    def compare_and_set(old_value, new_value)
+      if old_value.kind_of? Numeric
+        while true
+          old = get
+
+          return false unless old.kind_of? Numeric
+
+          return false unless old == old_value
+
+          result = _compare_and_set(old, new_value)
+          return result if result
+        end
+      else
+        _compare_and_set(old_value, new_value)
+      end
+    end
+    alias_method :compare_and_swap, :compare_and_set
+  end
+end

data/lib/concurrent/atomic_reference/rbx.rb

@@ -0,0 +1,19 @@
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # @!macro atomic_reference
+  #
+  # @note Extends `Rubinius::AtomicReference` version adding aliases
+  #   and numeric logic.
+  class RbxAtomic < Rubinius::AtomicReference
+    alias _compare_and_set compare_and_set
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    alias_method :value, :get
+    alias_method :value=, :set
+    alias_method :swap, :get_and_set
+  end
+end

data/lib/concurrent/atomic_reference/ruby.rb

@@ -0,0 +1,37 @@
+require_relative '../../extension_helper'
+
+if Concurrent.allow_c_extensions?
+  begin
+    require 'concurrent_ruby_ext'
+  rescue LoadError
+    # may be a Windows cross-compiled native gem
+    require "#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
+  end
+end
+
+require 'concurrent/atomic_reference/direct_update'
+require 'concurrent/atomic_reference/numeric_cas_wrapper'
+
+module Concurrent
+
+  # @!macro atomic_reference
+  class CAtomic
+    include Concurrent::AtomicDirectUpdate
+    include Concurrent::AtomicNumericCompareAndSetWrapper
+
+    # @!method initialize
+    #   @!macro atomic_reference_method_initialize
+
+    # @!method get
+    #   @!macro atomic_reference_method_get
+
+    # @!method set
+    #   @!macro atomic_reference_method_set
+
+    # @!method get_and_set
+    #   @!macro atomic_reference_method_get_and_set
+
+    # @!method _compare_and_set
+    #   @!macro atomic_reference_method_compare_and_set
+  end
+end