concurrent-ruby-edge 0.2.0.pre2 → 0.2.0.pre3

data/lib/concurrent/channel/selector.rb

@@ -0,0 +1,70 @@
+require 'concurrent/maybe'
+
+require 'concurrent/channel/selector/after_clause'
+require 'concurrent/channel/selector/default_clause'
+require 'concurrent/channel/selector/put_clause'
+require 'concurrent/channel/selector/take_clause'
+
+module Concurrent
+  class Channel
+
+    # @!visibility private
+    class Selector
+
+      def initialize
+        @clauses = []
+        @error_handler = nil
+      end
+
+      def case(channel, action, message = nil, &block)
+        if [:take, :poll, :receive, :~].include?(action)
+          take(channel, &block)
+        elsif [:put, :offer, :send, :<<].include?(action)
+          put(channel, message, &block)
+        else
+          raise ArgumentError.new('invalid action')
+        end
+      end
+
+      def take(channel, &block)
+        raise ArgumentError.new('no block given') unless block_given?
+        @clauses << TakeClause.new(channel, block)
+      end
+      alias_method :receive, :take
+
+      def put(channel, message, &block)
+        @clauses << PutClause.new(channel, message, block)
+      end
+      alias_method :send, :put
+
+      def after(seconds, &block)
+        @clauses << AfterClause.new(seconds, block)
+      end
+      alias_method :timeout, :after
+
+      def default(&block)
+        raise ArgumentError.new('no block given') unless block_given?
+        @clauses << DefaultClause.new(block)
+      end
+
+      def error(&block)
+        raise ArgumentError.new('no block given') unless block_given?
+        raise ArgumentError.new('only one error handler allowed') if @error_handler
+        @error_handler = block
+      end
+
+      def execute
+        loop do
+          done = @clauses.each do |clause|
+            result = clause.execute
+            break result if result.just?
+          end
+          break done.value if done.is_a?(Concurrent::Maybe)
+          Thread.pass
+        end
+      rescue => ex
+        @error_handler.call(ex) if @error_handler
+      end
+    end
+  end
+end

data/lib/concurrent/channel/selector/after_clause.rb

@@ -0,0 +1,27 @@
+require 'concurrent/maybe'
+require 'concurrent/utility/monotonic_time'
+
+module Concurrent
+  class Channel
+    class Selector
+
+      class AfterClause
+
+        def initialize(seconds, block)
+          raise ArgumentError.new('timeout must 0.0 or more') if seconds.to_f < 0.0
+          @end = Concurrent.monotonic_time + seconds.to_f
+          @block = block
+        end
+
+        def execute
+          if Concurrent.monotonic_time > @end
+            result = @block ? @block.call : nil
+            Concurrent::Maybe.just(result)
+          else
+            Concurrent::Maybe.nothing
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/selector/default_clause.rb

@@ -0,0 +1,19 @@
+require 'concurrent/maybe'
+
+module Concurrent
+  class Channel
+    class Selector
+
+      class DefaultClause
+
+        def initialize(block)
+          @block = block
+        end
+
+        def execute
+          Concurrent::Maybe.just(@block.call)
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/selector/error_clause.rb

@@ -0,0 +1,21 @@
+module Concurrent
+  class Channel
+    class Selector
+
+      class ErrorClause
+
+        def initialize(block)
+          @block = block
+        end
+
+        def execute(error)
+          @block.call(error)
+        rescue
+          # suppress and move on
+        ensure
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/selector/put_clause.rb

@@ -0,0 +1,26 @@
+require 'concurrent/maybe'
+
+module Concurrent
+  class Channel
+    class Selector
+
+      class PutClause
+
+        def initialize(channel, message, block)
+          @channel = channel
+          @message = message
+          @block = block
+        end
+
+        def execute
+          if @channel.offer?(@message).just?
+            result = @block ? @block.call : nil
+            Concurrent::Maybe.just(result)
+          else
+            Concurrent::Maybe.nothing
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/selector/take_clause.rb

@@ -0,0 +1,24 @@
+require 'concurrent/maybe'
+
+module Concurrent
+  class Channel
+    class Selector
+
+      class TakeClause
+
+        def initialize(channel, block)
+          @channel = channel
+          @block = block
+        end
+
+        def execute
+          if (result = @channel.poll?).just?
+            Concurrent::Maybe.just(@block.call(result.value))
+          else
+            Concurrent::Maybe.nothing
+          end
+        end
+      end
+    end
+  end
+end

data/lib/concurrent/channel/tick.rb

@@ -0,0 +1,55 @@
+require 'concurrent/utility/monotonic_time'
+
+module Concurrent
+  class Channel
+
+    # A convenience class representing a single moment in monotonic time.
+    # Returned by {Concurrent::Channel} tickers and timers when they
+    # resolve.
+    #
+    # Includes `Comparable` and can be compared to monotonic_time, UTC
+    # time, or epoch time.
+    #
+    # @see Concurrent.monotonic_time
+    # @see Concurrent::Channel.ticker
+    # @see Concurrent::Channel.timer
+    class Tick
+      include Comparable
+
+      STRING_FORMAT = '%F %T.%6N %z %Z'.freeze
+
+      attr_reader :monotonic, :utc
+
+      def initialize(tick = Concurrent.monotonic_time)
+        @monotonic = tick
+        @utc = monotonic_to_utc(tick).freeze
+      end
+
+      def epoch
+        @utc.to_f
+      end
+
+      def to_s
+        @utc.strftime(STRING_FORMAT)
+      end
+
+      def <=>(other)
+        if other.is_a? Numeric
+          @monotonic <=> other
+        elsif other.is_a? Time
+          @utc <=> other.utc
+        elsif other.is_a? Tick
+          @monotonic <=> other.monotonic
+        else
+          nil
+        end
+      end
+
+      private
+
+      def monotonic_to_utc(tick)
+        Time.now.utc + Concurrent.monotonic_time - tick
+      end
+    end
+  end
+end

data/lib/concurrent/edge/future.rb

@@ -94,9 +94,13 @@ module Concurrent
       # only proof of concept
       # @return [Future]
       def select(*channels)
-        probe = future
-        channels.each { |ch| ch.select probe }
-        probe
+        future do
+          Channel.select do |s|
+            channels.each do |ch|
+              s.take(ch) { |value| [value, ch] }
+            end
+          end
+        end
       end
 
       # post job on :fast executor
@@ -693,8 +697,8 @@ module Concurrent
 
       # @note may block
       # @note only proof of concept
-      def then_push(channel)
-        on_success(:io) { |value| channel.push value }
+      def then_put(channel)
+        on_success(:io) { |value| channel.put value }
       end
 
       # @yield [value] executed async on `executor` when success
@@ -1137,17 +1141,24 @@ module Concurrent
 
       def process_on_done(future)
         countdown = super(future)
-        value     = future.value!
         if countdown.nonzero?
+          internal_state = future.internal_state
+
+          unless internal_state.success?
+            complete_with internal_state
+            return countdown
+          end
+
+          value = internal_state.value
           case value
           when Future
             @BlockedBy.push value
             value.add_callback :pr_callback_notify_blocked, self
             @Countdown.value
           when Event
-            raise TypeError, 'cannot flatten to Event'
+            evaluate_to(lambda { raise TypeError, 'cannot flatten to Event' })
           else
-            raise TypeError, "returned value #{value.inspect} is not a Future"
+            evaluate_to(lambda { raise TypeError, "returned value #{value.inspect} is not a Future" })
           end
         end
         countdown
@@ -1170,6 +1181,10 @@ module Concurrent
         @BlockedBy.clear
         nil
       end
+
+      def completable?(countdown)
+        !@Future.internal_state.completed? && super(countdown)
+      end
     end
 
     # @!visibility private
@@ -1375,39 +1390,6 @@ module Concurrent
         end
       end
     end
-
-    # @note proof of concept
-    class Channel < Synchronization::Object
-      safe_initialization!
-
-      # TODO make lock free
-      def initialize
-        super()
-        @ProbeSet = Concurrent::Channel::WaitableList.new
-      end
-
-      def probe_set_size
-        @ProbeSet.size
-      end
-
-      def push(value)
-        until @ProbeSet.take.try_success([value, self])
-        end
-      end
-
-      def pop
-        select(Concurrent.future)
-      end
-
-      def select(probe)
-        @ProbeSet.put(probe)
-        probe
-      end
-
-      def inspect
-        to_s
-      end
-    end
   end
 
   extend Edge::FutureShortcuts

data/lib/concurrent/edge/lock_free_linked_set.rb

@@ -111,7 +111,8 @@ module Concurrent
           succ = curr.next_node
           removed = curr.successor_reference.compare_and_set succ, succ, false, true
 
-          next_node unless removed
+          #next_node unless removed
+          continue unless removed
 
           pred.successor_reference.compare_and_set curr, succ, false, false
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre2
+  version: 0.2.0.pre3
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-19 00:00:00.000000000 Z
+date: 2015-09-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre2
+        version: 1.0.0.pre3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre2
+        version: 1.0.0.pre3
 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
@@ -72,12 +72,21 @@ files:
 - lib/concurrent/actor/utils/broadcast.rb
 - lib/concurrent/actor/utils/pool.rb
 - lib/concurrent/channel.rb
-- lib/concurrent/channel/blocking_ring_buffer.rb
-- lib/concurrent/channel/buffered_channel.rb
-- lib/concurrent/channel/channel.rb
-- lib/concurrent/channel/ring_buffer.rb
-- lib/concurrent/channel/unbuffered_channel.rb
-- lib/concurrent/channel/waitable_list.rb
+- lib/concurrent/channel/buffer.rb
+- lib/concurrent/channel/buffer/base.rb
+- lib/concurrent/channel/buffer/buffered.rb
+- lib/concurrent/channel/buffer/dropping.rb
+- lib/concurrent/channel/buffer/sliding.rb
+- lib/concurrent/channel/buffer/ticker.rb
+- lib/concurrent/channel/buffer/timer.rb
+- lib/concurrent/channel/buffer/unbuffered.rb
+- lib/concurrent/channel/selector.rb
+- lib/concurrent/channel/selector/after_clause.rb
+- lib/concurrent/channel/selector/default_clause.rb
+- lib/concurrent/channel/selector/error_clause.rb
+- lib/concurrent/channel/selector/put_clause.rb
+- lib/concurrent/channel/selector/take_clause.rb
+- lib/concurrent/channel/tick.rb
 - lib/concurrent/edge/atomic_markable_reference.rb
 - lib/concurrent/edge/future.rb
 - lib/concurrent/edge/lock_free_linked_set.rb
@@ -104,7 +113,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Edge features and additions to the concurrent-ruby gem.

data/lib/concurrent/channel/blocking_ring_buffer.rb

@@ -1,82 +0,0 @@
-require 'concurrent/synchronization'
-
-module Concurrent
-  module Channel
-
-    # @api Channel
-    # @!macro edge_warning
-    class BlockingRingBuffer < Synchronization::LockableObject
-
-      def initialize(capacity)
-        super()
-        synchronize { ns_initialize capacity}
-      end
-
-      # @return [Integer] the capacity of the buffer
-      def capacity
-        synchronize { @buffer.capacity }
-      end
-
-      # @return [Integer] the number of elements currently in the buffer
-      def count
-        synchronize { @buffer.count }
-      end
-
-      # @return [Boolean] true if buffer is empty, false otherwise
-      def empty?
-        synchronize { @buffer.empty? }
-      end
-
-      # @return [Boolean] true if buffer is full, false otherwise
-      def full?
-        synchronize { @buffer.full? }
-      end
-
-      # @param [Object] value the value to be inserted
-      # @return [Boolean] true if value has been inserted, false otherwise
-      def put(value)
-        synchronize do
-          wait_while_full
-          @buffer.offer(value)
-          ns_signal
-          true
-        end
-      end
-
-      # @return [Object] the first available value and removes it from the buffer.
-      #   If buffer is empty it blocks until an element is available
-      def take
-        synchronize do
-          wait_while_empty
-          result = @buffer.poll
-          ns_signal
-          result
-        end
-      end
-
-      # @return [Object] the first available value and without removing it from
-      #   the buffer. If buffer is empty returns nil
-      def peek
-        synchronize { @buffer.peek }
-      end
-
-      protected
-
-      def ns_initialize(capacity)
-        @buffer = RingBuffer.new(capacity)
-        @first = @last = 0
-        @count = 0
-      end
-
-      private
-
-      def wait_while_full
-        ns_wait_until { !@buffer.full? }
-      end
-
-      def wait_while_empty
-        ns_wait_until { !@buffer.empty? }
-      end
-    end
-  end
-end