concurrent-ruby-edge 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 051e8d02906d153d112b5f2e2c86948d3cf0fd26
-  data.tar.gz: f4a53c06cfbf931dfc11245be8dabdf579d0e361
+  metadata.gz: da7e2be8cf30bba4051e8af6b0040d4f4892fae5
+  data.tar.gz: 70067e829e45a4365fa67fd9306be7658cc65d95
 SHA512:
-  metadata.gz: 9b8490d330375764f70d70f212de4697dd3fbf83b0b4a7da1ffba7c86599fc64df3c4f25801ea0531970a04d2b62e04bad7701df9ce25afd24779dbd6b54d0fd
-  data.tar.gz: 6fc402ca7a4434e2b8e97a71fd351c81bbf8ff9467ccceb8159c78993fc8219e032704644cfbb965a34879aa5922bddc8d96f5f78343d0b0834602340d122a52
+  metadata.gz: ae1e26dc4dd7dcd7df7185aa68d43eb010e6982bc7ea0da112c66c2c65ecf53456e71399145b0dc0c7c1f60a59382f1142224be367ff285d39807df585b85539
+  data.tar.gz: 0207d055c1c55f1ffe7ff7914acaebc0876b801391c7e0068c12f43beab2f2d6f97ad0c02cce9d7f8a92a2dabe5fe790008f995229d058c875c46b97c2c95b0e

data/README.md

@@ -84,7 +84,7 @@ Structure classes derived from Ruby's [Struct](http://ruby-doc.org/core-2.2.0/St
 
 Thread-safe variables:
 
-* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A way to manage shared, mutable, *asynchronous*, independent, state. Based on Clojure's [Agent](http://clojure.org/agents).
+* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A way to manage shared, mutable, *asynchronous*, independent state. Based on Clojure's [Agent](http://clojure.org/agents).
 * [Atom](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Atom.html): A way to manage shared, mutable, *synchronous*, independent state. Based on Clojure's [Atom](http://clojure.org/atoms).
 * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html) A boolean value that can be updated atomically.
 * [AtomicFixnum](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicFixnum.html) A numeric value that can be updated atomically.

data/lib/concurrent-edge.rb

@@ -14,3 +14,5 @@ require 'concurrent/edge/lock_free_stack'
 require 'concurrent/edge/promises'
 require 'concurrent/edge/cancellation'
 require 'concurrent/edge/throttle'
+
+require 'concurrent/edge/processing_actor'

data/lib/concurrent/actor/behaviour/termination.rb

@@ -70,7 +70,9 @@ module Concurrent
                              end
 
           all_terminations.chain_resolvable(@terminated)
-          all_terminations.chain_resolvable(envelope.future) if envelope && envelope.future
+          if envelope && envelope.future
+            all_terminations.chain { |fulfilled, _, reason| envelope.future.resolve fulfilled, true, reason }
+          end
 
           broadcast(true, [:terminated, reason]) # TODO do not end up in Dead Letter Router
           parent << :remove_child if parent

data/lib/concurrent/actor/utils/pool.rb

@@ -43,7 +43,7 @@ module Concurrent
           envelope_to_redirect = if envelope.future
                                    envelope
                                  else
-                                   Envelope.new(envelope.message, Concurrent::Promises.future, envelope.sender, envelope.address)
+                                   Envelope.new(envelope.message, Promises.resolvable_future, envelope.sender, envelope.address)
                                  end
           envelope_to_redirect.future.on_fulfillment! { @balancer << :subscribe } # TODO check safety of @balancer reading
           redirect @balancer, envelope_to_redirect

data/lib/concurrent/edge/atomic_markable_reference.rb

@@ -6,9 +6,8 @@ module Concurrent
     #   An atomic reference which maintains an object reference along with a mark bit
     #   that can be updated atomically.
     #
-    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicMarkableReference.html java.util.concurrent.atomic.AtomicMarkableReference
-    #
-    #   @api Edge
+    #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicMarkableReference.html
+    #     java.util.concurrent.atomic.AtomicMarkableReference
     class AtomicMarkableReference < ::Concurrent::Synchronization::Object
 
       private(*attr_atomic(:reference))

data/lib/concurrent/edge/cancellation.rb

@@ -1,14 +1,15 @@
 module Concurrent
 
   # Provides tools for cooperative cancellation.
-  # Inspired by https://msdn.microsoft.com/en-us/library/dd537607(v=vs.110).aspx
+  # Inspired by <https://msdn.microsoft.com/en-us/library/dd537607(v=vs.110).aspx>
+  #
   # @example
   #   # Create new cancellation. `cancellation` is used for cancelling, `token` is passed down to
   #   # tasks for cooperative cancellation
   #   cancellation, token = Concurrent::Cancellation.create
   #   Thread.new(token) do |token|
-  #     # Count 1+1 (simulating some other meaningful work) repeatedly until the token is cancelled through
-  #     # cancellation.
+  #     # Count 1+1 (simulating some other meaningful work) repeatedly
+  #     # until the token is cancelled through cancellation.
   #     token.loop_until_canceled { 1+1 }
   #   end
   #   sleep 0.1

data/lib/concurrent/edge/lock_free_queue.rb

@@ -1,5 +1,6 @@
 module Concurrent
 
+  # @!visibility private
   class LockFreeQueue < Synchronization::Object
 
     class Node < Synchronization::Object

data/lib/concurrent/edge/lock_free_stack.rb

@@ -1,4 +1,6 @@
 module Concurrent
+
+  # @!visibility private
   class LockFreeStack < Synchronization::Object
 
     safe_initialization!
@@ -118,5 +120,7 @@ module Concurrent
     def to_s
       format '<#%s:0x%x %s>', self.class, object_id << 1, to_a.to_s
     end
+
+    alias_method :inspect, :to_s
   end
 end

data/lib/concurrent/edge/processing_actor.rb

@@ -0,0 +1,161 @@
+module Concurrent
+
+  # A new implementation of actor which also simulates the process, therefore it can be used
+  # in the same way as Erlang's actors but **without** occupying thread. A tens of thousands
+  # ProcessingActors can run at the same time sharing a thread pool.
+  # @example
+  #     # Runs on a pool, does not consume 50_000 threads
+  #     actors = 50_000.times.map do |i|
+  #       Concurrent::ProcessingActor.act(i) { |a, i| a.receive.then_on(:fast, i) { |m, i| m + i } }
+  #     end
+  #
+  #     actors.each { |a| a.tell 1 }
+  #     values = actors.map(&:termination).map(&:value)
+  #     values[0,5]                                        # => [1, 2, 3, 4, 5]
+  #     values[-5, 5]                                      # => [49996, 49997, 49998, 49999, 50000]
+  # @!macro edge_warning
+  class ProcessingActor < Synchronization::Object
+    # TODO (pitr-ch 18-Dec-2016): (un)linking, bidirectional, sends special message, multiple link calls has no effect,
+    # TODO (pitr-ch 21-Dec-2016): Make terminated a cancellation token?
+    # link_spawn atomic, Can it be fixed by sending exit when linked dead actor?
+
+    safe_initialization!
+
+    # @return [Promises::Channel] actor's mailbox.
+    def mailbox
+      @Mailbox
+    end
+
+    # @return [Promises::Future(Object)] a future which is resolved when the actor ends its processing.
+    #   It can either be fulfilled with a value when actor ends normally or rejected with
+    #   a reason (exception) when actor fails.
+    def termination
+      @Terminated.with_hidden_resolvable
+    end
+
+    # Creates an actor.
+    # @see #act_listening Behaves the same way, but does not take mailbox as a first argument.
+    # @return [ProcessingActor]
+    # @example
+    #   actor = Concurrent::ProcessingActor.act do |actor|
+    #     actor.receive.then do |message|
+    #       # the actor ends normally with message
+    #       message
+    #     end
+    #   end
+    #
+    #   actor.tell :a_message
+    #       # => <#Concurrent::ProcessingActor:0x7fff11280560 termination:pending>
+    #   actor.termination.value! # => :a_message
+    def self.act(*args, &process)
+      act_listening Promises::Channel.new, *args, &process
+    end
+
+    # Creates an actor listening to a specified channel (mailbox).
+    # @param [Object] args Arguments passed to the process.
+    # @param [Promises::Channel] channel which serves as mailing box. The channel can have limited
+    #   size to achieve backpressure.
+    # @yield args to the process to get back a future which represents the actors execution.
+    # @yieldparam [Object] *args
+    # @yieldreturn [Promises::Future(Object)] a future representing next step of execution
+    # @return [ProcessingActor]
+    # @example
+    #   # TODO (pitr-ch 19-Jan-2017): actor with limited mailbox
+    def self.act_listening(channel, *args, &process)
+      actor = ProcessingActor.new channel
+      Promises.
+          future(actor, *args, &process).
+          run.
+          chain_resolvable(actor.instance_variable_get(:@Terminated))
+      actor
+    end
+
+    # Receives a message when available, used in the actor's process.
+    # @return [Promises::Future(Object)] a future which will be fulfilled with a message from
+    #   mailbox when it is available.
+    def receive(probe = Promises.resolvable_future)
+      # TODO (pitr-ch 27-Dec-2016): patterns
+      @Mailbox.pop probe
+    end
+
+    # Tells a message to the actor. May block current thread if the mailbox is full.
+    # {#tell} is a better option since it does not block. It's usually used to integrate with
+    # threading code.
+    # @example
+    #   Thread.new(actor) do |actor|
+    #     # ...
+    #     actor.tell! :a_message # blocks until the message is told
+    #     #   (there is a space for it in the channel)
+    #     # ...
+    #   end
+    # @param [Object] message
+    # @return [self]
+    def tell!(message)
+      @Mailbox.push(message).wait!
+      self
+    end
+
+    # Tells a message to the actor.
+    # @param [Object] message
+    # @return [Promises::Future(ProcessingActor)] a future which will be fulfilled with the actor
+    #   when the message is pushed to mailbox.
+    def tell(message)
+      @Mailbox.push(message).then(self) { |_, actor| actor }
+    end
+
+    # Simplifies common pattern when a message sender also requires an answer to the message
+    # from the actor. It appends a resolvable_future for the answer after the message.
+    # @todo has to be nice also on the receive side, cannot make structure like this [message = [...], answer]
+    #   all receives should receive something friendly
+    # @param [Object] message
+    # @param [Promises::ResolvableFuture] answer
+    # @return [Promises::Future] a future which will be fulfilled with the answer to the message
+    # @example
+    #     add_once_actor = Concurrent::ProcessingActor.act do |actor|
+    #       actor.receive.then do |(a, b), answer|
+    #         result = a + b
+    #         answer.fulfill result
+    #         # terminate with result value
+    #         result
+    #       end
+    #     end
+    #     # => <#Concurrent::ProcessingActor:0x7fcd1315f6e8 termination:pending>
+    #
+    #     add_once_actor.ask([1, 2]).value!                  # => 3
+    #     # fails the actor already added once
+    #     add_once_actor.ask(%w(ab cd)).reason
+    #     # => #<RuntimeError: actor terminated normally before answering with a value: 3>
+    #     add_once_actor.termination.value!                  # => 3
+    def ask(message, answer = Promises.resolvable_future)
+      tell [message, answer]
+      # do not leave answers unanswered when actor terminates.
+      Promises.any(
+          Promises.fulfilled_future(:answer).zip(answer),
+          Promises.fulfilled_future(:termination).zip(@Terminated)
+      ).chain do |fulfilled, (which, value), (_, reason)|
+        # TODO (pitr-ch 20-Jan-2017): we have to know which future was resolved
+        # TODO (pitr-ch 20-Jan-2017): make the combinator programmable, so anyone can create what is needed
+        # TODO (pitr-ch 19-Jan-2017): ensure no callbacks are accumulated on @Terminated
+        if which == :termination
+          raise reason.nil? ? format('actor terminated normally before answering with a value: %s', value) : reason
+        else
+          fulfilled ? value : raise(reason)
+        end
+      end
+    end
+
+    # @return [String] string representation.
+    def inspect
+      format '<#%s:0x%x termination:%s>', self.class, object_id << 1, termination.state
+    end
+
+    private
+
+    def initialize(channel = Promises::Channel.new)
+      @Mailbox    = channel
+      @Terminated = Promises.resolvable_future
+      super()
+    end
+
+  end
+end

data/lib/concurrent/edge/promises.rb

@@ -73,10 +73,21 @@ module Concurrent
     module FactoryMethods
       extend ReInclude
 
+      module Configuration
+        # @return [Executor, :io, :fast] the executor which is used when none is supplied
+        #   to a factory method. The method can be overridden in the receivers of
+        #   `include FactoryMethod`
+        def default_executor
+          :io
+        end
+      end
+
+      include Configuration
+
       # @!macro promises.shortcut.on
       # @return [ResolvableEvent]
       def resolvable_event
-        resolvable_event_on :io
+        resolvable_event_on default_executor
       end
 
       # Created resolvable event, user is responsible for resolving the event once by
@@ -84,14 +95,14 @@ module Concurrent
       #
       # @!macro promises.param.default_executor
       # @return [ResolvableEvent]
-      def resolvable_event_on(default_executor = :io)
+      def resolvable_event_on(default_executor = self.default_executor)
         ResolvableEventPromise.new(default_executor).future
       end
 
       # @!macro promises.shortcut.on
       # @return [ResolvableFuture]
       def resolvable_future
-        resolvable_future_on :io
+        resolvable_future_on default_executor
       end
 
       # Creates resolvable future, user is responsible for resolving the future once by
@@ -100,14 +111,14 @@ module Concurrent
       #
       # @!macro promises.param.default_executor
       # @return [ResolvableFuture]
-      def resolvable_future_on(default_executor = :io)
+      def resolvable_future_on(default_executor = self.default_executor)
         ResolvableFuturePromise.new(default_executor).future
       end
 
       # @!macro promises.shortcut.on
       # @return [Future]
       def future(*args, &task)
-        future_on(:io, *args, &task)
+        future_on(default_executor, *args, &task)
       end
 
       # @!macro [new] promises.future-on1
@@ -129,7 +140,7 @@ module Concurrent
       #
       # @!macro promises.param.default_executor
       # @return [Future]
-      def resolved_future(fulfilled, value, reason, default_executor = :io)
+      def resolved_future(fulfilled, value, reason, default_executor = self.default_executor)
         ImmediateFuturePromise.new(default_executor, fulfilled, value, reason).future
       end
 
@@ -137,7 +148,7 @@ module Concurrent
       #
       # @!macro promises.param.default_executor
       # @return [Future]
-      def fulfilled_future(value, default_executor = :io)
+      def fulfilled_future(value, default_executor = self.default_executor)
         resolved_future true, value, nil, default_executor
       end
 
@@ -145,7 +156,7 @@ module Concurrent
       #
       # @!macro promises.param.default_executor
       # @return [Future]
-      def rejected_future(reason, default_executor = :io)
+      def rejected_future(reason, default_executor = self.default_executor)
         resolved_future false, nil, reason, default_executor
       end
 
@@ -153,7 +164,7 @@ module Concurrent
       #
       # @!macro promises.param.default_executor
       # @return [Event]
-      def resolved_event(default_executor = :io)
+      def resolved_event(default_executor = self.default_executor)
         ImmediateEventPromise.new(default_executor).event
       end
 
@@ -164,26 +175,26 @@ module Concurrent
       # @!macro promises.param.default_executor
       # @return [Event, Future]
       #
-      # @overload create(nil, default_executor = :io)
+      # @overload create(nil, default_executor = self.default_executor)
       #   @param [nil] nil
       #   @return [Event] resolved event.
       #
-      # @overload create(a_future, default_executor = :io)
+      # @overload create(a_future, default_executor = self.default_executor)
       #   @param [Future] a_future
       #   @return [Future] a future which will be resolved when a_future is.
       #
-      # @overload create(an_event, default_executor = :io)
+      # @overload create(an_event, default_executor = self.default_executor)
       #   @param [Event] an_event
       #   @return [Event] an event which will be resolved when an_event is.
       #
-      # @overload create(exception, default_executor = :io)
+      # @overload create(exception, default_executor = self.default_executor)
       #   @param [Exception] exception
       #   @return [Future] a rejected future with the exception as its reason.
       #
-      # @overload create(value, default_executor = :io)
+      # @overload create(value, default_executor = self.default_executor)
       #   @param [Object] value when none of the above overloads fits
       #   @return [Future] a fulfilled future with the value.
-      def create(argument = nil, default_executor = :io)
+      def create(argument = nil, default_executor = self.default_executor)
         case argument
         when AbstractEventFuture
           # returning wrapper would change nothing
@@ -200,7 +211,7 @@ module Concurrent
       # @!macro promises.shortcut.on
       # @return [Future]
       def delay(*args, &task)
-        delay_on :io, *args, &task
+        delay_on default_executor, *args, &task
       end
 
       # @!macro promises.future-on1
@@ -214,7 +225,7 @@ module Concurrent
       # @!macro promises.shortcut.on
       # @return [Future]
       def schedule(intended_time, *args, &task)
-        schedule_on :io, intended_time, *args, &task
+        schedule_on default_executor, intended_time, *args, &task
       end
 
       # @!macro promises.future-on1
@@ -231,7 +242,7 @@ module Concurrent
       # @!macro promises.shortcut.on
       # @return [Future]
       def zip_futures(*futures_and_or_events)
-        zip_futures_on :io, *futures_and_or_events
+        zip_futures_on default_executor, *futures_and_or_events
       end
 
       # Creates new future which is resolved after all futures_and_or_events are resolved.
@@ -253,7 +264,7 @@ module Concurrent
       # @!macro promises.shortcut.on
       # @return [Event]
       def zip_events(*futures_and_or_events)
-        zip_events_on :io, *futures_and_or_events
+        zip_events_on default_executor, *futures_and_or_events
       end
 
       # Creates new event which is resolved after all futures_and_or_events are resolved.
@@ -269,7 +280,7 @@ module Concurrent
       # @!macro promises.shortcut.on
       # @return [Future]
       def any_resolved_future(*futures_and_or_events)
-        any_resolved_future_on :io, *futures_and_or_events
+        any_resolved_future_on default_executor, *futures_and_or_events
       end
 
       alias_method :any, :any_resolved_future
@@ -291,7 +302,7 @@ module Concurrent
       # @!macro promises.shortcut.on
       # @return [Future]
       def any_fulfilled_future(*futures_and_or_events)
-        any_fulfilled_future_on :io, *futures_and_or_events
+        any_fulfilled_future_on default_executor, *futures_and_or_events
       end
 
       # Creates new future which is resolved after first of futures_and_or_events is fulfilled.
@@ -310,7 +321,7 @@ module Concurrent
       # @!macro promises.shortcut.on
       # @return [Future]
       def any_event(*futures_and_or_events)
-        any_event_on :io, *futures_and_or_events
+        any_event_on default_executor, *futures_and_or_events
       end
 
       # Creates new event which becomes resolved after first of the futures_and_or_events resolves.
@@ -727,7 +738,18 @@ module Concurrent
         @Waiters.each.to_a
       end
 
+      # # @!visibility private
+      def add_callback_notify_blocked(promise, index)
+        add_callback :callback_notify_blocked, promise, index
+      end
+
       # @!visibility private
+      def add_callback_clear_delayed_node(node)
+        add_callback(:callback_clear_delayed_node, node)
+      end
+
+      private
+
       def add_callback(method, *args)
         state = internal_state
         if resolved?(state)
@@ -741,7 +763,9 @@ module Concurrent
         self
       end
 
-      private
+      def callback_clear_delayed_node(state, node)
+        node.value = nil
+      end
 
       # @return [Boolean]
       def wait_until_resolved(timeout)
@@ -962,7 +986,9 @@ module Concurrent
         if reason.size > 1
           Concurrent::MultipleErrors.new reason
         else
-          reason[0].exception(*args)
+          ex = reason[0].exception(*args)
+          ex.set_backtrace ex.backtrace + caller
+          ex
         end
       end
 
@@ -1200,7 +1226,7 @@ module Concurrent
       end
 
       def callback_on_resolution(state, args, callback)
-        callback.call state.result, *args
+        callback.call *state.result, *args
       end
 
     end
@@ -1324,7 +1350,7 @@ module Concurrent
 
       alias_method :inspect, :to_s
 
-      def delayed
+      def delayed_because
         nil
       end
 
@@ -1379,55 +1405,45 @@ module Concurrent
       private_class_method :new
 
       def self.new_blocked_by1(blocker, *args, &block)
-        blocker_delayed = blocker.promise.delayed
-        delayed         = blocker_delayed ? LockFreeStack.new.push(blocker_delayed) : nil
-        promise         = new(delayed, 1, *args, &block)
-      ensure
-        blocker.add_callback :callback_notify_blocked, promise, 0
+        blocker_delayed = blocker.promise.delayed_because
+        promise         = new(blocker_delayed, 1, *args, &block)
+        blocker.add_callback_notify_blocked promise, 0
+        promise
       end
 
       def self.new_blocked_by2(blocker1, blocker2, *args, &block)
-        blocker_delayed1 = blocker1.promise.delayed
-        blocker_delayed2 = blocker2.promise.delayed
-        # TODO (pitr-ch 23-Dec-2016): use arrays when we know it will not grow (only flat adds delay)
-        delayed          = if blocker_delayed1
-                             if blocker_delayed2
-                               LockFreeStack.of2(blocker_delayed1, blocker_delayed2)
-                             else
-                               LockFreeStack.of1(blocker_delayed1)
-                             end
+        blocker_delayed1 = blocker1.promise.delayed_because
+        blocker_delayed2 = blocker2.promise.delayed_because
+        delayed          = if blocker_delayed1 && blocker_delayed2
+                             # TODO (pitr-ch 23-Dec-2016): use arrays when we know it will not grow (only flat adds delay)
+                             LockFreeStack.of2(blocker_delayed1, blocker_delayed2)
                            else
-                             blocker_delayed2 ? LockFreeStack.of1(blocker_delayed2) : nil
+                             blocker_delayed1 || blocker_delayed2
                            end
         promise          = new(delayed, 2, *args, &block)
-      ensure
-        blocker1.add_callback :callback_notify_blocked, promise, 0
-        blocker2.add_callback :callback_notify_blocked, promise, 1
+        blocker1.add_callback_notify_blocked promise, 0
+        blocker2.add_callback_notify_blocked promise, 1
+        promise
       end
 
       def self.new_blocked_by(blockers, *args, &block)
-        delayed = blockers.reduce(nil, &method(:add_delayed))
+        delayed = blockers.reduce(nil) { |d, f| add_delayed d, f.promise.delayed_because }
         promise = new(delayed, blockers.size, *args, &block)
-      ensure
-        blockers.each_with_index { |f, i| f.add_callback :callback_notify_blocked, promise, i }
+        blockers.each_with_index { |f, i| f.add_callback_notify_blocked promise, i }
+        promise
       end
 
-      def self.add_delayed(delayed, blocker)
-        blocker_delayed = blocker.promise.delayed
-        if blocker_delayed
-          delayed = unless delayed
-                      LockFreeStack.of1(blocker_delayed)
-                    else
-                      delayed.push(blocker_delayed)
-                    end
+      def self.add_delayed(delayed1, delayed2)
+        if delayed1 && delayed2
+          delayed1.push delayed2
+          delayed1
+        else
+          delayed1 || delayed2
         end
-        delayed
       end
 
       def initialize(delayed, blockers_count, future)
         super(future)
-        # noinspection RubyArgCount
-        @Touched   = AtomicBoolean.new false
         @Delayed   = delayed
         # noinspection RubyArgCount
         @Countdown = AtomicFixnum.new blockers_count
@@ -1440,16 +1456,12 @@ module Concurrent
         on_resolvable(future, index) if resolvable
       end
 
-      def delayed
+      def delayed_because
         @Delayed
       end
 
       def touch
-        clear_propagate_touch if @Touched.make_true
-      end
-
-      def touched?
-        @Touched.value
+        clear_and_propagate_touch
       end
 
       # for inspection only
@@ -1461,13 +1473,11 @@ module Concurrent
 
       private
 
-      def clear_propagate_touch
-        @Delayed.clear_each { |o| propagate_touch o } if @Delayed
-      end
+      def clear_and_propagate_touch(stack_or_element = @Delayed)
+        return if stack_or_element.nil?
 
-      def propagate_touch(stack_or_element = @Delayed)
         if stack_or_element.is_a? LockFreeStack
-          stack_or_element.each { |element| propagate_touch element }
+          stack_or_element.clear_each { |element| clear_and_propagate_touch element }
         else
           stack_or_element.touch unless stack_or_element.nil? # if still present
         end
@@ -1570,8 +1580,28 @@ module Concurrent
 
     class AbstractFlatPromise < BlockedPromise
 
+      def initialize(delayed_because, blockers_count, event_or_future)
+        delayed = LockFreeStack.of1(self)
+        super(delayed, blockers_count, event_or_future)
+        # noinspection RubyArgCount
+        @Touched        = AtomicBoolean.new false
+        @DelayedBecause = delayed_because || LockFreeStack.new
+
+        event_or_future.add_callback_clear_delayed_node delayed.peek
+      end
+
+      def touch
+        if @Touched.make_true
+          clear_and_propagate_touch @DelayedBecause
+        end
+      end
+
       private
 
+      def touched?
+        @Touched.value
+      end
+
       def on_resolvable(resolved_future, index)
         resolve_with resolved_future.internal_state
       end
@@ -1581,11 +1611,12 @@ module Concurrent
       end
 
       def add_delayed_of(future)
+        delayed = future.promise.delayed_because
         if touched?
-          propagate_touch future.promise.delayed
+          clear_and_propagate_touch delayed
         else
-          BlockedPromise.add_delayed @Delayed, future
-          clear_propagate_touch if touched?
+          BlockedPromise.add_delayed @DelayedBecause, delayed
+          clear_and_propagate_touch @DelayedBecause if touched?
         end
       end
 
@@ -1613,7 +1644,7 @@ module Concurrent
           case value
           when Future, Event
             add_delayed_of value
-            value.add_callback :callback_notify_blocked, self, nil
+            value.add_callback_notify_blocked self, nil
             countdown
           else
             resolve_with RESOLVED
@@ -1649,7 +1680,7 @@ module Concurrent
           case value
           when Future
             add_delayed_of value
-            value.add_callback :callback_notify_blocked, self, nil
+            value.add_callback_notify_blocked self, nil
             countdown
           when Event
             evaluate_to(lambda { raise TypeError, 'cannot flatten to Event' })
@@ -1682,7 +1713,7 @@ module Concurrent
         case value
         when Future
           add_delayed_of value
-          value.add_callback :callback_notify_blocked, self, nil
+          value.add_callback_notify_blocked self, nil
         else
           resolve_with internal_state
         end
@@ -1849,17 +1880,17 @@ module Concurrent
     class DelayPromise < InnerPromise
 
       def initialize(default_executor)
-        super event = Event.new(self, default_executor)
-        @Delayed = LockFreeStack.new.push self
-        # TODO (pitr-ch 20-Dec-2016): implement directly without callback?
-        event.on_resolution!(@Delayed.peek) { |stack_node| stack_node.value = nil }
+        event    = Event.new(self, default_executor)
+        @Delayed = LockFreeStack.of1(self)
+        super event
+        event.add_callback_clear_delayed_node @Delayed.peek
       end
 
       def touch
         @Future.resolve_with RESOLVED
       end
 
-      def delayed
+      def delayed_because
         @Delayed
       end
 

data/lib/concurrent/edge/throttle.rb

@@ -10,6 +10,11 @@ module Concurrent
   #         end
   #       end
   #     end
+  # @!macro [new] throttle.example.throttled_future
+  #   @example
+  #     throttle.throttled_future(1) do |arg|
+  #       arg.succ
+  #     end
   # @!macro [new] throttle.example.throttled_future_chain
   #   @example
   #     throttle.throttled_future_chain do |trigger|
@@ -40,6 +45,7 @@ module Concurrent
   # A tool manage concurrency level of future tasks.
   #
   # @!macro throttle.example.then_throttled_by
+  # @!macro throttle.example.throttled_future
   # @!macro throttle.example.throttled_future_chain
   # @!macro throttle.example.throttled_block
   class Throttle < Synchronization::Object
@@ -132,6 +138,7 @@ module Concurrent
       # Behaves as {Promises::FactoryMethods#future} but the future is throttled.
       # @return [Promises::Future]
       # @see Promises::FactoryMethods#future
+      # @!macro throttle.example.throttled_future
       def throttled_future(*args, &task)
         trigger.chain(*args, &task).on_resolution! { release }
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-12-27 00:00:00.000000000 Z
+date: 2017-02-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -18,22 +18,20 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: 1.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.4
+        version: 1.0.5
 description: |
   These 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.
   Please see http://concurrent-ruby.com for more information.
-email:
-- jerry.dantonio@gmail.com
-- concurrent-ruby@googlegroups.com
+email: concurrent-ruby@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -95,6 +93,7 @@ files:
 - lib/concurrent/edge/lock_free_queue.rb
 - lib/concurrent/edge/lock_free_stack.rb
 - lib/concurrent/edge/old_channel_integration.rb
+- lib/concurrent/edge/processing_actor.rb
 - lib/concurrent/edge/promises.rb
 - lib/concurrent/edge/throttle.rb
 homepage: http://www.concurrent-ruby.com
@@ -117,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Edge features and additions to the concurrent-ruby gem.