concurrent-ruby 1.0.5 → 1.1.0.pre2

data/lib/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/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/atomics.rb

@@ -1,46 +1,3 @@
-# @!macro [new] 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
-#     @!macro [new] atomic_reference_method_initialize
-#       @param [Object] value The initial value.
-#
-#   @!method get
-#     @!macro [new] atomic_reference_method_get
-#       Gets the current value.
-#       @return [Object] the current value
-#
-#   @!method set
-#     @!macro [new] 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
-#     @!macro [new] 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
-#     @!macro [new] 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.
-
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/atomic/atomic_fixnum'

data/lib/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 = self.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/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/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/collection/non_concurrent_priority_queue.rb

@@ -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

data/lib/concurrent/concern/dereferenceable.rb

@@ -32,7 +32,7 @@ module Concurrent
         synchronize{ @value = value }
       end
 
-      # @!macro [attach] dereferenceable_set_deref_options
+      # @!macro dereferenceable_set_deref_options
       #   Set the options which define the operations #value performs before
       #   returning data to the caller (dereferencing).
       #

data/lib/concurrent/concern/logging.rb

@@ -17,7 +17,12 @@ module Concurrent
       def log(level, progname, message = nil, &block)
         #NOTE: Cannot require 'concurrent/configuration' above due to circular references.
         #      Assume that the gem has been initialized if we've gotten this far.
-        (@logger || Concurrent.global_logger).call level, progname, message, &block
+        logger = if defined?(@logger) && @logger
+                   @logger
+                 else
+                   Concurrent.global_logger
+                 end
+        logger.call level, progname, message, &block
       rescue => error
         $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
           "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"

data/lib/concurrent/concern/observable.rb

@@ -49,7 +49,7 @@ module Concurrent
     # or an AtomicFixum)
     module Observable
 
-      # @!macro [attach] observable_add_observer
+      # @!macro observable_add_observer
       #
       #   Adds an observer to this set. If a block is passed, the observer will be
       #   created by this method and no other params should be passed.
@@ -72,8 +72,8 @@ module Concurrent
         self
       end
 
-      # @!macro [attach] observable_delete_observer
-      # 
+      # @!macro observable_delete_observer
+      #
       #   Remove `observer` as an observer on this object so that it will no
       #   longer receive notifications.
       #
@@ -83,17 +83,17 @@ module Concurrent
         observers.delete_observer(observer)
       end
 
-      # @!macro [attach] observable_delete_observers
-      # 
+      # @!macro observable_delete_observers
+      #
       #   Remove all observers associated with this object.
-      #   
+      #
       #   @return [Observable] self
       def delete_observers
         observers.delete_observers
         self
       end
 
-      # @!macro [attach] observable_count_observers
+      # @!macro observable_count_observers
       #
       #   Return the number of observers associated with this object.
       #