polyphony 0.34 → 0.41

data/lib/polyphony/core/sync.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
-export :Mutex
+module Polyphony
+  # Implements mutex lock for synchronizing access to a shared resource
+  class Mutex
+    def initialize
+      @waiting_fibers = Polyphony::Queue.new
+    end
 
-# Implements mutex lock for synchronizing access to a shared resource
-class Mutex
-  def initialize
-    @waiting_fibers = []
-  end
-
-  def synchronize
-    fiber = Fiber.current
-    @waiting_fibers << fiber
-    suspend if @waiting_fibers.size > 1
-    yield
-  ensure
-    @waiting_fibers.delete(fiber)
-    @waiting_fibers.first&.schedule
-    snooze
+    def synchronize
+      fiber = Fiber.current
+      @waiting_fibers << fiber
+      suspend if @waiting_fibers.size > 1
+      yield
+    ensure
+      @waiting_fibers.delete(fiber)
+      @waiting_fibers.first&.schedule
+      snooze
+    end
   end
 end

data/lib/polyphony/core/thread_pool.rb

@@ -1,52 +1,64 @@
 # frozen_string_literal: true
 
-export_default :ThreadPool
-
 require 'etc'
 
-# Implements a pool of threads
-class ThreadPool
-  attr_reader :size
+module Polyphony
+  # Implements a pool of threads
+  class ThreadPool
+    attr_reader :size
 
-  def self.process(&block)
-    @default_pool ||= new
-    @default_pool.process(&block)
-  end
+    def self.process(&block)
+      @default_pool ||= new
+      @default_pool.process(&block)
+    end
 
-  def initialize(size = Etc.nprocessors)
-    @size = size
-    @task_queue = ::Queue.new
-    @threads = (1..@size).map { Thread.new { thread_loop } }
-  end
+    def self.reset
+      return unless @default_pool
 
-  def process(&block)
-    setup unless @task_queue
+      @default_pool.stop
+      @default_pool = nil
+    end
 
-    async = Gyro::Async.new
-    @task_queue << [block, async]
-    async.await
-  end
+    def initialize(size = Etc.nprocessors)
+      @size = size
+      @task_queue = Polyphony::Queue.new
+      @threads = (1..@size).map { Thread.new { thread_loop } }
+    end
 
-  def cast(&block)
-    setup unless @task_queue
+    def process(&block)
+      setup unless @task_queue
 
-    @task_queue << [block, nil]
-    self
-  end
+      watcher = Fiber.current.auto_watcher
+      @task_queue << [block, watcher]
+      watcher.await
+    end
 
-  def busy?
-    !@task_queue.empty?
-  end
+    def cast(&block)
+      setup unless @task_queue
 
-  def thread_loop
-    loop { run_queued_task }
-  end
+      @task_queue << [block, nil]
+      self
+    end
+
+    def busy?
+      !@task_queue.empty?
+    end
+
+    def thread_loop
+      loop { run_queued_task }
+    end
+
+    def run_queued_task
+      (block, watcher) = @task_queue.pop
+      result = block.()
+      watcher&.signal(result)
+    rescue Exception => e
+      watcher ? watcher.signal(e) : raise(e)
+    end
 
-  def run_queued_task
-    (block, watcher) = @task_queue.pop
-    result = block.()
-    watcher&.signal!(result)
-  rescue Exception => e
-    watcher ? watcher.signal!(e) : raise(e)
+    def stop
+      @threads.each(&:kill)
+      @threads.each(&:join)
+    end
   end
 end

data/lib/polyphony/core/throttler.rb

@@ -1,34 +1,41 @@
 # frozen_string_literal: true
 
-export_default :Throttler
+module Polyphony
+  # Implements general-purpose throttling
+  class Throttler
+    def initialize(rate)
+      @rate = rate_from_argument(rate)
+      @min_dt = 1.0 / @rate
+      @next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+    end
 
-# Implements general-purpose throttling
-class Throttler
-  def initialize(rate)
-    @rate = rate_from_argument(rate)
-    @min_dt = 1.0 / @rate
-  end
+    def call
+      now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+      delta = @next_time - now
+      Thread.current.agent.sleep(delta) if delta > 0
+      yield self
 
-  def call(&block)
-    @timer ||= Gyro::Timer.new(0, @min_dt)
-    @timer.await
-    block.call(self)
-  end
-  alias_method :process, :call
+      loop do
+        @next_time += @min_dt
+        break if @next_time > now
+      end
+    end
+    alias_method :process, :call
 
-  def stop
-    @timer&.stop
-  end
+    def stop
+      @stop = true
+    end
 
-  private
+    private
 
-  def rate_from_argument(arg)
-    return arg if arg.is_a?(Numeric)
+    def rate_from_argument(arg)
+      return arg if arg.is_a?(Numeric)
 
-    if arg.is_a?(Hash)
-      return 1.0 / arg[:interval] if arg[:interval]
-      return arg[:rate] if arg[:rate]
+      if arg.is_a?(Hash)
+        return 1.0 / arg[:interval] if arg[:interval]
+        return arg[:rate] if arg[:rate]
+      end
+      raise "Invalid rate argument #{arg.inspect}"
     end
-    raise "Invalid rate argument #{arg.inspect}"
   end
 end

data/lib/polyphony/event.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Polyphony
+  # Event watcher for thread-safe synchronisation
+  class Event
+    def initialize
+      @i, @o = IO.pipe
+    end
+
+    def await
+      Thread.current.agent.read(@i, +'', 8192, false)
+      raise @value if @value.is_a?(Exception)
+
+      @value
+    end
+
+    def await_no_raise
+      Thread.current.agent.read(@i, +'', 8192, false)
+      @value
+    end
+
+    def signal(value = nil)
+      @value = value
+      Thread.current.agent.write(@o, '1')
+    end
+  end
+end

data/lib/polyphony/extensions/core.rb

@@ -4,7 +4,7 @@ require 'fiber'
 require 'timeout'
 require 'open3'
 
-Exceptions = import('../core/exceptions')
+require_relative '../core/exceptions'
 
 # Exeption overrides
 class ::Exception
@@ -22,7 +22,7 @@ class ::Exception
     orig_initialize(*args)
   end
 
-  alias_method_once :orig_backtrace, :backtrace
+  alias_method :orig_backtrace, :backtrace
   def backtrace
     unless @first_backtrace_call || EXIT_EXCEPTION_CLASSES.include?(self.class)
       @first_backtrace_call = true
@@ -52,10 +52,13 @@ end
 
 # Overrides for Process
 module ::Process
-  def self.detach(pid)
-    fiber = spin { Gyro::Child.new(pid).await }
-    fiber.define_singleton_method(:pid) { pid }
-    fiber
+  class << self
+    alias_method :orig_detach, :detach
+    def detach(pid)
+      fiber = spin { Thread.current.agent.waitpid(pid) }
+      fiber.define_singleton_method(:pid) { pid }
+      fiber
+    end
   end
 end
 
@@ -67,10 +70,9 @@ module ::Kernel
   def `(cmd)
     Open3.popen3(cmd) do |i, o, e, _t|
       i.close
-      while (l = e.readpartial(8192))
-        $stderr << l
-      end
-      o.read
+      err = e.read
+      $stderr << err if err
+      o.read || ''
     end
   end
 
@@ -104,21 +106,28 @@ module ::Kernel
   def system(*args)
     Open3.popen2(*args) do |i, o, _t|
       i.close
-      while (l = o.readpartial(8192))
-        $stdout << l
-      end
+      pipe_to_eof(o, $stdout)
     end
     true
   rescue SystemCallError
     nil
   end
+
+  def pipe_to_eof(src, dest)
+    loop do
+      data = src.readpartial(8192)
+      dest << data
+    rescue EOFError
+      break
+    end
+  end
 end
 
 # Override Timeout to use cancel scope
 module ::Timeout
   def self.timeout(sec, klass = nil, message = nil, &block)
     cancel_after(sec, &block)
-  rescue Exceptions::Cancel => e
+  rescue Polyphony::Cancel => e
     error = klass ? klass.new(message) : ::Timeout::Error.new
     error.set_backtrace(e.backtrace)
     raise error

data/lib/polyphony/extensions/fiber.rb

@@ -2,340 +2,342 @@
 
 require 'fiber'
 
-Exceptions = import '../core/exceptions'
-
-# Fiber control API
-module FiberControl
-  def await
-    if @running == false
-      return @result.is_a?(Exception) ? (Kernel.raise @result) : @result
+require_relative '../core/exceptions'
+
+module Polyphony
+  # Fiber control API
+  module FiberControl
+    def await
+      if @running == false
+        return @result.is_a?(Exception) ? (Kernel.raise @result) : @result
+      end
+
+      fiber = Fiber.current
+      @waiting_fibers ||= {}
+      @waiting_fibers[fiber] = true
+      suspend
+    ensure
+      @waiting_fibers&.delete(fiber)
     end
+    alias_method :join, :await
 
-    fiber = Fiber.current
-    @waiting_fibers ||= {}
-    @waiting_fibers[fiber] = true
-    suspend
-  ensure
-    @waiting_fibers&.delete(fiber)
-  end
-  alias_method :join, :await
+    def interrupt(value = nil)
+      return if @running == false
 
-  def interrupt(value = nil)
-    return if @running == false
+      schedule Polyphony::MoveOn.new(value)
+    end
+    alias_method :stop, :interrupt
 
-    schedule Exceptions::MoveOn.new(value)
-  end
-  alias_method :stop, :interrupt
+    def restart(value = nil)
+      raise "Can''t restart main fiber" if @main
 
-  def restart(value = nil)
-    raise "Can''t restart main fiber" if @main
+      if @running
+        schedule Polyphony::Restart.new(value)
+        return self
+      end
 
-    if @running
-      schedule Exceptions::Restart.new(value)
-      return self
+      parent.spin(@tag, @caller, &@block).tap do |f|
+        f.schedule(value) unless value.nil?
+      end
     end
+    alias_method :reset, :restart
 
-    parent.spin(@tag, @caller, &@block).tap do |f|
-      f.schedule(value) unless value.nil?
-    end
-  end
-  alias_method :reset, :restart
-
-  def cancel!
-    return if @running == false
-
-    schedule Exceptions::Cancel.new
-  end
+    def cancel
+      return if @running == false
 
-  def terminate
-    return if @running == false
+      schedule Polyphony::Cancel.new
+    end
 
-    schedule Exceptions::Terminate.new
-  end
+    def terminate
+      return if @running == false
 
-  def raise(*args)
-    error = error_from_raise_args(args)
-    schedule(error)
-  end
+      schedule Polyphony::Terminate.new
+    end
 
-  def error_from_raise_args(args)
-    case (arg = args.shift)
-    when String then RuntimeError.new(arg)
-    when Class  then arg.new(args.shift)
-    when Exception then arg
-    else RuntimeError.new
+    def raise(*args)
+      error = error_from_raise_args(args)
+      schedule(error)
     end
-  end
-end
 
-# Fiber supervision
-module FiberSupervision
-  def supervise(opts = {})
-    @counter = 0
-    @on_child_done = proc do |fiber, result|
-      self << fiber unless result.is_a?(Exception)
+    def error_from_raise_args(args)
+      case (arg = args.shift)
+      when String then RuntimeError.new(arg)
+      when Class  then arg.new(args.shift)
+      when Exception then arg
+      else RuntimeError.new
+      end
     end
-    loop { supervise_perform(opts) }
-  ensure
-    @on_child_done = nil
   end
 
-  def supervise_perform(opts)
-    fiber = receive
-    restart_fiber(fiber, opts) if fiber
-  rescue Exceptions::Restart
-    restart_all_children
-  rescue Exception => e
-    Kernel.raise e if e.source_fiber.nil? || e.source_fiber == self
+  # Fiber supervision
+  module FiberSupervision
+    def supervise(opts = {})
+      @counter = 0
+      @on_child_done = proc do |fiber, result|
+        self << fiber unless result.is_a?(Exception)
+      end
+      loop { supervise_perform(opts) }
+    ensure
+      @on_child_done = nil
+    end
 
-    restart_fiber(e.source_fiber, opts)
-  end
+    def supervise_perform(opts)
+      fiber = receive
+      restart_fiber(fiber, opts) if fiber
+    rescue Polyphony::Restart
+      restart_all_children
+    rescue Exception => e
+      Kernel.raise e if e.source_fiber.nil? || e.source_fiber == self
 
-  def restart_fiber(fiber, opts)
-    opts[:watcher]&.send [:restart, fiber]
-    case opts[:restart]
-    when true
-      fiber.restart
-    when :one_for_all
-      @children.keys.each(&:restart)
+      restart_fiber(e.source_fiber, opts)
     end
-  end
-end
 
-# 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)
+    def restart_fiber(fiber, opts)
+      opts[:watcher]&.send [:restart, fiber]
+      case opts[:restart]
+      when true
+        fiber.restart
+      when :one_for_all
+        @children.keys.each(&:restart)
+      end
+    end
   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
+  # Class methods for controlling fibers (namely await and select)
+  module FiberControlClassMethods
+    def await(*fibers)
+      return [] if fibers.empty?
 
-  def await_setup_monitoring(fibers, state)
-    fibers.each do |f|
-      f.when_done { |r| await_fiber_done(f, r, state) }
+      state = setup_await_select_state(fibers)
+      await_setup_monitoring(fibers, state)
+      suspend
+      fibers.map(&:result)
+    ensure
+      await_select_cleanup(state)
     end
-  end
+    alias_method :join, :await
 
-  def await_fiber_done(fiber, result, state)
-    state[:pending].delete(fiber)
+    def setup_await_select_state(fibers)
+      {
+        awaiter: Fiber.current,
+        pending: fibers.each_with_object({}) { |f, h| h[f] = true }
+      }
+    end
 
-    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
+    def await_setup_monitoring(fibers, state)
+      fibers.each do |f|
+        f.when_done { |r| await_fiber_done(f, r, state) }
+      end
     end
-  end
 
-  def await_select_cleanup(state)
-    return if state[:pending].empty?
+    def await_fiber_done(fiber, result, state)
+      state[:pending].delete(fiber)
 
-    terminate = Exceptions::Terminate.new
-    state[:cleanup] = true
-    state[:pending].each_key { |f| f.schedule(terminate) }
-    suspend
-  end
+      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 select(*fibers)
-    state = setup_await_select_state(fibers)
-    select_setup_monitoring(fibers, state)
-    suspend
-  ensure
-    await_select_cleanup(state)
-  end
+    def await_select_cleanup(state)
+      return if state[:pending].empty?
 
-  def select_setup_monitoring(fibers, state)
-    fibers.each do |f|
-      f.when_done { |r| select_fiber_done(f, r, state) }
+      terminate = Polyphony::Terminate.new
+      state[:cleanup] = true
+      state[:pending].each_key { |f| f.schedule(terminate) }
+      suspend
     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
+    def select(*fibers)
+      state = setup_await_select_state(fibers)
+      select_setup_monitoring(fibers, state)
+      suspend
+    ensure
+      await_select_cleanup(state)
     end
-  end
-end
 
-# Messaging functionality
-module FiberMessaging
-  def <<(value)
-    @mailbox << value
-  end
-  alias_method :send, :<<
+    def select_setup_monitoring(fibers, state)
+      fibers.each do |f|
+        f.when_done { |r| select_fiber_done(f, r, state) }
+      end
+    end
 
-  def receive
-    @mailbox.shift
+    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
 
-  def receive_pending
-    @mailbox.shift_each
-  end
-end
+  # Messaging functionality
+  module FiberMessaging
+    def <<(value)
+      @mailbox << value
+    end
+    alias_method :send, :<<
 
-# Methods for controlling child fibers
-module ChildFiberControl
-  def children
-    (@children ||= {}).keys
-  end
+    def receive
+      @mailbox.shift
+    end
 
-  def spin(tag = nil, orig_caller = Kernel.caller, &block)
-    f = Fiber.new { |v| f.run(v) }
-    f.prepare(tag, block, orig_caller, self)
-    (@children ||= {})[f] = true
-    f
+    def receive_pending
+      @mailbox.shift_each
+    end
   end
 
-  def child_done(child_fiber, result)
-    @children.delete(child_fiber)
-    @on_child_done&.(child_fiber, result)
-  end
+  # Methods for controlling child fibers
+  module ChildFiberControl
+    def children
+      (@children ||= {}).keys
+    end
 
-  def terminate_all_children
-    return unless @children
+    def spin(tag = nil, orig_caller = Kernel.caller, &block)
+      f = Fiber.new { |v| f.run(v) }
+      f.prepare(tag, block, orig_caller, self)
+      (@children ||= {})[f] = true
+      f
+    end
 
-    e = Exceptions::Terminate.new
-    @children.each_key { |c| c.raise e }
-  end
+    def child_done(child_fiber, result)
+      @children.delete(child_fiber)
+      @on_child_done&.(child_fiber, result)
+    end
 
-  def await_all_children
-    return unless @children && !@children.empty?
+    def terminate_all_children
+      return unless @children
 
-    Fiber.await(*@children.keys)
-  end
+      e = Polyphony::Terminate.new
+      @children.each_key { |c| c.raise e }
+    end
 
-  def shutdown_all_children
-    terminate_all_children
-    await_all_children
-  end
-end
+    def await_all_children
+      return unless @children && !@children.empty?
 
-# Fiber life cycle methods
-module FiberLifeCycle
-  def prepare(tag, block, caller, parent)
-    @thread = Thread.current
-    @tag = tag
-    @parent = parent
-    @caller = caller
-    @block = block
-    @mailbox = Gyro::Queue.new
-    __fiber_trace__(:fiber_create, self)
-    schedule
-  end
+      Fiber.await(*@children.keys)
+    end
 
-  def run(first_value)
-    setup first_value
-    result = @block.(first_value)
-    finalize result
-  rescue Exceptions::Restart => e
-    restart_self(e.value)
-  rescue Exceptions::MoveOn, Exceptions::Terminate => e
-    finalize e.value
-  rescue Exception => e
-    e.source_fiber = self
-    finalize e, true
+    def shutdown_all_children
+      terminate_all_children
+      await_all_children
+    end
   end
 
-  def setup(first_value)
-    Kernel.raise first_value if first_value.is_a?(Exception)
+  # Fiber life cycle methods
+  module FiberLifeCycle
+    def prepare(tag, block, caller, parent)
+      @thread = Thread.current
+      @tag = tag
+      @parent = parent
+      @caller = caller
+      @block = block
+      @mailbox = Polyphony::Queue.new
+      __fiber_trace__(:fiber_create, self)
+      schedule
+    end
 
-    @running = true
-  end
+    def run(first_value)
+      setup first_value
+      result = @block.(first_value)
+      finalize result
+    rescue Polyphony::Restart => e
+      restart_self(e.value)
+    rescue Polyphony::MoveOn, Polyphony::Terminate => e
+      finalize e.value
+    rescue Exception => e
+      e.source_fiber = self
+      finalize e, true
+    end
 
-  # Performs setup for a "raw" Fiber created using Fiber.new. Note that this
-  # fiber is an orphan fiber (has no parent), since we cannot control how the
-  # fiber terminates after it has already been created. Calling #setup_raw
-  # allows the fiber to be scheduled and to receive messages.
-  def setup_raw
-    @thread = Thread.current
-    @mailbox = Gyro::Queue.new
-  end
+    def setup(first_value)
+      Kernel.raise first_value if first_value.is_a?(Exception)
 
-  def setup_main_fiber
-    @main = true
-    @tag = :main
-    @thread = Thread.current
-    @running = true
-    @children&.clear
-    @mailbox = Gyro::Queue.new
-  end
+      @running = true
+    end
 
-  def restart_self(first_value)
-    @mailbox = Gyro::Queue.new
-    @when_done_procs = nil
-    @waiting_fibers = nil
-    run(first_value)
-  end
+    # Performs setup for a "raw" Fiber created using Fiber.new. Note that this
+    # fiber is an orphan fiber (has no parent), since we cannot control how the
+    # fiber terminates after it has already been created. Calling #setup_raw
+    # allows the fiber to be scheduled and to receive messages.
+    def setup_raw
+      @thread = Thread.current
+      @mailbox = Polyphony::Queue.new
+    end
 
-  def finalize(result, uncaught_exception = false)
-    result, uncaught_exception = finalize_children(result, uncaught_exception)
-    __fiber_trace__(:fiber_terminate, self, result)
-    @result = result
-    @running = false
-    inform_dependants(result, uncaught_exception)
-  ensure
-    Thread.current.switch_fiber
-  end
+    def setup_main_fiber
+      @main = true
+      @tag = :main
+      @thread = Thread.current
+      @running = true
+      @children&.clear
+      @mailbox = Polyphony::Queue.new
+    end
 
-  # Shuts down all children of the current fiber. If any exception occurs while
-  # the children are shut down, it is returned along with the uncaught_exception
-  # flag set. Otherwise, it returns the given arguments.
-  def finalize_children(result, uncaught_exception)
-    begin
-      shutdown_all_children
-    rescue Exception => e
-      result = e
-      uncaught_exception = true
+    def restart_self(first_value)
+      @mailbox = Polyphony::Queue.new
+      @when_done_procs = nil
+      @waiting_fibers = nil
+      run(first_value)
     end
-    [result, uncaught_exception]
-  end
 
-  def inform_dependants(result, uncaught_exception)
-    @parent&.child_done(self, result)
-    @when_done_procs&.each { |p| p.(result) }
-    @waiting_fibers&.each_key do |f|
-      f.schedule(result)
+    def finalize(result, uncaught_exception = false)
+      result, uncaught_exception = finalize_children(result, uncaught_exception)
+      __fiber_trace__(:fiber_terminate, self, result)
+      @result = result
+      @running = false
+      inform_dependants(result, uncaught_exception)
+    ensure
+      Thread.current.switch_fiber
     end
-    return unless uncaught_exception && !@waiting_fibers
 
-    # propagate unaught exception to parent
-    @parent&.schedule(result)
-  end
+    # Shuts down all children of the current fiber. If any exception occurs while
+    # the children are shut down, it is returned along with the uncaught_exception
+    # flag set. Otherwise, it returns the given arguments.
+    def finalize_children(result, uncaught_exception)
+      begin
+        shutdown_all_children
+      rescue Exception => e
+        result = e
+        uncaught_exception = true
+      end
+      [result, uncaught_exception]
+    end
 
-  def when_done(&block)
-    @when_done_procs ||= []
-    @when_done_procs << block
+    def inform_dependants(result, uncaught_exception)
+      @parent&.child_done(self, result)
+      @when_done_procs&.each { |p| p.(result) }
+      @waiting_fibers&.each_key do |f|
+        f.schedule(result)
+      end
+      return unless uncaught_exception && !@waiting_fibers
+
+      # propagate unaught exception to parent
+      @parent&.schedule(result)
+    end
+
+    def when_done(&block)
+      @when_done_procs ||= []
+      @when_done_procs << block
+    end
   end
 end
 
 # Fiber extensions
 class ::Fiber
-  prepend FiberControl
-  include FiberSupervision
-  include FiberMessaging
-  include ChildFiberControl
-  include FiberLifeCycle
+  prepend Polyphony::FiberControl
+  include Polyphony::FiberSupervision
+  include Polyphony::FiberMessaging
+  include Polyphony::ChildFiberControl
+  include Polyphony::FiberLifeCycle
 
-  extend FiberControlClassMethods
+  extend Polyphony::FiberControlClassMethods
 
   attr_accessor :tag, :thread, :parent
   attr_reader :result
@@ -377,6 +379,6 @@ orig_pid = Process.pid
 at_exit do
   next unless orig_pid == Process.pid
 
-  Fiber.current.terminate_all_children
-  Fiber.current.await_all_children
+  Polyphony.terminate_threads
+  Fiber.current.shutdown_all_children
 end