concurrent-ruby 1.1.8 → 1.2.2

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

@@ -0,0 +1,189 @@
+require 'fiber'
+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

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

@@ -1,16 +1,18 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/safe_initialization'
 
 module Concurrent
 
   # @!macro atomic_boolean
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicBoolean < Synchronization::LockableObject
+  class MutexAtomicBoolean
+    extend Concurrent::Synchronization::SafeInitialization
 
     # @!macro atomic_boolean_method_initialize
     def initialize(initial = false)
       super()
-      synchronize { ns_initialize(initial) }
+      @Lock = ::Mutex.new
+      @value = !!initial
     end
 
     # @!macro atomic_boolean_method_value_get
@@ -46,8 +48,12 @@ module Concurrent
     protected
 
     # @!visibility private
-    def ns_initialize(initial)
-      @value = !!initial
+    def synchronize
+      if @Lock.owned?
+        yield
+      else
+        @Lock.synchronize { yield }
+      end
     end
 
     private

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

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/safe_initialization'
 require 'concurrent/utility/native_integer'
 
 module Concurrent
@@ -6,12 +6,14 @@ module Concurrent
   # @!macro atomic_fixnum
   # @!visibility private
   # @!macro internal_implementation_note
-  class MutexAtomicFixnum < Synchronization::LockableObject
+  class MutexAtomicFixnum
+    extend Concurrent::Synchronization::SafeInitialization
 
     # @!macro atomic_fixnum_method_initialize
     def initialize(initial = 0)
       super()
-      synchronize { ns_initialize(initial) }
+      @Lock = ::Mutex.new
+      ns_set(initial)
     end
 
     # @!macro atomic_fixnum_method_value_get
@@ -60,8 +62,12 @@ module Concurrent
     protected
 
     # @!visibility private
-    def ns_initialize(initial)
-      ns_set(initial)
+    def synchronize
+      if @Lock.owned?
+        yield
+      else
+        @Lock.synchronize { yield }
+      end
     end
 
     private

data/lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.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/mutex_semaphore.rb

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 require 'concurrent/utility/native_integer'
 
 module Concurrent
@@ -23,7 +23,14 @@ module Concurrent
 
       synchronize do
         try_acquire_timed(permits, nil)
-        nil
+      end
+
+      return unless block_given?
+
+      begin
+        yield
+      ensure
+        release(permits)
       end
     end
 
@@ -48,13 +55,22 @@ module Concurrent
       Utility::NativeInteger.ensure_integer_and_bounds permits
       Utility::NativeInteger.ensure_positive permits
 
-      synchronize do
+      acquired = synchronize do
         if timeout.nil?
           try_acquire_now(permits)
         else
           try_acquire_timed(permits, timeout)
         end
       end
+
+      return acquired unless block_given?
+      return unless acquired
+
+      begin
+        yield
+      ensure
+        release(permits)
+      end
     end
 
     # @!macro semaphore_method_release

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

@@ -1,7 +1,8 @@
 require 'thread'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lock'
 
 module Concurrent
 

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

@@ -1,8 +1,10 @@
 require 'thread'
 require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
-require 'concurrent/atomic/thread_local_var'
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lock'
+require 'concurrent/atomic/lock_local_var'
 
 module Concurrent
 
@@ -109,7 +111,7 @@ module Concurrent
       @Counter    = AtomicFixnum.new(0)       # single integer which represents lock state
       @ReadQueue  = Synchronization::Lock.new # used to queue waiting readers
       @WriteQueue = Synchronization::Lock.new # used to queue waiting writers
-      @HeldCount  = ThreadLocalVar.new(0)     # indicates # of R & W locks held by this thread
+      @HeldCount  = LockLocalVar.new(0) # indicates # of R & W locks held by this thread
     end
 
     # Execute a block operation within a read lock.
@@ -267,12 +269,10 @@ module Concurrent
         #   running right now, AND no writers who came before us still waiting to
         #   acquire the lock
         # Additionally, if any read locks have been taken, we must hold all of them
-        if c == held
-          # If we successfully swap the RUNNING_WRITER bit on, then we can go ahead
-          if @Counter.compare_and_set(c, c+RUNNING_WRITER)
-            @HeldCount.value = held + WRITE_LOCK_HELD
-            return true
-          end
+        if held > 0 && @Counter.compare_and_set(1, c+RUNNING_WRITER)
+          # If we are the only one reader and successfully swap the RUNNING_WRITER bit on, then we can go ahead
+          @HeldCount.value = held + WRITE_LOCK_HELD
+          return true
         elsif @Counter.compare_and_set(c, c+WAITING_WRITER)
           while true
             # Now we have successfully incremented, so no more readers will be able to increment

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

@@ -1,5 +1,4 @@
 require 'concurrent/atomic/mutex_semaphore'
-require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -11,19 +10,20 @@ module Concurrent
   #
   #   @param [Fixnum] count the initial count
   #
-  #   @raise [ArgumentError] if `count` is not an integer or is less than zero
+  #   @raise [ArgumentError] if `count` is not an integer
 
   # @!macro semaphore_method_acquire
   #
   #   Acquires the given number of permits from this semaphore,
-  #     blocking until all are available.
+  #     blocking until all are available. If a block is given,
+  #     yields to it and releases the permits afterwards.
   #
   #   @param [Fixnum] permits Number of permits to acquire
   #
-  #   @raise [ArgumentError] if `permits` is not an integer or is less than
-  #     one
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than zero
   #
-  #   @return [nil]
+  #   @return [nil, BasicObject] Without a block, `nil` is returned. If a block
+  #   is given, its return value is returned.
 
   # @!macro semaphore_method_available_permits
   #
@@ -41,18 +41,21 @@ module Concurrent
   #
   #   Acquires the given number of permits from this semaphore,
   #     only if all are available at the time of invocation or within
-  #     `timeout` interval
+  #     `timeout` interval. If a block is given, yields to it if the permits
+  #     were successfully acquired, and releases them afterward, returning the
+  #     block's return value.
   #
   #   @param [Fixnum] permits the number of permits to acquire
   #
   #   @param [Fixnum] timeout the number of seconds to wait for the counter
   #     or `nil` to return immediately
   #
-  #   @raise [ArgumentError] if `permits` is not an integer or is less than
-  #     one
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than zero
   #
-  #   @return [Boolean] `false` if no permits are available, `true` when
-  #     acquired a permit
+  #   @return [true, false, nil, BasicObject] `false` if no permits are
+  #     available, `true` when acquired a permit. If a block is given, the
+  #     block's return value is returned if the permits were acquired; if not,
+  #     `nil` is returned.
 
   # @!macro semaphore_method_release
   #
@@ -60,7 +63,7 @@ module Concurrent
   #
   #   @param [Fixnum] permits Number of permits to return to the semaphore.
   #
-  #   @raise [ArgumentError] if `permits` is not a number or is less than one
+  #   @raise [ArgumentError] if `permits` is not a number or is less than zero
   #
   #   @return [nil]
 
@@ -90,8 +93,8 @@ module Concurrent
 
   # @!visibility private
   # @!macro internal_implementation_note
-  SemaphoreImplementation = case
-                            when defined?(JavaSemaphore)
+  SemaphoreImplementation = if Concurrent.on_jruby?
+                              require 'concurrent/utility/native_extension_loader'
                               JavaSemaphore
                             else
                               MutexSemaphore
@@ -106,6 +109,8 @@ module Concurrent
   #   releasing a blocking acquirer.
   #   However, no actual permit objects are used; the Semaphore just keeps a
   #   count of the number available and acts accordingly.
+  #   Alternatively, permits may be acquired within a block, and automatically
+  #   released after the block finishes executing.
   #
   # @!macro semaphore_public_api
   # @example
@@ -140,6 +145,19 @@ module Concurrent
   #   # Thread 4 releasing semaphore
   #   # Thread 1 acquired semaphore
   #
+  # @example
+  #   semaphore = Concurrent::Semaphore.new(1)
+  #
+  #   puts semaphore.available_permits
+  #   semaphore.acquire do
+  #     puts semaphore.available_permits
+  #   end
+  #   puts semaphore.available_permits
+  #
+  #   # prints:
+  #   # 1
+  #   # 0
+  #   # 1
   class Semaphore < SemaphoreImplementation
   end
 end