polyphony 0.29 → 0.30

data/lib/polyphony/extensions/fiber.rb

@@ -11,10 +11,12 @@ module FiberControl
       return @result.is_a?(Exception) ? (Kernel.raise @result) : @result
     end
 
-    @waiting_fiber = Fiber.current
+    fiber = Fiber.current
+    @waiting_fibers ||= {}
+    @waiting_fibers[fiber] = true
     suspend
   ensure
-    @waiting_fiber = nil
+    @waiting_fibers&.delete(fiber)
   end
   alias_method :join, :await
 
@@ -22,7 +24,6 @@ module FiberControl
     return if @running == false
 
     schedule Exceptions::MoveOn.new(nil, value)
-    snooze
   end
   alias_method :stop, :interrupt
 
@@ -30,13 +31,17 @@ module FiberControl
     return if @running == false
 
     schedule Exceptions::Cancel.new
-    snooze
+  end
+
+  def terminate
+    return if @running == false
+
+    schedule Exceptions::Terminate.new
   end
 
   def raise(*args)
     error = error_from_raise_args(args)
     schedule(error)
-    snooze
   end
 
   def error_from_raise_args(args)
@@ -49,123 +54,196 @@ module FiberControl
   end
 end
 
-# Messaging functionality
-module FiberMessaging
-  def <<(value)
-    if @receive_waiting && @running
-      schedule value
-    else
-      @queued_messages ||= Gyro::Queue.new
-      @queued_messages << value
+# Class methods for controlling fibers (namely await and select)
+module FiberControlClassMethods
+  def await(*fibers)
+    return [] if fibers.empty?
+
+    state = setup_await_select_state(fibers)
+    await_setup_monitoring(fibers, state)
+    suspend
+    fibers.map(&:result)
+  ensure
+    await_select_cleanup(state)
+  end
+  alias_method :join, :await
+
+  def setup_await_select_state(fibers)
+    {
+      awaiter: Fiber.current,
+      pending: fibers.each_with_object({}) { |f, h| h[f] = true }
+    }
+  end
+
+  def await_setup_monitoring(fibers, state)
+    fibers.each do |f|
+      f.when_done { |r| await_fiber_done(f, r, state) }
     end
-    snooze
   end
-  alias_method :send, :<<
 
-  def receive
-    if !@queued_messages || @queued_messages&.empty?
-      wait_for_message
-    else
-      value = @queued_messages.shift
-      snooze
-      value
+  def await_fiber_done(fiber, result, state)
+    state[:pending].delete(fiber)
+
+    if state[:cleanup]
+      state[:awaiter].schedule if state[:pending].empty?
+    elsif !state[:done] && (result.is_a?(Exception) || state[:pending].empty?)
+      state[:awaiter].schedule(result)
+      state[:done] = true
     end
   end
 
-  def wait_for_message
-    Gyro.ref
-    @receive_waiting = true
+  def await_select_cleanup(state)
+    return if state[:pending].empty?
+
+    move_on = Exceptions::MoveOn.new
+    state[:cleanup] = true
+    state[:pending].each_key { |f| f.schedule(move_on) }
+    suspend
+  end
+
+  def select(*fibers)
+    state = setup_await_select_state(fibers)
+    select_setup_monitoring(fibers, state)
     suspend
   ensure
-    Gyro.unref
-    @receive_waiting = nil
+    await_select_cleanup(state)
+  end
+
+  def select_setup_monitoring(fibers, state)
+    fibers.each do |f|
+      f.when_done { |r| select_fiber_done(f, r, state) }
+    end
+  end
+
+  def select_fiber_done(fiber, result, state)
+    state[:pending].delete(fiber)
+    if state[:cleanup]
+      # in cleanup mode the selector is resumed if no more pending fibers
+      state[:awaiter].schedule if state[:pending].empty?
+    elsif !state[:selected]
+      # first fiber to complete, we schedule the result
+      state[:awaiter].schedule([fiber, result])
+      state[:selected] = true
+    end
   end
 end
 
-# Fiber extensions
-class ::Fiber
-  prepend FiberControl
-  include FiberMessaging
+# Messaging functionality
+module FiberMessaging
+  def <<(value)
+    @mailbox << value
+    snooze
+  end
+  alias_method :send, :<<
 
-  def self.reset!
-    @running_fibers_map = { Thread.current.main_fiber => true }
+  def receive
+    @mailbox.shift
   end
+end
 
-  reset!
+# Methods for controlling child fibers
+module ChildFiberControl
+  def children
+    (@children ||= {}).keys
+  end
 
-  def self.map
-    @running_fibers_map
+  def spin(tag = nil, orig_caller = caller, &block)
+    f = Fiber.new { |v| f.run(v) }
+    f.prepare(tag, block, orig_caller)
+    (@children ||= {})[f] = true
+    f
   end
 
-  def self.list
-    @running_fibers_map.keys
+  def child_done(child_fiber)
+    @children.delete(child_fiber)
   end
 
-  def self.count
-    @running_fibers_map.size
+  def terminate_all_children
+    return unless @children
+
+    e = Exceptions::Terminate.new
+    @children.each_key { |c| c.raise e }
   end
 
-  def self.spin(tag = nil, orig_caller = caller, &block)
-    f = new { |v| f.run(v) }
-    f.setup(tag, block, orig_caller)
-    f
+  def await_all_children
+    return unless @children && !@children.empty?
+
+    Fiber.await(*@children.keys)
   end
+end
+
+# Fiber extensions
+class ::Fiber
+  prepend FiberControl
+  include FiberMessaging
+  include ChildFiberControl
+
+  extend FiberControlClassMethods
 
   attr_accessor :tag, :thread
 
-  def setup(tag, block, caller)
+  def prepare(tag, block, caller)
     __fiber_trace__(:fiber_create, self)
     @thread = Thread.current
     @tag = tag
-    @calling_fiber = Fiber.current
+    @parent = Fiber.current
     @caller = caller
     @block = block
+    @mailbox = Gyro::Queue.new
     schedule
   end
 
   def setup_main_fiber
+    @main = true
     @tag = :main
     @thread = Thread.current
     @running = true
+    @children&.clear
+    @mailbox = Gyro::Queue.new
   end
 
   def run(first_value)
-    Kernel.raise first_value if first_value.is_a?(Exception)
-
-    start_execution(first_value)
-  rescue ::Interrupt, ::SystemExit => e
-    Thread.current.main_fiber.transfer e.class.new
-  rescue ::SignalException => e
-    Thread.current.main_fiber.transfer e
-  rescue Exceptions::MoveOn => e
-    finish_execution(e.value)
+    setup(first_value)
+    uncaught = nil
+    result = @block.(first_value)
+  rescue Exceptions::MoveOn, Exceptions::Terminate => e
+    result = e.value
   rescue Exception => e
-    finish_execution(e, true)
+    result = e
+    uncaught = true
+  ensure
+    finalize(result, uncaught)
   end
 
-  def start_execution(first_value)
+  def setup(first_value)
+    Kernel.raise first_value if first_value.is_a?(Exception)
+
     @running = true
-    self.class.map[self] = true
-    result = @block.(first_value)
-    finish_execution(result)
   end
 
-  def finish_execution(result, uncaught_exception = false)
+  def finalize(result, uncaught_exception = false)
+    terminate_all_children
+    await_all_children
     __fiber_trace__(:fiber_terminate, self, result)
     @result = result
     @running = false
-    self.class.map.delete(self)
-    @when_done&.(result)
-    @waiting_fiber&.schedule(result)
-    return unless uncaught_exception && !@waiting_fiber
-
-    exception_receiving_fiber.schedule(result)
+    inform_dependants(result, uncaught_exception)
   ensure
     Thread.current.switch_fiber
   end
 
-  def exception_receiving_fiber
-    @calling_fiber.running? ? @calling_fiber : Thread.current.main_fiber
+  def inform_dependants(result, uncaught_exception)
+    @parent.child_done(self)
+    @when_done_procs&.each { |p| p.(result) }
+    has_waiting_fibers = nil
+    @waiting_fibers&.each_key do |f|
+      has_waiting_fibers = true
+      f.schedule(result)
+    end
+    return unless uncaught_exception && !has_waiting_fibers
+
+    # propagate unaught exception to parent
+    @parent.schedule(result)
   end
 
   attr_reader :result
@@ -175,7 +253,7 @@ class ::Fiber
   end
 
   def when_done(&block)
-    @when_done = block
+    (@when_done_procs ||= []) << block
   end
 
   def inspect
@@ -189,12 +267,21 @@ class ::Fiber
 
   def caller
     spin_caller = @caller || []
-    if @calling_fiber
-      spin_caller + @calling_fiber.caller
+    if @parent
+      spin_caller + @parent.caller
     else
       spin_caller
     end
   end
+
+  def main?
+    @main
+  end
 end
 
 Fiber.current.setup_main_fiber
+
+at_exit do
+  Fiber.current.terminate_all_children
+  Fiber.current.await_all_children
+end

data/lib/polyphony/extensions/io.rb

@@ -178,10 +178,8 @@ class ::IO
     end
 
     until eof?
-      result = outbuf ? readpartial(8192, outbuf) : readpartial(8192)
-      break unless result
-
-      outbuf = result
+      outbuf ||= +''
+      outbuf << readpartial(8192)
     end
     outbuf
   end

data/lib/polyphony/extensions/openssl.rb

@@ -39,23 +39,6 @@ class ::OpenSSL::SSL::SSLSocket
     # @sync = osync
   end
 
-  # def do_write(s)
-  #   @wbuffer = "" unless defined? @wbuffer
-  #   @wbuffer << s
-  #   @wbuffer.force_encoding(Encoding::BINARY)
-  #   @sync ||= false
-  #   if @sync or @wbuffer.size > BLOCK_SIZE
-  #     until @wbuffer.empty?
-  #       begin
-  #         nwrote = syswrite(@wbuffer)
-  #       rescue Errno::EAGAIN
-  #         retry
-  #       end
-  #       @wbuffer[0, nwrote] = ""
-  #     end
-  #   end
-  # end
-
   def syswrite(buf)
     read_watcher = nil
     write_watcher = nil

data/lib/polyphony/extensions/thread.rb

@@ -4,45 +4,69 @@ Exceptions = import '../core/exceptions'
 
 # Thread extensions
 class ::Thread
-  def self.join_queue_mutex
-    @join_queue_mutex ||= Mutex.new
-  end
-
   attr_reader :main_fiber
 
   alias_method :orig_initialize, :initialize
   def initialize(*args, &block)
     @join_wait_queue = Gyro::Queue.new
+    @args = args
     @block = block
-    orig_initialize do
-      Fiber.current.setup_main_fiber
-      setup_fiber_scheduling
-      block.(*args)
-    ensure
-      signal_waiters
-      stop_event_selector
-    end
+    orig_initialize { execute }
   end
 
-  def signal_waiters
-    @join_wait_queue.shift_each { |w| w.signal!(self) }
+  def execute
+    setup
+    result = @block.(*@args)
+  rescue Exceptions::MoveOn, Exceptions::Terminate => e
+    result = e.value
+  rescue Exception => e
+    result = e
+  ensure
+    finalize(result)
   end
 
-  alias_method :orig_join, :join
-  def join(timeout = nil)
-    async = Gyro::Async.new
-    Thread.join_queue_mutex.synchronize do
-      return unless alive?
+  def setup
+    @main_fiber = Fiber.current
+    @main_fiber.setup_main_fiber
+    setup_fiber_scheduling
+  end
 
-      @join_wait_queue << async
+  def finalize(result)
+    unless Fiber.current.children.empty?
+      Fiber.current.terminate_all_children
+      Fiber.current.await_all_children
     end
+    signal_waiters(result)
+    stop_event_selector
+  end
 
+  def signal_waiters(result)
+    @join_wait_queue.shift_each { |w| w.signal!(result) }
+  end
+
+  alias_method :orig_join, :join
+  def join(timeout = nil)
     if timeout
-      move_on_after(timeout) { async.await }
+      move_on_after(timeout) { join_perform }
     else
-      async.await
+      join_perform
     end
   end
+  alias_method :await, :join
+
+  alias_method :orig_raise, :raise
+  def raise(error = nil)
+    Thread.pass until @main_fiber
+    error = RuntimeError.new if error.nil?
+    error = RuntimeError.new(error) if error.is_a?(String)
+    error = error.new if error.is_a?(Class)
+    @main_fiber.raise(error)
+  end
+
+  alias_method :orig_kill, :kill
+  def kill
+    raise Exceptions::Terminate
+  end
 
   alias_method :orig_inspect, :inspect
   def inspect

data/lib/polyphony/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Polyphony
-  VERSION = '0.29'
+  VERSION = '0.30'
 end

data/lib/polyphony.rb

@@ -21,8 +21,9 @@ module Polyphony
   ::Object.include GlobalAPI
 
   exceptions = import './polyphony/core/exceptions'
-  Cancel = exceptions::Cancel
-  MoveOn = exceptions::MoveOn
+  Cancel    = exceptions::Cancel
+  MoveOn    = exceptions::MoveOn
+  Terminate = exceptions::Terminate
 
   Net = import './polyphony/net'
 
@@ -31,7 +32,6 @@ module Polyphony
     Channel:      './polyphony/core/channel',
     FS:           './polyphony/fs',
     ResourcePool: './polyphony/core/resource_pool',
-    Supervisor:   './polyphony/core/supervisor',
     Sync:         './polyphony/core/sync',
     ThreadPool:   './polyphony/core/thread_pool',
     Throttler:    './polyphony/core/throttler',
@@ -40,21 +40,13 @@ module Polyphony
   )
 
   class << self
-    # def trap(sig, ref = false, &callback)
-    #   sig = Signal.list[sig.to_s.upcase] if sig.is_a?(Symbol)
-    #   puts "sig = #{sig.inspect}"
-    #   watcher = Gyro::Signal.new(sig, &callback)
-    #   # Gyro.unref unless ref
-    #   watcher
-    # end
-
     def wait_for_signal(sig)
       fiber = Fiber.current
       Gyro.ref
-      trap(sig) do
-        trap(sig, :DEFAULT)
+      old_trap = trap(sig) do
         Gyro.unref
-        fiber.transfer(sig)
+        fiber.schedule(sig)
+        trap(sig, old_trap)
       end
       suspend
     end
@@ -64,13 +56,23 @@ module Polyphony
         Gyro.post_fork
         Fiber.current.setup_main_fiber
         block.()
+      ensure
+        Fiber.current.terminate_all_children
+        Fiber.current.await_all_children
       end
       pid
     end
+  end
+end
 
-    def reset!
-      Thread.current.reset_fiber_scheduling
-      Fiber.reset!
-    end
+# install signal handlers
+
+def install_terminating_signal_handler(signal, exception_class)
+  trap(signal) do
+    exception = exception_class.new
+    Thread.current.break_out_of_ev_loop(exception)
   end
 end
+
+install_terminating_signal_handler('SIGTERM', SystemExit)
+install_terminating_signal_handler('SIGINT', Interrupt)

data/test/coverage.rb

@@ -46,7 +46,7 @@ class << SimpleCov::LinesClassifier
     # apparently TracePoint tracing does not cover lines including only keywords
     # such as begin end etc, so here we mark those lines as whitespace, so they
     # won't count towards the coverage score.
-    line.strip =~ /^(begin|end|ensure|else|\})|(\s*rescue\s.+)$/ ||
+    line.strip =~ /^(begin|end|ensure|else|\{|\})|(\s*rescue\s.+)$/ ||
                   orig_whitespace_line?(line)
   end
 end

data/test/helper.rb

@@ -20,13 +20,17 @@ Minitest::Reporters.use! [
 
 class MiniTest::Test
   def setup
+    if Fiber.current.children.size > 0
+      puts "Children left: #{Fiber.current.children.inspect}"
+      exit!
+    end
     Fiber.current.setup_main_fiber
+    sleep 0
   end
 
   def teardown
-    # wait for any remaining scheduled work
-    Thread.current.switch_fiber
-    Polyphony.reset!
+    Fiber.current.terminate_all_children
+    Fiber.current.await_all_children
   end
 end