concurrent-ruby 1.0.5 → 1.1.10

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/ruby_thread_local_var.rb

@@ -28,16 +28,31 @@ module Concurrent
     # But when a Thread is GC'd, we need to drop the reference to its thread-local
     #   array, so we don't leak memory
 
-    # @!visibility private
-    FREE   = []
-    LOCK   = Mutex.new
-    ARRAYS = {} # used as a hash set
-    @@next = 0
-    private_constant :FREE, :LOCK, :ARRAYS
+    FREE                = []
+    LOCK                = Mutex.new
+    THREAD_LOCAL_ARRAYS = {} # used as a hash set
+
+    # synchronize when not on MRI
+    # on MRI using lock in finalizer leads to "can't be called from trap context" error
+    # so the code is carefully written to be tread-safe on MRI relying on GIL
+
+    if Concurrent.on_cruby?
+      # @!visibility private
+      def self.semi_sync(&block)
+        block.call
+      end
+    else
+      # @!visibility private
+      def self.semi_sync(&block)
+        LOCK.synchronize(&block)
+      end
+    end
+
+    private_constant :FREE, :LOCK, :THREAD_LOCAL_ARRAYS
 
     # @!macro thread_local_var_method_get
     def value
-      if array = get_threadlocal_array
+      if (array = get_threadlocal_array)
         value = array[@index]
         if value.nil?
           default
@@ -57,10 +72,10 @@ module Concurrent
       # We could keep the thread-local arrays in a hash, keyed by Thread
       # But why? That would require locking
       # Using Ruby's built-in thread-local storage is faster
-      unless array = get_threadlocal_array(me)
+      unless (array = get_threadlocal_array(me))
         array = set_threadlocal_array([], me)
-        LOCK.synchronize { ARRAYS[array.object_id] = array }
-        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
+        self.class.semi_sync { THREAD_LOCAL_ARRAYS[array.object_id] = array }
+        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array.object_id))
       end
       array[@index] = (value.nil? ? NULL : value)
       value
@@ -70,48 +85,52 @@ module Concurrent
 
     # @!visibility private
     def allocate_storage
-      @index = LOCK.synchronize do
-        FREE.pop || begin
-          result = @@next
-          @@next += 1
-          result
-        end
-      end
-      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
+      @index = FREE.pop || next_index
+
+      ObjectSpace.define_finalizer(self, self.class.thread_local_finalizer(@index))
     end
 
     # @!visibility private
-    def self.threadlocal_finalizer(index)
+    def self.thread_local_finalizer(index)
       proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            FREE.push(index)
-            # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-            # But that is natural! More threads means more storage is used per TLV
-            # So naturally more CPU time is required to free more storage
-            ARRAYS.each_value do |array|
-              array[index] = nil
-            end
-          end
+        semi_sync do
+          # The cost of GC'ing a TLV is linear in the number of threads using TLVs
+          # But that is natural! More threads means more storage is used per TLV
+          # 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 #value= method
+          THREAD_LOCAL_ARRAYS.values.each { |array| array[index] = nil }
+          # free index has to be published after the arrays are cleared
+          FREE.push(index)
         end
       end
     end
 
     # @!visibility private
-    def self.thread_finalizer(array)
+    def self.thread_finalizer(id)
       proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            # The thread which used this thread-local array is now gone
-            # So don't hold onto a reference to the array (thus blocking GC)
-            ARRAYS.delete(array.object_id)
-          end
+        semi_sync do
+          # The thread which used this thread-local array is now gone
+          # So don't hold onto a reference to the array (thus blocking GC)
+          THREAD_LOCAL_ARRAYS.delete(id)
         end
       end
     end
 
     private
 
+    # noinspection RubyClassVariableUsageInspection
+    @@next = 0
+    # noinspection RubyClassVariableUsageInspection
+    def next_index
+      LOCK.synchronize do
+        result = @@next
+        @@next += 1
+        result
+      end
+    end
+
     if Thread.instance_methods.include?(:thread_variable_get)
 
       def get_threadlocal_array(thread = Thread.current)
@@ -136,21 +155,22 @@ module Concurrent
     # This exists only for use in testing
     # @!visibility private
     def value_for(thread)
-      if array = get_threadlocal_array(thread)
+      if (array = get_threadlocal_array(thread))
         value = array[@index]
         if value.nil?
-          default_for(thread)
+          get_default
         elsif value.equal?(NULL)
           nil
         else
           value
         end
       else
-        default_for(thread)
+        get_default
       end
     end
 
-    def default_for(thread)
+    # @!visibility private
+    def get_default
       if @default_block
         raise "Cannot use default_for with default block"
       else

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/semaphore.rb

@@ -5,7 +5,7 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] semaphore_method_initialize
+  # @!macro semaphore_method_initialize
   #
   #   Create a new `Semaphore` with the initial `count`.
   #
@@ -13,35 +13,39 @@ module Concurrent
   #
   #   @raise [ArgumentError] if `count` is not an integer or is less than zero
 
-  # @!macro [new] semaphore_method_acquire
+  # @!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
   #
-  #   @return [nil]
+  #   @return [nil, BasicObject] Without a block, `nil` is returned. If a block
+  #   is given, its return value is returned.
 
-  # @!macro [new] semaphore_method_available_permits
+  # @!macro semaphore_method_available_permits
   #
   #   Returns the current number of permits available in this semaphore.
   #
   #   @return [Integer]
 
-  # @!macro [new] semaphore_method_drain_permits
+  # @!macro semaphore_method_drain_permits
   #
   #   Acquires and returns all permits that are immediately available.
   #
   #   @return [Integer]
 
-  # @!macro [new] semaphore_method_try_acquire
+  # @!macro semaphore_method_try_acquire
   #
   #   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
   #
@@ -51,10 +55,12 @@ module Concurrent
   #   @raise [ArgumentError] if `permits` is not an integer or is less than
   #     one
   #
-  #   @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 [new] semaphore_method_release
+  # @!macro semaphore_method_release
   #
   #   Releases the given number of permits, returning them to the semaphore.
   #
@@ -66,7 +72,7 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] semaphore_public_api
+  # @!macro semaphore_public_api
   #
   #   @!method initialize(count)
   #     @!macro semaphore_method_initialize
@@ -98,7 +104,7 @@ module Concurrent
                             end
   private_constant :SemaphoreImplementation
 
-  # @!macro [attach] semaphore
+  # @!macro semaphore
   #
   #   A counting semaphore. Conceptually, a semaphore maintains a set of
   #   permits. Each {#acquire} blocks if necessary until a permit is
@@ -106,6 +112,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 +148,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

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/thread_local_var.rb

@@ -1,12 +1,12 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/ruby_thread_local_var'
 require 'concurrent/atomic/java_thread_local_var'
-require 'concurrent/utility/engine'
 
 module Concurrent
 
   ###################################################################
 
-  # @!macro [new] thread_local_var_method_initialize
+  # @!macro thread_local_var_method_initialize
   #
   #   Creates a thread local variable.
   #
@@ -14,20 +14,20 @@ module Concurrent
   #   @param [Proc] default_block Optional block that gets called to obtain the
   #     default value for each thread
 
-  # @!macro [new] thread_local_var_method_get
+  # @!macro thread_local_var_method_get
   #
   #   Returns the value in the current thread's copy of this thread-local variable.
   #
   #   @return [Object] the current value
 
-  # @!macro [new] thread_local_var_method_set
+  # @!macro thread_local_var_method_set
   #
   #   Sets the current thread's copy of this thread-local variable to the specified value.
   #
   #   @param [Object] value the value to set
   #   @return [Object] the new value
 
-  # @!macro [new] thread_local_var_method_bind
+  # @!macro thread_local_var_method_bind
   #
   #   Bind the given value to thread local storage during
   #   execution of the given block.
@@ -39,9 +39,9 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] thread_local_var_public_api
+  # @!macro thread_local_var_public_api
   #
-  #   @!method initialize(default = nil)
+  #   @!method initialize(default = nil, &default_block)
   #     @!macro thread_local_var_method_initialize
   #
   #   @!method value
@@ -65,7 +65,7 @@ module Concurrent
                                  end
   private_constant :ThreadLocalVarImplementation
 
-  # @!macro [attach] thread_local_var
+  # @!macro thread_local_var
   #
   #   A `ThreadLocalVar` is a variable where the value is different for each thread.
   #   Each variable may have a default value, but when you modify the variable only

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic_reference/mutex_atomic.rb

@@ -1,16 +1,11 @@
-require 'concurrent/synchronization'
-require 'concurrent/atomic_reference/direct_update'
-require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
 module Concurrent
 
-  # @!macro atomic_reference
-  #
   # @!visibility private
   # @!macro internal_implementation_note
   class MutexAtomicReference < Synchronization::LockableObject
-    include Concurrent::AtomicDirectUpdate
-    include Concurrent::AtomicNumericCompareAndSetWrapper
+    include AtomicDirectUpdate
+    include AtomicNumericCompareAndSetWrapper
+    alias_method :compare_and_swap, :compare_and_set
 
     # @!macro atomic_reference_method_initialize
     def initialize(value = nil)

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic_reference/numeric_cas_wrapper.rb

@@ -23,6 +23,6 @@ module Concurrent
         _compare_and_set(old_value, new_value)
       end
     end
-    alias_method :compare_and_swap, :compare_and_set
+
   end
 end

data/lib/concurrent-ruby/concurrent/atomics.rb

@@ -0,0 +1,10 @@
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/cyclic_barrier'
+require 'concurrent/atomic/count_down_latch'
+require 'concurrent/atomic/event'
+require 'concurrent/atomic/read_write_lock'
+require 'concurrent/atomic/reentrant_read_write_lock'
+require 'concurrent/atomic/semaphore'
+require 'concurrent/atomic/thread_local_var'

data/lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb

@@ -0,0 +1,158 @@
+module Concurrent
+
+  # @!macro warn.edge
+  class LockFreeStack < Synchronization::Object
+
+    safe_initialization!
+
+    class Node
+      # TODO (pitr-ch 20-Dec-2016): Could be unified with Stack class?
+
+      # @return [Node]
+      attr_reader :next_node
+
+      # @return [Object]
+      attr_reader :value
+
+      # @!visibility private
+      # allow to nil-ify to free GC when the entry is no longer relevant, not synchronised
+      attr_writer :value
+
+      def initialize(value, next_node)
+        @value     = value
+        @next_node = next_node
+      end
+
+      singleton_class.send :alias_method, :[], :new
+    end
+
+    # The singleton for empty node
+    EMPTY = Node[nil, nil]
+    def EMPTY.next_node
+      self
+    end
+
+    attr_atomic(:head)
+    private :head, :head=, :swap_head, :compare_and_set_head, :update_head
+
+    # @!visibility private
+    def self.of1(value)
+      new Node[value, EMPTY]
+    end
+
+    # @!visibility private
+    def self.of2(value1, value2)
+      new Node[value1, Node[value2, EMPTY]]
+    end
+
+    # @param [Node] head
+    def initialize(head = EMPTY)
+      super()
+      self.head = head
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def empty?(head = head())
+      head.equal? EMPTY
+    end
+
+    # @param [Node] head
+    # @param [Object] value
+    # @return [true, false]
+    def compare_and_push(head, value)
+      compare_and_set_head head, Node[value, head]
+    end
+
+    # @param [Object] value
+    # @return [self]
+    def push(value)
+      while true
+        current_head = head
+        return self if compare_and_set_head current_head, Node[value, current_head]
+      end
+    end
+
+    # @return [Node]
+    def peek
+      head
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def compare_and_pop(head)
+      compare_and_set_head head, head.next_node
+    end
+
+    # @return [Object]
+    def pop
+      while true
+        current_head = head
+        return current_head.value if compare_and_set_head current_head, current_head.next_node
+      end
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def compare_and_clear(head)
+      compare_and_set_head head, EMPTY
+    end
+
+    include Enumerable
+
+    # @param [Node] head
+    # @return [self]
+    def each(head = nil)
+      return to_enum(:each, head) unless block_given?
+      it = head || peek
+      until it.equal?(EMPTY)
+        yield it.value
+        it = it.next_node
+      end
+      self
+    end
+
+    # @return [true, false]
+    def clear
+      while true
+        current_head = head
+        return false if current_head == EMPTY
+        return true if compare_and_set_head current_head, EMPTY
+      end
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def clear_if(head)
+      compare_and_set_head head, EMPTY
+    end
+
+    # @param [Node] head
+    # @param [Node] new_head
+    # @return [true, false]
+    def replace_if(head, new_head)
+      compare_and_set_head head, new_head
+    end
+
+    # @return [self]
+    # @yield over the cleared stack
+    # @yieldparam [Object] value
+    def clear_each(&block)
+      while true
+        current_head = head
+        return self if current_head == EMPTY
+        if compare_and_set_head current_head, EMPTY
+          each current_head, &block
+          return self
+        end
+      end
+    end
+
+    # @return [String] Short string representation.
+    def to_s
+      format '%s %s>', super[0..-2], to_a.to_s
+    end
+
+    alias_method :inspect, :to_s
+  end
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/map/atomic_reference_map_backend.rb

@@ -289,7 +289,7 @@ module Concurrent
                   end
                 end
               elsif cas_hash(my_hash, my_hash | WAITING)
-                force_aquire_lock(table, i)
+                force_acquire_lock(table, i)
                 break
               end
             end
@@ -330,7 +330,7 @@ module Concurrent
         end
 
         private
-        def force_aquire_lock(table, i)
+        def force_acquire_lock(table, i)
           cheap_synchronize do
             if equal?(table.volatile_get(i)) && (hash & WAITING) == WAITING
               cheap_wait
@@ -831,7 +831,7 @@ module Concurrent
             # no lock needed (or available) if bin >= 0, because we're not popping values from locked_indexes until we've run through the whole table
             redo unless (bin >= 0 ? table.cas(i, nil, forwarder) : lock_and_clean_up_reverse_forwarders(table, old_table_size, new_table, i, forwarder))
           elsif Node.locked_hash?(node_hash = node.hash)
-            locked_indexes ||= Array.new
+            locked_indexes ||= ::Array.new
             if bin < 0 && locked_arr_idx > 0
               locked_arr_idx -= 1
               i, locked_indexes[locked_arr_idx] = locked_indexes[locked_arr_idx], i # swap with another bin

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/map/mri_map_backend.rb

@@ -19,7 +19,7 @@ module Concurrent
       end
 
       def compute_if_absent(key)
-        if stored_value = _get(key) # fast non-blocking path for the most likely case
+        if NULL != (stored_value = @backend.fetch(key, NULL)) # fast non-blocking path for the most likely case
           stored_value
         else
           @write_lock.synchronize { super }

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/map/non_concurrent_map_backend.rb

@@ -10,7 +10,7 @@ module Concurrent
 
       # WARNING: all public methods of the class must operate on the @backend
       # directly without calling each other. This is important because of the
-      # SynchronizedMapBackend which uses a non-reentrant mutex for perfomance
+      # SynchronizedMapBackend which uses a non-reentrant mutex for performance
       # reasons.
       def initialize(options = nil)
         @backend = {}
@@ -95,7 +95,6 @@ module Concurrent
       end
 
       def each_pair
-        return enum_for :each_pair unless block_given?
         dupped_backend.each_pair do |k, v|
           yield k, v
         end

data/lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb

@@ -0,0 +1,14 @@
+module Concurrent
+
+  # @!visibility private
+  module Collection
+
+    # @!visibility private
+    class TruffleRubyMapBackend < TruffleRuby::ConcurrentMap
+      def initialize(options = nil)
+        options ||= {}
+        super(initial_capacity: options[:initial_capacity], load_factor: options[:load_factor])
+      end
+    end
+  end
+end