polyphony 0.19 → 0.20

data/lib/polyphony/core/exceptions.rb

@@ -1,8 +1,14 @@
 # frozen_string_literal: true
 
-export :CoprocessInterrupt, :MoveOn, :Stop, :Cancel, :debug, :debug=
+export :Interrupt, :MoveOn, :Cancel
 
-class CoprocessInterrupt < ::Exception
+# Common exception class for interrupting coprocesses. These exceptions allow
+# control of coprocesses. Interrupt exceptions can encapsulate a value and thus
+# provide a way to interrupt long-running blocking operations while still
+# passing a value back to the call site. Interrupt exceptions can also
+# references a cancel scope in order to allow correct bubbling of exceptions
+# through nested cancel scopes.
+class Interrupt < ::Exception
   attr_reader :scope, :value
 
   def initialize(scope = nil, value = nil)
@@ -11,14 +17,10 @@ class CoprocessInterrupt < ::Exception
   end
 end
 
-class Stop < CoprocessInterrupt; end
-class MoveOn < CoprocessInterrupt; end
-class Cancel < CoprocessInterrupt; end
+# MoveOn is used to interrupt a long-running blocking operation, while
+# continuing the rest of the computation.
+class MoveOn < Interrupt; end
 
-def debug
-  @debug
-end
-
-def debug=(value)
-  @debug = value
-end
+# Cancel is used to interrupt a long-running blocking operation, bubbling the
+# exception up through cancel scopes and supervisors.
+class Cancel < Interrupt; end

data/lib/polyphony/core/resource_pool.rb

@@ -18,25 +18,34 @@ class ResourcePool
   end
 
   def acquire
-    resource = wait
+    resource = wait_for_resource
+    return unless resource
+
     yield resource
   ensure
-    @available << resource if resource
-    dequeue unless @waiting.empty?
+    dequeue(resource) || return_to_stock(resource) if resource
   end
 
-  def wait
+  def wait_for_resource
     fiber = Fiber.current
     @waiting << fiber
-    dequeue
+    ready_resource = from_stock
+    return ready_resource if ready_resource
+
     suspend
   ensure
     @waiting.delete(fiber)
   end
 
-  def dequeue
-    return unless (resource = from_stock)
-    EV.next_tick { @waiting[0]&.transfer(resource) }
+  def dequeue(resource)
+    return nil if @waiting.empty?
+
+    @waiting[0]&.schedule(resource)
+    true
+  end
+
+  def return_to_stock(resource)
+    @available << resource
   end
 
   def from_stock
@@ -47,6 +56,10 @@ class ResourcePool
     acquire { |r| r.send(sym, *args, &block) }
   end
 
+  def respond_to_missing?(*_args)
+    true
+  end
+
   # Allocates a resource
   # @return [any] allocated resource
   def allocate

data/lib/polyphony/core/supervisor.rb

@@ -5,6 +5,7 @@ export_default :Supervisor
 Coprocess   = import('./coprocess')
 Exceptions  = import('./exceptions')
 
+# Implements a supervision mechanism for controlling multiple coprocesses
 class Supervisor
   def initialize
     @coprocesses = []
@@ -17,6 +18,10 @@ class Supervisor
   rescue Exceptions::MoveOn => e
     e.value
   ensure
+    finalize_await
+  end
+
+  def finalize_await
     if still_running?
       stop_all_tasks
       suspend
@@ -29,7 +34,7 @@ class Supervisor
     proc = Coprocess.new(&(proc || block)) unless proc.is_a?(Coprocess)
     @coprocesses << proc
     proc.when_done { task_completed(proc) }
-    proc.run unless proc.running?
+    proc.run unless proc.alive?
     proc
   end
 
@@ -39,21 +44,21 @@ class Supervisor
 
   def stop!(result = nil)
     return unless @supervisor_fiber && !@stopped
-  
+
     @stopped = true
     @supervisor_fiber.transfer Exceptions::MoveOn.new(nil, result)
   end
 
   def stop_all_tasks
-    exception = Exceptions::Stop.new
+    exception = Exceptions::MoveOn.new
     @coprocesses.each do |c|
-      EV.next_tick { c.interrupt(exception) }
+      c.transfer(exception)
     end
   end
 
   def task_completed(coprocess)
     return unless @coprocesses.include?(coprocess)
-    
+
     @coprocesses.delete(coprocess)
     @supervisor_fiber&.transfer if @coprocesses.empty?
   end

data/lib/polyphony/core/sync.rb

@@ -2,19 +2,20 @@
 
 export :Mutex
 
-# Implements mutex lock for synchronizing async operations
+# Implements mutex lock for synchronizing access to a shared resource
 class Mutex
   def initialize
-    @waiting = []
+    @waiting_fibers = []
   end
 
   def synchronize
     fiber = Fiber.current
-    @waiting << fiber
-    suspend if @waiting.size > 1
+    @waiting_fibers << fiber
+    suspend if @waiting_fibers.size > 1
     yield
   ensure
-    @waiting.delete(fiber)
-    EV.next_tick { @waiting[0]&.transfer } unless @waiting.empty?
+    @waiting_fibers.delete(fiber)
+    @waiting_fibers.first&.schedule
+    snooze
   end
 end

data/lib/polyphony/core/thread.rb

@@ -11,9 +11,9 @@ Exceptions = import('./exceptions')
 def spawn(&block)
   async do
     ctx = {
-      fiber:    Fiber.current,
-      watcher:  EV::Async.new { complete_thread_task(ctx) },
-      thread:   Thread.new { run_in_thread(ctx, &block) }
+      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
@@ -23,7 +23,7 @@ end
 
 def wait_for_thread(ctx)
   suspend
-rescue Exceptions::CoprocessInterrupt => e
+rescue Exceptions::Interrupt => e
   ctx[:fiber] = nil
   ctx[:thread]&.raise(e)
   raise e

data/lib/polyphony/core/thread_pool.rb

@@ -11,11 +11,11 @@ def process(&block)
 end
 
 def start_task_on_thread(block)
-  EV.ref
+  Gyro.ref
   @task_queue << [block, Fiber.current]
   suspend
 ensure
-  EV.unref
+  Gyro.unref
 end
 
 def size=(size)
@@ -30,8 +30,8 @@ def setup
   @task_queue = ::Queue.new
   @resolve_queue = ::Queue.new
 
-  @async_watcher = EV::Async.new { resolve_from_queue }
-  EV.unref
+  @async_watcher = Gyro::Async.new { resolve_from_queue }
+  Gyro.unref
 
   @threads = (1..@size).map { Thread.new { thread_loop } }
 end

data/lib/polyphony/core/throttler.rb

@@ -2,6 +2,7 @@
 
 export_default :Throttler
 
+# Implements general-purpose throttling
 class Throttler
   def initialize(rate)
     @rate = rate_from_argument(rate)
@@ -16,9 +17,9 @@ class Throttler
   def call(&block)
     now = clock
     dt = now - @last_iteration_clock
-    if dt < @min_dt
-      sleep(@min_dt - dt)
-    end
+
+    sleep(@min_dt - dt) if dt < @min_dt
+
     @last_iteration_clock = dt > @min_dt ? now : @last_iteration_clock + @min_dt
     block.call(self)
   end
@@ -26,9 +27,10 @@ class Throttler
   alias_method :process, :call
 
   private
-  
+
   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]

data/lib/polyphony/extensions/core.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'fiber'
+require 'timeout'
+require 'open3'
+
+Coprocess   = import('../core/coprocess')
+Exceptions  = import('../core/exceptions')
+Supervisor  = import('../core/supervisor')
+Throttler   = import('../core/throttler')
+
+# Fiber extensions
+class ::Fiber
+  attr_accessor :__calling_fiber__
+  attr_writer :__caller__
+  attr_writer :cancelled
+  attr_accessor :coprocess, :scheduled_value
+
+  class << self
+    alias_method :orig_new, :new
+    def new(&block)
+      calling_fiber = Fiber.current
+      fiber_caller = caller
+      fiber = orig_new do |v|
+        block.call(v)
+      ensure
+        $__reactor_fiber__.safe_transfer if $__reactor_fiber__.alive?
+      end
+      fiber.__calling_fiber__ = calling_fiber
+      fiber.__caller__ = fiber_caller
+      fiber
+    end
+
+    def root
+      @root_fiber
+    end
+
+    def set_root_fiber
+      @root_fiber = current
+    end
+    end
+
+  def caller
+    @__caller__ ||= []
+    if @__calling_fiber__
+      @__caller__ + @__calling_fiber__.caller
+    else
+      @__caller__
+    end
+  end
+
+  def cancelled?
+    @cancelled
+  end
+
+  # Associate a (pseudo-)coprocess with the root fiber
+  current.coprocess = Coprocess.new(current)
+  set_root_fiber
+end
+
+# Exeption overrides
+class ::Exception
+  class << self
+    attr_accessor :__disable_sanitized_backtrace__
+  end
+
+  alias_method :orig_initialize, :initialize
+
+  def initialize(*args)
+    @__raising_fiber__ = Fiber.current
+    orig_initialize(*args)
+  end
+
+  alias_method_once :orig_backtrace, :backtrace
+  def backtrace
+    unless @first_backtrace_call
+      @first_backtrace_call = true
+      return orig_backtrace
+    end
+
+    if @__raising_fiber__
+      backtrace = orig_backtrace || []
+      sanitize(backtrace + @__raising_fiber__.caller)
+    else
+      sanitize(orig_backtrace)
+    end
+  end
+
+  POLYPHONY_DIR = File.expand_path(File.join(__dir__, '..'))
+
+  def sanitize(backtrace)
+    return backtrace if ::Exception.__disable_sanitized_backtrace__
+
+    backtrace.reject { |l| l[POLYPHONY_DIR] }
+  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)
+    spin do
+      Gyro::Child.new(pid).await
+    end.tap { |coproc| coproc.define_singleton_method(:pid) { pid } }
+  end
+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 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_backtick, :`
+  def `(cmd)
+    # $stdout.orig_puts '*' * 60
+    # $stdout.orig_puts caller.join("\n")
+    Open3.popen3(cmd) do |i, o, e, _t|
+      i.close
+      while (l = e.readpartial(8192))
+        $stderr << l
+      end
+      o.read
+    end
+  end
+
+  ARGV_GETS_LOOP = proc do |calling_fiber|
+    ARGV.each do |fn|
+      File.open(fn, 'r') do |f|
+        while (line = f.gets)
+          calling_fiber = calling_fiber.transfer(line)
+        end
+      end
+    end
+  rescue Exception => e
+    calling_fiber.transfer(e)
+  end
+
+  alias_method :orig_gets, :gets
+  def gets(*_args)
+    return $stdin.gets if ARGV.empty?
+
+    @gets_fiber ||= Fiber.new(&ARGV_GETS_LOOP)
+    return @gets_fiber.safe_transfer(Fiber.current) if @gets_fiber.alive?
+
+    nil
+  end
+
+  alias_method :orig_system, :system
+  def system(*args)
+    Open3.popen2(*args) do |i, o, _t|
+      i.close
+      while (l = o.readpartial(8192))
+        $stdout << l
+      end
+    end
+    true
+  rescue SystemCallError
+    nil
+  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
+    error = klass ? klass.new(message) : ::Timeout::Error.new
+    error.set_backtrace(e.backtrace)
+    raise error
+  end
+end