concurrent-ruby 1.0.5 → 1.1.1

data/lib/concurrent/re_include.rb

@@ -0,0 +1,58 @@
+module Concurrent
+
+  # Methods form module A included to a module B, which is already included into class C,
+  # will not be visible in the C class. If this module is extended to B then A's methods
+  # are correctly made visible to C.
+  #
+  # @example
+  #   module A
+  #     def a
+  #       :a
+  #     end
+  #   end
+  #
+  #   module B1
+  #   end
+  #
+  #   class C1
+  #     include B1
+  #   end
+  #
+  #   module B2
+  #     extend Concurrent::ReInclude
+  #   end
+  #
+  #   class C2
+  #     include B2
+  #   end
+  #
+  #   B1.send :include, A
+  #   B2.send :include, A
+  #
+  #   C1.new.respond_to? :a # => false
+  #   C2.new.respond_to? :a # => true
+  module ReInclude
+    # @!visibility private
+    def included(base)
+      (@re_include_to_bases ||= []) << [:include, base]
+      super(base)
+    end
+
+    # @!visibility private
+    def extended(base)
+      (@re_include_to_bases ||= []) << [:extend, base]
+      super(base)
+    end
+
+    # @!visibility private
+    def include(*modules)
+      result = super(*modules)
+      modules.reverse.each do |module_being_included|
+        (@re_include_to_bases ||= []).each do |method, mod|
+          mod.send method, module_being_included
+        end
+      end
+      result
+    end
+  end
+end

data/lib/concurrent/set.rb

@@ -0,0 +1,66 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+require 'set'
+
+module Concurrent
+
+  # @!macro concurrent_set
+  #
+  #   A thread-safe subclass of Set. This version locks against the object
+  #   itself for every method call, ensuring only one thread can be reading
+  #   or writing at a time. This includes iteration methods like `#each`.
+  #
+  #   @note `a += b` is **not** a **thread-safe** operation on
+  #   `Concurrent::Set`. It reads Set `a`, then it creates new `Concurrent::Set`
+  #   which is union of `a` and `b`, then it writes the union to `a`.
+  #   The read and write are independent operations they do not form a single atomic
+  #   operation therefore when two `+=` operations are executed concurrently updates
+  #   may be lost. Use `#merge` instead.
+  #
+  #   @see http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html Ruby standard library `Set`
+
+
+  # @!macro internal_implementation_note
+  SetImplementation = case
+                      when Concurrent.on_cruby?
+                        # Because MRI never runs code in parallel, the existing
+                        # non-thread-safe structures should usually work fine.
+                        ::Set
+
+                      when Concurrent.on_jruby?
+                        require 'jruby/synchronized'
+
+                        class JRubySet < ::Set
+                          include JRuby::Synchronized
+                        end
+                        JRubySet
+
+                      when Concurrent.on_rbx?
+                        require 'monitor'
+                        require 'concurrent/thread_safe/util/data_structures'
+
+                        class RbxSet < ::Set
+                        end
+                        ThreadSafe::Util.make_synchronized_on_rbx Concurrent::RbxSet
+                        RbxSet
+
+                      when Concurrent.on_truffleruby?
+                        require 'concurrent/thread_safe/util/data_structures'
+
+                        class TruffleRubySet < ::Set
+                        end
+
+                        ThreadSafe::Util.make_synchronized_on_truffleruby Concurrent::TruffleRubySet
+                        TruffleRubySet
+
+                      else
+                        warn 'Possibly unsupported Ruby implementation'
+                        ::Set
+                      end
+  private_constant :SetImplementation
+
+  # @!macro concurrent_set
+  class Set < SetImplementation
+  end
+end
+

data/lib/concurrent/settable_struct.rb

@@ -107,6 +107,7 @@ module Concurrent
         synchronize do
           clazz = Synchronization::AbstractStruct.define_struct_class(SettableStruct, Synchronization::LockableObject, name, members, &block)
           members.each_with_index do |member, index|
+            clazz.send :remove_method, member if clazz.instance_methods.include? member
             clazz.send(:define_method, member) do
               synchronize { @values[index] }
             end

data/lib/concurrent/synchronization/abstract_lockable_object.rb

@@ -6,7 +6,7 @@ module Concurrent
 
       protected
 
-      # @!macro [attach] synchronization_object_method_synchronize
+      # @!macro synchronization_object_method_synchronize
       #
       #   @yield runs the block synchronized against this object,
       #     equivalent of java's `synchronize(this) {}`
@@ -15,7 +15,7 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ns_wait_until
+      # @!macro synchronization_object_method_ns_wait_until
       #
       #   Wait until condition is met or timeout passes,
       #   protects against spurious wake-ups.
@@ -45,7 +45,7 @@ module Concurrent
         end
       end
 
-      # @!macro [attach] synchronization_object_method_ns_wait
+      # @!macro synchronization_object_method_ns_wait
       #
       #   Wait until another thread calls #signal or #broadcast,
       #   spurious wake-ups can happen.
@@ -63,7 +63,7 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ns_signal
+      # @!macro synchronization_object_method_ns_signal
       #
       #   Signal one waiting thread.
       #   @return [self]
@@ -78,7 +78,7 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ns_broadcast
+      # @!macro synchronization_object_method_ns_broadcast
       #
       #   Broadcast to all waiting threads.
       #   @return [self]

data/lib/concurrent/synchronization/abstract_struct.rb

@@ -11,7 +11,7 @@ module Concurrent
         ns_initialize(*values)
       end
 
-      # @!macro [attach] struct_length
+      # @!macro struct_length
       #
       #   Returns the number of struct members.
       #
@@ -21,7 +21,7 @@ module Concurrent
       end
       alias_method :size, :length
 
-      # @!macro [attach] struct_members
+      # @!macro struct_members
       #
       #   Returns the struct members as an array of symbols.
       #
@@ -117,7 +117,7 @@ module Concurrent
 
       # @!visibility private
       def pr_underscore(clazz)
-        word = clazz.to_s
+        word = clazz.to_s.dup # dup string to workaround JRuby 9.2.0.0 bug https://github.com/jruby/jruby/issues/5229
         word.gsub!(/::/, '/')
         word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
         word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
@@ -138,13 +138,15 @@ module Concurrent
         end
         unless name.nil?
           begin
+            parent.send :remove_const, name if parent.const_defined? name
             parent.const_set(name, clazz)
-            parent.const_get(name)
+            clazz
           rescue NameError
             raise NameError.new("identifier #{name} needs to be constant")
           end
         end
         members.each_with_index do |member, index|
+          clazz.send :remove_method, member if clazz.instance_methods.include? member
           clazz.send(:define_method, member) do
             @values[index]
           end

data/lib/concurrent/synchronization/lockable_object.rb

@@ -5,18 +5,18 @@ module Concurrent
     # @!macro internal_implementation_note
     LockableObjectImplementation = case
                                    when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
-                                     MriMonitorLockableObject
+                                     MonitorLockableObject
                                    when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
-                                     MriMutexLockableObject
+                                     MutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject
                                    when Concurrent.on_rbx?
                                      RbxLockableObject
-                                   when Concurrent.on_truffle?
-                                     MriMutexLockableObject
+                                   when Concurrent.on_truffleruby?
+                                     MutexLockableObject
                                    else
                                      warn 'Possibly unsupported Ruby implementation'
-                                     MriMonitorLockableObject
+                                     MonitorLockableObject
                                    end
     private_constant :LockableObjectImplementation
 
@@ -31,7 +31,7 @@ module Concurrent
     #     `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
     #     `Thread#wakeup` will not work on all platforms.
     #
-    #   @see {Event} implementation as an example of this class use
+    #   @see Event implementation as an example of this class use
     #
     #   @example simple
     #     class AnClass < Synchronization::Object

data/lib/concurrent/synchronization/{mri_lockable_object.rb → mutex_lockable_object.rb}

@@ -1,18 +1,19 @@
 module Concurrent
+  # noinspection RubyInstanceVariableNamingConvention
   module Synchronization
 
     # @!visibility private
     # @!macro internal_implementation_note
-    class MriLockableObject < AbstractLockableObject
+    module ConditionSignalling
       protected
 
       def ns_signal
-        @__condition__.signal
+        @__Condition__.signal
         self
       end
 
       def ns_broadcast
-        @__condition__.broadcast
+        @__Condition__.broadcast
         self
       end
     end
@@ -20,50 +21,54 @@ module Concurrent
 
     # @!visibility private
     # @!macro internal_implementation_note
-    class MriMutexLockableObject < MriLockableObject
+    class MutexLockableObject < AbstractLockableObject
+      include ConditionSignalling
+
       safe_initialization!
 
       def initialize(*defaults)
         super(*defaults)
-        @__lock__      = ::Mutex.new
-        @__condition__ = ::ConditionVariable.new
+        @__Lock__      = ::Mutex.new
+        @__Condition__ = ::ConditionVariable.new
       end
 
       protected
 
       def synchronize
-        if @__lock__.owned?
+        if @__Lock__.owned?
           yield
         else
-          @__lock__.synchronize { yield }
+          @__Lock__.synchronize { yield }
         end
       end
 
       def ns_wait(timeout = nil)
-        @__condition__.wait @__lock__, timeout
+        @__Condition__.wait @__Lock__, timeout
         self
       end
     end
 
     # @!visibility private
     # @!macro internal_implementation_note
-    class MriMonitorLockableObject < MriLockableObject
+    class MonitorLockableObject < AbstractLockableObject
+      include ConditionSignalling
+
       safe_initialization!
 
       def initialize(*defaults)
         super(*defaults)
-        @__lock__      = ::Monitor.new
-        @__condition__ = @__lock__.new_cond
+        @__Lock__      = ::Monitor.new
+        @__Condition__ = @__Lock__.new_cond
       end
 
       protected
 
       def synchronize # TODO may be a problem with lock.synchronize { lock.wait }
-        @__lock__.synchronize { yield }
+        @__Lock__.synchronize { yield }
       end
 
       def ns_wait(timeout = nil)
-        @__condition__.wait timeout
+        @__Condition__.wait timeout
         self
       end
     end

data/lib/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
@@ -134,8 +135,11 @@ module Concurrent
       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
+        assignments = @volatile_cas_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_volatile_with_cas
             super
             #{assignments}

data/lib/concurrent/synchronization/truffleruby_object.rb

@@ -0,0 +1,46 @@
+module Concurrent
+  module Synchronization
+
+    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/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/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/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/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/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/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/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/utility/193.rb

@@ -0,0 +1,17 @@
+require_relative 'engine'
+
+if Concurrent.ruby_version :<, 2, 0, 0
+  # @!visibility private
+  module Kernel
+    def __dir__
+      File.dirname __FILE__
+    end
+  end
+
+  # @!visibility private
+  class LoadError < ScriptError
+    def path
+      message.split(' -- ').last
+    end
+  end
+end

data/lib/concurrent/utility/at_exit.rb

@@ -16,7 +16,7 @@ module Concurrent
     end
 
     # Add a handler to be run at `Kernel#at_exit`
-    # @param [Object] handler_id optionally provide an id, if allready present, handler is replaced
+    # @param [Object] handler_id optionally provide an id, if already present, handler is replaced
     # @yield the handler
     # @return id of the handler
     def add(handler_id = nil, &handler)