polyphony 0.22 → 0.23

data/lib/polyphony/core/coprocess.rb

@@ -41,14 +41,14 @@ class Coprocess
 
   include Messaging
 
-  @@list = {}
+  @@map = {}
 
-  def self.list
-    @@list
+  def self.map
+    @@map
   end
 
   def self.count
-    @@list.size
+    @@map.size
   end
 
   attr_reader :result, :fiber
@@ -58,19 +58,29 @@ class Coprocess
     @block = block
   end
 
+  def location
+    @block ? @block.source_location.join(':') : nil
+  end
+
+  def caller
+    @fiber ? @fiber.caller[2..-1] : nil
+  end
+
   def run
     @calling_fiber = Fiber.current
 
-    @fiber = Fiber.new { execute }
+    @fiber = Fiber.new(location) { |v| execute(v) }
     @fiber.schedule
     @ran = true
     self
   end
 
-  def execute
-    # uncaught_exception = nil
-    @@list[@fiber] = self
-    @fiber.coprocess = self
+  def execute(first_value)
+    # The first value passed to the coprocess can be used to stop it before it
+    # is scheduled for the first time
+    raise first_value if first_value.is_a?(Exception)
+
+    @@map[@fiber] = @fiber.coprocess = self
     @result = @block.call(self)
   rescue Exceptions::MoveOn => e
     @result = e.value
@@ -82,7 +92,7 @@ class Coprocess
   end
 
   def finish_execution(uncaught_exception)
-    @@list.delete(@fiber)
+    @@map.delete(@fiber)
     @fiber.coprocess = nil
     @fiber = nil
     @awaiting_fiber&.schedule @result
@@ -92,7 +102,8 @@ class Coprocess
 
     # if no awaiting fiber, raise any uncaught error by passing it to the
     # calling fiber, or to the root fiber if the calling fiber
-    calling_fiber = @calling_fiber || Fiber.root
+    calling_fiber_alive = @calling_fiber && @calling_fiber.state != :dead
+    calling_fiber = calling_fiber_alive ? @calling_fiber : Fiber.root
     calling_fiber.transfer @result
   end
 
@@ -100,14 +111,6 @@ class Coprocess
     @fiber
   end
 
-  def caller
-    @fiber && @fiber.__caller__[2..-1]
-  end
-
-  def location
-    caller[0]
-  end
-
   # Kernel.await expects the given argument / block to be a callable, so #call
   # in fact waits for the coprocess to finish
   def await
@@ -133,6 +136,10 @@ class Coprocess
     @when_done = block
   end
 
+  def schedule(value = nil)
+    @fiber&.schedule(value)
+  end
+
   def resume(value = nil)
     return unless @fiber
 
@@ -148,10 +155,6 @@ class Coprocess
   end
   alias_method :stop, :interrupt
 
-  def transfer(value = nil)
-    @fiber&.schedule(value)
-  end
-
   def cancel!
     return unless @fiber
 

data/lib/polyphony/core/global_api.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+export_default :API
+
+import '../extensions/core'
+
+Coprocess   = import '../core/coprocess'
+Exceptions  = import '../core/exceptions'
+Supervisor  = import '../core/supervisor'
+Throttler   = import '../core/throttler'
+
+# Global API methods to be included in ::Object
+module API
+  def after(interval, &block)
+    spin do
+      sleep interval
+      block.()
+    end
+  end
+
+  def cancel_after(interval, &block)
+    fiber = ::Fiber.current
+    canceller = spin do
+      sleep interval
+      fiber.schedule Exceptions::Cancel.new
+    end
+    block.call
+  ensure
+    canceller.stop
+  end
+
+  def defer(&block)
+    ::Fiber.new(&block).schedule
+  end
+
+  def spin(&block)
+    Coprocess.new(&block).run
+  end
+
+  def spin_loop(&block)
+    spin { loop(&block) }
+  end
+
+  def every(interval)
+    timer = Gyro::Timer.new(interval, interval)
+    loop do
+      timer.await
+      yield
+    end
+  end
+
+  def move_on_after(interval, with_value: nil, &block)
+    fiber = ::Fiber.current
+    canceller = spin do
+      sleep interval
+      fiber.schedule Exceptions::MoveOn.new(nil, with_value)
+    end
+    block.call
+  rescue Exceptions::MoveOn => e
+    e.value
+  ensure
+    canceller.stop
+  end
+
+  def receive
+    Fiber.current.coprocess.receive
+  end
+
+  def sleep(duration)
+    timer = Gyro::Timer.new(duration, 0)
+    timer.await
+  end
+
+  def supervise(&block)
+    Supervisor.new.await(&block)
+  end
+
+  def throttled_loop(rate, count: nil, &block)
+    throttler = Throttler.new(rate)
+    if count
+      count.times { throttler.(&block) }
+    else
+      loop { throttler.(&block) }
+    end
+  end
+end

data/lib/polyphony/core/resource_pool.rb

@@ -102,6 +102,6 @@ class ResourcePool
   end
 
   def preheat!
-    (@limit - @size).times { @stock << from_stock }
+    (@limit - @size).times { @stock << allocate }
   end
 end

data/lib/polyphony/core/supervisor.rb

@@ -9,10 +9,11 @@ Exceptions  = import('./exceptions')
 class Supervisor
   def initialize
     @coprocesses = []
-    @pending = []
+    @pending = {}
   end
 
   def await(&block)
+    @mode = :await
     @supervisor_fiber = Fiber.current
     block&.(self)
     suspend
@@ -22,6 +23,20 @@ class Supervisor
   ensure
     finalize_await
   end
+  alias_method :join, :await
+
+  def select(&block)
+    @mode = :select
+    @select_coproc = nil
+    @supervisor_fiber = Fiber.current
+    block&.(self)
+    suspend
+    [@select_coproc.result, @select_coproc]
+  rescue Exceptions::MoveOn => e
+    e.value
+  ensure
+    finalize_select
+  end
 
   def finalize_await
     if still_running?
@@ -32,10 +47,15 @@ class Supervisor
     end
   end
 
+  def finalize_select
+    stop_all_tasks if still_running?
+    @supervisor_fiber = nil
+  end
+
   def spin(coproc = nil, &block)
     coproc = Coprocess.new(&(coproc || block)) unless coproc.is_a?(Coprocess)
     @coprocesses << coproc
-    @pending << coproc
+    @pending[coproc] = true
     coproc.when_done { task_completed(coproc) }
     coproc.run unless coproc.alive?
     coproc
@@ -43,43 +63,57 @@ class Supervisor
 
   def add(coproc)
     @coprocesses << coproc
-    @pending << coproc
+    @pending[coproc] = true
     coproc.when_done { task_completed(coproc) }
     coproc.run unless coproc.alive?
     coproc
   end
+  alias_method :<<, :add
 
   def still_running?
-    !@coprocesses.empty?
+    !@pending.empty?
   end
 
-  def stop!(result = nil)
+  def interrupt(result = nil)
     return unless @supervisor_fiber && !@stopped
 
     @stopped = true
-    @supervisor_fiber.transfer Exceptions::MoveOn.new(nil, result)
+    @supervisor_fiber.schedule Exceptions::MoveOn.new(nil, result)
   end
+  alias_method :stop, :interrupt
 
   def stop_all_tasks
     exception = Exceptions::MoveOn.new
-    @pending.each do |c|
-      c.transfer(exception)
+    @pending.each_key do |c|
+      c.schedule(exception)
     end
   end
 
   def task_completed(coprocess)
-    return unless @pending.include?(coprocess)
+    return unless @pending[coprocess]
 
     @pending.delete(coprocess)
-    @supervisor_fiber&.transfer if @pending.empty?
+    return unless @pending.empty? || (@mode == :select && !@select_coproc)
+
+    @select_coproc = coprocess if @mode == :select
+    @supervisor_fiber&.schedule
   end
 end
 
 # Extension for Coprocess class
 class Coprocess
-  def self.await(*coprocs)
-    supervise do |s|
-      coprocs.each { |cp| s.add cp }
+  class << self
+    def await(*coprocs)
+      supervisor = Supervisor.new
+      coprocs.each { |cp| supervisor << cp }
+      supervisor.await
+    end
+    alias_method :join, :await
+
+    def select(*coprocs)
+      supervisor = Supervisor.new
+      coprocs.each { |cp| supervisor << cp }
+      supervisor.select
     end
   end
 end

data/lib/polyphony/core/thread.rb

@@ -1,49 +1,23 @@
 # frozen_string_literal: true
 
-export :spawn
+export :process
 
 Exceptions = import('./exceptions')
 
-# Runs the given block in a separate thread, returning a promise fulfilled
-# once the thread is done. The signalling for the thread is done using an
-# I/O pipe.
-# @return [Proc]
-def spawn(&block)
-  async do
-    ctx = {
-      fiber:   Fiber.current,
-      watcher: Gyro::Async.new { complete_thread_task(ctx) },
-      thread:  Thread.new { run_in_thread(ctx, &block) }
-    }
-    ctx[:thread].report_on_exception = false
-    ctx[:thread].abort_on_exception = false
-    wait_for_thread(ctx)
-  end
-end
-
-def wait_for_thread(ctx)
-  suspend
-rescue Exceptions::Interrupt => e
-  ctx[:fiber] = nil
-  ctx[:thread]&.raise(e)
-  raise e
+def process(&block)
+  watcher = Gyro::Async.new
+  thread = Thread.new { run_in_thread(watcher, &block) }
+  watcher.await
 ensure
-  ctx[:watcher]&.stop
-end
-
-def complete_thread_task(ctx)
-  ctx[:fiber]&.transfer ctx[:value]
+  thread.kill if thread.alive?
 end
 
 # Runs the given block, passing the result or exception to the given context
 # @param ctx [Hash] context
 # @return [void]
-def run_in_thread(ctx)
-  ctx[:value] = yield
-  ctx[:thread] = nil
-  ctx[:watcher].signal!
+def run_in_thread(watcher)
+  result = yield
+  watcher.signal!(result)
 rescue Exception => e
-  ctx[:value] = e
-  ctx[:watcher].signal! if ctx[:fiber]
-  raise e
+  watcher.signal!(e)
 end

data/lib/polyphony/core/thread_pool.rb

@@ -7,15 +7,9 @@ export :process, :setup, :size=, :busy?
 def process(&block)
   setup unless @task_queue
 
-  start_task_on_thread(block)
-end
-
-def start_task_on_thread(block)
-  Gyro.ref
-  @task_queue << [block, Fiber.current]
-  suspend
-ensure
-  Gyro.unref
+  watcher = Gyro::Async.new
+  @task_queue << [block, watcher]
+  watcher.await
 end
 
 def size=(size)
@@ -28,31 +22,17 @@ end
 
 def setup
   @task_queue = ::Queue.new
-  @resolve_queue = ::Queue.new
-
-  @async_watcher = Gyro::Async.new { resolve_from_queue }
-  Gyro.unref
-
   @threads = (1..@size).map { Thread.new { thread_loop } }
 end
 
-def resolve_from_queue
-  until @resolve_queue.empty?
-    (fiber, result) = @resolve_queue.pop(true)
-    fiber.transfer result unless fiber.cancelled?
-  end
-end
-
 def thread_loop
   loop { run_queued_task }
 end
 
 def run_queued_task
-  (block, fiber) = @task_queue.pop
+  (block, watcher) = @task_queue.pop
   result = block.()
-  @resolve_queue << [fiber, result]
-  @async_watcher.signal!
+  watcher.signal!(result)
 rescue Exception => e
-  @resolve_queue << [fiber, e]
-  @async_watcher.signal!
+  watcher.signal!(e)
 end

data/lib/polyphony/extensions/core.rb

@@ -13,26 +13,43 @@ Throttler   = import('../core/throttler')
 class ::Fiber
   attr_accessor :__calling_fiber__
   attr_accessor :__caller__
+  attr_accessor :__location__
   attr_writer :cancelled
   attr_accessor :coprocess
 
+  def location
+    __location__ || (__caller__ && __caller__[0])
+  end
+
+  def inspect
+    "#<Fiber:#{object_id} #{location} (#{state})"
+  end
+  alias_method :to_s, :inspect
+
+  def set_calling_context(location, calling_fiber, fiber_caller)
+    @__location__ = location
+    @__calling_fiber__ = calling_fiber
+    @__caller__ = fiber_caller
+    self
+  end
+
   class << self
     alias_method :orig_new, :new
-    def new(&block)
-      calling_fiber = Fiber.current
-      fiber_caller = caller
+    def new(location = nil, &block)
+      fiber = create_fiber_with_block(&block)
+      fiber.set_calling_context(location, Fiber.current, caller)
+      fiber
+    end
+
+    def create_fiber_with_block(&block)
       fiber = orig_new do |v|
         block.call(v)
       rescue Exception => e
-        puts "Uncaught exception #{calling_fiber.alive?}"
-        calling_fiber.transfer e if calling_fiber.alive?
+        __calling_fiber__.transfer e if __calling_fiber__.alive?
       ensure
         fiber.mark_as_done!
-        suspend
+        Gyro.run
       end
-      fiber.__calling_fiber__ = calling_fiber
-      fiber.__caller__ = fiber_caller
-      fiber
     end
 
     def root
@@ -41,6 +58,9 @@ class ::Fiber
 
     def set_root_fiber
       @root_fiber = current
+    
+      # Associate a (pseudo-)coprocess with the root fiber
+      Coprocess.map[current] = current.coprocess = Coprocess.new(current)
     end
   end
 
@@ -57,8 +77,6 @@ class ::Fiber
     @cancelled
   end
 
-  # Associate a (pseudo-)coprocess with the root fiber
-  current.coprocess = Coprocess.new(current)
   set_root_fiber
 end
 
@@ -99,21 +117,6 @@ class ::Exception
   end
 end
 
-# Pulser abstraction for recurring operations
-class Pulser
-  def initialize(freq)
-    @timer = Gyro::Timer.new(freq, freq)
-  end
-
-  def await
-    @timer.await
-  end
-
-  def stop
-    @timer.stop
-  end
-end
-
 # Overrides for Process
 module ::Process
   def self.detach(pid)
@@ -125,80 +128,7 @@ end
 
 # Kernel extensions (methods available to all objects / call sites)
 module ::Kernel
-  def after(interval, &block)
-    Gyro::Timer.new(interval, 0).start(&block)
-  end
-
-  def cancel_after(interval, &block)
-    timer = Gyro::Timer.new(interval, 0)
-    fiber = Fiber.current
-    timer.start { fiber.schedule Exceptions::Cancel.new }
-    block.call
-  ensure
-    timer.stop
-  end
-
-  def defer(&block)
-    Fiber.new(&block).schedule
-  end
-
-  def spin(&block)
-    Coprocess.new(&block).run
-  end
-
-  def spin_loop(&block)
-    spin { loop(&block) }
-  end
-
-  def every(freq, &block)
-    Gyro::Timer.new(freq, freq).start(&block)
-  end
-
-  def move_on_after(interval, with_value: nil, &block)
-    timer = Gyro::Timer.new(interval, 0)
-    fiber = Fiber.current
-    timer.start { fiber.schedule Exceptions::MoveOn.new(nil, with_value) }
-    block.call
-  rescue Exceptions::MoveOn => e
-    e.value
-  ensure
-    timer.stop
-  end
-
-  def pulse(freq)
-    Pulser.new(freq)
-  end
-
-  def receive
-    Fiber.current.coprocess.receive
-  end
-
-  alias_method :sync_sleep, :sleep
-  def sleep(duration)
-    timer = Gyro::Timer.new(duration, 0)
-    timer.await
-  ensure
-    timer.stop
-  end
-
-  def supervise(&block)
-    Supervisor.new.await(&block)
-  end
-
-  def throttled_loop(rate, count: nil, &block)
-    throttler = Throttler.new(rate)
-    if count
-      count.times { throttler.(&block) }
-    else
-      loop { throttler.(&block) }
-    end
-  end
-
-  def throttle(rate)
-    Throttler.new(rate)
-  end
-
-  # patches
+  alias_method :orig_sleep, :sleep
 
   alias_method :orig_backtick, :`
   def `(cmd)