concurrent-ruby 1.0.5 → 1.1.10

data/lib/concurrent/atomic/atomic_reference.rb

@@ -1,51 +0,0 @@
-require 'concurrent/synchronization'
-require 'concurrent/utility/engine'
-require 'concurrent/atomic_reference/concurrent_update_error'
-require 'concurrent/atomic_reference/mutex_atomic'
-
-begin
-  # force fallback impl with FORCE_ATOMIC_FALLBACK=1
-  if /[^0fF]/ =~ ENV['FORCE_ATOMIC_FALLBACK']
-    ruby_engine = 'mutex_atomic'
-  else
-    ruby_engine = Concurrent.ruby_engine
-  end
-
-  require "concurrent/atomic_reference/#{ruby_engine}"
-rescue LoadError
-  #warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
-end
-
-if defined? Concurrent::JavaAtomicReference
-
-  # @!macro atomic_reference
-  class Concurrent::AtomicReference < Concurrent::JavaAtomicReference
-  end
-
-elsif defined? Concurrent::RbxAtomicReference
-
-  # @!macro atomic_reference
-  class Concurrent::AtomicReference < Concurrent::RbxAtomicReference
-  end
-
-elsif defined? Concurrent::CAtomicReference
-
-  # @!macro atomic_reference
-  class Concurrent::AtomicReference < Concurrent::CAtomicReference
-  end
-
-else
-
-  # @!macro atomic_reference
-  class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
-  end
-end
-
-class Concurrent::AtomicReference
-  # @return [String] Short string representation.
-  def to_s
-    format '<#%s:0x%x value:%s>', self.class, object_id << 1, get
-  end
-
-  alias_method :inspect, :to_s
-end

data/lib/concurrent/atomic_reference/concurrent_update_error.rb

@@ -1,8 +0,0 @@
-module Concurrent
-
-  # @!macro atomic_reference
-  class ConcurrentUpdateError < ThreadError
-    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
-    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
-  end
-end

data/lib/concurrent/atomic_reference/direct_update.rb

@@ -1,81 +0,0 @@
-require 'concurrent/atomic_reference/concurrent_update_error'
-
-module Concurrent
-
-  # Define update methods that use direct paths
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  module AtomicDirectUpdate
-
-    # @!macro [attach] atomic_reference_method_update
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. May retry if the value changes
-    # during the block's execution.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @return [Object] the new value
-    def update
-      true until compare_and_set(old_value = get, new_value = yield(old_value))
-      new_value
-    end
-
-    # @!macro [attach] atomic_reference_method_try_update
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. Return nil if the update fails.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @note This method was altered to avoid raising an exception by default.
-    # Instead, this method now returns `nil` in case of failure. For more info,
-    # please see: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #
-    # @return [Object] the new value, or nil if update failed
-    def try_update
-      old_value = get
-      new_value = yield old_value
-
-      return unless compare_and_set old_value, new_value
-
-      new_value
-    end
-
-    # @!macro [attach] atomic_reference_method_try_update!
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. Raise an exception if the update
-    # fails.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @note This behavior mimics the behavior of the original
-    # `AtomicReference#try_update` API. The reason this was changed was to
-    # avoid raising exceptions (which are inherently slow) by default. For more
-    # info: https://github.com/ruby-concurrency/concurrent-ruby/pull/336
-    #
-    # @return [Object] the new value
-    #
-    # @raise [Concurrent::ConcurrentUpdateError] if the update fails
-    def try_update!
-      old_value = get
-      new_value = yield old_value
-      unless compare_and_set(old_value, new_value)
-        if $VERBOSE
-          raise ConcurrentUpdateError, "Update failed"
-        else
-          raise ConcurrentUpdateError, "Update failed", ConcurrentUpdateError::CONC_UP_ERR_BACKTRACE
-        end
-      end
-      new_value
-    end
-  end
-end

data/lib/concurrent/atomic_reference/jruby+truffle.rb

@@ -1,2 +0,0 @@
-require 'atomic'
-require 'concurrent/atomic_reference/rbx'

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,16 +0,0 @@
-require 'concurrent/synchronization'
-
-if defined?(Concurrent::JavaAtomicReference)
-  require 'concurrent/atomic_reference/direct_update'
-
-  module Concurrent
-
-    # @!macro atomic_reference
-    #
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class JavaAtomicReference
-      include Concurrent::AtomicDirectUpdate
-    end
-  end
-end

data/lib/concurrent/atomic_reference/rbx.rb

@@ -1,22 +0,0 @@
-require 'concurrent/atomic_reference/direct_update'
-require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-module Concurrent
-
-  # @!macro atomic_reference
-  #
-  # @note Extends `Rubinius::AtomicReference` version adding aliases
-  #   and numeric logic.
-  #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class RbxAtomicReference < Rubinius::AtomicReference
-    alias _compare_and_set compare_and_set
-    include Concurrent::AtomicDirectUpdate
-    include Concurrent::AtomicNumericCompareAndSetWrapper
-
-    alias_method :value, :get
-    alias_method :value=, :set
-    alias_method :swap, :get_and_set
-  end
-end

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,32 +0,0 @@
-if defined? Concurrent::CAtomicReference
-  require 'concurrent/synchronization'
-  require 'concurrent/atomic_reference/direct_update'
-  require 'concurrent/atomic_reference/numeric_cas_wrapper'
-
-  module Concurrent
-
-    # @!macro atomic_reference
-    #
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class CAtomicReference
-      include Concurrent::AtomicDirectUpdate
-      include Concurrent::AtomicNumericCompareAndSetWrapper
-
-      # @!method initialize
-      #   @!macro atomic_reference_method_initialize
-
-      # @!method get
-      #   @!macro atomic_reference_method_get
-
-      # @!method set
-      #   @!macro atomic_reference_method_set
-
-      # @!method get_and_set
-      #   @!macro atomic_reference_method_get_and_set
-
-      # @!method _compare_and_set
-      #   @!macro atomic_reference_method_compare_and_set
-    end
-  end
-end

data/lib/concurrent/atomics.rb

@@ -1,53 +0,0 @@
-# @!macro [new] atomic_reference
-#
-#   An object reference that may be updated atomically. All read and write
-#   operations have java volatile semantic.
-#
-#   @!macro thread_safe_variable_comparison
-#
-#   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/AtomicReference.html
-#   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/atomic/package-summary.html
-#
-#   @!method initialize
-#     @!macro [new] atomic_reference_method_initialize
-#       @param [Object] value The initial value.
-#
-#   @!method get
-#     @!macro [new] atomic_reference_method_get
-#       Gets the current value.
-#       @return [Object] the current value
-#
-#   @!method set
-#     @!macro [new] atomic_reference_method_set
-#       Sets to the given value.
-#       @param [Object] new_value the new value
-#       @return [Object] the new value
-#
-#   @!method get_and_set
-#     @!macro [new] atomic_reference_method_get_and_set
-#       Atomically sets to the given value and returns the old value.
-#       @param [Object] new_value the new value
-#       @return [Object] the old value
-#
-#   @!method compare_and_set
-#     @!macro [new] atomic_reference_method_compare_and_set
-#
-#       Atomically sets the value to the given updated value if
-#       the current value == the expected value.
-#
-#       @param [Object] old_value the expected value
-#       @param [Object] new_value the new value
-#
-#       @return [Boolean] `true` if successful. A `false` return indicates
-#       that the actual value was not equal to the expected value.
-
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/atomic/atomic_boolean'
-require 'concurrent/atomic/atomic_fixnum'
-require 'concurrent/atomic/cyclic_barrier'
-require 'concurrent/atomic/count_down_latch'
-require 'concurrent/atomic/event'
-require 'concurrent/atomic/read_write_lock'
-require 'concurrent/atomic/reentrant_read_write_lock'
-require 'concurrent/atomic/semaphore'
-require 'concurrent/atomic/thread_local_var'

data/lib/concurrent/edge.rb

@@ -1,26 +0,0 @@
-module Concurrent
-
-  # A submodule for unstable, highly experimental features that are likely to
-  # change often and which may never become part of the core gem. Also for
-  # new, experimental version of abstractions already in the core gem.
-  #
-  # Most new features should start in this module, clearly indicating the
-  # experimental and unstable nature of the feature. Once a feature becomes
-  # more stable and is a candidate for inclusion in the core gem it should
-  # be moved up to the `Concurrent` module, where it would reside once merged
-  # into the core gem.
-  #
-  # The only exception to this is for features which *replace* features from
-  # the core gem in ways that are breaking and not backward compatible. These
-  # features should remain in this module until merged into the core gem. This
-  # will prevent namespace collisions.
-  #
-  # @!macro [attach] edge_warning
-  #   @api Edge
-  #   @note **Edge Feature:** Edge features are under active development and may change frequently. They are expected not to
-  #     keep backward compatibility (there may also lack tests and documentation). Semantic versions will
-  #     be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move
-  #     to `concurrent-ruby` when final.
-  module Edge
-  end
-end

data/lib/concurrent/hash.rb

@@ -1,36 +0,0 @@
-require 'concurrent/utility/engine'
-require 'concurrent/thread_safe/util'
-
-module Concurrent
-  if Concurrent.on_cruby?
-
-    # @!macro [attach] concurrent_hash
-    #
-    #   A thread-safe subclass of Hash. 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`,
-    #   which takes the lock repeatedly when reading an item.
-    #
-    #   @see http://ruby-doc.org/core-2.2.0/Hash.html Ruby standard library `Hash`
-    class Hash < ::Hash;
-    end
-
-  elsif Concurrent.on_jruby?
-    require 'jruby/synchronized'
-
-    # @!macro concurrent_hash
-    class Hash < ::Hash
-      include JRuby::Synchronized
-    end
-
-  elsif Concurrent.on_rbx? || Concurrent.on_truffle?
-    require 'monitor'
-    require 'concurrent/thread_safe/util/array_hash_rbx'
-
-    # @!macro concurrent_hash
-    class Hash < ::Hash
-    end
-
-    ThreadSafe::Util.make_synchronized_on_rbx Hash
-  end
-end

data/lib/concurrent/lazy_register.rb

@@ -1,81 +0,0 @@
-require 'concurrent/atomic/atomic_reference'
-require 'concurrent/delay'
-
-module Concurrent
-
-  # Hash-like collection that store lazys evaluated values.
-  #
-  # @example
-  #   register = Concurrent::LazyRegister.new
-  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
-  #   register[:key]
-  #   #=> nil
-  #   register.add(:key) { Concurrent::Actor.spawn!(Actor::AdHoc, :ping) { -> message { message } } }
-  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
-  #   register[:key]
-  #   #=> #<Concurrent::Actor::Reference /ping (Concurrent::Actor::AdHoc)>
-  #
-  # @!macro edge_warning
-  class LazyRegister < Synchronization::Object
-
-    private(*attr_atomic(:data))
-
-    def initialize
-      super
-      self.data = {}
-    end
-
-    # Element reference. Retrieves the value object corresponding to the
-    # key object. Returns nil if the key is not found. Raises an exception
-    # if the stored item raised an exception when the block was evaluated.
-    #
-    # @param [Object] key
-    # @return [Object] value stored for the key or nil if the key is not found
-    #
-    # @raise Exception when the initialization block fails
-    def [](key)
-      delay = data[key]
-      delay ? delay.value! : nil
-    end
-
-    # Returns true if the given key is present.
-    #
-    # @param [Object] key
-    # @return [true, false] if the key is registered
-    def registered?(key)
-      data.key?(key)
-    end
-
-    alias_method :key?, :registered?
-    alias_method :has_key?, :registered?
-
-    # Element assignment. Associates the value given by value with the
-    # key given by key.
-    #
-    # @param [Object] key
-    # @yield the object to store under the key
-    #
-    # @return [LazyRegister] self
-    def register(key, &block)
-      delay = Delay.new(executor: :immediate, &block)
-      update_data { |h| h.merge(key => delay) }
-      self
-    end
-
-    alias_method :add, :register
-    alias_method :store, :register
-
-    # Un-registers the object under key, realized or not.
-    #
-    # @param [Object] key
-    #
-    # @return [LazyRegister] self
-    def unregister(key)
-      update_data { |h| h.dup.tap { |j| j.delete(key) } }
-      self
-    end
-
-    alias_method :remove, :unregister
-    alias_method :delete, :unregister
-  end
-end

data/lib/concurrent/map.rb

@@ -1,240 +0,0 @@
-require 'thread'
-require 'concurrent/constants'
-require 'concurrent/synchronization'
-
-module Concurrent
-  # @!visibility private
-  module Collection
-
-    # @!visibility private
-    MapImplementation = if Concurrent.java_extensions_loaded?
-                          # noinspection RubyResolve
-                          JRubyMapBackend
-                        elsif defined?(RUBY_ENGINE)
-                          case RUBY_ENGINE
-                          when 'ruby'
-                            require 'concurrent/collection/map/mri_map_backend'
-                            MriMapBackend
-                          when 'rbx'
-                            require 'concurrent/collection/map/atomic_reference_map_backend'
-                            AtomicReferenceMapBackend
-                          when 'jruby+truffle'
-                            require 'concurrent/collection/map/atomic_reference_map_backend'
-                            AtomicReferenceMapBackend
-                          else
-                            warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation' if $VERBOSE
-                            require 'concurrent/collection/map/synchronized_map_backend'
-                            SynchronizedMapBackend
-                          end
-                        else
-                          MriMapBackend
-                        end
-  end
-
-  # `Concurrent::Map` is a hash-like object and should have much better performance
-  # characteristics, especially under high concurrency, than `Concurrent::Hash`.
-  # However, `Concurrent::Map `is not strictly semantically equivalent to a ruby `Hash`
-  # -- for instance, it does not necessarily retain ordering by insertion time as `Hash`
-  # does. For most uses it should do fine though, and we recommend you consider
-  # `Concurrent::Map` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
-  #
-  # > require 'concurrent'
-  # >
-  # > map = Concurrent::Map.new
-  class Map < Collection::MapImplementation
-
-    # @!macro [new] map_method_is_atomic
-    #   This method is atomic. Atomic methods of `Map` which accept a block
-    #   do not allow the `self` instance to be used within the block. Doing
-    #   so will cause a deadlock.
-
-    # @!method put_if_absent
-    #   @!macro map_method_is_atomic
-
-    # @!method compute_if_absent
-    #   @!macro map_method_is_atomic
-
-    # @!method compute_if_present
-    #   @!macro map_method_is_atomic
-
-    # @!method compute
-    #   @!macro map_method_is_atomic
-
-    # @!method merge_pair
-    #   @!macro map_method_is_atomic
-
-    # @!method replace_pair
-    #   @!macro map_method_is_atomic
-
-    # @!method replace_if_exists
-    #   @!macro map_method_is_atomic
-
-    # @!method get_and_set
-    #   @!macro map_method_is_atomic
-
-    # @!method delete
-    #   @!macro map_method_is_atomic
-
-    # @!method delete_pair
-    #   @!macro map_method_is_atomic
-
-    def initialize(options = nil, &block)
-      if options.kind_of?(::Hash)
-        validate_options_hash!(options)
-      else
-        options = nil
-      end
-
-      super(options)
-      @default_proc = block
-    end
-
-    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
-
-    alias_method :get, :[]
-    alias_method :put, :[]=
-
-    # @!macro [attach] map_method_not_atomic
-    #   The "fetch-then-act" methods of `Map` are not atomic. `Map` is intended
-    #   to be use as a concurrency primitive with strong happens-before
-    #   guarantees. It is not intended to be used as a high-level abstraction
-    #   supporting complex operations. All read and write operations are
-    #   thread safe, but no guarantees are made regarding race conditions
-    #   between the fetch operation and yielding to the block. Additionally,
-    #   this method does not support recursion. This is due to internal
-    #   constraints that are very unlikely to change in the near future.
-    def fetch(key, default_value = NULL)
-      if NULL != (value = get_or_default(key, NULL))
-        value
-      elsif block_given?
-        yield key
-      elsif NULL != default_value
-        default_value
-      else
-        raise_fetch_no_key
-      end
-    end
-
-    # @!macro map_method_not_atomic
-    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))
-      end
-    end
-
-    # @!macro map_method_is_atomic
-    def put_if_absent(key, value)
-      computed = false
-      result = compute_if_absent(key) do
-        computed = true
-        value
-      end
-      computed ? nil : result
-    end unless method_defined?(:put_if_absent)
-
-    def value?(value)
-      each_value do |v|
-        return true if value.equal?(v)
-      end
-      false
-    end
-
-    def keys
-      arr = []
-      each_pair {|k, v| arr << k}
-      arr
-    end unless method_defined?(:keys)
-
-    def values
-      arr = []
-      each_pair {|k, v| arr << v}
-      arr
-    end unless method_defined?(:values)
-
-    def each_key
-      each_pair {|k, v| yield k}
-    end unless method_defined?(:each_key)
-
-    def each_value
-      each_pair {|k, v| yield v}
-    end unless method_defined?(:each_value)
-
-    alias_method :each, :each_pair unless method_defined?(:each)
-
-    def key(value)
-      each_pair {|k, v| return k if v == value}
-      nil
-    end unless method_defined?(:key)
-    alias_method :index, :key if RUBY_VERSION < '1.9'
-
-    def empty?
-      each_pair {|k, v| return false}
-      true
-    end unless method_defined?(:empty?)
-
-    def size
-      count = 0
-      each_pair {|k, v| count += 1}
-      count
-    end unless method_defined?(:size)
-
-    def marshal_dump
-      raise TypeError, "can't dump hash with default proc" if @default_proc
-      h = {}
-      each_pair {|k, v| h[k] = v}
-      h
-    end
-
-    def marshal_load(hash)
-      initialize
-      populate_from(hash)
-    end
-
-    undef :freeze
-
-    # @!visibility private
-    DEFAULT_OBJ_ID_STR_WIDTH = 0.size == 4 ? 7 : 14 # we want to look "native", 7 for 32-bit, 14 for 64-bit
-    # override default #inspect() method: firstly, we don't want to be spilling our guts (i-vars), secondly, MRI backend's
-    # #inspect() call on its @backend i-var will bump @backend's iter level while possibly yielding GVL
-    def inspect
-      id_str = (object_id << 1).to_s(16).rjust(DEFAULT_OBJ_ID_STR_WIDTH, '0')
-      "#<#{self.class.name}:0x#{id_str} entries=#{size} default_proc=#{@default_proc.inspect}>"
-    end
-
-    private
-    def raise_fetch_no_key
-      raise KeyError, 'key not found'
-    end
-
-    def initialize_copy(other)
-      super
-      populate_from(other)
-    end
-
-    def populate_from(hash)
-      hash.each_pair {|k, v| self[k] = v}
-      self
-    end
-
-    def validate_options_hash!(options)
-      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Integer) || initial_capacity < 0)
-        raise ArgumentError, ":initial_capacity must be a positive Integer"
-      end
-      if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
-        raise ArgumentError, ":load_factor must be a number between 0 and 1"
-      end
-    end
-  end
-end