concurrent-ruby 1.1.9 → 1.2.2

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

@@ -1,6 +1,5 @@
 require 'thread'
 require 'concurrent/constants'
-require 'concurrent/synchronization'
 require 'concurrent/utility/engine'
 
 module Concurrent
@@ -10,17 +9,20 @@ module Concurrent
     # @!visibility private
     MapImplementation = case
                         when Concurrent.on_jruby?
+                          require 'concurrent/utility/native_extension_loader'
                           # noinspection RubyResolve
                           JRubyMapBackend
                         when Concurrent.on_cruby?
                           require 'concurrent/collection/map/mri_map_backend'
                           MriMapBackend
-                        when Concurrent.on_truffleruby? && defined?(::TruffleRuby::ConcurrentMap)
-                          require 'concurrent/collection/map/truffleruby_map_backend'
-                          TruffleRubyMapBackend
-                        when Concurrent.on_truffleruby? || Concurrent.on_rbx?
-                          require 'concurrent/collection/map/atomic_reference_map_backend'
-                          AtomicReferenceMapBackend
+                        when Concurrent.on_truffleruby?
+                          if defined?(::TruffleRuby::ConcurrentMap)
+                            require 'concurrent/collection/map/truffleruby_map_backend'
+                            TruffleRubyMapBackend
+                          else
+                            require 'concurrent/collection/map/atomic_reference_map_backend'
+                            AtomicReferenceMapBackend
+                          end
                         else
                           warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation'
                           require 'concurrent/collection/map/synchronized_map_backend'
@@ -44,6 +46,12 @@ module Concurrent
     #   @note Atomic methods taking a block do not allow the `self` instance
     #     to be used within the block. Doing so will cause a deadlock.
 
+    # @!method []=(key, value)
+    #   Set a value with key
+    #   @param [Object] key
+    #   @param [Object] value
+    #   @return [Object] the new value
+
     # @!method compute_if_absent(key)
     #   Compute and store new value for key if the key is absent.
     #   @param [Object] key
@@ -117,41 +125,38 @@ module Concurrent
     #   @return [true, false] true if deleted
     #   @!macro map.atomic_method
 
-    #
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
+    # NonConcurrentMapBackend handles default_proc natively
+    unless defined?(Collection::NonConcurrentMapBackend) and self < Collection::NonConcurrentMapBackend
 
-      super(options)
-      @default_proc = block
-    end
+      # @param [Hash, nil] options options to set the :initial_capacity or :load_factor. Ignored on some Rubies.
+      # @param [Proc] default_proc Optional block to compute the default value if the key is not set, like `Hash#default_proc`
+      def initialize(options = nil, &default_proc)
+        if options.kind_of?(::Hash)
+          validate_options_hash!(options)
+        else
+          options = nil
+        end
 
-    # Get a value with key
-    # @param [Object] key
-    # @return [Object] the value
-    def [](key)
-      if value = super # non-falsy value is an existing mapping, return it right away
-        value
-        # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-        # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
-        # would be returned)
-        # note: nil == value check is not technically necessary
-      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
-        @default_proc.call(self, key)
-      else
-        value
+        super(options)
+        @default_proc = default_proc
       end
-    end
 
-    # Set a value with key
-    # @param [Object] key
-    # @param [Object] value
-    # @return [Object] the new value
-    def []=(key, value)
-      super
+      # Get a value with key
+      # @param [Object] key
+      # @return [Object] the value
+      def [](key)
+        if value = super # non-falsy value is an existing mapping, return it right away
+          value
+          # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
+          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
+          # would be returned)
+          # note: nil == value check is not technically necessary
+        elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
+          @default_proc.call(self, key)
+        else
+          value
+        end
+      end
     end
 
     alias_method :get, :[]
@@ -197,7 +202,6 @@ module Concurrent
     # @yieldparam key [Object]
     # @yieldreturn [Object] default value
     # @return [Object] the value or default value
-    # @!macro map.atomic_method_with_block
     def fetch_or_store(key, default_value = NULL)
       fetch(key) do
         put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
@@ -281,7 +285,6 @@ module Concurrent
       each_pair { |k, v| return k if v == value }
       nil
     end unless method_defined?(:key)
-    alias_method :index, :key if RUBY_VERSION < '1.9'
 
     # Is map empty?
     # @return [true, false]

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

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 

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

@@ -1,5 +1,5 @@
 require 'concurrent/synchronization/abstract_struct'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 

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

@@ -1,5 +1,5 @@
 require 'concurrent/concern/dereferenceable'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 

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

@@ -66,7 +66,7 @@ module Concurrent
   # Start by requiring promises
   #
   # ```ruby
-  # require 'concurrent'
+  # require 'concurrent/promise'
   # ```
   #
   # Then create one

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

@@ -1,7 +1,8 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 require 'concurrent/atomic/atomic_boolean'
 require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/collection/lock_free_stack'
+require 'concurrent/configuration'
 require 'concurrent/errors'
 require 'concurrent/re_include'
 
@@ -313,7 +314,7 @@ module Concurrent
       end
 
       # @!macro promises.shortcut.on
-      # @return [Future]
+      # @return [Event]
       def any_event(*futures_and_or_events)
         any_event_on default_executor, *futures_and_or_events
       end
@@ -892,7 +893,7 @@ module Concurrent
       private
 
       def rejected_resolution(raise_on_reassign, state)
-        Concurrent::MultipleAssignmentError.new('Event can be resolved only once') if raise_on_reassign
+        raise Concurrent::MultipleAssignmentError.new('Event can be resolved only once') if raise_on_reassign
         return false
       end
 
@@ -1298,7 +1299,7 @@ module Concurrent
 
       # @!macro promise.param.raise_on_reassign
       #   @param [Boolean] raise_on_reassign should method raise exception if already resolved
-      #   @return [self, false] false is returner when raise_on_reassign is false and the receiver
+      #   @return [self, false] false is returned when raise_on_reassign is false and the receiver
       #     is already resolved.
       #
 
@@ -2074,8 +2075,8 @@ module Concurrent
 
       private
 
-      def resolvable?(countdown, future, index)
-        future.fulfilled? ||
+      def resolvable?(countdown, event_or_future, index)
+        (event_or_future.is_a?(Event) ? event_or_future.resolved? : event_or_future.fulfilled?) ||
             # inlined super from BlockedPromise
             countdown.zero?
       end

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

@@ -31,6 +31,8 @@ module Concurrent
   #
   #   C1.new.respond_to? :a # => false
   #   C2.new.respond_to? :a # => true
+  #
+  # @!visibility private
   module ReInclude
     # @!visibility private
     def included(base)

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

@@ -57,30 +57,43 @@ module Concurrent
   #
   # @example Basic usage
   #
-  #   require 'concurrent'
-  #   require 'thread'   # for Queue
-  #   require 'open-uri' # for open(uri)
+  #   require 'concurrent/scheduled_task'
+  #   require 'csv'
+  #   require 'open-uri'
   #
   #   class Ticker
-  #     def get_year_end_closing(symbol, year)
-  #       uri = "http://ichart.finance.yahoo.com/table.csv?s=#{symbol}&a=11&b=01&c=#{year}&d=11&e=31&f=#{year}&g=m"
-  #       data = open(uri) {|f| f.collect{|line| line.strip } }
-  #       data[1].split(',')[4].to_f
-  #     end
+  #     def get_year_end_closing(symbol, year, api_key)
+  #      uri = "https://www.alphavantage.co/query?function=TIME_SERIES_MONTHLY&symbol=#{symbol}&apikey=#{api_key}&datatype=csv"
+  #      data = []
+  #      csv = URI.parse(uri).read
+  #      if csv.include?('call frequency')
+  #        return :rate_limit_exceeded
+  #      end
+  #      CSV.parse(csv, headers: true) do |row|
+  #        data << row['close'].to_f if row['timestamp'].include?(year.to_s)
+  #      end
+  #      year_end = data.first
+  #      year_end
+  #    rescue => e
+  #      p e
+  #    end
   #   end
   #
+  #   api_key = ENV['ALPHAVANTAGE_KEY']
+  #   abort(error_message) unless api_key
+  #
   #   # Future
-  #   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013) }
+  #   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013, api_key) }
   #   price.state #=> :pending
-  #   sleep(1)    # do other stuff
-  #   price.value #=> 63.65
-  #   price.state #=> :fulfilled
+  #   price.pending? #=> true
+  #   price.value(0) #=> nil (does not block)
   #
-  #   # ScheduledTask
-  #   task = Concurrent::ScheduledTask.execute(2){ Ticker.new.get_year_end_closing('INTC', 2013) }
-  #   task.state #=> :pending
-  #   sleep(3)   # do other stuff
-  #   task.value #=> 25.96
+  #    sleep(1)    # do other stuff
+  #
+  #   price.value #=> 63.65 (after blocking if necessary)
+  #   price.state #=> :fulfilled
+  #   price.fulfilled? #=> true
+  #   price.value #=> 63.65
   #
   # @example Successful task execution
   #

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

@@ -42,16 +42,6 @@ module Concurrent
 
                         JRubySet
 
-                      when Concurrent.on_rbx?
-                        require 'monitor'
-                        require 'concurrent/thread_safe/util/data_structures'
-
-                        class RbxSet < ::Set
-                        end
-
-                        ThreadSafe::Util.make_synchronized_on_rbx RbxSet
-                        RbxSet
-
                       when Concurrent.on_truffleruby?
                         require 'concurrent/thread_safe/util/data_structures'
 

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

@@ -1,6 +1,6 @@
-require 'concurrent/synchronization/abstract_struct'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/abstract_struct'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 

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

@@ -1,3 +1,7 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/synchronization/object'
+
 module Concurrent
   module Synchronization
 
@@ -34,7 +38,7 @@ module Concurrent
         if timeout
           wait_until = Concurrent.monotonic_time + timeout
           loop do
-            now              = Concurrent.monotonic_time
+            now = Concurrent.monotonic_time
             condition_result = condition.call
             return condition_result if now >= wait_until || condition_result
             ns_wait wait_until - now

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

@@ -4,10 +4,8 @@ module Concurrent
     # @!visibility private
     # @!macro internal_implementation_note
     class AbstractObject
-
-      # @abstract has to be implemented based on Ruby runtime
       def initialize
-        raise NotImplementedError
+        # nothing to do
       end
 
       # @!visibility private

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

@@ -1,3 +1,5 @@
+require 'concurrent/synchronization/lockable_object'
+
 module Concurrent
   module Synchronization
 

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

@@ -0,0 +1,29 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+module Concurrent
+  module Synchronization
+    case
+    when Concurrent.on_cruby?
+      def self.full_memory_barrier
+        # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
+        # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
+      end
+
+    when Concurrent.on_jruby?
+      require 'concurrent/utility/native_extension_loader'
+      def self.full_memory_barrier
+        JRubyAttrVolatile.full_memory_barrier
+      end
+
+    when Concurrent.on_truffleruby?
+      def self.full_memory_barrier
+        TruffleRuby.full_memory_barrier
+      end
+
+    else
+      warn 'Possibly unsupported Ruby implementation'
+      def self.full_memory_barrier
+      end
+    end
+  end
+end

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

@@ -1,7 +1,9 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 module Concurrent
   module Synchronization
 
-    if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
+    if Concurrent.on_jruby?
 
       # @!visibility private
       # @!macro internal_implementation_note

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

@@ -1,3 +1,5 @@
+require 'concurrent/synchronization/lockable_object'
+
 module Concurrent
   module Synchronization
 

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

@@ -1,17 +1,18 @@
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/abstract_lockable_object'
+require 'concurrent/synchronization/mutex_lockable_object'
+require 'concurrent/synchronization/jruby_lockable_object'
+
 module Concurrent
   module Synchronization
 
     # @!visibility private
     # @!macro internal_implementation_note
     LockableObjectImplementation = case
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
-                                     MonitorLockableObject
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
+                                   when Concurrent.on_cruby?
                                      MutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject
-                                   when Concurrent.on_rbx?
-                                     RbxLockableObject
                                    when Concurrent.on_truffleruby?
                                      MutexLockableObject
                                    else

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

@@ -1,5 +1,6 @@
+require 'concurrent/synchronization/abstract_lockable_object'
+
 module Concurrent
-  # noinspection RubyInstanceVariableNamingConvention
   module Synchronization
 
     # @!visibility private
@@ -26,8 +27,8 @@ module Concurrent
 
       safe_initialization!
 
-      def initialize(*defaults)
-        super(*defaults)
+      def initialize
+        super()
         @__Lock__      = ::Mutex.new
         @__Condition__ = ::ConditionVariable.new
       end
@@ -61,8 +62,8 @@ module Concurrent
 
       safe_initialization!
 
-      def initialize(*defaults)
-        super(*defaults)
+      def initialize
+        super()
         @__Lock__      = ::Monitor.new
         @__Condition__ = @__Lock__.new_cond
       end

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