concurrently 1.1.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e10c69de9f9db4d13d7411544b336709be235688
-  data.tar.gz: a519b852d6ac6d07689daf39bd893fe1594c76eb
+  metadata.gz: a76cfe92534837645dfc5c4104d0e0954262c726
+  data.tar.gz: 5a6535677b4b12510c3f32305266b10b81436321
 SHA512:
-  metadata.gz: e81443aec073e777bb7bdb18a293383716d66028a884d773208205aae52a15f2af993ed8f427f78e4515d83b379b07ee287c3d5f1ac2f10c478267258aff2872
-  data.tar.gz: 87102e7ee79831c03975175f52527b78da04100d6ddaaca56e479b208f59d03a362ea5ddbf3df16f08d37bf41d5157978c222f1b3c1afbb3e920f3e3b6d7b3e2
+  metadata.gz: bc43d2ae55910b31451d855607caf2a64654a684e32c382060ebbe48f7a2cfd596f11158f1e8d7c92c15ce6b388e0b550cb9f3bee2eb2aafe2afb97dc5846ede
+  data.tar.gz: 0be9f1e7ac0fa65fde27f4e33999c9eab1000b9d5290e7c8c990042101ce2c754db9328a8f5d52a4115a4cb0c04ea75a3bc2c5ec84d4e6f0bb195f17daa3ba47

data/.rspec

@@ -1,4 +1,4 @@
 --format documentation
 --color
 --require spec_helper.rb
---default-path test/Ruby
+--default-path test/CRuby

data/RELEASE_NOTES.md

@@ -1,5 +1,13 @@
 # Release Notes
 
+## 1.2.0 (2017-12-12)
+
+### Added [Concurrently::Debug](http://www.rubydoc.info/github/christopheraue/m-ruby-concurrently/Concurrently/Debug) interface 
+* [.enable](http://www.rubydoc.info/github/christopheraue/m-ruby-concurrently/Concurrently/Debug#enable-class_method)
+
+### Extended [Concurrently::Proc](http://www.rubydoc.info/github/christopheraue/m-ruby-concurrently/Concurrently/Proc) interface
+* [.error_log_output=](http://www.rubydoc.info/github/christopheraue/m-ruby-concurrently/Concurrently/Proc#error_log_output=-class_method)
+
 ## 1.1.0 (2017-07-10)
 
 ### Improvements

data/Rakefile

@@ -5,8 +5,8 @@ perf_dir = File.expand_path "perf"
 # Ruby
 ruby = {
   test: "rspec" ,
-  benchmark: "ruby -Iperf/Ruby -rstage",
-  profile: "ruby -Iperf/Ruby -rstage" }
+  benchmark: "ruby -Iperf/CRuby -rstage",
+  profile: "ruby -Iperf/CRuby -rstage" }
 
 mruby_dir = File.expand_path "mruby_builds"
 mruby = {
@@ -73,7 +73,7 @@ end
 
 namespace :mruby do
   file mruby[:src] do
-    sh "git clone --depth=1 git://github.com/mruby/mruby.git #{mruby[:src]}"
+    sh "git clone git://github.com/mruby/mruby.git #{mruby[:src]}"
   end
 
   desc "Checkout a tag or commit of the mruby source. Executes: git checkout reference"

data/concurrently.gemspec

@@ -27,11 +27,11 @@ DESC
   spec.authors       = ["Christopher Aue"]
   spec.email         = ["rubygems@christopheraue.net"]
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
-  spec.require_paths = ["lib/Ruby"]
+  spec.require_paths = ["lib/CRuby"]
 
   spec.required_ruby_version = ">= 2.2.7"
 
   spec.add_dependency "nio4r", "~> 2.1"
   spec.add_dependency "hitimes", "~> 1.2"
-  spec.add_dependency "callbacks_attachable", "~> 2.2"
+  spec.add_dependency "callbacks_attachable", "~> 3.0"
 end

data/ext/{Ruby → CRuby}/thread.rb

@@ -1,11 +1,6 @@
 # @api ruby_patches
 # @since 1.0.0
 class Thread
-  # Attach an event loop to every thread in Ruby.
-  def __concurrently_event_loop__
-    @__concurrently_event_loop__ ||= Concurrently::EventLoop.new
-  end
-
   # Disable fiber-local variables and treat variables using the fiber-local
   # interface as thread-local. Most of the code out there is not using
   # fibers explicitly and really intends to attach values to the current

data/guides/Performance.md

@@ -57,19 +57,19 @@ than that.
         
     Results for ruby 2.4.1
     ----------------------
-      proc.call:                11048400 executions in 1.0000 seconds
-      conproc.call:               734000 executions in 1.0000 seconds
-      conproc.call_nonblock:      857800 executions in 1.0001 seconds
-      conproc.call_detached:      464800 executions in 1.0002 seconds
-      conproc.call_and_forget:    721800 executions in 1.0001 seconds
+      proc.call:                11521800 executions in 1.0000 seconds
+      conproc.call:               756000 executions in 1.0001 seconds
+      conproc.call_nonblock:      881800 executions in 1.0001 seconds
+      conproc.call_detached:      443500 executions in 1.0001 seconds
+      conproc.call_and_forget:    755600 executions in 1.0001 seconds
     
     Results for mruby 1.3.0
     -----------------------
-      proc.call:                 4771700 executions in 1.0000 seconds
-      conproc.call:               362000 executions in 1.0002 seconds
-      conproc.call_nonblock:      427400 executions in 1.0000 seconds
-      conproc.call_detached:      188900 executions in 1.0005 seconds
-      conproc.call_and_forget:    383400 executions in 1.0002 seconds
+      proc.call:                 5801400 executions in 1.0000 seconds
+      conproc.call:               449100 executions in 1.0002 seconds
+      conproc.call_nonblock:      523400 executions in 1.0000 seconds
+      conproc.call_detached:      272500 executions in 1.0000 seconds
+      conproc.call_and_forget:    490500 executions in 1.0001 seconds
 
 *conproc.call_detached* and *conproc.call_and_forget* call `wait 0` after each
 batch so the scheduled evaluations have [a chance to run]
@@ -150,15 +150,15 @@ to expect in these cases.
         
     Results for ruby 2.4.1
     ----------------------
-      wait:                       291100 executions in 1.0001 seconds
-      await_readable:             147800 executions in 1.0005 seconds
-      await_writable:             148300 executions in 1.0003 seconds
+      wait:                       331300 executions in 1.0001 seconds
+      await_readable:             152500 executions in 1.0001 seconds
+      await_writable:             150700 executions in 1.0001 seconds
     
     Results for mruby 1.3.0
     -----------------------
-      wait:                       104300 executions in 1.0002 seconds
-      await_readable:             132600 executions in 1.0006 seconds
-      await_writable:             130500 executions in 1.0005 seconds
+      wait:                       160700 executions in 1.0004 seconds
+      await_readable:             176700 executions in 1.0005 seconds
+      await_writable:             177700 executions in 1.0003 seconds
 
 Explanation of the results:
 
@@ -257,25 +257,25 @@ performance in these scenarios.
         
     Results for ruby 2.4.1
     ----------------------
-      call:                       687600 executions in 1.0001 seconds
-      call_nonblock:              855600 executions in 1.0001 seconds
-      call_detached:              426400 executions in 1.0000 seconds
-      call_and_forget:            722200 executions in 1.0000 seconds
-      waiting call:                90300 executions in 1.0005 seconds
-      waiting call_nonblock:      191800 executions in 1.0001 seconds
-      waiting call_detached:      190300 executions in 1.0003 seconds
-      waiting call_and_forget:    207100 executions in 1.0001 seconds
+      call:                       753800 executions in 1.0000 seconds
+      call_nonblock:              913400 executions in 1.0000 seconds
+      call_detached:              418700 executions in 1.0001 seconds
+      call_and_forget:            748800 executions in 1.0001 seconds
+      waiting call:                89400 executions in 1.0001 seconds
+      waiting call_nonblock:      198800 executions in 1.0001 seconds
+      waiting call_detached:      199600 executions in 1.0004 seconds
+      waiting call_and_forget:    225300 executions in 1.0001 seconds
     
     Results for mruby 1.3.0
     -----------------------
-      call:                       319900 executions in 1.0003 seconds
-      call_nonblock:              431700 executions in 1.0002 seconds
-      call_detached:              158400 executions in 1.0006 seconds
-      call_and_forget:            397700 executions in 1.0002 seconds
-      waiting call:                49900 executions in 1.0015 seconds
-      waiting call_nonblock:       74600 executions in 1.0001 seconds
-      waiting call_detached:       73300 executions in 1.0006 seconds
-      waiting call_and_forget:     85200 executions in 1.0008 seconds
+      call:                       444200 executions in 1.0002 seconds
+      call_nonblock:              525300 executions in 1.0001 seconds
+      call_detached:              232600 executions in 1.0003 seconds
+      call_and_forget:            464500 executions in 1.0000 seconds
+      waiting call:                60100 executions in 1.0004 seconds
+      waiting call_nonblock:       95400 executions in 1.0004 seconds
+      waiting call_detached:      102100 executions in 1.0005 seconds
+      waiting call_and_forget:    118500 executions in 1.0005 seconds
 
 `wait 0` is used as a stand in for all wait methods. Measurements of concurrent
 procs doing nothing are included for comparision.

data/lib/{Ruby → CRuby}/concurrently.rb

@@ -6,7 +6,7 @@ require "callbacks_attachable"
 root = File.dirname File.dirname File.dirname __FILE__
 files =
   Dir[File.join(root, 'ext', 'all', '**', '*.rb')].sort +
-  Dir[File.join(root, 'ext', 'Ruby', '**', '*.rb')].sort +
+  Dir[File.join(root, 'ext', 'CRuby', '**', '*.rb')].sort +
   Dir[File.join(root, 'lib', 'all', '**', '*.rb')].sort +
-  Dir[File.join(root, 'lib', 'Ruby', '**', '*.rb')].sort
+  Dir[File.join(root, 'lib', 'CRuby', '**', '*.rb')].sort
 files.each{ |f| require f }

data/lib/{Ruby → CRuby}/concurrently/proc/evaluation/error.rb

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

data/lib/CRuby/thread.rb

@@ -0,0 +1,8 @@
+# @private
+# @since 1.0.0
+class Thread
+  # Attach an event loop to every thread in Ruby.
+  def __concurrently_event_loop__
+    @__concurrently_event_loop__ ||= Concurrently::EventLoop.new
+  end
+end

data/lib/all/concurrently.rb

@@ -0,0 +1,7 @@
+# @api public
+# @since 1.0.0
+#
+# The namespace this library lives in
+module Concurrently
+
+end

data/lib/all/concurrently/debug.rb

@@ -0,0 +1,151 @@
+module Concurrently
+  # @api public
+  # @since 1.2.0
+  #
+  # With `Concurrently::Debug` the locations where concurrent procs are
+  # entered, suspended, resumed and exited at can be logged. The log shows
+  # the subsequent order in which concurrent procs are executed.
+  #
+  # It looks like:
+  #
+  #     .---- BEGIN 94khk test/CRuby/event_loop_spec.rb:16
+  #     '-> SUSPEND 94khk lib/all/concurrently/proc/evaluation.rb:86:in `__suspend__'
+  #     ... [other entries] ...
+  #     .--- RESUME 94khk lib/all/concurrently/proc/evaluation.rb:86:in `__suspend__'
+  #     '-----> END 94khk test/CRuby/event_loop_spec.rb:16
+  #
+  # This log section indicates that the concurrent proc defined at
+  # `test/CRuby/event_loop_spec.rb:16` has been started to be evaluated. It is
+  # assigned the id `94khk`. The code of the proc is evaluated until it is
+  # suspended at `lib/all/concurrently/proc/evaluation.rb:86`. After other
+  # concurrent procs where scheduled to run, proc `94khk` is resumed again and
+  # from there on is evaluated until its end.
+  #
+  # Next to `END`, there are two other variations how the evaluation of a
+  # concurrent proc can be marked as concluded. These are
+  # * `CANCEL` if the evaluation is prematurely concluded with
+  #   {Proc::Evaluation#conclude_to} and
+  # * `ERROR` if the evaluation raises an error.
+  #
+  # The id of an evaluation may (and very likely will) be reused after the
+  # evaluation was concluded.
+  module Debug
+    @overwrites = []
+    @fibers = {}
+
+    @concurrently_path = 'm-ruby-concurrently'.freeze
+
+    class << self
+      # Enables debugging
+      #
+      # @param [Logger] logger
+      # @param [Array<String>] filter An array of strings to filter
+      #   stacktrace locations by. The first location in a stacktrace
+      #   containing one of the given strings will be used in the log message.
+      #   If no filter is given, the first location is logged.
+      # @return [true]
+      #
+      # @example
+      #   require 'logger'
+      #   Concurrently::Debug.enable Logger.new(STDOUT), ['file2']
+      #
+      #   # Assuming the stacktrace when resuming/suspending looks like:
+      #   #   /path/to/file1.rb
+      #   #   /path/to/file2.rb
+      #   #   /path/to/file3.rb
+      #   #
+      #   # Then, the logged location will be /path/to/file2.rb
+      def enable(logger, filter = false)
+        @logger = logger
+        @filter = filter
+        @log_concurrently_gem = filter && filter.any?{ |f| f.include? @concurrently_path }
+        @overwrites.each{ |overwrite| overwrite.call }
+        true
+      end
+
+      # @private
+      #
+      # Defines blocks of code to evaluate once debugging is enabled. Used
+      # internally only.
+      #
+      # @param [Class] klass The class in whose scope the given block will be evaluated
+      #                      with `#class_eval`
+      # @param [Proc] block The block of code to evaluate
+      def overwrite(klass, &block)
+        @overwrites << proc{ klass.class_eval &block }
+      end
+
+
+      # @private
+      def notice_for(fiber)
+        <<-MSG
+  Evaluation id: #{fiber.__id__.to_s 36}
+  To debug how this happened enable logging of control flow with:
+
+      require 'logger'
+      Concurrently::Debug.enable Logger.new STDOUT
+        MSG
+      end
+
+      # @private
+      def log_begin(fiber, location)
+        return unless @logger
+        return unless satisfies_filter? location
+        @fibers[fiber.__id__] = location
+        @logger.debug ".---- BEGIN #{fiber.__id__.to_s 36} #{location}"
+      end
+
+      # @private
+      def log_suspend(fiber, locations)
+        return unless @logger
+        return unless @fibers.key? fiber.__id__
+        return unless location = locations.find{ |loc| satisfies_filter? loc }
+        @logger.debug "'-> SUSPEND #{fiber.__id__.to_s 36} #{location}"
+      end
+
+      # @private
+      def log_schedule(fiber, locations)
+        return unless @logger
+        return unless location = locations.find{ |loc| satisfies_filter? loc }
+
+        prefix = (@fibers.key? Fiber.current.__id__) ? '|' : ' '
+        @logger.debug "#{prefix}  SCHEDULE #{fiber.__id__.to_s 36} from #{location}"
+      end
+
+      # @private
+      def log_resume(fiber, locations)
+        return unless @logger
+        return unless @fibers.key? fiber.__id__
+        return unless location = locations.find{ |loc| satisfies_filter? loc }
+        @logger.debug ".--- RESUME #{fiber.__id__.to_s 36} #{location}"
+      end
+
+      # @private
+      def log_end(fiber)
+        return unless @logger
+        return unless location = @fibers.delete(fiber.__id__)
+        @logger.debug "'-----> END #{fiber.__id__.to_s 36} #{location}"
+      end
+
+      # @private
+      def log_cancel(fiber)
+        return unless @logger
+        return unless location = @fibers.delete(fiber.__id__)
+        @logger.debug "'--> CANCEL #{fiber.__id__.to_s 36} #{location}"
+      end
+
+      # @private
+      def log_error(fiber)
+        return unless @logger
+        return unless location = @fibers.delete(fiber.__id__)
+        @logger.debug "'---> ERROR #{fiber.__id__.to_s 36} #{location}"
+      end
+
+      # @private
+      private def satisfies_filter?(location)
+        (not location.include? @concurrently_path or @log_concurrently_gem) and
+          (not @filter or @filter.any?{ |filter| location.include? filter })
+      end
+    end
+  end
+end

data/lib/all/concurrently/evaluation.rb

@@ -22,7 +22,7 @@ module Concurrently
     #     Concurrently::Evaluation.current # => #<Concurrently::Proc::Evaluation:0x00000000e56910>
     #   end
     #
-    #   Concurrently::Evaluation.current # => #<Concurrently::Evaluation0x00000000e5be10>
+    #   Concurrently::Evaluation.current # => #<Concurrently::Evaluation:0x00000000e5be10>
     def self.current
       EventLoop.current.run_queue.current_evaluation
     end
@@ -30,23 +30,43 @@ module Concurrently
     # @private
     def initialize(fiber)
       @fiber = fiber
+      @waiting = false
     end
 
     # @private
     #
-    # The fiber the evaluation runs inside.
+    # Suspends the evaluation. This is a method called internally only.
+    def __suspend__(event_loop_fiber)
+      @waiting = true
+      event_loop_fiber.resume
+    end
+
+    # @private
+    #
+    # Resumes the evaluation. This is a method called internally only.
     def __resume__(result)
       @scheduled = false
-      @fiber.resume result
+      Fiber.yield result
     end
 
     # @!attribute [r] waiting?
     #
-    # Checks if the evaluation is waiting
+    # Checks if the evaluation is not running and not resumed.
     #
     # @return [Boolean]
     def waiting?
-      @waiting
+      !!@waiting
+    end
+
+    # @private
+    #
+    # Called by {Proc::Evaluation#await_result}. This is a method called
+    # internally only.
+    def __await_result_of__(evaluation, opts)
+      evaluation.__add_waiting_evaluation__ self
+      await_resume! opts
+    ensure
+      evaluation.__remove_waiting_evaluation__ self
     end
     
     # @note The exclamation mark in its name stands for: Watch out!
@@ -76,7 +96,8 @@ module Concurrently
     # because of a manual call of {Kernel#await_resume!}.
     #
     # @return [:resumed]
-    # @raise [Error] if the evaluation is already scheduled to resume
+    # @raise [Error] if the evaluation is not waiting or is already scheduled
+    #   to be resumed
     #
     # @example
     #   # Control flow is indicated by (N)
@@ -92,8 +113,10 @@ module Concurrently
     #   evaluation.resume! :result
     #   # (5)
     #   evaluation.await_result # => :result
-    def resume!(result = nil)
-      raise Error, "already scheduled to resume" if @scheduled
+    def __resume__!(result = nil)
+      raise self.class::Error, "already scheduled\n#{Debug.notice_for @fiber}" if @scheduled
+      raise self.class::Error, "not waiting\n#{Debug.notice_for @fiber}" unless @waiting
+      @waiting = false
       @scheduled = true
 
       run_queue = Concurrently::EventLoop.current.run_queue
@@ -107,5 +130,13 @@ module Concurrently
       run_queue.schedule_immediately(self, result)
       :resumed
     end
+    alias resume! __resume__!
+
+    Debug.overwrite(self) do
+      def resume!(result = nil)
+        Debug.log_schedule @fiber, caller
+        __resume__! result
+      end
+    end
   end
 end

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

@@ -8,15 +8,29 @@ module Concurrently
     # There are two tracks. The fast track and the regular cart track. The
     # fast track exists for evaluations to be scheduled immediately. Having a
     # dedicated track lets us just push carts to the track in the order they
-    # appear. This saves us the rather expensive #bisect_left computation where
+    # appear. This saves us the rather expensive #find_index computation where
     # on the regular cart track to insert the cart.
 
     # The additional cart index exists so carts can be cancelled by their
     # evaluation. Cancelled carts have their evaluation set to false.
 
     class Track < Array
-      def bisect_left
-        bsearch_index{ |item| yield item } || length
+      def find_index(ref)
+        # For a track size < 64, a linear search is faster than a binary one.
+        if (len = size) < 64
+          idx = 0
+          while idx < len
+            break if self[idx][TIME] <= ref
+            idx += 1
+          end
+          idx
+        else
+          bsearch_index{ |cart| cart[TIME] <= ref } || length
+        end
+      end
+
+      def insert(cart)
+        super find_index(cart[TIME]), cart
       end
 
       def next
@@ -34,17 +48,32 @@ module Concurrently
       @immediate_track = Track.new
     end
 
-    def schedule_immediately(evaluation, result = nil, cancellable = true)
+    def __schedule_immediately__(evaluation, result = nil, cancellable = true)
       cart = [evaluation, false, result]
       evaluation.instance_variable_set :@__cart__, cart if cancellable
       @immediate_track << cart
     end
+    alias schedule_immediately __schedule_immediately__
+
+    Debug.overwrite(self) do
+      def schedule_immediately(evaluation, result = nil, cancellable = true)
+        evaluation.instance_variable_set :@scheduled_caller, caller if cancellable
+        __schedule_immediately__(evaluation, result, cancellable)
+      end
+    end
 
-    def schedule_deferred(evaluation, seconds, result = nil)
+    def __schedule_deferred__(evaluation, seconds, result = nil)
       cart = [evaluation, @loop.lifetime+seconds, result]
       evaluation.instance_variable_set :@__cart__, cart
-      index = @deferred_track.bisect_left{ |tcart| tcart[TIME] <= cart[TIME] }
-      @deferred_track.insert(index, cart)
+      @deferred_track.insert(cart)
+    end
+    alias schedule_deferred __schedule_deferred__
+
+    Debug.overwrite(self) do
+      def schedule_deferred(evaluation, seconds, result = nil)
+        evaluation.instance_variable_set :@scheduled_caller, caller
+        __schedule_deferred__(evaluation, seconds, result)
+      end
     end
 
     def cancel(evaluation, only_if_deferred = false)
@@ -61,7 +90,7 @@ module Concurrently
 
       if @deferred_track.size > 0
         now = @loop.lifetime
-        index = @deferred_track.bisect_left{ |cart| cart[TIME] <= now }
+        index = @deferred_track.find_index now
 
         processable_count = @deferred_track.size-index
         while processable_count > 0
@@ -94,12 +123,9 @@ module Concurrently
       when Proc::Fiber # this will only happen when calling Concurrently::Proc#call_and_forget
         @current_evaluation = nil
         evaluation.resume result
-      when Proc::Evaluation
+      when Evaluation
         @current_evaluation = evaluation
         evaluation.__resume__ result
-      when Evaluation
-        @current_evaluation = nil
-        Fiber.yield result
       else
         raise Error, "#{evaluation.inspect} cannot be resumed"
       end

data/lib/all/concurrently/proc.rb

@@ -5,12 +5,18 @@ module Concurrently
     #
     # mruby's Proc does not support instance variables. So, whe have to make
     # it a normal class that does not inherit from Proc :(
-    class Proc; end
+    #
+    # It is continued to be implemented in the mruby folder of lib/
+    class Proc
+      def original_call(*args)
+        @proc.call *args
+      end
+    end
   else
     class Proc < ::Proc
       # @private
       # Calls the concurrent proc like a normal proc
-      alias_method :__proc_call__, :call
+      alias_method :original_call, :call
     end
   end
 
@@ -25,13 +31,15 @@ module Concurrently
   # execution of its thread.
   #
   # 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
-  # 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.
+  # their result with {Evaluation#await_result}. They are also logged to
+  # stderr by default. This behavior can be controlled by {.error_log_output=}.
+  # In addition, errors can be watched by registering callbacks for the
+  # `:error` event as shown in the example below. This is useful as a central
+  # access point to errors happening inside concurrent evaluations for recovery
+  # purposes. Also, concurrent procs evaluated with {Proc#call_and_forget} are
+  # evaluated in the background with no access to their evaluation and if they
+  # fail they do so silently. The callbacks are the only way to gain access to
+  # their errors.
   #
   # The callbacks can be registered for all procs or only for one specific
   # proc:
@@ -68,6 +76,45 @@ module Concurrently
   class Proc
     include CallbacksAttachable
 
+    # @private
+    def self.default_error_log_message(proc, error)
+      <<MSG
+Concurrent proc exited with error!
+Source location: #{proc.source_location.join ':'}
+Error: (#{error.class}) #{error}
+Backtrace: #{error.backtrace.join "\n"}
+MSG
+    end
+
+    # @api public
+    # @since 1.2.0
+    #
+    # Sets the output to which errors in concurrent procs are written to.
+    #
+    # @param [IO|Logger|false|nil] output
+    #
+    # By default, errors are written to stderr. To disable logging of errors,
+    # set the output to `nil` or `false`.
+    #
+    # @example
+    #   require 'logger'
+    #   Concurrently::Proc.error_log_output = Logger.new(STDOUT)
+    def self.error_log_output=(output)
+      if Object.const_defined? :Logger and Logger === output
+        @error_handler.cancel if @error_handler
+        @error_handler = on(:error){ |error| output.error Proc.default_error_log_message self, error }
+      elsif IO === output
+        @error_handler.cancel if @error_handler
+        @error_handler = on(:error){ |error| output.puts Proc.default_error_log_message self, error }
+      elsif !output
+        remove_instance_variable(:@error_handler).cancel if @error_handler
+      else
+        raise Error, "output no logger or IO"
+      end
+    end
+
+    self.error_log_output = STDERR
+
     # A new instance of {Proc}
     #
     # @param [Class] evaluation_class It can be given a custom class to create
@@ -78,6 +125,26 @@ module Concurrently
       @evaluation_class = evaluation_class
     end
 
+    # @private
+    # Calls the concurrent proc from a fiber
+    alias_method :__original_call__, :original_call
+
+    Debug.overwrite(self) do
+      def original_call(*args)
+        Debug.log_begin Fiber.current, source_location.join(':')
+        result = __original_call__ *args
+      rescue Evaluation::Cancelled => e
+        Debug.log_cancel Fiber.current
+        raise e
+      rescue Exception => e
+        Debug.log_error Fiber.current
+        raise e
+      else
+        Debug.log_end Fiber.current
+        result
+      end
+    end
+
     # Evaluates the concurrent proc in a blocking manner.
     #
     # Evaluating the proc this way executes its block of code immediately

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

@@ -18,7 +18,7 @@ module Concurrently
     def initialize(fiber)
       super
       @concluded = false
-      @awaiting_result = {}
+      @waiting_evaluations = {}
       @data = {}
     end
 
@@ -76,6 +76,49 @@ module Concurrently
       @data.keys
     end
 
+    # @private
+    #
+    # Suspends the evaluation. This is a method called internally only.
+    def __suspend__(event_loop_fiber)
+      @waiting = true
+      # Yield back to the event loop fiber or the evaluation evaluating this one.
+      # Pass along itself to indicate it is not yet fully evaluated.
+      Proc::Fiber.yield self
+    ensure
+      @waiting = false
+    end
+
+    # @private
+    #
+    # Resumes the evaluation. This is a method called internally only.
+    def __resume__(result)
+      @scheduled = false
+      @fiber.resume result
+    end
+
+    Debug.overwrite(self) do
+      def __resume__(result)
+        @scheduled = false
+        @fiber.resume result, @scheduled_caller
+      end
+    end
+
+    # @private
+    #
+    # Manages bookkeeping of evaluations awaiting the result of this
+    # evaluation. This is a method called internally only.
+    def __add_waiting_evaluation__(evaluation, result_override = false)
+      @waiting_evaluations.store evaluation, result_override
+    end
+
+    # @private
+    #
+    # Manages bookkeeping of evaluations awaiting the result of this
+    # evaluation. This is a method called internally only.
+    def __remove_waiting_evaluation__(evaluation)
+      @waiting_evaluations.delete evaluation
+    end
+
     # Waits for the evaluation to be concluded with a result.
     #
     # The result can be awaited from multiple places at once. All of them are
@@ -171,19 +214,15 @@ module Concurrently
     #     evaluation.await_result{ |result| raise "invalid result" if result != :result }
     #     # => raises "invalid result"
     def await_result(opts = {}) # &with_result
-      if @concluded
-        result = @result
-      else
-        result = begin
-          evaluation = Concurrently::Evaluation.current
-          @awaiting_result.store evaluation, false
-          await_resume! opts
-        rescue Exception => error
-          error
-        ensure
-          @awaiting_result.delete evaluation
-        end
-      end
+      result = if @concluded
+                 @result
+               else
+                 begin
+                   Concurrently::Evaluation.current.__await_result_of__ self, opts
+                 rescue Exception => error
+                   error
+                 end
+               end
 
       result = yield result if block_given?
 
@@ -195,9 +234,9 @@ module Concurrently
     # Checks if the evaluation is concluded
     #
     # @return [Boolean]
-    def concluded?
-      @concluded
-    end
+    attr_reader :concluded
+    alias concluded? concluded
+    undef concluded
 
     # Cancels the concurrent evaluation prematurely by injecting a result.
     #
@@ -228,29 +267,23 @@ module Concurrently
     #   # (6)
     def conclude_to(result)
       if @concluded
-        raise self.class::Error, "already concluded"
+        raise self.class::Error, "already concluded\n#{Debug.notice_for @fiber}"
       end
 
       @result = result
       @concluded = true
 
       if Fiber.current != @fiber
-        # Cancel its fiber by resuming it with itself as argument
+        # Cancel its fiber
+        run_queue = Concurrently::EventLoop.current.run_queue
+        previous_evaluation = run_queue.current_evaluation
+        run_queue.current_evaluation = self
         @fiber.resume Cancelled
+        run_queue.current_evaluation = previous_evaluation
       end
 
-      @awaiting_result.each{ |evaluation, override| evaluation.resume! (override or result) }
+      @waiting_evaluations.each{ |evaluation, override| evaluation.resume! (override or result) }
       :concluded
     end
-
-    # Schedules the evaluation to be resumed
-    #
-    # For details see: {Concurrently::Evaluation#resume!}
-    #
-    # @raise [Evaluation::Error] if the evaluation is already concluded
-    def resume!(*)
-      raise Evaluation::Error, "already concluded to #{@result.inspect}" if @concluded
-      super
-    end
   end
 end

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

@@ -36,8 +36,10 @@ module Concurrently
               "there is a bug in Concurrently."
           else
             begin
-              result = proc.__proc_call__ *args
-              (evaluation = evaluation_bucket[0]) and evaluation.conclude_to result
+              result = proc.original_call *args
+              if (evaluation = evaluation_bucket[0]) and not evaluation.concluded?
+                evaluation.conclude_to result
+              end
               result
             rescue Proc::Evaluation::Cancelled
               # raised in Kernel#await_resume!
@@ -45,9 +47,10 @@ module Concurrently
             rescue Proc::Evaluation::RescueableError => error
               # Rescue all errors not critical for other concurrent evaluations
               # and don't let them leak to the loop to keep it up and running.
-              STDERR.puts error
               proc.trigger :error, error
-              (evaluation = evaluation_bucket[0]) and evaluation.conclude_to error
+              if (evaluation = evaluation_bucket[0]) and not evaluation.concluded?
+                evaluation.conclude_to error
+              end
               error
             end
           end
@@ -56,9 +59,25 @@ module Concurrently
 
           # Yield back to the event loop fiber or the fiber evaluating this one
           # and wait for the next proc to evaluate.
-          proc, args, evaluation_bucket = Fiber.yield result
+          proc, args, evaluation_bucket = Proc::Fiber.yield result
         end
       end
     end
+
+    Debug.overwrite(self) do
+      def self.yield(*)
+        Debug.log_suspend Fiber.current, caller
+        super
+      ensure
+        Debug.log_resume Fiber.current, caller
+      end
+
+      def resume(result, stacktrace = caller)
+        Debug.log_suspend Fiber.current, stacktrace
+        super result
+      ensure
+        Debug.log_resume Fiber.current, stacktrace
+      end
+    end
   end
 end

data/lib/all/concurrently/version.rb

@@ -1,8 +1,4 @@
-# @api public
-# @since 1.0.0
-#
-# The namespace this library lives in
 module Concurrently
   # The version
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/all/kernel.rb

@@ -9,7 +9,7 @@ module Kernel
   #
   # This is a shortcut for {Concurrently::Proc#call_detached}.
   #
-  # @return [nil]
+  # @return [Evaluation]
   #
   # @example
   #   concurrently(a,b,c) do |a,b,c|
@@ -120,20 +120,11 @@ module Kernel
       run_queue.schedule_deferred(evaluation, seconds, timeout_result)
     end
 
-    evaluation.instance_variable_set :@waiting, true
-    result = case evaluation
-    when Concurrently::Proc::Evaluation
-      # Yield back to the event loop fiber or the evaluation evaluating this one.
-      # Pass along itself to indicate it is not yet fully evaluated.
-      Fiber.yield evaluation
-    else
-      event_loop.fiber.resume
-    end
-    evaluation.instance_variable_set :@waiting, false
+    result = evaluation.__suspend__ event_loop.fiber
 
     if Concurrently::Proc::Evaluation::Cancelled.equal? result
       run_queue.cancel evaluation # in case the evaluation has already been scheduled to resume
-      raise Concurrently::Proc::Evaluation::Cancelled, ''
+      raise Concurrently::Proc::Evaluation::Cancelled, '' # TODO: add empty backtrace as last argument once murby supports it
     elsif Concurrently::Evaluation::TimeoutError.equal? result
       raise Concurrently::Evaluation::TimeoutError, "evaluation timed out after #{seconds} second(s)"
     else
@@ -242,10 +233,10 @@ module Kernel
     else
       begin
         curr_eval = Concurrently::Evaluation.current
-        evaluations.each{ |e| e.instance_eval{ @awaiting_result.store curr_eval, self } }
+        evaluations.each{ |eval| eval.__add_waiting_evaluation__ curr_eval, eval }
         await_resume! opts
       ensure
-        evaluations.each{ |e| e.instance_eval{ @awaiting_result.delete curr_eval } }
+        evaluations.each{ |eval| eval.__remove_waiting_evaluation__ curr_eval }
       end
     end
   end

data/lib/mruby/concurrently/proc.rb

@@ -10,12 +10,12 @@ module Concurrently
       @proc = proc
     end
 
-    def arity
-      @proc.arity
+    def source_location
+      @proc.source_location || ['main', 0]
     end
 
-    def __proc_call__(*args)
-      @proc.call *args
+    def arity
+      @proc.arity
     end
   end
 end

data/mrbgem.rake

@@ -25,9 +25,12 @@ DESC
   spec.license      = 'Apache-2.0'
   spec.authors      = ['Christopher Aue']
 
-  # patch build process so we can set source files with spec.rbfiles
-  @generate_functions = true
-  @objs << objfile("#{build_dir}/gem_init")
+  unless system("git merge-base --is-ancestor 5a9eedf5417266b82e3695ae0c29797182a5d04e HEAD")
+    # mruby commit 5a9eedf fixed the usage of spec.rbfiles. mruby 1.3.0
+    # did not have that commit, yet. Add the patch for this case:
+    @generate_functions = true
+    @objs << objfile("#{build_dir}/gem_init")
+  end
 
   spec.rbfiles      =
     Dir["#{spec.dir}/ext/all/**/*.rb"].sort +
@@ -36,13 +39,16 @@ DESC
     Dir["#{spec.dir}/lib/mruby/**/*.rb"].sort
   spec.test_rbfiles = Dir["#{spec.dir}/test/mruby/*.rb"]
 
+  spec.add_dependency 'mruby-hash-ext', :core => 'mruby-hash-ext'
   spec.add_dependency 'mruby-array-ext', :core => 'mruby-array-ext'
   spec.add_dependency 'mruby-numeric-ext', :core => 'mruby-numeric-ext'
+  spec.add_dependency 'mruby-proc-ext', :core => 'mruby-proc-ext'
+  spec.add_dependency 'mruby-kernel-ext', :core => 'mruby-kernel-ext'
   spec.add_dependency 'mruby-enumerator', :core => 'mruby-enumerator'
   spec.add_dependency 'mruby-fiber', :core => 'mruby-fiber'
   spec.add_dependency 'mruby-time', :core => 'mruby-time'
   spec.add_dependency 'mruby-io'
-  spec.add_dependency 'mruby-callbacks_attachable', '~> 2.2', github: 'christopheraue/m-ruby-callbacks_attachable'
+  spec.add_dependency 'mruby-callbacks_attachable', '~> 3.0', github: 'christopheraue/m-ruby-callbacks_attachable'
 
   # use mruby-poll only on unix-like OSes
   if ENV['VisualStudioVersion'] || ENV['VSINSTALLDIR']

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrently
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
 platform: ruby
 authors:
 - Christopher Aue
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-15 00:00:00.000000000 Z
+date: 2017-12-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: nio4r
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
 description: "Concurrently is a concurrency framework for Ruby and mruby based on\nfibers.
   With it code can be evaluated independently in its own execution\ncontext similar
   to a thread:\n\n    hello = concurrently do\n      wait 0.2 # seconds\n      \"hello\"\n
@@ -73,7 +73,7 @@ files:
 - RELEASE_NOTES.md
 - Rakefile
 - concurrently.gemspec
-- ext/Ruby/thread.rb
+- ext/CRuby/thread.rb
 - ext/all/array.rb
 - ext/mruby/fiber.rb
 - ext/mruby/io.rb
@@ -81,10 +81,13 @@ files:
 - guides/Overview.md
 - guides/Performance.md
 - guides/Troubleshooting.md
-- lib/Ruby/concurrently.rb
-- lib/Ruby/concurrently/event_loop.rb
-- lib/Ruby/concurrently/event_loop/io_selector.rb
-- lib/Ruby/concurrently/proc/evaluation/error.rb
+- lib/CRuby/concurrently.rb
+- lib/CRuby/concurrently/event_loop.rb
+- lib/CRuby/concurrently/event_loop/io_selector.rb
+- lib/CRuby/concurrently/proc/evaluation/error.rb
+- lib/CRuby/thread.rb
+- lib/all/concurrently.rb
+- lib/all/concurrently/debug.rb
 - lib/all/concurrently/error.rb
 - lib/all/concurrently/evaluation.rb
 - lib/all/concurrently/evaluation/error.rb
@@ -105,7 +108,7 @@ files:
 - lib/mruby/kernel.rb
 - mrbgem.rake
 - mruby_builds/build_config.rb
-- perf/Ruby/stage.rb
+- perf/CRuby/stage.rb
 - perf/benchmark_call_methods.rb
 - perf/benchmark_call_methods_waiting.rb
 - perf/benchmark_wait_methods.rb
@@ -128,7 +131,7 @@ metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
-- lib/Ruby
+- lib/CRuby
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -141,7 +144,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: A concurrency framework based on fibers