concurrent-ruby-edge 0.3.1 → 0.7.0

data/lib/concurrent/edge/cancellation.rb

@@ -1,138 +0,0 @@
-module Concurrent
-
-  # Provides tools for cooperative cancellation.
-  # 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.
-  #     token.loop_until_canceled { 1+1 }
-  #   end
-  #   sleep 0.1
-  #   cancellation.cancel # Stop the thread by cancelling
-  class Cancellation < Synchronization::Object
-    safe_initialization!
-
-    # Creates the cancellation object. Returns both the cancellation and the token for convenience.
-    # @param [Object] resolve_args resolve_args Arguments which are used when resolve method is called on
-    #   resolvable_future_or_event
-    # @param [Promises::Resolvable] resolvable_future_or_event resolvable used to track cancellation.
-    #   Can be retrieved by `token.to_future` ot `token.to_event`.
-    # @example
-    #   cancellation, token = Concurrent::Cancellation.create
-    # @return [Array(Cancellation, Cancellation::Token)]
-    def self.create(resolvable_future_or_event = Promises.resolvable_event, *resolve_args)
-      cancellation = new(resolvable_future_or_event, *resolve_args)
-      [cancellation, cancellation.token]
-    end
-
-    private_class_method :new
-
-    # Returns the token associated with the cancellation.
-    # @return [Token]
-    def token
-      @Token
-    end
-
-    # Cancel this cancellation. All executions depending on the token will cooperatively stop.
-    # @return [true, false]
-    # @raise when cancelling for the second tim
-    def cancel(raise_on_repeated_call = true)
-      !!@Cancel.resolve(*@ResolveArgs, raise_on_repeated_call)
-    end
-
-    # Is the cancellation cancelled?
-    # @return [true, false]
-    def canceled?
-      @Cancel.resolved?
-    end
-
-    # Short string representation.
-    # @return [String]
-    def to_s
-      format '<#%s:0x%x canceled:%s>', self.class, object_id << 1, canceled?
-    end
-
-    alias_method :inspect, :to_s
-
-    private
-
-    def initialize(future, *resolve_args)
-      raise ArgumentError, 'future is not Resolvable' unless future.is_a?(Promises::Resolvable)
-      @Cancel      = future
-      @Token       = Token.new @Cancel.with_hidden_resolvable
-      @ResolveArgs = resolve_args
-    end
-
-    # Created through {Cancellation.create}, passed down to tasks to be able to check if canceled.
-    class Token < Synchronization::Object
-      safe_initialization!
-
-      # @return [Event] Event which will be resolved when the token is cancelled.
-      def to_event
-        @Cancel.to_event
-      end
-
-      # @return [Future] Future which will be resolved when the token is cancelled with arguments passed in
-      #   {Cancellation.create} .
-      def to_future
-        @Cancel.to_future
-      end
-
-      # Is the token cancelled?
-      # @return [true, false]
-      def canceled?
-        @Cancel.resolved?
-      end
-
-      # Repeatedly evaluates block until the token is {#canceled?}.
-      # @yield to the block repeatedly.
-      # @yieldreturn [Object]
-      # @return [Object] last result of the block
-      def loop_until_canceled(&block)
-        until canceled?
-          result = block.call
-        end
-        result
-      end
-
-      # Raise error when cancelled
-      # @param [#exception] error to be risen
-      # @raise the error
-      # @return [self]
-      def raise_if_canceled(error = CancelledOperationError)
-        raise error if canceled?
-        self
-      end
-
-      # Creates a new token which is cancelled when any of the tokens is.
-      # @param [Token] tokens to combine
-      # @return [Token] new token
-      def join(*tokens, &block)
-        block ||= -> tokens { Promises.any_event(*tokens.map(&:to_event)) }
-        self.class.new block.call([@Cancel, *tokens])
-      end
-
-      # Short string representation.
-      # @return [String]
-      def to_s
-        format '<#%s:0x%x canceled:%s>', self.class, object_id << 1, canceled?
-      end
-
-      alias_method :inspect, :to_s
-
-      private
-
-      def initialize(cancel)
-        @Cancel = cancel
-      end
-    end
-
-    # FIXME (pitr-ch 27-Mar-2016): cooperation with mutex, condition, select etc?
-    # TODO (pitr-ch 27-Mar-2016): examples (scheduled to be cancelled in 10 sec)
-  end
-end

data/lib/concurrent/edge/lock_free_stack.rb

@@ -1,126 +0,0 @@
-module Concurrent
-
-  # @!visibility private
-  class LockFreeStack < Synchronization::Object
-
-    safe_initialization!
-
-    class Node
-      # TODO (pitr-ch 20-Dec-2016): Could be unified with Stack class?
-
-      attr_reader :value, :next_node
-      # allow to nil-ify to free GC when the entry is no longer relevant, not synchronised
-      attr_writer :value
-
-      def initialize(value, next_node)
-        @value     = value
-        @next_node = next_node
-      end
-
-      singleton_class.send :alias_method, :[], :new
-    end
-
-    class Empty < Node
-      def next_node
-        self
-      end
-    end
-
-    EMPTY = Empty[nil, nil]
-
-    private(*attr_atomic(:head))
-
-    def self.of1(value)
-      new Node[value, EMPTY]
-    end
-
-    def self.of2(value1, value2)
-      new Node[value1, Node[value2, EMPTY]]
-    end
-
-    def initialize(head = EMPTY)
-      super()
-      self.head = head
-    end
-
-    def empty?(head = self.head)
-      head.equal? EMPTY
-    end
-
-    def compare_and_push(head, value)
-      compare_and_set_head head, Node[value, head]
-    end
-
-    def push(value)
-      while true
-        current_head = head
-        return self if compare_and_set_head current_head, Node[value, current_head]
-      end
-    end
-
-    def peek
-      head
-    end
-
-    def compare_and_pop(head)
-      compare_and_set_head head, head.next_node
-    end
-
-    def pop
-      while true
-        current_head = head
-        return current_head.value if compare_and_set_head current_head, current_head.next_node
-      end
-    end
-
-    def compare_and_clear(head)
-      compare_and_set_head head, EMPTY
-    end
-
-    include Enumerable
-
-    def each(head = nil)
-      return to_enum(:each, head) unless block_given?
-      it = head || peek
-      until it.equal?(EMPTY)
-        yield it.value
-        it = it.next_node
-      end
-      self
-    end
-
-    def clear
-      while true
-        current_head = head
-        return false if current_head == EMPTY
-        return true if compare_and_set_head current_head, EMPTY
-      end
-    end
-
-    def clear_if(head)
-      compare_and_set_head head, EMPTY
-    end
-
-    def replace_if(head, new_head)
-      compare_and_set_head head, new_head
-    end
-
-    def clear_each(&block)
-      while true
-        current_head = head
-        return self if current_head == EMPTY
-        if compare_and_set_head current_head, EMPTY
-          each current_head, &block
-          return self
-        end
-      end
-    end
-
-    # @return [String] Short string representation.
-    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

@@ -1,161 +0,0 @@
-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