concurrent-ruby 0.7.0.rc1-x86-solaris-2.11 → 0.7.0.rc2-x86-solaris-2.11

data/lib/concurrent/agent.rb

@@ -38,10 +38,6 @@ module Concurrent
     include Concurrent::Observable
     include Logging
 
-    # The default timeout value (in seconds); used when no timeout option
-    # is given at initialization
-    TIMEOUT = 5
-
     attr_reader :timeout, :task_executor, :operation_executor
 
     # Initialize a new Agent with the given initial value and provided options.
@@ -49,8 +45,6 @@ module Concurrent
     # @param [Object] initial the initial value
     # @param [Hash] opts the options used to define the behavior at update and deref
     #
-    # @option opts [Fixnum] :timeout (TIMEOUT) maximum number of seconds before an update is cancelled
-    #
     # @option opts [Boolean] :operation (false) when `true` will execute the future on the global
     #   operation pool (for long-running operations), when `false` will execute the future on the
     #   global task pool (for short-running tasks)
@@ -65,7 +59,6 @@ module Concurrent
       @value                = initial
       @rescuers             = []
       @validator            = Proc.new { |result| true }
-      @timeout              = opts.fetch(:timeout, TIMEOUT).freeze
       self.observers        = CopyOnWriteObserverSet.new
       @serialized_execution = SerializedExecution.new
       @task_executor        = OptionsParser.get_task_executor_from(opts)
@@ -145,12 +138,19 @@ module Concurrent
     # Update the current value with the result of the given block operation,
     # block can do blocking calls
     #
+    # @param [Fixnum, nil] timeout maximum number of seconds before an update is cancelled
+    #
     # @yield the operation to be performed with the current value in order to calculate
     #   the new value
     # @yieldparam [Object] value the current value
     # @yieldreturn [Object] the new value
     # @return [true, nil] nil when no block is given
-    def post_off(&block)
+    def post_off(timeout = nil, &block)
+      block = if timeout
+                lambda { |value| Concurrent::timeout(timeout) { block.call(value) } }
+              else
+                block
+              end
       post_on(@operation_executor, &block)
     end
 
@@ -203,10 +203,8 @@ module Concurrent
       validator, value = mutex.synchronize { [@validator, @value] }
 
       begin
-        result, valid = Concurrent::timeout(@timeout) do
-          result = handler.call(value)
-          [result, validator.call(result)]
-        end
+        result = handler.call(value)
+        valid  = validator.call(result)
       rescue Exception => ex
         exception = ex
       end

data/lib/concurrent/atomic.rb

@@ -20,7 +20,38 @@ if defined? Concurrent::JavaAtomic
   #
   #   An object reference that may be updated atomically.
   #
-  #   @since 0.7.0.rc0
+  #       Testing with ruby 2.1.2
+  #       
+  #       *** Sequential updates ***
+  #                        user     system      total        real
+  #       no lock      0.000000   0.000000   0.000000 (  0.005502)
+  #       mutex        0.030000   0.000000   0.030000 (  0.025158)
+  #       MutexAtomic  0.100000   0.000000   0.100000 (  0.103096)
+  #       CAtomic      0.040000   0.000000   0.040000 (  0.034012)
+  #       
+  #       *** Parallel updates ***
+  #                        user     system      total        real
+  #       no lock      0.010000   0.000000   0.010000 (  0.009387)
+  #       mutex        0.030000   0.010000   0.040000 (  0.032545)
+  #       MutexAtomic  0.830000   2.280000   3.110000 (  2.146622)
+  #       CAtomic      0.040000   0.000000   0.040000 (  0.038332)
+  #
+  #       Testing with jruby 1.9.3
+  #       
+  #       *** Sequential updates ***
+  #                        user     system      total        real
+  #       no lock      0.170000   0.000000   0.170000 (  0.051000)
+  #       mutex        0.370000   0.010000   0.380000 (  0.121000)
+  #       MutexAtomic  1.530000   0.020000   1.550000 (  0.471000)
+  #       JavaAtomic   0.370000   0.010000   0.380000 (  0.112000)
+  #       
+  #       *** Parallel updates ***
+  #                        user     system      total        real
+  #       no lock      0.390000   0.000000   0.390000 (  0.105000)
+  #       mutex        0.480000   0.040000   0.520000 (  0.145000)
+  #       MutexAtomic  1.600000   0.180000   1.780000 (  0.511000)
+  #       JavaAtomic   0.460000   0.010000   0.470000 (  0.131000)
+  #
   #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
   #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
   class Concurrent::Atomic < Concurrent::JavaAtomic

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -6,21 +6,32 @@ module Concurrent
   #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
   #   briefly but no explicit locking is required.
   #
-  #   @since 0.6.0
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         2.790000   0.000000   2.790000 (  2.791454)
+  #       Testing with Concurrent::CAtomicBoolean...
+  #         0.740000   0.000000   0.740000 (  0.740206)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicBoolean...
+  #         5.240000   2.520000   7.760000 (  3.683000)
+  #       Testing with Concurrent::JavaAtomicBoolean...
+  #         3.340000   0.010000   3.350000 (  0.855000)
+  #
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
   class MutexAtomicBoolean
 
     # @!macro [attach] atomic_boolean_method_initialize
     #
-    # Creates a new `AtomicBoolean` with the given initial value.
+    #   Creates a new `AtomicBoolean` with the given initial value.
     #
-    # @param [Boolean] initial the initial value
+    #   @param [Boolean] initial the initial value
     def initialize(initial = false)
       @value = !!initial
       @mutex = Mutex.new
     end
 
-    # @!macro [attach] atomic_boolean_method_value
+    # @!macro [attach] atomic_boolean_method_value_get
     #
     #   Retrieves the current `Boolean` value.
     #
@@ -32,7 +43,7 @@ module Concurrent
       @mutex.unlock
     end
 
-    # @!macro [attach] atomic_boolean_method_value_eq
+    # @!macro [attach] atomic_boolean_method_value_set
     #
     #   Explicitly sets the value.
     #
@@ -47,9 +58,9 @@ module Concurrent
       @mutex.unlock
     end
 
-    # @!macro [attach] atomic_boolean_method_is_true
+    # @!macro [attach] atomic_boolean_method_true_question
     #
-    #   Is the current value `true`?
+    #   Is the current value `true`
     #
     #   @return [Boolean] true if the current value is `true`, else false
     def true?
@@ -59,9 +70,9 @@ module Concurrent
       @mutex.unlock
     end
 
-    # @!macro [attach] atomic_boolean_method_is_false
+    # @!macro atomic_boolean_method_false_question
     #
-    #   Is the current value `true`?false
+    #   Is the current value `false`
     #
     #   @return [Boolean] true if the current value is `false`, else false
     def false?
@@ -111,24 +122,24 @@ module Concurrent
         @atomic = java.util.concurrent.atomic.AtomicBoolean.new(!!initial)
       end
 
-      # @!macro atomic_boolean_method_value
+      # @!macro atomic_boolean_method_value_get
       #
       def value
         @atomic.get
       end
 
-      # @!macro atomic_boolean_method_value_eq
+      # @!macro atomic_boolean_method_value_set
       #
       def value=(value)
         @atomic.set(!!value)
       end
 
-      # @!macro [attach] atomic_boolean_method_is_true
+      # @!macro atomic_boolean_method_true_question
       def true?
         @atomic.get
       end
 
-      # @!macro [attach] atomic_boolean_method_is_false
+      # @!macro atomic_boolean_method_false_question
       def false?
         !@atomic.get
       end
@@ -148,6 +159,37 @@ module Concurrent
     class AtomicBoolean < JavaAtomicBoolean
     end
 
+  elsif defined? Concurrent::CAtomicBoolean
+
+    # @!macro atomic_boolean
+    class CAtomicBoolean
+
+      # @!method initialize
+      #   @!macro atomic_boolean_method_initialize
+
+      # @!method value
+      #   @!macro atomic_boolean_method_value_get
+
+      # @!method value=
+      #   @!macro atomic_boolean_method_value_set
+
+      # @!method true?
+      #   @!macro atomic_boolean_method_true_question
+
+      # @!method false?
+      #   @!macro atomic_boolean_method_false_question
+
+      # @!method make_true
+      #   @!macro atomic_boolean_method_make_true
+
+      # @!method make_false
+      #   @!macro atomic_boolean_method_make_false
+    end
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < CAtomicBoolean
+    end
+
   else
 
     # @!macro atomic_boolean

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -6,23 +6,38 @@ module Concurrent
   #   fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
   #   briefly but no explicit locking is required.
   #
-  #   @since 0.5.0
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         3.130000   0.000000   3.130000 (  3.136505)
+  #       Testing with Concurrent::CAtomicFixnum...
+  #         0.790000   0.000000   0.790000 (  0.785550)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         5.460000   2.460000   7.920000 (  3.715000)
+  #       Testing with Concurrent::JavaAtomicFixnum...
+  #         4.520000   0.030000   4.550000 (  1.187000)
+  #
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
   class MutexAtomicFixnum
 
+    # http://stackoverflow.com/questions/535721/ruby-max-integer
+    MIN_VALUE = -(2**(0.size * 8 -2))
+    MAX_VALUE = (2**(0.size * 8 -2) -1)
+
     # @!macro [attach] atomic_fixnum_method_initialize
     #
-    # Creates a new `AtomicFixnum` with the given initial value.
+    #   Creates a new `AtomicFixnum` with the given initial value.
     #
-    # @param [Fixnum] init the initial value
-    # @raise [ArgumentError] if the initial value is not a `Fixnum`
+    #   @param [Fixnum] init the initial value
+    #   @raise [ArgumentError] if the initial value is not a `Fixnum`
     def initialize(init = 0)
       raise ArgumentError.new('initial value must be a Fixnum') unless init.is_a?(Fixnum)
       @value = init
       @mutex = Mutex.new
     end
 
-    # @!macro [attach] atomic_fixnum_method_value
+    # @!macro [attach] atomic_fixnum_method_value_get
     #
     #   Retrieves the current `Fixnum` value.
     #
@@ -34,7 +49,7 @@ module Concurrent
       @mutex.unlock
     end
 
-    # @!macro [attach] atomic_fixnum_method_value_eq
+    # @!macro [attach] atomic_fixnum_method_value_set
     #
     #   Explicitly sets the value.
     #
@@ -106,44 +121,39 @@ module Concurrent
     # @!macro atomic_fixnum
     class JavaAtomicFixnum
 
+      MIN_VALUE = Java::JavaLang::Long::MIN_VALUE
+      MAX_VALUE = Java::JavaLang::Long::MAX_VALUE
+
       # @!macro atomic_fixnum_method_initialize
-      #
       def initialize(init = 0)
         raise ArgumentError.new('initial value must be a Fixnum') unless init.is_a?(Fixnum)
         @atomic = java.util.concurrent.atomic.AtomicLong.new(init)
       end
 
-      # @!macro atomic_fixnum_method_value
-      #
+      # @!macro atomic_fixnum_method_value_get
       def value
         @atomic.get
       end
 
-      # @!macro atomic_fixnum_method_value_eq
-      #
+      # @!macro atomic_fixnum_method_value_set
       def value=(value)
         raise ArgumentError.new('value must be a Fixnum') unless value.is_a?(Fixnum)
         @atomic.set(value)
       end
 
       # @!macro atomic_fixnum_method_increment
-      #
       def increment
         @atomic.increment_and_get
       end
-
       alias_method :up, :increment
 
       # @!macro atomic_fixnum_method_decrement
-      #
       def decrement
         @atomic.decrement_and_get
       end
-
       alias_method :down, :decrement
 
       # @!macro atomic_fixnum_method_compare_and_set
-      #
       def compare_and_set(expect, update)
         @atomic.compare_and_set(expect, update)
       end
@@ -153,6 +163,34 @@ module Concurrent
     class AtomicFixnum < JavaAtomicFixnum
     end
 
+  elsif defined? Concurrent::CAtomicFixnum
+
+    # @!macro atomic_fixnum
+    class CAtomicFixnum
+
+      # @!method initialize
+      #   @!macro atomic_fixnum_method_initialize
+
+      # @!method value
+      #   @!macro atomic_fixnum_method_value_get
+
+      # @!method value=
+      #   @!macro atomic_fixnum_method_value_set
+
+      # @!method increment
+      #   @!macro atomic_fixnum_method_increment
+
+      # @!method decrement
+      #   @!macro atomic_fixnum_method_decrement
+
+      # @!method compare_and_set
+      #   @!macro atomic_fixnum_method_compare_and_set
+    end
+
+    # @!macro atomic_fixnum
+    class AtomicFixnum < CAtomicFixnum
+    end
+
   else
 
     # @!macro atomic_fixnum

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

@@ -1,54 +1,19 @@
-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
+require 'concurrent/atomic'
 
-    def set(value)
-      Thread.current[@symbol] = value
-    end
-
-  end
-
-  module ThreadLocalNewStorage
-
-    include ThreadLocalSymbolAllocator
+module Concurrent
 
-    protected
+  module ThreadLocalRubyStorage
 
     def allocate_storage
-      allocate_symbol
+      @storage = Atomic.new Hash.new
     end
 
     def get
-      Thread.current.thread_variable_get(@symbol)
+      @storage.get[Thread.current]
     end
 
     def set(value)
-      Thread.current.thread_variable_set(@symbol, value)
+      @storage.update { |s| s.merge Thread.current => value }
     end
 
   end
@@ -71,18 +36,10 @@ module Concurrent
 
   end
 
-  class ThreadLocalVar
+  class AbstractThreadLocalVar
 
     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
@@ -114,4 +71,12 @@ module Concurrent
 
   end
 
+  class ThreadLocalVar < AbstractThreadLocalVar
+    if RUBY_PLATFORM == 'java'
+      include ThreadLocalJavaStorage
+    else
+      include ThreadLocalRubyStorage
+    end
+  end
+
 end