concurrent-ruby 0.8.0 → 0.9.0.pre2

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -3,6 +3,9 @@ require 'concurrent/atomic_reference/concurrent_update_error'
 module Concurrent
 
   # Define update methods that use direct paths
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
   module AtomicDirectUpdate
 
     # @!macro [attach] atomic_reference_method_update

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,12 +1,15 @@
-require_relative '../../extension_helper'
+require 'concurrent/utility/native_extension_loader'
 
-if defined?(Concurrent::JavaAtomic)
+if defined?(Concurrent::JavaAtomicReference)
   require 'concurrent/atomic_reference/direct_update'
 
   module Concurrent
 
     # @!macro atomic_reference
-    class JavaAtomic
+    #
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class JavaAtomicReference
       include Concurrent::AtomicDirectUpdate
     end
   end

data/lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -5,45 +5,32 @@ require 'concurrent/atomic_reference/numeric_cas_wrapper'
 module Concurrent
 
   # @!macro atomic_reference
-  class MutexAtomic
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class MutexAtomicReference
     include Concurrent::AtomicDirectUpdate
     include Concurrent::AtomicNumericCompareAndSetWrapper
 
-    # @!macro [attach] atomic_reference_method_initialize
+    # @!macro atomic_reference_method_initialize
     def initialize(value = nil)
       @mutex = Mutex.new
       @value = value
     end
 
-    # @!macro [attach] atomic_reference_method_get
-    #
-    #   Gets the current value.
-    #
-    #   @return [Object] the current value
+    # @!macro atomic_reference_method_get
     def get
       @mutex.synchronize { @value }
     end
     alias_method :value, :get
 
-    # @!macro [attach] atomic_reference_method_set
-    #
-    #   Sets to the given value.
-    #
-    #   @param [Object] new_value the new value
-    #
-    #   @return [Object] the new value
+    # @!macro atomic_reference_method_set
     def set(new_value)
       @mutex.synchronize { @value = new_value }
     end
     alias_method :value=, :set
 
-    # @!macro [attach] 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
+    # @!macro atomic_reference_method_get_and_set
     def get_and_set(new_value)
       @mutex.synchronize do
         old_value = @value
@@ -53,17 +40,8 @@ module Concurrent
     end
     alias_method :swap, :get_and_set
 
-    # @!macro [attach] 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.
-    def _compare_and_set(old_value, new_value) #:nodoc:
+    # @!macro atomic_reference_method_compare_and_set
+    def _compare_and_set(old_value, new_value)
       return false unless @mutex.try_lock
       begin
         return false unless @value.equal? old_value

data/lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -1,6 +1,9 @@
 module Concurrent
 
   # Special "compare and set" handling of numeric values.
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
   module AtomicNumericCompareAndSetWrapper
 
     # @!macro atomic_reference_method_compare_and_set

data/lib/concurrent/atomic_reference/rbx.rb

@@ -7,7 +7,10 @@ module Concurrent
   #
   # @note Extends `Rubinius::AtomicReference` version adding aliases
   #   and numeric logic.
-  class RbxAtomic < Rubinius::AtomicReference
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class RbxAtomicReference < Rubinius::AtomicReference
     alias _compare_and_set compare_and_set
     include Concurrent::AtomicDirectUpdate
     include Concurrent::AtomicNumericCompareAndSetWrapper

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,12 +1,15 @@
-if defined? Concurrent::CAtomic
-  require_relative '../../extension_helper'
+if defined? Concurrent::CAtomicReference
+  require 'concurrent/utility/native_extension_loader'
   require 'concurrent/atomic_reference/direct_update'
   require 'concurrent/atomic_reference/numeric_cas_wrapper'
 
   module Concurrent
 
     # @!macro atomic_reference
-    class CAtomic
+    #
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class CAtomicReference
       include Concurrent::AtomicDirectUpdate
       include Concurrent::AtomicNumericCompareAndSetWrapper
 

data/lib/concurrent/atomics.rb

@@ -1,12 +1,82 @@
-require 'concurrent/atomic'
+# @!macro [new] atomic_reference
+#
+#   An object reference that may be updated atomically.
+#
+#       Testing with ruby 2.1.2
+#       
+#       *** Sequential updates ***
+#                                 user     system      total        real
+#       no lock               0.000000   0.000000   0.000000 (  0.005502)
+#       mutex                 0.030000   0.000000   0.030000 (  0.025158)
+#       MutexAtomicReference  0.100000   0.000000   0.100000 (  0.103096)
+#       CAtomicReference      0.040000   0.000000   0.040000 (  0.034012)
+#       
+#       *** Parallel updates ***
+#                                 user     system      total        real
+#       no lock               0.010000   0.000000   0.010000 (  0.009387)
+#       mutex                 0.030000   0.010000   0.040000 (  0.032545)
+#       MutexAtomicReference  0.830000   2.280000   3.110000 (  2.146622)
+#       CAtomicReference      0.040000   0.000000   0.040000 (  0.038332)
+#
+#       Testing with jruby 1.9.3
+#       
+#       *** Sequential updates ***
+#                                 user     system      total        real
+#       no lock               0.170000   0.000000   0.170000 (  0.051000)
+#       mutex                 0.370000   0.010000   0.380000 (  0.121000)
+#       MutexAtomicReference  1.530000   0.020000   1.550000 (  0.471000)
+#       JavaAtomicReference   0.370000   0.010000   0.380000 (  0.112000)
+#       
+#       *** Parallel updates ***
+#                                 user     system      total        real
+#       no lock               0.390000   0.000000   0.390000 (  0.105000)
+#       mutex                 0.480000   0.040000   0.520000 (  0.145000)
+#       MutexAtomicReference  1.600000   0.180000   1.780000 (  0.511000)
+#       JavaAtomicReference   0.460000   0.010000   0.470000 (  0.131000)
+#
+#   @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'
 require 'concurrent/atomic/condition'
-require 'concurrent/atomic/copy_on_notify_observer_set'
-require 'concurrent/atomic/copy_on_write_observer_set'
 require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'
-require 'concurrent/atomic/synchronization'
+require 'concurrent/atomic/read_write_lock'
 require 'concurrent/atomic/semaphore'
 require 'concurrent/atomic/thread_local_var'

data/lib/concurrent/collection/copy_on_notify_observer_set.rb

@@ -0,0 +1,115 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # A thread safe observer set implemented using copy-on-read approach:
+    # observers are added and removed from a thread safe collection; every time
+    # a notification is required the internal data structure is copied to
+    # prevent concurrency issues
+    # 
+    # @api private
+    class CopyOnNotifyObserverSet < Synchronization::Object
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # 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
+      #
+      # @param [Object] observer the observer to add
+      # @param [Symbol] func the function to call on the observer during notification.
+      #   Default is :update
+      # @return [Object] the added observer
+      def add_observer(observer=nil, func=:update, &block)
+        if observer.nil? && block.nil?
+          raise ArgumentError, 'should pass observer as a first argument or block'
+        elsif observer && block
+          raise ArgumentError.new('cannot provide both an observer and a block')
+        end
+
+        if block
+          observer = block
+          func     = :call
+        end
+
+        synchronize do
+          @observers[observer] = func
+          observer
+        end
+      end
+
+      # @param [Object] observer the observer to remove
+      # @return [Object] the deleted observer
+      def delete_observer(observer)
+        synchronize do
+          @observers.delete(observer)
+          observer
+        end
+      end
+
+      # Deletes all observers
+      # @return [CopyOnWriteObserverSet] self
+      def delete_observers
+        synchronize do
+          @observers.clear
+          self
+        end
+      end
+
+      # @return [Integer] the observers count
+      def count_observers
+        synchronize { @observers.count }
+      end
+
+      # Notifies all registered observers with optional args
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_observers(*args, &block)
+        observers = duplicate_observers
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      # Notifies all registered observers with optional args and deletes them.
+      #
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_and_delete_observers(*args, &block)
+        observers = duplicate_and_clear_observers
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      end
+
+      private
+
+      def duplicate_and_clear_observers
+        synchronize do
+          observers = @observers.dup
+          @observers.clear
+          observers
+        end
+      end
+
+      def duplicate_observers
+        synchronize { observers = @observers.dup }
+      end
+
+      def notify_to(observers, *args)
+        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+        observers.each do |observer, function|
+          args = yield if block_given?
+          observer.send(function, *args)
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/collection/copy_on_write_observer_set.rb

@@ -0,0 +1,119 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # A thread safe observer set implemented using copy-on-write approach:
+    # every time an observer is added or removed the whole internal data structure is
+    # duplicated and replaced with a new one.
+    # 
+    # @api private
+    class CopyOnWriteObserverSet < Synchronization::Object
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # 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
+      # @param [Object] observer the observer to add
+      # @param [Symbol] func the function to call on the observer during notification.
+      #   Default is :update
+      # @return [Object] the added observer
+      def add_observer(observer=nil, func=:update, &block)
+        if observer.nil? && block.nil?
+          raise ArgumentError, 'should pass observer as a first argument or block'
+        elsif observer && block
+          raise ArgumentError.new('cannot provide both an observer and a block')
+        end
+
+        if block
+          observer = block
+          func = :call
+        end
+
+        synchronize do
+          new_observers = @observers.dup
+          new_observers[observer] = func
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # @param [Object] observer the observer to remove
+      # @return [Object] the deleted observer
+      def delete_observer(observer)
+        synchronize do
+          new_observers = @observers.dup
+          new_observers.delete(observer)
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # Deletes all observers
+      # @return [CopyOnWriteObserverSet] self
+      def delete_observers
+        self.observers = {}
+        self
+      end
+
+      # @return [Integer] the observers count
+      def count_observers
+        observers.count
+      end
+
+      # Notifies all registered observers with optional args
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_observers(*args, &block)
+        notify_to(observers, *args, &block)
+        self
+      end
+
+      # Notifies all registered observers with optional args and deletes them.
+      #
+      # @param [Object] args arguments to be passed to each observer
+      # @return [CopyOnWriteObserverSet] self
+      def notify_and_delete_observers(*args, &block)
+        old = clear_observers_and_return_old
+        notify_to(old, *args, &block)
+        self
+      end
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      end
+
+      private
+
+      def notify_to(observers, *args)
+        raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+        observers.each do |observer, function|
+          args = yield if block_given?
+          observer.send(function, *args)
+        end
+      end
+
+      def observers
+        synchronize { @observers }
+      end
+
+      def observers=(new_set)
+        synchronize { @observers = new_set }
+      end
+
+      def clear_observers_and_return_old
+        synchronize do
+          old_observers = @observers
+          @observers = {}
+          old_observers
+        end
+      end
+    end
+  end
+end