concurrent-ruby 1.0.5 → 1.1.6

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,7 +13,7 @@ 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.
@@ -25,19 +25,19 @@ module Concurrent
   #
   #   @return [nil]
 
-  # @!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
@@ -54,7 +54,7 @@ module Concurrent
   #   @return [Boolean] `false` if no permits are available, `true` when
   #     acquired a permit
 
-  # @!macro [new] semaphore_method_release
+  # @!macro semaphore_method_release
   #
   #   Releases the given number of permits, returning them to the semaphore.
   #
@@ -66,7 +66,7 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] semaphore_public_api
+  # @!macro semaphore_public_api
   #
   #   @!method initialize(count)
   #     @!macro semaphore_method_initialize
@@ -98,7 +98,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

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/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 → concurrent-ruby/concurrent}/collection/non_concurrent_priority_queue.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/collection/java_non_concurrent_priority_queue'
 require 'concurrent/collection/ruby_non_concurrent_priority_queue'
-require 'concurrent/utility/engine'
 
 module Concurrent
   module Collection
@@ -15,7 +15,7 @@ module Concurrent
                                                end
     private_constant :NonConcurrentPriorityQueueImplementation
 
-    # @!macro [attach] priority_queue
+    # @!macro priority_queue
     #
     #   A queue collection in which the elements are sorted based on their
     #   comparison (spaceship) operator `<=>`. Items are added to the queue
@@ -45,7 +45,7 @@ module Concurrent
     #   @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
     #
     #   @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
-    # 
+    #
     # @!visibility private
     class NonConcurrentPriorityQueue < NonConcurrentPriorityQueueImplementation
 
@@ -60,83 +60,83 @@ module Concurrent
       alias_method :enq, :push
 
       # @!method initialize(opts = {})
-      #   @!macro [new] priority_queue_method_initialize
+      #   @!macro priority_queue_method_initialize
       #
       #     Create a new priority queue with no items.
-      #    
+      #
       #     @param [Hash] opts the options for creating the queue
       #     @option opts [Symbol] :order (:max) dictates the order in which items are
       #       stored: from highest to lowest when `:max` or `:high`; from lowest to
       #       highest when `:min` or `:low`
 
       # @!method clear
-      #   @!macro [new] priority_queue_method_clear
+      #   @!macro priority_queue_method_clear
       #
       #     Removes all of the elements from this priority queue.
 
       # @!method delete(item)
-      #   @!macro [new] priority_queue_method_delete
+      #   @!macro priority_queue_method_delete
       #
       #     Deletes all items from `self` that are equal to `item`.
-      #  
+      #
       #     @param [Object] item the item to be removed from the queue
       #     @return [Object] true if the item is found else false
 
       # @!method empty?
-      #   @!macro [new] priority_queue_method_empty
-      #  
+      #   @!macro priority_queue_method_empty
+      #
       #     Returns `true` if `self` contains no elements.
-      #  
+      #
       #     @return [Boolean] true if there are no items in the queue else false
 
       # @!method include?(item)
-      #   @!macro [new] priority_queue_method_include
+      #   @!macro priority_queue_method_include
       #
       #     Returns `true` if the given item is present in `self` (that is, if any
       #     element == `item`), otherwise returns false.
-      #  
+      #
       #     @param [Object] item the item to search for
-      #  
+      #
       #     @return [Boolean] true if the item is found else false
 
       # @!method length
-      #   @!macro [new] priority_queue_method_length
-      #    
+      #   @!macro priority_queue_method_length
+      #
       #     The current length of the queue.
-      #    
+      #
       #     @return [Fixnum] the number of items in the queue
 
       # @!method peek
-      #   @!macro [new] priority_queue_method_peek
-      #    
+      #   @!macro priority_queue_method_peek
+      #
       #     Retrieves, but does not remove, the head of this queue, or returns `nil`
       #     if this queue is empty.
-      #     
+      #
       #     @return [Object] the head of the queue or `nil` when empty
 
       # @!method pop
-      #   @!macro [new] priority_queue_method_pop
-      #    
+      #   @!macro priority_queue_method_pop
+      #
       #     Retrieves and removes the head of this queue, or returns `nil` if this
       #     queue is empty.
-      #     
+      #
       #     @return [Object] the head of the queue or `nil` when empty
 
       # @!method push(item)
-      #   @!macro [new] priority_queue_method_push
-      #    
+      #   @!macro priority_queue_method_push
+      #
       #     Inserts the specified element into this priority queue.
-      #    
+      #
       #     @param [Object] item the item to insert onto the queue
 
       # @!method self.from_list(list, opts = {})
-      #   @!macro [new] priority_queue_method_from_list
-      #    
+      #   @!macro priority_queue_method_from_list
+      #
       #     Create a new priority queue from the given list.
-      #    
+      #
       #     @param [Enumerable] list the list to build the queue from
       #     @param [Hash] opts the options for creating the queue
-      #    
+      #
       #     @return [NonConcurrentPriorityQueue] the newly created and populated queue
     end
   end