concurrent-ruby 1.1.9 → 1.2.0

data/lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb

@@ -1,5 +1,6 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 require 'concurrent/atomic/mutex_atomic_boolean'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -79,10 +80,10 @@ module Concurrent
   # @!visibility private
   # @!macro internal_implementation_note
   AtomicBooleanImplementation = case
-                                when defined?(JavaAtomicBoolean)
-                                  JavaAtomicBoolean
-                                when defined?(CAtomicBoolean)
+                                when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
                                   CAtomicBoolean
+                                when Concurrent.on_jruby?
+                                  JavaAtomicBoolean
                                 else
                                   MutexAtomicBoolean
                                 end

data/lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb

@@ -1,5 +1,6 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 require 'concurrent/atomic/mutex_atomic_fixnum'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -96,10 +97,10 @@ module Concurrent
   # @!visibility private
   # @!macro internal_implementation_note
   AtomicFixnumImplementation = case
-                               when defined?(JavaAtomicFixnum)
-                                 JavaAtomicFixnum
-                               when defined?(CAtomicFixnum)
+                               when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
                                  CAtomicFixnum
+                               when Concurrent.on_jruby?
+                                 JavaAtomicFixnum
                                else
                                  MutexAtomicFixnum
                                end

data/lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb

@@ -1,3 +1,6 @@
+require 'concurrent/errors'
+require 'concurrent/synchronization/object'
+
 module Concurrent
   # An atomic reference which maintains an object reference along with a mark bit
   # that can be updated atomically.

data/lib/concurrent-ruby/concurrent/atomic/atomic_reference.rb

@@ -1,6 +1,8 @@
-require 'concurrent/synchronization'
-require 'concurrent/utility/engine'
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/atomic_reference/atomic_direct_update'
 require 'concurrent/atomic_reference/numeric_cas_wrapper'
+require 'concurrent/atomic_reference/mutex_atomic'
 
 # Shim for TruffleRuby::AtomicReference
 if Concurrent.on_truffleruby? && !defined?(TruffleRuby::AtomicReference)
@@ -12,138 +14,6 @@ end
 
 module Concurrent
 
-  # Define update methods that use direct paths
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicDirectUpdate
-
-    # @!macro 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 atomic_reference_method_try_update
-    #
-    #   Pass the current value to the given block, replacing it
-    #   with the block's result. Return nil 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
-    #   @note This method was altered to avoid raising an exception by default.
-    #     Instead, this method now returns `nil` in case of failure. For more info,
-    #     please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #   @return [Object] the new value, or nil if update failed
-    def try_update
-      old_value = get
-      new_value = yield old_value
-
-      return unless compare_and_set old_value, new_value
-
-      new_value
-    end
-
-    # @!macro 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
-    #   @note This behavior mimics the behavior of the original
-    #     `AtomicReference#try_update` API. The reason this was changed was to
-    #     avoid raising exceptions (which are inherently slow) by default. For more
-    #     info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #   @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
-
-  require 'concurrent/atomic_reference/mutex_atomic'
-
-  # @!macro atomic_reference
-  #
-  #   An object reference that may be updated atomically. All read and write
-  #   operations have java volatile semantic.
-  #
-  #   @!macro thread_safe_variable_comparison
-  #
-  #   @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
-  #
-  #   @!method initialize(value = nil)
-  #     @!macro atomic_reference_method_initialize
-  #       @param [Object] value The initial value.
-  #
-  #   @!method get
-  #     @!macro atomic_reference_method_get
-  #       Gets the current value.
-  #       @return [Object] the current value
-  #
-  #   @!method set(new_value)
-  #     @!macro atomic_reference_method_set
-  #       Sets to the given value.
-  #       @param [Object] new_value the new value
-  #       @return [Object] the new value
-  #
-  #   @!method get_and_set(new_value)
-  #     @!macro 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
-  #
-  #   @!method compare_and_set(old_value, new_value)
-  #     @!macro 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.
-  #
-  #   @!method update
-  #     @!macro atomic_reference_method_update
-  #
-  #   @!method try_update
-  #     @!macro atomic_reference_method_try_update
-  #
-  #   @!method try_update!
-  #     @!macro atomic_reference_method_try_update!
-
-
-  # @!macro internal_implementation_note
-  class ConcurrentUpdateError < ThreadError
-    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
-    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
-  end
-
   # @!macro internal_implementation_note
   AtomicReferenceImplementation = case
                                   when Concurrent.on_cruby? && Concurrent.c_extensions_loaded?
@@ -170,28 +40,89 @@ module Concurrent
                                       alias_method :compare_and_swap, :compare_and_set
                                       alias_method :swap, :get_and_set
                                     end
-                                  when Concurrent.on_rbx?
-                                    # @note Extends `Rubinius::AtomicReference` version adding aliases
-                                    #   and numeric logic.
-                                    #
-                                    # @!visibility private
-                                    # @!macro internal_implementation_note
-                                    class RbxAtomicReference < Rubinius::AtomicReference
-                                      alias_method :_compare_and_set, :compare_and_set
-                                      include AtomicDirectUpdate
-                                      include AtomicNumericCompareAndSetWrapper
-                                      alias_method :value, :get
-                                      alias_method :value=, :set
-                                      alias_method :swap, :get_and_set
-                                      alias_method :compare_and_swap, :compare_and_set
-                                    end
-                                    RbxAtomicReference
+                                    TruffleRubyAtomicReference
                                   else
                                     MutexAtomicReference
                                   end
   private_constant :AtomicReferenceImplementation
 
-  # @!macro atomic_reference
+  # An object reference that may be updated atomically. All read and write
+  # operations have java volatile semantic.
+  #
+  # @!macro thread_safe_variable_comparison
+  #
+  # @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
+  #
+  # @!method initialize(value = nil)
+  #   @!macro atomic_reference_method_initialize
+  #     @param [Object] value The initial value.
+  #
+  # @!method get
+  #   @!macro atomic_reference_method_get
+  #     Gets the current value.
+  #     @return [Object] the current value
+  #
+  # @!method set(new_value)
+  #   @!macro atomic_reference_method_set
+  #     Sets to the given value.
+  #     @param [Object] new_value the new value
+  #     @return [Object] the new value
+  #
+  # @!method get_and_set(new_value)
+  #   @!macro 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
+  #
+  # @!method compare_and_set(old_value, new_value)
+  #   @!macro 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.
+  #
+  # @!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
+  #
+  # @!method try_update
+  #   Pass the current value to the given block, replacing it
+  #   with the block's result. Return nil 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
+  #   @note This method was altered to avoid raising an exception by default.
+  #     Instead, this method now returns `nil` in case of failure. For more info,
+  #     please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
+  #   @return [Object] the new value, or nil if update failed
+  #
+  # @!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
+  #   @note This behavior mimics the behavior of the original
+  #     `AtomicReference#try_update` API. The reason this was changed was to
+  #     avoid raising exceptions (which are inherently slow) by default. For more
+  #     info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
+  #   @return [Object] the new value
+  #   @raise [Concurrent::ConcurrentUpdateError] if the update fails
   class AtomicReference < AtomicReferenceImplementation
 
     # @return [String] Short string representation.

data/lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 require 'concurrent/utility/native_integer'
 
 module Concurrent

data/lib/concurrent-ruby/concurrent/atomic/event.rb

@@ -1,5 +1,5 @@
 require 'thread'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
@@ -19,7 +19,7 @@ module Concurrent
   #   t1 = Thread.new do
   #     puts "t1 is waiting"
   #     event.wait(1)
-  #     puts "event ocurred"
+  #     puts "event occurred"
   #   end
   #
   #   t2 = Thread.new do
@@ -30,8 +30,8 @@ module Concurrent
   #   [t1, t2].each(&:join)
   #
   #   # prints:
-  #   # t2 calling set
   #   # t1 is waiting
+  #   # t2 calling set
   #   # event occurred
   class Event < Synchronization::LockableObject
 

data/lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb

@@ -0,0 +1,109 @@
+require 'concurrent/constants'
+require_relative 'locals'
+
+module Concurrent
+
+  # A `FiberLocalVar` is a variable where the value is different for each fiber.
+  # Each variable may have a default value, but when you modify the variable only
+  # the current fiber will ever see that change.
+  #
+  # This is similar to Ruby's built-in fiber-local variables (`Thread.current[:name]`),
+  # but with these major advantages:
+  # * `FiberLocalVar` has its own identity, it doesn't need a Symbol.
+  # * Each Ruby's built-in fiber-local variable leaks some memory forever (it's a Symbol held forever on the fiber),
+  #   so it's only OK to create a small amount of them.
+  #   `FiberLocalVar` has no such issue and it is fine to create many of them.
+  # * Ruby's built-in fiber-local variables leak forever the value set on each fiber (unless set to nil explicitly).
+  #   `FiberLocalVar` automatically removes the mapping for each fiber once the `FiberLocalVar` instance is GC'd.
+  #
+  # @example
+  #   v = FiberLocalVar.new(14)
+  #   v.value #=> 14
+  #   v.value = 2
+  #   v.value #=> 2
+  #
+  # @example
+  #   v = FiberLocalVar.new(14)
+  #
+  #   Fiber.new do
+  #     v.value #=> 14
+  #     v.value = 1
+  #     v.value #=> 1
+  #   end.resume
+  #
+  #   Fiber.new do
+  #     v.value #=> 14
+  #     v.value = 2
+  #     v.value #=> 2
+  #   end.resume
+  #
+  #   v.value #=> 14
+  class FiberLocalVar
+    LOCALS = FiberLocals.new
+
+    # Creates a fiber local variable.
+    #
+    # @param [Object] default the default value when otherwise unset
+    # @param [Proc] default_block Optional block that gets called to obtain the
+    #   default value for each fiber
+    def initialize(default = nil, &default_block)
+      if default && block_given?
+        raise ArgumentError, "Cannot use both value and block as default value"
+      end
+
+      if block_given?
+        @default_block = default_block
+        @default = nil
+      else
+        @default_block = nil
+        @default = default
+      end
+
+      @index = LOCALS.next_index(self)
+    end
+
+    # Returns the value in the current fiber's copy of this fiber-local variable.
+    #
+    # @return [Object] the current value
+    def value
+      LOCALS.fetch(@index) { default }
+    end
+
+    # Sets the current fiber's copy of this fiber-local variable to the specified value.
+    #
+    # @param [Object] value the value to set
+    # @return [Object] the new value
+    def value=(value)
+      LOCALS.set(@index, value)
+    end
+
+    # Bind the given value to fiber local storage during
+    # execution of the given block.
+    #
+    # @param [Object] value the value to bind
+    # @yield the operation to be performed with the bound variable
+    # @return [Object] the value
+    def bind(value)
+      if block_given?
+        old_value = self.value
+        self.value = value
+        begin
+          yield
+        ensure
+          self.value = old_value
+        end
+      end
+    end
+
+    protected
+
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
+  end
+end

data/lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb

@@ -1,4 +1,5 @@
 if Concurrent.on_jruby?
+  require 'concurrent/utility/native_extension_loader'
 
   module Concurrent
 

data/lib/concurrent-ruby/concurrent/atomic/locals.rb

@@ -0,0 +1,188 @@
+require 'concurrent/utility/engine'
+require 'concurrent/constants'
+
+module Concurrent
+  # @!visibility private
+  # @!macro internal_implementation_note
+  #
+  # An abstract implementation of local storage, with sub-classes for
+  # per-thread and per-fiber locals.
+  #
+  # Each execution context (EC, thread or fiber) has a lazily initialized array
+  # of local variable values. Each time a new local variable is created, we
+  # allocate an "index" for it.
+  #
+  # For example, if the allocated index is 1, that means slot #1 in EVERY EC's
+  # locals array will be used for the value of that variable.
+  #
+  # The good thing about using a per-EC structure to hold values, rather than
+  # a global, is that no synchronization is needed when reading and writing
+  # those values (since the structure is only ever accessed by a single
+  # thread).
+  #
+  # Of course, when a local variable is GC'd, 1) we need to recover its index
+  # for use by other new local variables (otherwise the locals arrays could
+  # get bigger and bigger with time), and 2) we need to null out all the
+  # references held in the now-unused slots (both to avoid blocking GC of those
+  # objects, and also to prevent "stale" values from being passed on to a new
+  # local when the index is reused).
+  #
+  # Because we need to null out freed slots, we need to keep references to
+  # ALL the locals arrays, so we can null out the appropriate slots in all of
+  # them. This is why we need to use a finalizer to clean up the locals array
+  # when the EC goes out of scope.
+  class AbstractLocals
+    def initialize
+      @free = []
+      @lock = Mutex.new
+      @all_arrays = {}
+      @next = 0
+    end
+
+    def synchronize
+      @lock.synchronize { yield }
+    end
+
+    if Concurrent.on_cruby?
+      def weak_synchronize
+        yield
+      end
+    else
+      alias_method :weak_synchronize, :synchronize
+    end
+
+    def next_index(local)
+      index = synchronize do
+        if @free.empty?
+          @next += 1
+        else
+          @free.pop
+        end
+      end
+
+      # When the local goes out of scope, we should free the associated index
+      # and all values stored into it.
+      ObjectSpace.define_finalizer(local, local_finalizer(index))
+
+      index
+    end
+
+    def free_index(index)
+      weak_synchronize do
+        # The cost of GC'ing a TLV is linear in the number of ECs using local
+        # variables. But that is natural! More ECs means more storage is used
+        # per local variable. So naturally more CPU time is required to free
+        # more storage.
+        #
+        # DO NOT use each_value which might conflict with new pair assignment
+        # into the hash in #set method.
+        @all_arrays.values.each do |locals|
+          locals[index] = nil
+        end
+
+        # free index has to be published after the arrays are cleared:
+        @free << index
+      end
+    end
+
+    def fetch(index)
+      locals = self.locals
+      value = locals ? locals[index] : nil
+
+      if nil == value
+        yield
+      elsif NULL.equal?(value)
+        nil
+      else
+        value
+      end
+    end
+
+    def set(index, value)
+      locals = self.locals!
+      locals[index] = (nil == value ? NULL : value)
+
+      value
+    end
+
+    private
+
+    # When the local goes out of scope, clean up that slot across all locals currently assigned.
+    def local_finalizer(index)
+      proc do
+        free_index(index)
+      end
+    end
+
+    # When a thread/fiber goes out of scope, remove the array from @all_arrays.
+    def thread_fiber_finalizer(array_object_id)
+      proc do
+        weak_synchronize do
+          @all_arrays.delete(array_object_id)
+        end
+      end
+    end
+
+    # Returns the locals for the current scope, or nil if none exist.
+    def locals
+      raise NotImplementedError
+    end
+
+    # Returns the locals for the current scope, creating them if necessary.
+    def locals!
+      raise NotImplementedError
+    end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  # An array-backed storage of indexed variables per thread.
+  class ThreadLocals < AbstractLocals
+    def locals
+      Thread.current.thread_variable_get(:concurrent_thread_locals)
+    end
+
+    def locals!
+      thread = Thread.current
+      locals = thread.thread_variable_get(:concurrent_thread_locals)
+
+      unless locals
+        locals = thread.thread_variable_set(:concurrent_thread_locals, [])
+        weak_synchronize do
+          @all_arrays[locals.object_id] = locals
+        end
+        # When the thread goes out of scope, we should delete the associated locals:
+        ObjectSpace.define_finalizer(thread, thread_fiber_finalizer(locals.object_id))
+      end
+
+      locals
+    end
+  end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  # An array-backed storage of indexed variables per fiber.
+  class FiberLocals < AbstractLocals
+    def locals
+      Thread.current[:concurrent_fiber_locals]
+    end
+
+    def locals!
+      thread = Thread.current
+      locals = thread[:concurrent_fiber_locals]
+
+      unless locals
+        locals = thread[:concurrent_fiber_locals] = []
+        weak_synchronize do
+          @all_arrays[locals.object_id] = locals
+        end
+        # When the fiber goes out of scope, we should delete the associated locals:
+        ObjectSpace.define_finalizer(Fiber.current, thread_fiber_finalizer(locals.object_id))
+      end
+
+      locals
+    end
+  end
+
+  private_constant :AbstractLocals, :ThreadLocals, :FiberLocals
+end

data/lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb

@@ -0,0 +1,28 @@
+require 'concurrent/utility/engine'
+require_relative 'fiber_local_var'
+require_relative 'thread_local_var'
+
+module Concurrent
+  # @!visibility private
+  def self.mutex_owned_per_thread?
+    return false if Concurrent.on_jruby? || Concurrent.on_truffleruby?
+
+    mutex = Mutex.new
+    # Lock the mutex:
+    mutex.synchronize do
+      # Check if the mutex is still owned in a child fiber:
+      Fiber.new { mutex.owned? }.resume
+    end
+  end
+
+  if mutex_owned_per_thread?
+    LockLocalVar = ThreadLocalVar
+  else
+    LockLocalVar = FiberLocalVar
+  end
+
+  # Either {FiberLocalVar} or {ThreadLocalVar} depending on whether Mutex (and Monitor)
+  # are held, respectively, per Fiber or per Thread.
+  class LockLocalVar
+  end
+end