concurrent-ruby 1.0.0.pre4 → 1.0.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c97013c9e44933fb0b71553938a6c582c540234
-  data.tar.gz: 7c5e9eaa3ff9649b50384c5a68ea39dbe1bacd80
+  metadata.gz: ce52e17c1838d75c89822e42bdeee79df25ce25a
+  data.tar.gz: 801d6c3194364d5854ecc4d6a00165d5ae604494
 SHA512:
-  metadata.gz: 8e138f95c21c8fdc05e9c3c107e5d58029acebef7dbad68a0fe3b6f7e79dd0faee9db8d255deef0871e7bdadf7e9c641a21dd13b88f1528d96d424ddcef7399f
-  data.tar.gz: 8f860fef518fbd5ea8df55bd0e5da79eabeb3fe48e615cf98e48946c6dcdbd09010b84709678c41e26380c02905b4310fb875d73b8609ab474cd16c4ec27f160
+  metadata.gz: 3f170a4801f643440e0aa6d36f1a14f4285c83462b6d3b455ae0674ee3d30d9aa1c706edaf99b60ff158ca0bbf0679e87cab9ed12a9324e4bae4306ea5dd6d5b
+  data.tar.gz: 062520ed68fb0f9b7b322fc33c06d2f3cc2aa55d65126de60a79161976544fca78bb9db366c971c74d4b94682db38ad69d714cce9de3de8dba5f9497f5c9dd3d

data/CHANGELOG.md

@@ -1,6 +1,16 @@
 ### Upcoming Release v1.0.0 (TBD)
 
-## Current Release v1.0.0.pre4 (08 October 2015)
+## Current Release v1.0.0.pre5 (04 November 2015)
+
+* Further updates and improvements to the synchronization layer.
+* Performance and memory usage performance with `Actor` logging.
+* Fixed `ThreadPoolExecutor` task count methods.
+* Improved `Async` performance for both short and long-lived objects.
+* Fixed bug in `LockFreeLinkedSet`.
+* Fixed bug in which `Agent#await` triggered a validation failure.
+* Further `Channel` updates.
+
+### Release v1.0.0.pre4 (08 October 2015)
 
 * Adopted a project Code of Conduct
 * Cleared interpreter warnings

data/lib/concurrent/agent.rb

@@ -166,6 +166,7 @@ module Concurrent
     class Error < StandardError
       def initialize(message = nil)
         message ||= 'agent must be restarted before jobs can post'
+        super(message)
       end
     end
 
@@ -174,6 +175,7 @@ module Concurrent
     class ValidationError < Error
       def initialize(message = nil)
         message ||= 'invalid value'
+        super(message)
       end
     end
 
@@ -545,7 +547,9 @@ module Concurrent
       new_value     = job.action.call(old_value, *job.args)
       @caller.value = nil
 
-      if new_value != AWAIT_FLAG && ns_validate(new_value)
+      return if new_value == AWAIT_FLAG
+
+      if ns_validate(new_value)
         @current.value = new_value
         observers.notify_observers(Time.now, old_value, new_value)
       else

data/lib/concurrent/async.rb

@@ -1,5 +1,6 @@
+require 'concurrent/configuration'
 require 'concurrent/ivar'
-require 'concurrent/executor/single_thread_executor'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
@@ -10,14 +11,14 @@ module Concurrent
   #
   # A more feature-rich {Concurrent::Actor} is also available when the
   # capabilities of `Async` are too limited.
-  # 
+  #
   # ```cucumber
   # Feature:
   #   As a stateful, plain old Ruby class
   #   I want safe, asynchronous behavior
   #   So my long-running methods don't block the main thread
   # ```
-  # 
+  #
   # The `Async` module is a way to mix simple yet powerful asynchronous
   # capabilities into any plain old Ruby object or class, turning each object
   # into a simple Actor. Method calls are processed on a background thread. The
@@ -37,14 +38,13 @@ module Concurrent
   # send messages to the `gen_server` via the `cast` and `call` methods. Unlike
   # Erlang's `gen_server`, however, `Async` classes do not support linking or
   # supervision trees.
-  # 
+  #
   # ## Basic Usage
   #
   # When this module is mixed into a class, objects of the class become inherently
-  # asynchronous. Each object gets its own background thread (specifically,
-  # `SingleThreadExecutor`) on which to post asynchronous method calls.
-  # Asynchronous method calls are executed in the background one at a time in
-  # the order they are received.
+  # asynchronous. Each object gets its own background thread on which to post
+  # asynchronous method calls. Asynchronous method calls are executed in the
+  # background one at a time in the order they are received.
   #
   # To create an asynchronous class, simply mix in the `Concurrent::Async` module:
   #
@@ -200,30 +200,30 @@ module Concurrent
   #
   # Class methods which are pure functions are safe. Class methods which modify
   # class variables should be avoided, for all the reasons listed above.
-  # 
+  #
   # ## An Important Note About Thread Safe Guarantees
-  # 
+  #
   # > Thread safe guarantees can only be made when asynchronous method calls
   # > are not mixed with direct method calls. Use only direct method calls
   # > when the object is used exclusively on a single thread. Use only
   # > `async` and `await` when the object is shared between threads. Once you
   # > call a method using `async` or `await`, you should no longer call methods
   # > directly on the object. Use `async` and `await` exclusively from then on.
-  # 
+  #
   # @example
-  # 
+  #
   #   class Echo
   #     include Concurrent::Async
-  #   
+  #
   #     def echo(msg)
   #       print "#{msg}\n"
   #     end
   #   end
-  #   
+  #
   #   horn = Echo.new
   #   horn.echo('zero')      # synchronous, not thread-safe
   #                          # returns the actual return value of the method
-  #   
+  #
   #   horn.async.echo('one') # asynchronous, non-blocking, thread-safe
   #                          # returns an IVar in the :pending state
   #
@@ -231,7 +231,6 @@ module Concurrent
   #                          # returns an IVar in the :complete state
   #
   # @see Concurrent::Actor
-  # @see Concurrent::SingleThreadExecutor
   # @see https://en.wikipedia.org/wiki/Actor_model "Actor Model" at Wikipedia
   # @see http://www.erlang.org/doc/man/gen_server.html Erlang gen_server
   # @see http://c2.com/cgi/wiki?LetItCrash "Let It Crash" at http://c2.com/
@@ -299,24 +298,20 @@ module Concurrent
     # Delegates asynchronous, thread-safe method calls to the wrapped object.
     #
     # @!visibility private
-    class AsyncDelegator
+    class AsyncDelegator < Synchronization::LockableObject
+      safe_initialization!
 
-      # Create a new delegator object wrapping the given delegate,
-      # protecting it with the given serializer, and executing it on the
-      # given executor. Block if necessary.
+      # Create a new delegator object wrapping the given delegate.
       #
       # @param [Object] delegate the object to wrap and delegate method calls to
-      # @param [Concurrent::ExecutorService] executor the executor on which to execute delegated method calls
-      # @param [Boolean] blocking will block awaiting result when `true`
-      def initialize(delegate, executor, blocking)
+      def initialize(delegate)
+        super()
         @delegate = delegate
-        @executor = executor
-        @blocking = blocking
+        @queue = []
+        @executor = Concurrent.global_io_executor
       end
 
-      # Delegates method calls to the wrapped object. For performance,
-      # dynamically defines the given method on the delegator so that
-      # all future calls to `method` will not be directed here.
+      # Delegates method calls to the wrapped object.
       #
       # @param [Symbol] method the method being called
       # @param [Array] args zero or more arguments to the method
@@ -330,19 +325,67 @@ module Concurrent
         Async::validate_argc(@delegate, method, *args)
 
         ivar = Concurrent::IVar.new
-        @executor.post(args) do |arguments|
+        synchronize do
+          @queue.push [ivar, method, args, block]
+          @executor.post { perform } if @queue.length == 1
+        end
+
+        ivar
+      end
+
+      # Perform all enqueued tasks.
+      #
+      # This method must be called from within the executor. It must not be
+      # called while already running. It will loop until the queue is empty.
+      def perform
+        loop do
+          ivar, method, args, block = synchronize { @queue.first }
+          break unless ivar # queue is empty
+
           begin
-            ivar.set(@delegate.send(method, *arguments, &block))
+            ivar.set(@delegate.send(method, *args, &block))
           rescue => error
             ivar.fail(error)
           end
+
+          synchronize do
+            @queue.shift
+            return if @queue.empty?
+          end
         end
-        ivar.wait if @blocking
-        ivar
       end
     end
     private_constant :AsyncDelegator
 
+    # Delegates synchronous, thread-safe method calls to the wrapped object.
+    #
+    # @!visibility private
+    class AwaitDelegator
+
+      # Create a new delegator object wrapping the given delegate.
+      #
+      # @param [AsyncDelegator] delegate the object to wrap and delegate method calls to
+      def initialize(delegate)
+        @delegate = delegate
+      end
+
+      # Delegates method calls to the wrapped object.
+      #
+      # @param [Symbol] method the method being called
+      # @param [Array] args zero or more arguments to the method
+      #
+      # @return [IVar] the result of the method call
+      #
+      # @raise [NameError] the object does not respond to `method` method
+      # @raise [ArgumentError] the given `args` do not match the arity of `method`
+      def method_missing(method, *args, &block)
+        ivar = @delegate.send(method, *args, &block)
+        ivar.wait
+        ivar
+      end
+    end
+    private_constant :AwaitDelegator
+
     # Causes the chained method call to be performed asynchronously on the
     # object's thread. The delegated method will return a future in the
     # `:pending` state and the method call will have been scheduled on the
@@ -385,8 +428,6 @@ module Concurrent
     end
     alias_method :call, :await
 
-    private
-
     # Initialize the internal serializer and other stnchronization mechanisms.
     #
     # @note This method *must* be called immediately upon object construction.
@@ -396,10 +437,8 @@ module Concurrent
     def init_synchronization
       return self if @__async_initialized__
       @__async_initialized__ = true
-      @__async_executor__ = Concurrent::SingleThreadExecutor.new(
-        fallback_policy: :caller_runs, auto_terminate: true)
-      @__await_delegator__ = AsyncDelegator.new(self, @__async_executor__, true)
-      @__async_delegator__ = AsyncDelegator.new(self, @__async_executor__, false)
+      @__async_delegator__ = AsyncDelegator.new(self)
+      @__await_delegator__ = AwaitDelegator.new(@__async_delegator__)
       self
     end
   end

data/lib/concurrent/atom.rb

@@ -111,9 +111,10 @@ module Concurrent
     #
     # @raise [ArgumentError] if the validator is not a `Proc` (when given)
     def initialize(value, opts = {})
+      super()
       @Validator     = opts.fetch(:validator, -> v { true })
       self.observers = Collection::CopyOnNotifyObserverSet.new
-      super(value)
+      self.value     = value
     end
 
     # @!method value

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -1,5 +1,5 @@
 require 'concurrent/atomic/mutex_atomic_boolean'
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 
 module Concurrent
 

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -1,5 +1,5 @@
 require 'concurrent/atomic/mutex_atomic_fixnum'
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 
 module Concurrent
 

data/lib/concurrent/atomic/atomic_reference.rb

@@ -1,4 +1,4 @@
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 require 'concurrent/utility/engine'
 require 'concurrent/atomic_reference/concurrent_update_error'
 require 'concurrent/atomic_reference/mutex_atomic'

data/lib/concurrent/atomic/semaphore.rb

@@ -1,5 +1,5 @@
 require 'concurrent/atomic/mutex_semaphore'
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 
 module Concurrent
 

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

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

data/lib/concurrent/atomic_reference/jruby.rb

@@ -1,4 +1,4 @@
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 
 if defined?(Concurrent::JavaAtomicReference)
   require 'concurrent/atomic_reference/direct_update'

data/lib/concurrent/atomic_reference/ruby.rb

@@ -1,5 +1,5 @@
 if defined? Concurrent::CAtomicReference
-  require 'concurrent/utility/native_extension_loader'
+  require 'concurrent/synchronization'
   require 'concurrent/atomic_reference/direct_update'
   require 'concurrent/atomic_reference/numeric_cas_wrapper'
 

data/lib/concurrent/concern/dereferenceable.rb

@@ -9,13 +9,17 @@ module Concurrent
     #
     # @!macro copy_options
     module Dereferenceable
+      # NOTE: This module is going away in 2.0. In the mean time we need it to
+      # play nicely with the synchronization layer. This means that the
+      # including class SHOULD be synchronized and it MUST implement a
+      # `#synchronize` method. Not doing so will lead to runtime errors.
 
       # Return the value this object represents after applying the options specified
       # by the `#set_deref_options` method.
       #
       # @return [Object] the current value of the object
       def value
-        mutex.synchronize { apply_deref_options(@value) }
+        synchronize { apply_deref_options(@value) }
       end
       alias_method :deref, :value
 
@@ -25,43 +29,24 @@ module Concurrent
       #
       # @param [Object] value the new value
       def value=(value)
-        mutex.synchronize{ @value = value }
-      end
-
-      # A mutex lock used for synchronizing thread-safe operations. Methods defined
-      # by `Dereferenceable` are synchronized using the `Mutex` returned from this
-      # method. Operations performed by the including class that operate on the
-      # `@value` instance variable should be locked with this `Mutex`.
-      #
-      # @return [Mutex] the synchronization object
-      def mutex
-        @mutex
-      end
-
-      # Initializes the internal `Mutex`.
-      #
-      # @note This method *must* be called from within the constructor of the including class.
-      #
-      # @see #mutex
-      def init_mutex(mutex = Mutex.new)
-        @mutex = mutex
+        synchronize{ @value = value }
       end
 
       # @!macro [attach] dereferenceable_set_deref_options
       #   Set the options which define the operations #value performs before
       #   returning data to the caller (dereferencing).
-      #  
+      #
       #   @note Most classes that include this module will call `#set_deref_options`
       #   from within the constructor, thus allowing these options to be set at
       #   object creation.
-      #  
+      #
       #   @param [Hash] opts the options defining dereference behavior.
       #   @option opts [String] :dup_on_deref (false) call `#dup` before returning the data
       #   @option opts [String] :freeze_on_deref (false) call `#freeze` before returning the data
       #   @option opts [String] :copy_on_deref (nil) call the given `Proc` passing
       #     the internal value and returning the value returned from the proc
       def set_deref_options(opts = {})
-        mutex.synchronize{ ns_set_deref_options(opts) }
+        synchronize{ ns_set_deref_options(opts) }
       end
 
       # @!macro dereferenceable_set_deref_options

data/lib/concurrent/concern/obligation.rb

@@ -9,6 +9,10 @@ module Concurrent
 
     module Obligation
       include Concern::Dereferenceable
+      # NOTE: The Dereferenceable module is going away in 2.0. In the mean time
+      # we need it to place nicely with the synchronization layer. This means
+      # that the including class SHOULD be synchronized and it MUST implement a
+      # `#synchronize` method. Not doing so will lead to runtime errors.
 
       # Has the obligation been fulfilled?
       #
@@ -104,7 +108,7 @@ module Concurrent
       #
       # @return [Symbol] the current state
       def state
-        mutex.synchronize { @state }
+        synchronize { @state }
       end
 
       # If an exception was raised during processing this will return the
@@ -113,7 +117,7 @@ module Concurrent
       #
       # @return [Exception] the exception raised during processing or `nil`
       def reason
-        mutex.synchronize { @reason }
+        synchronize { @reason }
       end
 
       # @example allows Obligation to be risen
@@ -132,8 +136,7 @@ module Concurrent
       end
 
       # @!visibility private
-      def init_obligation(*args)
-        init_mutex(*args)
+      def init_obligation
         @event = Event.new
       end
 
@@ -155,7 +158,7 @@ module Concurrent
 
       # @!visibility private
       def state=(value)
-        mutex.synchronize { ns_set_state(value) }
+        synchronize { ns_set_state(value) }
       end
 
       # Atomic compare and set operation
@@ -163,12 +166,12 @@ module Concurrent
       #
       # @param [Symbol] next_state
       # @param [Symbol] expected_current
-      # 
+      #
       # @return [Boolean] true is state is changed, false otherwise
       #
       # @!visibility private
       def compare_and_set_state(next_state, *expected_current)
-        mutex.synchronize do
+        synchronize do
           if expected_current.include? @state
             @state = next_state
             true
@@ -184,7 +187,7 @@ module Concurrent
       #
       # @!visibility private
       def if_state(*expected_states)
-        mutex.synchronize do
+        synchronize do
           raise ArgumentError.new('no block given') unless block_given?
 
           if expected_states.include? @state