concurrent-ruby 1.0.5 → 1.1.6

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

@@ -10,9 +10,10 @@ module Concurrent
                              JRubyObject
                            when Concurrent.on_rbx?
                              RbxObject
-                           when Concurrent.on_truffle?
-                             TruffleObject
+                           when Concurrent.on_truffleruby?
+                             TruffleRubyObject
                            else
+                             warn 'Possibly unsupported Ruby implementation'
                              MriObject
                            end
     private_constant :ObjectImplementation
@@ -26,15 +27,15 @@ module Concurrent
 
       # @!method self.attr_volatile(*names)
       #   Creates methods for reading and writing (as `attr_accessor` does) to a instance variable with
-      #   volatile (Java) semantic. The instance variable should be accessed oly through generated methods.
+      #   volatile (Java) semantic. The instance variable should be accessed only through generated methods.
       #
-      #   @param [Array<Symbol>] names of the instance variables to be volatile
-      #   @return [Array<Symbol>] names of defined method names
+      #   @param [::Array<Symbol>] names of the instance variables to be volatile
+      #   @return [::Array<Symbol>] names of defined method names
 
       # Has to be called by children.
       def initialize
         super
-        initialize_volatile_with_cas
+        __initialize_atomic_fields__
       end
 
       # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
@@ -48,10 +49,12 @@ module Concurrent
       #       @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
@@ -69,6 +72,8 @@ module Concurrent
 
       # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains
       # any instance variables with CamelCase names and isn't {.safe_initialization?}.
+      # @raise when offend found
+      # @return [true]
       def self.ensure_safe_initialization_when_final_fields_are_present
         Object.class_eval do
           def self.new(*args, &block)
@@ -80,6 +85,7 @@ module Concurrent
             end
           end
         end
+        true
       end
 
       # Creates methods for reading and writing to a instance variable with
@@ -88,13 +94,30 @@ module Concurrent
       # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
       # `swap_value(new_value) #=> old_value`,
       # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
-      # @param [Array<Symbol>] names of the instance variables to be volatile with CAS.
-      # @return [Array<Symbol>] names of defined method names.
+      # @param [::Array<Symbol>] names of the instance variables to be volatile with CAS.
+      # @return [::Array<Symbol>] names of defined method names.
+      # @!macro attr_atomic
+      #   @!method $1
+      #     @return [Object] The $1.
+      #   @!method $1=(new_$1)
+      #     Set the $1.
+      #     @return [Object] new_$1.
+      #   @!method swap_$1(new_$1)
+      #     Set the $1 to new_$1 and return the old $1.
+      #     @return [Object] old $1
+      #   @!method compare_and_set_$1(expected_$1, new_$1)
+      #     Sets the $1 to new_$1 if the current $1 is expected_$1
+      #     @return [true, false]
+      #   @!method update_$1(&block)
+      #     Updates the $1 using the block.
+      #     @yield [Object] Calculate a new $1 using given (old) $1
+      #     @yieldparam [Object] old $1
+      #     @return [Object] new $1
       def self.attr_atomic(*names)
-        @volatile_cas_fields ||= []
-        @volatile_cas_fields += names
+        @__atomic_fields__ ||= []
+        @__atomic_fields__ += names
         safe_initialization!
-        define_initialize_volatile_with_cas
+        define_initialize_atomic_fields
 
         names.each do |name|
           ivar = :"@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
@@ -123,29 +146,36 @@ module Concurrent
         names.flat_map { |n| [n, :"#{n}=", :"swap_#{n}", :"compare_and_set_#{n}", :"update_#{n}"] }
       end
 
-      # @param [true,false] inherited should inherited volatile with CAS fields be returned?
-      # @return [Array<Symbol>] Returns defined volatile with CAS fields on this class.
-      def self.volatile_cas_fields(inherited = true)
-        @volatile_cas_fields ||= []
-        ((superclass.volatile_cas_fields if superclass.respond_to?(:volatile_cas_fields) && inherited) || []) +
-            @volatile_cas_fields
+      # @param [true, false] inherited should inherited volatile with CAS fields be returned?
+      # @return [::Array<Symbol>] Returns defined volatile with CAS fields on this class.
+      def self.atomic_attributes(inherited = true)
+        @__atomic_fields__ ||= []
+        ((superclass.atomic_attributes if superclass.respond_to?(:atomic_attributes) && inherited) || []) + @__atomic_fields__
+      end
+
+      # @return [true, false] is the attribute with name atomic?
+      def self.atomic_attribute?(name)
+        atomic_attributes.include? name
       end
 
       private
 
-      def self.define_initialize_volatile_with_cas
-        assignments = @volatile_cas_fields.map { |name| "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = AtomicReference.new(nil)" }.join("\n")
-        class_eval <<-RUBY
-          def initialize_volatile_with_cas
+      def self.define_initialize_atomic_fields
+        assignments = @__atomic_fields__.map do |name|
+          "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = Concurrent::AtomicReference.new(nil)"
+        end.join("\n")
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def __initialize_atomic_fields__
             super
             #{assignments}
           end
         RUBY
       end
 
-      private_class_method :define_initialize_volatile_with_cas
+      private_class_method :define_initialize_atomic_fields
 
-      def initialize_volatile_with_cas
+      def __initialize_atomic_fields__
       end
 
     end

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

@@ -1,6 +1,7 @@
 module Concurrent
   module Synchronization
 
+    # @!visibility private
     module RbxAttrVolatile
       def self.included(base)
         base.extend(ClassMethods)

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-ruby/concurrent/thread_safe/util/data_structures.rb

@@ -0,0 +1,63 @@
+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_rbx(klass)
+        klass.class_eval do
+          private
+
+          def _mon_initialize
+            @_monitor = Monitor.new unless @_monitor # 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 *(12.times.collect{ |i| "padding_#{i}".to_sym })
+          end
+          padding
         end
 
         extend Volatile

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

@@ -126,6 +126,7 @@ module Concurrent
   #   task = Concurrent::TimerTask.new(execution_interval: 1, timeout_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
@@ -164,7 +165,7 @@ 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)
@@ -189,6 +190,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?
@@ -280,6 +282,7 @@ module Concurrent
       @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 +308,7 @@ module Concurrent
     # @!visibility private
     def execute_task(completion)
       return nil unless @running.true?
-      ScheduledTask.execute(execution_interval, args: [completion], &method(:timeout_task))
+      ScheduledTask.execute(timeout_interval, args: [completion], &method(:timeout_task))
       _success, value, reason = @executor.execute(self)
       if completion.try?
         self.value = value

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,7 +8,7 @@ module Concurrent
   #
   # @!macro thread_safe_variable_comparison
   #
-  # {include:file:doc/tvar.md}
+  # {include:file:docs-source/tvar.md}
   class TVar < Synchronization::Object
     safe_initialization!
 
@@ -162,7 +162,7 @@ module Concurrent
 
   class Transaction
 
-    ABORTED = Object.new
+    ABORTED = ::Object.new
 
     ReadLogEntry = Struct.new(:tvar, :version)
 

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 → concurrent-ruby/concurrent}/utility/monotonic_time.rb

@@ -42,12 +42,12 @@ module Concurrent
   GLOBAL_MONOTONIC_CLOCK = class_definition.new
   private_constant :GLOBAL_MONOTONIC_CLOCK
 
-  # @!macro [attach] monotonic_get_time
+  # @!macro monotonic_get_time
   #
   #   Returns the current time a tracked by the application monotonic clock.
   #
-  #   @return [Float] The current monotonic time when `since` not given else
-  #     the elapsed monotonic time between `since` and the current time
+  #   @return [Float] The current monotonic time since some unspecified
+  #     starting point
   #
   #   @!macro monotonic_clock_warning
   def monotonic_time