concurrent-ruby 1.1.10 → 1.3.7

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/adder.rb

@@ -9,7 +9,7 @@ module Concurrent
     # @!visibility private
     module Util
 
-      # A Ruby port of the Doug Lea's jsr166e.LondAdder class version 1.8
+      # A Ruby port of the Doug Lea's jsr166e.LongAdder class version 1.8
       # available in public domain.
       #
       # Original source code available here:

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/thread_safe/util/xor_shift_random.rb

@@ -15,7 +15,7 @@ module Concurrent
       # Usage:
       #   x = XorShiftRandom.get # uses Kernel.rand to generate an initial seed
       #   while true
-      #     if (x = XorShiftRandom.xorshift).odd? # thread-localy generate a next random number
+      #     if (x = XorShiftRandom.xorshift).odd? # thread-locally generate a next random number
       #       do_something_at_random
       #     end
       #   end

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

@@ -2,6 +2,7 @@ require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/concern/dereferenceable'
 require 'concurrent/concern/observable'
 require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/ruby_executor_service'
 require 'concurrent/executor/safe_task_executor'
@@ -32,6 +33,17 @@ module Concurrent
   # be tested separately then passed to the `TimerTask` for scheduling and
   # running.
   #
+  # A `TimerTask` supports two different types of interval calculations.
+  # A fixed delay will always wait the same amount of time between the
+  # completion of one task and the start of the next. A fixed rate will
+  # attempt to maintain a constant rate of execution regardless of the
+  # duration of the task. For example, if a fixed rate task is scheduled
+  # to run every 60 seconds but the task itself takes 10 seconds to
+  # complete, the next task will be scheduled to run 50 seconds after
+  # the start of the previous task. If the task takes 70 seconds to
+  # complete, the next task will be start immediately after the previous
+  # task completes. Tasks will not be executed concurrently.
+  #
   # In some cases it may be necessary for a `TimerTask` to affect its own
   # execution cycle. To facilitate this, a reference to the TimerTask instance
   # is passed as an argument to the provided block every time the task is
@@ -74,6 +86,12 @@ module Concurrent
   #
   #   #=> 'Boom!'
   #
+  # @example Configuring `:interval_type` with either :fixed_delay or :fixed_rate, default is :fixed_delay
+  #   task = Concurrent::TimerTask.new(execution_interval: 5, interval_type: :fixed_rate) do
+  #          puts 'Boom!'
+  #        end
+  #   task.interval_type #=> :fixed_rate
+  #
   # @example Last `#value` and `Dereferenceable` mixin
   #   task = Concurrent::TimerTask.new(
   #     dup_on_deref: true,
@@ -87,7 +105,7 @@ module Concurrent
   #
   # @example Controlling execution from within the block
   #   timer_task = Concurrent::TimerTask.new(execution_interval: 1) do |task|
-  #     task.execution_interval.times{ print 'Boom! ' }
+  #     task.execution_interval.to_i.times{ print 'Boom! ' }
   #     print "\n"
   #     task.execution_interval += 1
   #     if task.execution_interval > 5
@@ -96,7 +114,7 @@ module Concurrent
   #     end
   #   end
   #
-  #   timer_task.execute # blocking call - this task will stop itself
+  #   timer_task.execute
   #   #=> Boom!
   #   #=> Boom! Boom!
   #   #=> Boom! Boom! Boom!
@@ -152,18 +170,30 @@ module Concurrent
     # Default `:execution_interval` in seconds.
     EXECUTION_INTERVAL = 60
 
-    # Default `:timeout_interval` in seconds.
-    TIMEOUT_INTERVAL = 30
+    # Maintain the interval between the end of one execution and the start of the next execution.
+    FIXED_DELAY = :fixed_delay
+
+    # Maintain the interval between the start of one execution and the start of the next.
+    # If execution time exceeds the interval, the next execution will start immediately
+    # after the previous execution finishes. Executions will not run concurrently.
+    FIXED_RATE = :fixed_rate
+
+    # Default `:interval_type`
+    DEFAULT_INTERVAL_TYPE = FIXED_DELAY
 
     # Create a new TimerTask with the given task and configuration.
     #
     # @!macro timer_task_initialize
     #   @param [Hash] opts the options defining task execution.
-    #   @option opts [Integer] :execution_interval number of seconds between
+    #   @option opts [Float] :execution_interval number of seconds between
     #     task executions (default: EXECUTION_INTERVAL)
     #   @option opts [Boolean] :run_now Whether to run the task immediately
     #     upon instantiation or to wait until the first #  execution_interval
     #     has passed (default: false)
+    #   @options opts [Symbol] :interval_type method to calculate the interval
+    #     between executions, can be either :fixed_rate or :fixed_delay.
+    #     (default: :fixed_delay)
+    #   @option opts [Executor] executor, default is `global_io_executor`
     #
     #   @!macro deref_options
     #
@@ -207,6 +237,7 @@ module Concurrent
       synchronize do
         if @running.false?
           @running.make_true
+          @age.increment
           schedule_next_task(@run_now ? 0 : @execution_interval)
         end
       end
@@ -242,6 +273,10 @@ module Concurrent
       end
     end
 
+    # @!attribute [r] interval_type
+    # @return [Symbol] method to calculate the interval between executions
+    attr_reader :interval_type
+
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
@@ -264,12 +299,19 @@ module Concurrent
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
+      if opts[:interval_type] && ![FIXED_DELAY, FIXED_RATE].include?(opts[:interval_type])
+        raise ArgumentError.new('interval_type must be either :fixed_delay or :fixed_rate')
+      end
       if opts[:timeout] || opts[:timeout_interval]
         warn 'TimeTask timeouts are now ignored as these were not able to be implemented correctly'
       end
+
       @run_now = opts[:now] || opts[:run_now]
-      @executor = Concurrent::SafeTaskExecutor.new(task)
+      @interval_type = opts[:interval_type] || DEFAULT_INTERVAL_TYPE
+      @task = Concurrent::SafeTaskExecutor.new(task)
+      @executor = opts[:executor] || Concurrent.global_io_executor
       @running = Concurrent::AtomicBoolean.new(false)
+      @age = Concurrent::AtomicFixnum.new(0)
       @value = nil
 
       self.observers = Collection::CopyOnNotifyObserverSet.new
@@ -289,17 +331,20 @@ module Concurrent
 
     # @!visibility private
     def schedule_next_task(interval = execution_interval)
-      ScheduledTask.execute(interval, args: [Concurrent::Event.new], &method(:execute_task))
+      ScheduledTask.execute(interval, executor: @executor, args: [Concurrent::Event.new, @age.value], &method(:execute_task))
       nil
     end
 
     # @!visibility private
-    def execute_task(completion)
+    def execute_task(completion, age_when_scheduled)
       return nil unless @running.true?
-      _success, value, reason = @executor.execute(self)
+      return nil unless @age.value == age_when_scheduled
+
+      start_time = Concurrent.monotonic_time
+      _success, value, reason = @task.execute(self)
       if completion.try?
         self.value = value
-        schedule_next_task
+        schedule_next_task(calculate_next_interval(start_time))
         time = Time.now
         observers.notify_observers do
           [time, self.value, reason]
@@ -307,5 +352,15 @@ module Concurrent
       end
       nil
     end
+
+    # @!visibility private
+    def calculate_next_interval(start_time)
+      if @interval_type == FIXED_RATE
+        run_time = Concurrent.monotonic_time - start_time
+        [execution_interval - run_time, 0].max
+      else # FIXED_DELAY
+        execution_interval
+      end
+    end
   end
 end

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