concurrent-ruby 1.0.5 → 1.1.10

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

@@ -0,0 +1,47 @@
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    module TruffleRubyAttrVolatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def attr_volatile(*names)
+          names.each do |name|
+            ivar = :"@volatile_#{name}"
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                full_memory_barrier
+                #{ivar}                  
+              end
+
+              def #{name}=(value)
+                #{ivar} = value
+                full_memory_barrier
+              end
+            RUBY
+          end
+
+          names.map { |n| [n, :"#{n}="] }.flatten
+        end
+      end
+
+      def full_memory_barrier
+        TruffleRuby.full_memory_barrier
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class TruffleRubyObject < AbstractObject
+      include TruffleRubyAttrVolatile
+
+      def initialize
+        # nothing to do
+      end
+    end
+  end
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/volatile.rb

@@ -21,14 +21,16 @@ module Concurrent
     #  => 2
 
     Volatile = case
-    when Concurrent.on_cruby?
-      MriAttrVolatile
-    when Concurrent.on_jruby?
-      JRubyAttrVolatile
-    when Concurrent.on_rbx? || Concurrent.on_truffle?
-      RbxAttrVolatile
-    else
-      MriAttrVolatile
-    end
+               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

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization.rb

@@ -7,15 +7,14 @@ Concurrent.load_native_extensions
 require 'concurrent/synchronization/mri_object'
 require 'concurrent/synchronization/jruby_object'
 require 'concurrent/synchronization/rbx_object'
-require 'concurrent/synchronization/truffle_object'
+require 'concurrent/synchronization/truffleruby_object'
 require 'concurrent/synchronization/object'
 require 'concurrent/synchronization/volatile'
 
 require 'concurrent/synchronization/abstract_lockable_object'
-require 'concurrent/synchronization/mri_lockable_object'
+require 'concurrent/synchronization/mutex_lockable_object'
 require 'concurrent/synchronization/jruby_lockable_object'
 require 'concurrent/synchronization/rbx_lockable_object'
-require 'concurrent/synchronization/truffle_lockable_object'
 
 require 'concurrent/synchronization/lockable_object'
 
@@ -23,8 +22,8 @@ require 'concurrent/synchronization/condition'
 require 'concurrent/synchronization/lock'
 
 module Concurrent
-  # {include:file:doc/synchronization.md}
-  # {include:file:doc/synchronization-notes.md}
+  # {include:file:docs-source/synchronization.md}
+  # {include:file:docs-source/synchronization-notes.md}
   module Synchronization
   end
 end

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

@@ -0,0 +1,88 @@
+require 'concurrent/thread_safe/util'
+
+# Shim for TruffleRuby.synchronized
+if Concurrent.on_truffleruby? && !TruffleRuby.respond_to?(:synchronized)
+  module TruffleRuby
+    def self.synchronized(object, &block)
+      Truffle::System.synchronized(object, &block)
+    end
+  end
+end
+
+module Concurrent
+  module ThreadSafe
+    module Util
+      def self.make_synchronized_on_cruby(klass)
+        klass.class_eval do
+          def initialize(*args, &block)
+            @_monitor = Monitor.new
+            super
+          end
+
+          def initialize_copy(other)
+            # make sure a copy is not sharing a monitor with the original object!
+            @_monitor = Monitor.new
+            super
+          end
+        end
+
+        klass.superclass.instance_methods(false).each do |method|
+          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
+
+      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
+            def #{method}(*args, &block)    
+              TruffleRuby.synchronized(self) { super(*args, &block) }
+            end
+          RUBY
+        end
+      end
+    end
+  end
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/thread_safe/util/striped64.rb

@@ -86,15 +86,20 @@ module Concurrent
         # @!visibility private
         class Cell < Concurrent::AtomicReference
 
-          # TODO: this only adds padding after the :value slot, need to find a way to add padding before the slot
-          # @!visibility private
-          attr_reader *(12.times.collect{ |i| "padding_#{i}".to_sym })
-
           alias_method :cas, :compare_and_set
 
           def cas_computed
             cas(current_value = value, yield(current_value))
           end
+
+          # @!visibility private
+          def self.padding
+            # TODO: this only adds padding after the :value slot, need to find a way to add padding before the slot
+            # TODO (pitr-ch 28-Jul-2018): the padding instance vars may not be created
+            # hide from yardoc in a method
+            attr_reader :padding_0, :padding_1, :padding_2, :padding_3, :padding_4, :padding_5, :padding_6, :padding_7, :padding_8, :padding_9, :padding_10, :padding_11
+          end
+          padding
         end
 
         extend Volatile

data/lib/{concurrent → concurrent-ruby/concurrent}/timer_task.rb

@@ -25,9 +25,7 @@ module Concurrent
   # Should the task experience an unrecoverable crash only the task thread will
   # crash. This makes the `TimerTask` very fault tolerant. Additionally, the
   # `TimerTask` thread can respond to the success or failure of the task,
-  # performing logging or ancillary operations. `TimerTask` can also be
-  # configured with a timeout value allowing it to kill a task that runs too
-  # long.
+  # performing logging or ancillary operations.
   #
   # One other advantage of `TimerTask` is that it forces the business logic to
   # be completely decoupled from the concurrency logic. The business logic can
@@ -48,9 +46,7 @@ module Concurrent
   # {http://ruby-doc.org/stdlib-2.0/libdoc/observer/rdoc/Observable.html
   # Observable} module. On execution the `TimerTask` will notify the observers
   # with three arguments: time of execution, the result of the block (or nil on
-  # failure), and any raised exceptions (or nil on success). If the timeout
-  # interval is exceeded the observer will receive a `Concurrent::TimeoutError`
-  # object as the third argument.
+  # failure), and any raised exceptions (or nil on success).
   #
   # @!macro copy_options
   #
@@ -59,20 +55,18 @@ module Concurrent
   #   task.execute
   #
   #   task.execution_interval #=> 60 (default)
-  #   task.timeout_interval   #=> 30 (default)
   #
   #   # wait 60 seconds...
   #   #=> 'Boom!'
   #
   #   task.shutdown #=> true
   #
-  # @example Configuring `:execution_interval` and `:timeout_interval`
-  #   task = Concurrent::TimerTask.new(execution_interval: 5, timeout_interval: 5) do
+  # @example Configuring `:execution_interval`
+  #   task = Concurrent::TimerTask.new(execution_interval: 5) do
   #          puts 'Boom!'
   #        end
   #
   #   task.execution_interval #=> 5
-  #   task.timeout_interval   #=> 5
   #
   # @example Immediate execution with `:run_now`
   #   task = Concurrent::TimerTask.new(run_now: true){ puts 'Boom!' }
@@ -115,24 +109,23 @@ module Concurrent
   #     def update(time, result, ex)
   #       if result
   #         print "(#{time}) Execution successfully returned #{result}\n"
-  #       elsif ex.is_a?(Concurrent::TimeoutError)
-  #         print "(#{time}) Execution timed out\n"
   #       else
   #         print "(#{time}) Execution failed with error #{ex}\n"
   #       end
   #     end
   #   end
   #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ 42 }
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ 42 }
   #   task.add_observer(TaskObserver.new)
   #   task.execute
+  #   sleep 4
   #
   #   #=> (2013-10-13 19:08:58 -0400) Execution successfully returned 42
   #   #=> (2013-10-13 19:08:59 -0400) Execution successfully returned 42
   #   #=> (2013-10-13 19:09:00 -0400) Execution successfully returned 42
   #   task.shutdown
   #
-  #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_interval: 1){ sleep }
+  #   task = Concurrent::TimerTask.new(execution_interval: 1){ sleep }
   #   task.add_observer(TaskObserver.new)
   #   task.execute
   #
@@ -164,12 +157,10 @@ module Concurrent
 
     # Create a new TimerTask with the given task and configuration.
     #
-    # @!macro [attach] timer_task_initialize
+    # @!macro timer_task_initialize
     #   @param [Hash] opts the options defining task execution.
     #   @option opts [Integer] :execution_interval number of seconds between
     #     task executions (default: EXECUTION_INTERVAL)
-    #   @option opts [Integer] :timeout_interval number of seconds a task can
-    #     run before it is considered to have failed (default: TIMEOUT_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)
@@ -189,6 +180,7 @@ module Concurrent
     def initialize(opts = {}, &task)
       raise ArgumentError.new('no block given') unless block_given?
       super
+      set_deref_options opts
     end
 
     # Is the executor running?
@@ -254,18 +246,14 @@ module Concurrent
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
     def timeout_interval
-      synchronize { @timeout_interval }
+      warn 'TimerTask timeouts are now ignored as these were not able to be implemented correctly'
     end
 
     # @!attribute [rw] timeout_interval
     # @return [Fixnum] Number of seconds the task can run before it is
     #   considered to have failed.
     def timeout_interval=(value)
-      if (value = value.to_f) <= 0.0
-        raise ArgumentError.new('must be greater than zero')
-      else
-        synchronize { @timeout_interval = value }
-      end
+      warn 'TimerTask timeouts are now ignored as these were not able to be implemented correctly'
     end
 
     private :post, :<<
@@ -276,10 +264,13 @@ module Concurrent
       set_deref_options(opts)
 
       self.execution_interval = opts[:execution] || opts[:execution_interval] || EXECUTION_INTERVAL
-      self.timeout_interval = opts[:timeout] || opts[:timeout_interval] || TIMEOUT_INTERVAL
+      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)
       @running = Concurrent::AtomicBoolean.new(false)
+      @value = nil
 
       self.observers = Collection::CopyOnNotifyObserverSet.new
     end
@@ -305,7 +296,6 @@ module Concurrent
     # @!visibility private
     def execute_task(completion)
       return nil unless @running.true?
-      ScheduledTask.execute(execution_interval, args: [completion], &method(:timeout_task))
       _success, value, reason = @executor.execute(self)
       if completion.try?
         self.value = value
@@ -317,15 +307,5 @@ module Concurrent
       end
       nil
     end
-
-    # @!visibility private
-    def timeout_task(completion)
-      return unless @running.true?
-      if completion.try?
-        self.value = value
-        schedule_next_task
-        observers.notify_observers(Time.now, nil, Concurrent::TimeoutError.new)
-      end
-    end
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/tuple.rb

@@ -24,7 +24,7 @@ module Concurrent
     attr_reader :size
 
     # @!visibility private
-    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : Array
+    Tuple = defined?(Rubinius::Tuple) ? Rubinius::Tuple : ::Array
     private_constant :Tuple
 
     # Create a new tuple of the given size.

data/lib/{concurrent → concurrent-ruby/concurrent}/tvar.rb

@@ -8,14 +8,13 @@ module Concurrent
   #
   # @!macro thread_safe_variable_comparison
   #
-  # {include:file:doc/tvar.md}
+  # {include:file:docs-source/tvar.md}
   class TVar < Synchronization::Object
     safe_initialization!
 
     # Create a new `TVar` with an initial value.
     def initialize(value)
       @value = value
-      @version = 0
       @lock = Mutex.new
     end
 
@@ -43,16 +42,6 @@ module Concurrent
       @value = value
     end
 
-    # @!visibility private
-    def unsafe_version # :nodoc:
-      @version
-    end
-
-    # @!visibility private
-    def unsafe_increment_version # :nodoc:
-      @version += 1
-    end
-
     # @!visibility private
     def unsafe_lock # :nodoc:
       @lock
@@ -162,52 +151,41 @@ module Concurrent
 
   class Transaction
 
-    ABORTED = Object.new
+    ABORTED = ::Object.new
 
-    ReadLogEntry = Struct.new(:tvar, :version)
+    OpenEntry = Struct.new(:value, :modified)
 
     AbortError = Class.new(StandardError)
     LeaveError = Class.new(StandardError)
 
     def initialize
-      @read_log  = []
-      @write_log = {}
+      @open_tvars = {}
     end
 
     def read(tvar)
-      Concurrent::abort_transaction unless valid?
-
-      if @write_log.has_key? tvar
-        @write_log[tvar]
-      else
-        @read_log.push(ReadLogEntry.new(tvar, tvar.unsafe_version))
-        tvar.unsafe_value
-      end
+      entry = open(tvar)
+      entry.value
     end
 
     def write(tvar, value)
-      # Have we already written to this TVar?
+      entry = open(tvar)
+      entry.modified = true
+      entry.value = value
+    end
 
-      unless @write_log.has_key? tvar
-        # Try to lock the TVar
+    def open(tvar)
+      entry = @open_tvars[tvar]
 
+      unless entry
         unless tvar.unsafe_lock.try_lock
-          # Someone else is writing to this TVar - abort
           Concurrent::abort_transaction
         end
 
-        # If we previously wrote to it, check the version hasn't changed
-
-        @read_log.each do |log_entry|
-          if log_entry.tvar == tvar and tvar.unsafe_version > log_entry.version
-            Concurrent::abort_transaction
-          end
-        end
+        entry = OpenEntry.new(tvar.unsafe_value, false)
+        @open_tvars[tvar] = entry
       end
 
-      # Record the value written
-
-      @write_log[tvar] = value
+      entry
     end
 
     def abort
@@ -215,32 +193,17 @@ module Concurrent
     end
 
     def commit
-      return false unless valid?
-
-      @write_log.each_pair do |tvar, value|
-        tvar.unsafe_value = value
-        tvar.unsafe_increment_version
-      end
-
-      unlock
-
-      true
-    end
-
-    def valid?
-      @read_log.each do |log_entry|
-        unless @write_log.has_key? log_entry.tvar
-          if log_entry.tvar.unsafe_version > log_entry.version
-            return false
-          end
+      @open_tvars.each do |tvar, entry|
+        if entry.modified
+          tvar.unsafe_value = entry.value
         end
       end
 
-      true
+      unlock
     end
 
     def unlock
-      @write_log.each_key do |tvar|
+      @open_tvars.each_key do |tvar|
         tvar.unsafe_lock.unlock
       end
     end

data/lib/{concurrent → concurrent-ruby/concurrent}/utility/engine.rb

@@ -8,7 +8,7 @@ module Concurrent
       end
 
       def on_jruby_9000?
-        on_jruby? && ruby_version(:>=, 9, 0, 0, JRUBY_VERSION)
+        on_jruby? && ruby_version(JRUBY_VERSION, :>=, 9, 0, 0)
       end
 
       def on_cruby?
@@ -19,8 +19,8 @@ module Concurrent
         ruby_engine == 'rbx'
       end
 
-      def on_truffle?
-        ruby_engine == 'jruby+truffle'
+      def on_truffleruby?
+        ruby_engine == 'truffleruby'
       end
 
       def on_windows?
@@ -39,7 +39,7 @@ module Concurrent
         defined?(RUBY_ENGINE) ? RUBY_ENGINE : 'ruby'
       end
 
-      def ruby_version(comparison, major, minor, patch, version = RUBY_VERSION)
+      def ruby_version(version = RUBY_VERSION, comparison, major, minor, patch)
         result      = (version.split('.').map(&:to_i) <=> [major, minor, patch])
         comparisons = { :== => [0],
                         :>= => [1, 0],

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

@@ -0,0 +1,90 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # @!macro monotonic_get_time
+  #
+  #   Returns the current time a 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,
+  #     :millisecond, :microsecond, or :nanosecond default to :float_second.
+  #
+  #   @return [Float] The current monotonic time since some unspecified
+  #     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
+  end
+  module_function :monotonic_time
+end