concurrently 1.0.1 → 1.1.0

data/lib/Ruby/concurrently/proc/evaluation/error.rb

@@ -0,0 +1,10 @@
+module Concurrently
+  class Proc::Evaluation
+    module RescueableError
+      # Ruby has additional error classes
+      [NoMemoryError, SecurityError].each do |error_class|
+        append_features error_class
+      end
+    end
+  end
+end

data/lib/all/concurrently/error.rb

@@ -4,7 +4,4 @@ module Concurrently
   #
   # The general error of this gem.
   class Error < StandardError; end
-
-  # @private
-  RESCUABLE_ERRORS = [ScriptError, StandardError, SystemStackError]
 end

data/lib/all/concurrently/evaluation.rb

@@ -3,13 +3,12 @@ module Concurrently
   # @since 1.0.0
   #
   # `Concurrently::Evaluation` represents the evaluation of the main thread
-  # outside of any concurrent procs.
+  # outside of any concurrent evaluations.
   #
   # @note Evaluations are **not thread safe**. They are operating on a fiber.
   #   Fibers cannot be resumed inside a thread they were not created in.
   #
-  # An instance will be returned by {current} if called outside of any
-  # concurrent procs.
+  # An instance will be returned by {current} if called by the root evaluation.
   class Evaluation
     # The evaluation that is currently running in the current thread.
     #
@@ -19,9 +18,9 @@ module Concurrently
     # @return [Evaluation]
     #
     # @example
-    #   concurrent_proc do
+    #   concurrently do
     #     Concurrently::Evaluation.current # => #<Concurrently::Proc::Evaluation:0x00000000e56910>
-    #   end.call_nonblock
+    #   end
     #
     #   Concurrently::Evaluation.current # => #<Concurrently::Evaluation0x00000000e5be10>
     def self.current
@@ -46,9 +45,6 @@ module Concurrently
     def waiting?
       @waiting
     end
-
-    # @private
-    DEFAULT_RESUME_OPTS = { deferred_only: true }.freeze
     
     # @note The exclamation mark in its name stands for: Watch out!
     #   This method is potentially dangerous and can break stuff. It also
@@ -65,10 +61,10 @@ module Concurrently
     # actually awaiting has not happened yet:
     #
     # ```ruby
-    # conproc = concurrent_proc do
+    # evaluation = concurrent_proc do
     #   wait 1
     #   await_resume!
-    # end
+    # end.call_nonblock
     #
     # conproc.resume! # resumes the wait call prematurely
     # ```
@@ -98,9 +94,9 @@ module Concurrently
 
       # Cancel running the fiber if it has already been scheduled to run; but
       # only if it was scheduled with a time offset. This is used to cancel the
-      # timeout of a wait operation if the waiting fiber is resume before the
+      # timeout of a wait operation if the waiting fiber is resumed before the
       # timeout is triggered.
-      run_queue.cancel(self, DEFAULT_RESUME_OPTS)
+      run_queue.cancel(self, true)
 
       run_queue.schedule_immediately(self, result)
       :resumed

data/lib/all/concurrently/event_loop.rb

@@ -72,7 +72,7 @@ module Concurrently
 
     # @private
     #
-    # Its run queue keeping track of and scheduling all concurrent procs
+    # Its run queue keeping track of and scheduling all evaluations
     attr_reader :run_queue
 
     # @private

data/lib/all/concurrently/event_loop/fiber.rb

@@ -15,7 +15,7 @@ module Concurrently
               io_selector.process_ready_in waiting_time if io_selector.awaiting?
 
               run_queue.process_pending
-            elsif io_selector.awaiting? or waiting_time
+            elsif io_selector.awaiting? or waiting_time < Float::INFINITY
               io_selector.process_ready_in waiting_time
             else
               # Having no pending timeouts or IO events would make run this loop
@@ -24,12 +24,12 @@ module Concurrently
               # is complete. Therefore, we never reach this part of the code unless
               # there is a bug or it is messed around with the internals of this gem.
               raise Error, "Infinitely running event loop detected: There " <<
-                "are no concurrent procs or fibers scheduled and no IOs to await."
+                "are no evaluations scheduled and no IOs to await."
             end
           end
         rescue Exception => e
           Concurrently::EventLoop.current.reinitialize!
-          raise Error, "Event loop teared down by #{e.inspect}"
+          raise e
         end
       end
     end

data/lib/all/concurrently/event_loop/io_selector.rb

@@ -9,7 +9,7 @@ module Concurrently
     end
 
     def awaiting?
-      @evaluations.any?
+      @evaluations.size > 0
     end
 
     def await_reader(io, evaluation)

data/lib/all/concurrently/event_loop/run_queue.rb

@@ -14,36 +14,41 @@ module Concurrently
     # The additional cart index exists so carts can be cancelled by their
     # evaluation. Cancelled carts have their evaluation set to false.
 
-    DEFAULT_CANCEL_OPTS = { deferred_only: false }.freeze
-
     class Track < Array
       def bisect_left
         bsearch_index{ |item| yield item } || length
       end
+
+      def next
+        idx = size-1
+        while idx >= 0
+          return self[idx] if self[idx][EVALUATION]
+          idx -= 1
+        end
+      end
     end
 
     def initialize(loop)
       @loop = loop
-      @cart_index = {}
       @deferred_track = Track.new
       @immediate_track = Track.new
     end
 
-    def schedule_immediately(evaluation, result = nil)
+    def schedule_immediately(evaluation, result = nil, cancellable = true)
       cart = [evaluation, false, result]
-      @cart_index[evaluation.hash] = cart
+      evaluation.instance_variable_set :@__cart__, cart if cancellable
       @immediate_track << cart
     end
 
     def schedule_deferred(evaluation, seconds, result = nil)
       cart = [evaluation, @loop.lifetime+seconds, result]
-      @cart_index[evaluation.hash] = cart
+      evaluation.instance_variable_set :@__cart__, cart
       index = @deferred_track.bisect_left{ |tcart| tcart[TIME] <= cart[TIME] }
       @deferred_track.insert(index, cart)
     end
 
-    def cancel(evaluation, opts = DEFAULT_CANCEL_OPTS)
-      if (cart = @cart_index[evaluation.hash]) and (not opts[:deferred_only] or cart[TIME])
+    def cancel(evaluation, only_if_deferred = false)
+      if (cart = evaluation.instance_variable_get :@__cart__) and (not only_if_deferred or cart[TIME])
         cart[EVALUATION] = false
       end
     end
@@ -54,26 +59,31 @@ module Concurrently
       processing = @immediate_track
       @immediate_track = []
 
-      if @deferred_track.any?
+      if @deferred_track.size > 0
         now = @loop.lifetime
         index = @deferred_track.bisect_left{ |cart| cart[TIME] <= now }
-        @deferred_track.pop(@deferred_track.length-index).reverse_each do |cart|
-          processing << cart
+
+        processable_count = @deferred_track.size-index
+        while processable_count > 0
+          processing << @deferred_track.pop
+          processable_count -= 1
         end
       end
 
       processing.each do |cart|
-        @cart_index.delete cart[EVALUATION].hash
-        resume_evaluation! cart[EVALUATION], cart[RESULT] if cart[EVALUATION]
+        evaluation = cart[EVALUATION]
+        resume_evaluation! evaluation, cart[RESULT] if evaluation
       end
     end
 
     def waiting_time
-      if @immediate_track.any?
+      if @immediate_track.size > 0
         0
-      elsif next_cart = @deferred_track.reverse_each.find{ |cart| cart[EVALUATION] }
-        waiting_time = next_cart[TIME] - @loop.lifetime
+      elsif cart = @deferred_track.next
+        waiting_time = cart[TIME] - @loop.lifetime
         waiting_time < 0 ? 0 : waiting_time
+      else
+        Float::INFINITY
       end
     end
 
@@ -87,9 +97,11 @@ module Concurrently
       when Proc::Evaluation
         @current_evaluation = evaluation
         evaluation.fiber.resume result
-      else
+      when Evaluation
         @current_evaluation = nil
         Fiber.yield result
+      else
+        raise Error, "#{evaluation.inspect} cannot be resumed"
       end
     ensure
       @current_evaluation = previous_evaluation

data/lib/all/concurrently/proc.rb

@@ -21,17 +21,17 @@ module Concurrently
   #
   # A `Concurrently::Proc` is like a regular Proc except its block of code is
   # evaluated concurrently. Its evaluation can wait for other stuff to happen
-  # (e.g. result of another concurrent proc or readiness of an IO) without
-  # blocking the execution of its thread.
+  # (e.g. result of evaluations or readiness of an IO) without blocking the
+  # execution of its thread.
   #
-  # Errors raised inside concurrent procs are re-raised when getting their
-  # result with {Evaluation#await_result}. They can also be watched by
+  # Errors raised inside concurrent evaluations are re-raised when getting
+  # their result with {Evaluation#await_result}. They can also be watched by
   # registering callbacks for the `:error` event as shown in the example below.
-  # This is useful as a central hook to all errors inside concurrent procs for
-  # monitoring or logging purposes. Also, concurrent procs evaluated with
-  # {Kernel#concurrently} resp. {Proc#call_and_forget} are run in the
-  # background and will fail silently. The callbacks are the only way to be
-  # notified about errors inside them.
+  # This is useful as a central hook to all errors inside concurrent
+  # evaluations for monitoring or logging purposes. Also, concurrent procs
+  # evaluated with {Proc#call_and_forget} are evaluated in the background with
+  # no access to their evaluation and will fail silently. The callbacks are the
+  # only way to be notified about errors inside them.
   #
   # The callbacks can be registered for all procs or only for one specific
   # proc:
@@ -187,6 +187,9 @@ module Concurrently
     # thread of execution and schedules its start during the next iteration of
     # the event loop.
     #
+    # To execute code this way you can also use the shortcut
+    # {Kernel#concurrently}.
+    #
     # @return [Evaluation]
     #
     # @example
@@ -208,9 +211,6 @@ module Concurrently
     # because we save creating an {Evaluation} instance this is slightly faster
     # than {#call_detached}.
     #
-    # To execute code this way you can also use the shortcut
-    # {Kernel#concurrently}.
-    #
     # @return [nil]
     #
     # @example
@@ -225,7 +225,7 @@ module Concurrently
       event_loop = EventLoop.current
       # run without creating an Evaluation object at first. It will be created
       # if the proc needs to wait for something.
-      event_loop.run_queue.schedule_immediately event_loop.proc_fiber_pool.take_fiber, [self, args]
+      event_loop.run_queue.schedule_immediately event_loop.proc_fiber_pool.take_fiber, [self, args], false
 
       nil
     end

data/lib/all/concurrently/proc/evaluation.rb

@@ -8,8 +8,8 @@ module Concurrently
   # @note Evaluations are **not thread safe**. They are operating on a fiber.
   #   Fibers cannot be resumed inside a thread they were not created in.
   #
-  # An instance will be returned by {Evaluation.current} if called from inside
-  # a concurrent proc. It will also be returned by every call of
+  # An instance will be returned by {Evaluation.current} if called by code
+  # inside a concurrent proc. It will also be returned by every call of
   # {Concurrently::Proc#call_detached} and also by
   # {Concurrently::Proc#call_nonblock} if the evaluation cannot be concluded in
   # one go and needs to wait.
@@ -29,7 +29,7 @@ module Concurrently
     # @return [value]
     #
     # @example
-    #   evaluation = concurrent_proc{ :result }.call_detached
+    #   evaluation = concurrently{ :result }
     #   evaluation[:key] = :value
     #   evaluation[:key]  # => :value
     def []=(key, value)
@@ -42,7 +42,7 @@ module Concurrently
     # @return [Object] the stored value
     #
     # @example
-    #   evaluation = concurrent_proc{ :result }.call_detached
+    #   evaluation = concurrently{ :result }
     #   evaluation[:key] = :value
     #   evaluation[:key]  # => :value
     def [](key)
@@ -55,7 +55,7 @@ module Concurrently
     # @return [Boolean]
     #
     # @example
-    #   evaluation = concurrent_proc{ :result }.call_detached
+    #   evaluation = concurrently{ :result }
     #   evaluation[:key] = :value
     #   evaluation.key? :key          # => true
     #   evaluation.key? :another_key  # => false
@@ -68,7 +68,7 @@ module Concurrently
     # @return [Array]
     #
     # @example
-    #   evaluation = concurrent_proc{ :result }.call_detached
+    #   evaluation = concurrently{ :result }
     #   evaluation[:key1] = :value1
     #   evaluation[:key2] = :value2
     #   evaluation.keys  # => [:key1, :key2]
@@ -91,14 +91,14 @@ module Concurrently
     # @raise [Concurrently::Evaluation::TimeoutError] if a given maximum waiting time
     #   is exceeded and no custom timeout result is given.
     #
-    # @example Waiting inside another concurrent proc
+    # @example Waiting inside another concurrent evaluation
     #   # Control flow is indicated by (N)
     #
     #   # (1)
-    #   evaluation = concurrent_proc do
+    #   evaluation = concurrently do
     #     # (4)
     #     :result
-    #   end.call_detached
+    #   end
     #
     #   # (2)
     #   concurrent_proc do
@@ -108,41 +108,41 @@ module Concurrently
     #   end.call # => :result
     #   # (6)
     #
-    # @example Waiting outside a concurrent proc
+    # @example Waiting outside a concurrent evaluation
     #   # Control flow is indicated by (N)
     #
     #   # (1)
-    #   evaluation = concurrent_proc do
-    #      # (3)
+    #   evaluation = concurrently do
+    #     # (3)
     #     :result
-    #   end.call_detached
+    #   end
     #
     #   # (2)
     #   evaluation.await_result # => :result
     #   # (4)
     #
     # @example Waiting with a timeout
-    #   evaluation = concurrent_proc do
+    #   evaluation = concurrently do
     #     wait 1
     #     :result
-    #   end.call_detached
+    #   end
     #
     #   evaluation.await_result within: 0.1
-    #   # => raises a TimeoutError after 0.1 second
+    #   # => raises a TimeoutError after 0.1 seconds
     #
     # @example Waiting with a timeout and a timeout result
-    #   evaluation = concurrent_proc do
+    #   evaluation = concurrently do
     #     wait 1
     #     :result
-    #   end.call_detached
+    #   end
     #
     #   evaluation.await_result within: 0.1, timeout_result: false
-    #   # => returns false after 0.1 second
+    #   # => returns false after 0.1 seconds
     #
     # @example When the evaluation raises or returns an error
-    #   evaluation = concurrent_proc do
+    #   evaluation = concurrently do
     #     RuntimeError.new("self destruct!") # equivalent: raise "self destruct!"
-    #   end.call_detached
+    #   end
     #
     #   evaluation.await_result # => raises "self destruct!"
     #
@@ -156,17 +156,17 @@ module Concurrently
     #   @yieldreturn [Object] a (potentially) transformed result
     #
     #   @example Transforming a result
-    #     evaluation = concurrent_proc do
+    #     evaluation = concurrently do
     #       :result
-    #     end.call_detached
+    #     end
     #
     #     evaluation.await_result{ |result| "transformed_#{result}" }
     #     # => "transformed_result"
     #
     #   @example Validating a result
-    #     evaluation = concurrent_proc do
+    #     evaluation = concurrently do
     #       :invalid_result
-    #     end.call_detached
+    #     end
     #
     #     evaluation.await_result{ |result| raise "invalid result" if result != :result }
     #     # => raises "invalid result"
@@ -176,7 +176,7 @@ module Concurrently
       else
         result = begin
           evaluation = Concurrently::Evaluation.current
-          @awaiting_result.store evaluation, true
+          @awaiting_result.store evaluation, false
           await_resume! opts
         rescue Exception => error
           error
@@ -210,12 +210,12 @@ module Concurrently
     #   # Control flow is indicated by (N)
     #
     #   # (1)
-    #   evaluation = concurrent_proc do
+    #   evaluation = concurrently do
     #     # (4)
     #     wait 1
     #     # never reached
     #     :result
-    #   end.call_nonblock
+    #   end
     #
     #   # (2)
     #   concurrently do
@@ -239,7 +239,7 @@ module Concurrently
         @fiber.resume @fiber
       end
 
-      @awaiting_result.each_key{ |evaluation| evaluation.resume! result }
+      @awaiting_result.each{ |evaluation, override| evaluation.resume! (override or result) }
       :concluded
     end
   end