concurrent-ruby 1.1.10 → 1.2.2

data/lib/concurrent-ruby/concurrent/synchronization/object.rb

@@ -1,28 +1,20 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/synchronization/safe_initialization'
+require 'concurrent/synchronization/volatile'
+require 'concurrent/atomic/atomic_reference'
+
 module Concurrent
   module Synchronization
 
-    # @!visibility private
-    # @!macro internal_implementation_note
-    ObjectImplementation = case
-                           when Concurrent.on_cruby?
-                             MriObject
-                           when Concurrent.on_jruby?
-                             JRubyObject
-                           when Concurrent.on_rbx?
-                             RbxObject
-                           when Concurrent.on_truffleruby?
-                             TruffleRubyObject
-                           else
-                             warn 'Possibly unsupported Ruby implementation'
-                             MriObject
-                           end
-    private_constant :ObjectImplementation
-
     # Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
     # - final instance variables see {Object.safe_initialization!}
     # - volatile instance variables see {Object.attr_volatile}
     # - volatile instance variables see {Object.attr_atomic}
-    class Object < ObjectImplementation
+    # @!visibility private
+    class Object < AbstractObject
+      include Volatile
+
       # TODO make it a module if possible
 
       # @!method self.attr_volatile(*names)
@@ -38,36 +30,12 @@ module Concurrent
         __initialize_atomic_fields__
       end
 
-      # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
-      # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
-      # same behaviour as Java's final fields.
-      # @example
-      #   class AClass < Concurrent::Synchronization::Object
-      #     safe_initialization!
-      #
-      #     def initialize
-      #       @AFinalValue = 'value' # published safely, does not have to be synchronized
-      #     end
-      #   end
-      # @return [true]
       def self.safe_initialization!
-        # define only once, and not again in children
-        return if safe_initialization?
-
-        # @!visibility private
-        def self.new(*args, &block)
-          object = super(*args, &block)
-        ensure
-          object.full_memory_barrier if object
-        end
-
-        @safe_initialization = true
+        extend SafeInitialization unless safe_initialization?
       end
 
-      # @return [true, false] if this class is safely initialized.
       def self.safe_initialization?
-        @safe_initialization = false unless defined? @safe_initialization
-        @safe_initialization || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
+        self.singleton_class < SafeInitialization
       end
 
       # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains

data/lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb

@@ -0,0 +1,36 @@
+require 'concurrent/synchronization/full_memory_barrier'
+
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    #
+    # By extending this module, a class and all its children are marked to be constructed safely. Meaning that
+    # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
+    # same behaviour as Java's final fields.
+    #
+    # Due to using Kernel#extend, the module is not included again if already present in the ancestors,
+    # which avoids extra overhead.
+    #
+    # @example
+    #   class AClass < Concurrent::Synchronization::Object
+    #     extend Concurrent::Synchronization::SafeInitialization
+    #
+    #     def initialize
+    #       @AFinalValue = 'value' # published safely, #foo will never return nil
+    #     end
+    #
+    #     def foo
+    #       @AFinalValue
+    #     end
+    #   end
+    module SafeInitialization
+      def new(*args, &block)
+        super(*args, &block)
+      ensure
+        Concurrent::Synchronization.full_memory_barrier
+      end
+    end
+  end
+end

data/lib/concurrent-ruby/concurrent/synchronization/volatile.rb

@@ -1,3 +1,7 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/full_memory_barrier'
+
 module Concurrent
   module Synchronization
 
@@ -19,18 +23,79 @@ module Concurrent
     #  => 1
     #  foo.bar = 2
     #  => 2
+    #
+    # @!visibility private
+    module Volatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def full_memory_barrier
+        Synchronization.full_memory_barrier
+      end
+
+      module ClassMethods
+        if Concurrent.on_cruby?
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  #{ivar}
+                end
+
+                def #{name}=(value)
+                  #{ivar} = value
+                end
+              RUBY
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+
+        elsif Concurrent.on_jruby?
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  ::Concurrent::Synchronization::JRubyAttrVolatile.instance_variable_get_volatile(self, :#{ivar})
+                end
+
+                def #{name}=(value)
+                  ::Concurrent::Synchronization::JRubyAttrVolatile.instance_variable_set_volatile(self, :#{ivar}, value)
+                end
+              RUBY
+
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+
+        else
+          warn 'Possibly unsupported Ruby implementation' unless Concurrent.on_truffleruby?
+
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  ::Concurrent::Synchronization.full_memory_barrier
+                  #{ivar}
+                end
+
+                def #{name}=(value)
+                  #{ivar} = value
+                  ::Concurrent::Synchronization.full_memory_barrier
+                end
+              RUBY
+            end
+
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+        end
+      end
 
-    Volatile = case
-               when Concurrent.on_cruby?
-                 MriAttrVolatile
-               when Concurrent.on_jruby?
-                 JRubyAttrVolatile
-               when Concurrent.on_rbx?
-                 RbxAttrVolatile
-               when Concurrent.on_truffleruby?
-                 TruffleRubyAttrVolatile
-               else
-                 MriAttrVolatile
-               end
+    end
   end
 end

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

@@ -1,29 +1,12 @@
-require 'concurrent/utility/engine'
-
-require 'concurrent/synchronization/abstract_object'
 require 'concurrent/utility/native_extension_loader' # load native parts first
-Concurrent.load_native_extensions
 
-require 'concurrent/synchronization/mri_object'
-require 'concurrent/synchronization/jruby_object'
-require 'concurrent/synchronization/rbx_object'
-require 'concurrent/synchronization/truffleruby_object'
 require 'concurrent/synchronization/object'
-require 'concurrent/synchronization/volatile'
-
-require 'concurrent/synchronization/abstract_lockable_object'
-require 'concurrent/synchronization/mutex_lockable_object'
-require 'concurrent/synchronization/jruby_lockable_object'
-require 'concurrent/synchronization/rbx_lockable_object'
-
 require 'concurrent/synchronization/lockable_object'
-
 require 'concurrent/synchronization/condition'
 require 'concurrent/synchronization/lock'
 
 module Concurrent
-  # {include:file:docs-source/synchronization.md}
-  # {include:file:docs-source/synchronization-notes.md}
+  # @!visibility private
   module Synchronization
   end
 end

data/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb

@@ -2,49 +2,46 @@ require 'delegate'
 require 'monitor'
 
 module Concurrent
-  unless defined?(SynchronizedDelegator)
-
-    # This class provides a trivial way to synchronize all calls to a given object
-    # by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
-    # around the delegated `#send`. Example:
-    #
-    #   array = [] # not thread-safe on many impls
-    #   array = SynchronizedDelegator.new([]) # thread-safe
-    #
-    # A simple `Monitor` provides a very coarse-grained way to synchronize a given
-    # object, in that it will cause synchronization for methods that have no need
-    # for it, but this is a trivial way to get thread-safety where none may exist
-    # currently on some implementations.
-    #
-    # This class is currently being considered for inclusion into stdlib, via
-    # https://bugs.ruby-lang.org/issues/8556
-    #
-    # @!visibility private
-    class SynchronizedDelegator < SimpleDelegator
-      def setup
-        @old_abort = Thread.abort_on_exception
-        Thread.abort_on_exception = true
-      end
+  # This class provides a trivial way to synchronize all calls to a given object
+  # by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
+  # around the delegated `#send`. Example:
+  #
+  #   array = [] # not thread-safe on many impls
+  #   array = SynchronizedDelegator.new([]) # thread-safe
+  #
+  # A simple `Monitor` provides a very coarse-grained way to synchronize a given
+  # object, in that it will cause synchronization for methods that have no need
+  # for it, but this is a trivial way to get thread-safety where none may exist
+  # currently on some implementations.
+  #
+  # This class is currently being considered for inclusion into stdlib, via
+  # https://bugs.ruby-lang.org/issues/8556
+  #
+  # @!visibility private
+  class SynchronizedDelegator < SimpleDelegator
+    def setup
+      @old_abort = Thread.abort_on_exception
+      Thread.abort_on_exception = true
+    end
 
-      def teardown
-        Thread.abort_on_exception = @old_abort
-      end
+    def teardown
+      Thread.abort_on_exception = @old_abort
+    end
 
-      def initialize(obj)
-        __setobj__(obj)
-        @monitor = Monitor.new
-      end
+    def initialize(obj)
+      __setobj__(obj)
+      @monitor = Monitor.new
+    end
 
-      def method_missing(method, *args, &block)
-        monitor = @monitor
-        begin
-          monitor.enter
-          super
-        ensure
-          monitor.exit
-        end
+    def method_missing(method, *args, &block)
+      monitor = @monitor
+      begin
+        monitor.enter
+        super
+      ensure
+        monitor.exit
       end
-
     end
+
   end
 end

data/lib/concurrent-ruby/concurrent/thread_safe/util/cheap_lockable.rb

@@ -1,5 +1,6 @@
 require 'concurrent/thread_safe/util'
 require 'concurrent/thread_safe/util/volatile'
+require 'concurrent/utility/engine'
 
 module Concurrent
 
@@ -32,45 +33,7 @@ module Concurrent
       # @!visibility private
       module CheapLockable
         private
-        engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
-        if engine == 'rbx'
-          # Making use of the Rubinius' ability to lock via object headers to avoid the overhead of the extra Mutex objects.
-          def cheap_synchronize
-            Rubinius.lock(self)
-            begin
-              yield
-            ensure
-              Rubinius.unlock(self)
-            end
-          end
-
-          def cheap_wait
-            wchan = Rubinius::Channel.new
-
-            begin
-              waiters = @waiters ||= []
-              waiters.push wchan
-              Rubinius.unlock(self)
-              signaled = wchan.receive_timeout nil
-            ensure
-              Rubinius.lock(self)
-
-              unless signaled or waiters.delete(wchan)
-                # we timed out, but got signaled afterwards (e.g. while waiting to
-                # acquire @lock), so pass that signal on to the next waiter
-                waiters.shift << true unless waiters.empty?
-              end
-            end
-
-            self
-          end
-
-          def cheap_broadcast
-            waiters = @waiters ||= []
-            waiters.shift << true until waiters.empty?
-            self
-          end
-        elsif engine == 'jruby'
+        if Concurrent.on_jruby?
           # Use Java's native synchronized (this) { wait(); notifyAll(); } to avoid the overhead of the extra Mutex objects
           require 'jruby'
 

data/lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb

@@ -1,4 +1,5 @@
 require 'concurrent/thread_safe/util'
+require 'concurrent/utility/engine'
 
 # Shim for TruffleRuby.synchronized
 if Concurrent.on_truffleruby? && !TruffleRuby.respond_to?(:synchronized)
@@ -37,43 +38,6 @@ module Concurrent
         end
       end
 
-      def self.make_synchronized_on_rbx(klass)
-        klass.class_eval do
-          private
-
-          def _mon_initialize
-            @_monitor ||= Monitor.new # avoid double initialisation
-          end
-
-          def self.new(*args)
-            obj = super(*args)
-            obj.send(:_mon_initialize)
-            obj
-          end
-        end
-
-        klass.superclass.instance_methods(false).each do |method|
-          case method
-          when :new_range, :new_reserved
-            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method}(*args)
-                obj = super
-                obj.send(:_mon_initialize)
-                obj
-              end
-            RUBY
-          else
-            klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{method}(*args)
-                monitor = @_monitor
-                monitor or raise("BUG: Internal monitor was not properly initialized. Please report this to the concurrent-ruby developers.")
-                monitor.synchronize { super }
-              end
-            RUBY
-          end
-        end
-      end
-
       def self.make_synchronized_on_truffleruby(klass)
         klass.superclass.instance_methods(false).each do |method|
           klass.class_eval <<-RUBY, __FILE__, __LINE__ + 1

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

@@ -23,16 +23,12 @@ module Concurrent
     # The (fixed) size of the tuple.
     attr_reader :size
 
-    # @!visibility private
-    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : ::Array
-    private_constant :Tuple
-
     # Create a new tuple of the given size.
     #
     # @param [Integer] size the number of elements in the tuple
     def initialize(size)
       @size = size
-      @tuple = tuple = Tuple.new(size)
+      @tuple = tuple = ::Array.new(size)
       i = 0
       while i < size
         tuple[i] = Concurrent::AtomicReference.new

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

@@ -1,5 +1,5 @@
 require 'set'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 
@@ -149,6 +149,7 @@ module Concurrent
 
   private
 
+  # @!visibility private
   class Transaction
 
     ABORTED = ::Object.new

data/lib/concurrent-ruby/concurrent/utility/engine.rb

@@ -1,26 +1,19 @@
 module Concurrent
+  # @!visibility private
   module Utility
 
     # @!visibility private
     module EngineDetector
-      def on_jruby?
-        ruby_engine == 'jruby'
-      end
-
-      def on_jruby_9000?
-        on_jruby? && ruby_version(JRUBY_VERSION, :>=, 9, 0, 0)
-      end
-
       def on_cruby?
-        ruby_engine == 'ruby'
+        RUBY_ENGINE == 'ruby'
       end
 
-      def on_rbx?
-        ruby_engine == 'rbx'
+      def on_jruby?
+        RUBY_ENGINE == 'jruby'
       end
 
       def on_truffleruby?
-        ruby_engine == 'truffleruby'
+        RUBY_ENGINE == 'truffleruby'
       end
 
       def on_windows?
@@ -35,10 +28,6 @@ module Concurrent
         !(RbConfig::CONFIG['host_os'] =~ /linux/).nil?
       end
 
-      def ruby_engine
-        defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
-      end
-
       def ruby_version(version = RUBY_VERSION, comparison, major, minor, patch)
         result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
         comparisons = { :== => [0],

data/lib/concurrent-ruby/concurrent/utility/monotonic_time.rb

@@ -1,10 +1,8 @@
-require 'concurrent/synchronization'
-
 module Concurrent
 
   # @!macro monotonic_get_time
   #
-  #   Returns the current time a tracked by the application monotonic clock.
+  #   Returns the current time as tracked by the application monotonic clock.
   #
   #   @param [Symbol] unit the time unit to be returned, can be either
   #     :float_second, :float_millisecond, :float_microsecond, :second,
@@ -14,77 +12,8 @@ module Concurrent
   #     starting point
   #
   #   @!macro monotonic_clock_warning
-  if defined?(Process::CLOCK_MONOTONIC)
-
-    def monotonic_time(unit = :float_second)
-      Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
-    end
-
-  elsif Concurrent.on_jruby?
-
-    # @!visibility private
-    TIME_UNITS = Hash.new { |_hash, key| raise ArgumentError, "unexpected unit: #{key}" }.compare_by_identity
-    TIME_UNITS.merge!(
-      second: 1_000_000_000,
-      millisecond: 1_000_000,
-      microsecond: 1_000,
-      nanosecond: 1,
-      float_second: 1_000_000_000.0,
-      float_millisecond: 1_000_000.0,
-      float_microsecond: 1_000.0,
-    )
-    TIME_UNITS.freeze
-    private_constant :TIME_UNITS
-
-    def monotonic_time(unit = :float_second)
-      java.lang.System.nanoTime() / TIME_UNITS[unit]
-    end
-
-  else
-
-    class_definition = Class.new(Synchronization::LockableObject) do
-      def initialize
-        @last_time = Time.now.to_f
-        @time_units = Hash.new { |_hash, key| raise ArgumentError, "unexpected unit: #{key}" }.compare_by_identity
-        @time_units.merge!(
-          second: [nil, true],
-          millisecond: [1_000, true],
-          microsecond: [1_000_000, true],
-          nanosecond: [1_000_000_000, true],
-          float_second: [nil, false],
-          float_millisecond: [1_000.0, false],
-          float_microsecond: [1_000_000.0, false],
-        )
-        super()
-      end
-
-      # @!visibility private
-      def get_time(unit)
-        synchronize do
-          now = Time.now.to_f
-          if @last_time < now
-            @last_time = now
-          else # clock has moved back in time
-            @last_time += 0.000_001
-          end
-          scale, to_int = @time_units[unit]
-          now *= scale if scale
-          now = now.to_i if to_int
-          now
-        end
-      end
-    end
-
-    # Clock that cannot be set and represents monotonic time since
-    # some unspecified starting point.
-    #
-    # @!visibility private
-    GLOBAL_MONOTONIC_CLOCK = class_definition.new
-    private_constant :GLOBAL_MONOTONIC_CLOCK
-    
-    def monotonic_time(unit = :float_second)
-      GLOBAL_MONOTONIC_CLOCK.get_time(unit)
-    end
+  def monotonic_time(unit = :float_second)
+    Process.clock_gettime(Process::CLOCK_MONOTONIC, unit)
   end
   module_function :monotonic_time
 end

data/lib/concurrent-ruby/concurrent/utility/native_extension_loader.rb

@@ -1,9 +1,10 @@
 require 'concurrent/utility/engine'
+# Synchronization::AbstractObject must be defined before loading the extension
+require 'concurrent/synchronization/abstract_object'
 
 module Concurrent
-
+  # @!visibility private
   module Utility
-
     # @!visibility private
     module NativeExtensionLoader
 
@@ -15,15 +16,7 @@ module Concurrent
         defined?(@c_extensions_loaded) && @c_extensions_loaded
       end
 
-      def java_extensions_loaded?
-        defined?(@java_extensions_loaded) && @java_extensions_loaded
-      end
-
       def load_native_extensions
-        unless defined? Synchronization::AbstractObject
-          raise 'native_extension_loader loaded before Synchronization::AbstractObject'
-        end
-
         if Concurrent.on_cruby? && !c_extensions_loaded?
           ['concurrent/concurrent_ruby_ext',
            "concurrent/#{RUBY_VERSION[0..2]}/concurrent_ruby_ext"
@@ -54,6 +47,10 @@ module Concurrent
         @c_extensions_loaded = true
       end
 
+      def java_extensions_loaded?
+        defined?(@java_extensions_loaded) && @java_extensions_loaded
+      end
+
       def set_java_extensions_loaded
         @java_extensions_loaded = true
       end
@@ -77,3 +74,4 @@ module Concurrent
   extend Utility::NativeExtensionLoader
 end
 
+Concurrent.load_native_extensions

data/lib/concurrent-ruby/concurrent/utility/native_integer.rb

@@ -1,4 +1,5 @@
 module Concurrent
+  # @!visibility private
   module Utility
     # @private
     module NativeInteger