polyphony 0.13

data/lib/polyphony/core/supervisor.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+export_default :Supervisor
+
+Coroutine   = import('./coroutine')
+Exceptions  = import('./exceptions')
+
+class Supervisor
+  def initialize
+    @coroutines = []
+  end
+
+  def await(&block)
+    @supervisor_fiber = Fiber.current
+    block&.(self)
+    suspend
+  rescue Exceptions::MoveOn => e
+    e.value
+  ensure
+    if still_running?
+      stop_all_tasks
+      suspend
+    else
+      @supervisor_fiber = nil
+    end
+  end
+
+  def spawn(proc = nil, &block)
+    if proc.is_a?(Coroutine)
+      spawn_coroutine(proc)
+    else
+      spawn_proc(block || proc)
+    end
+  end
+
+  def spawn_coroutine(proc)
+    @coroutines << proc
+    proc.when_done { task_completed(proc) }
+    proc.run unless proc.running?
+    proc
+  end
+
+  def spawn_proc(proc)
+    @coroutines << Object.spawn do |coroutine|
+      proc.call(coroutine)
+      task_completed(coroutine)
+    rescue Exception => e
+      task_completed(coroutine)
+    end
+  end
+
+  def still_running?
+    !@coroutines.empty?
+  end
+
+  def stop!(result = nil)
+    return unless @supervisor_fiber
+  
+    @supervisor_fiber&.transfer Exceptions::MoveOn.new(nil, result)
+  end
+
+  def stop_all_tasks
+    exception = Exceptions::Stop.new
+    @coroutines.each do |c|
+      EV.next_tick { c.interrupt(exception) }
+    end
+  end
+
+  def task_completed(coroutine)
+    return unless @coroutines.include?(coroutine)
+    
+    @coroutines.delete(coroutine)
+    @supervisor_fiber&.transfer if @coroutines.empty?
+  end
+end

data/lib/polyphony/core/sync.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+export :Mutex
+
+# Implements mutex lock for synchronizing async operations
+class Mutex
+  def initialize
+    @waiting = []
+  end
+
+  def synchronize
+    fiber = Fiber.current
+    @waiting << fiber
+    suspend if @waiting.size > 1
+    yield
+  ensure
+    @waiting.delete(fiber)
+    EV.next_tick { @waiting[0]&.transfer } unless @waiting.empty?
+  end
+end

data/lib/polyphony/core/thread.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+export :spawn
+
+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:  EV::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::CoroutineInterrupt => e
+  ctx[:fiber] = nil
+  ctx[:thread]&.raise(e)
+  raise e
+ensure
+  ctx[:watcher]&.stop
+end
+
+def complete_thread_task(ctx)
+  ctx[:fiber]&.transfer ctx[:value]
+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!
+rescue Exception => e
+  ctx[:value] = e
+  ctx[:watcher].signal! if ctx[:fiber]
+  raise e
+end

data/lib/polyphony/core/thread_pool.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+export :process, :setup, :size=, :busy?
+
+@size = 10
+
+def process(&block)
+  setup unless @task_queue
+
+  start_task_on_thread(block)
+end
+
+def start_task_on_thread(block)
+  EV.ref
+  @task_queue << [block, Fiber.current]
+  suspend
+ensure
+  EV.unref
+end
+
+def size=(size)
+  @size = size
+end
+
+def busy?
+  !@queue.empty?
+end
+
+def setup
+  @task_queue = ::Queue.new
+  @resolve_queue = ::Queue.new
+
+  @async_watcher = EV::Async.new { resolve_from_queue }
+  EV.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
+  result = block.()
+  @resolve_queue << [fiber, result]
+  @async_watcher.signal!
+rescue Exception => e
+  @resolve_queue << [fiber, e]
+  @async_watcher.signal!
+end

data/lib/polyphony/core/throttler.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+export_default :Throttler
+
+class Throttler
+  def initialize(rate)
+    @rate = rate_from_argument(rate)
+    @min_dt = 1.0 / @rate
+    @last_iteration_clock = clock - @min_dt
+  end
+
+  def clock
+    ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
+  end
+
+  def call(&block)
+    now = clock
+    dt = now - @last_iteration_clock
+    if dt < @min_dt
+      sleep(@min_dt - dt)
+    end
+    @last_iteration_clock = dt > @min_dt ? now : @last_iteration_clock + @min_dt
+    block.call(self)
+  end
+
+  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]
+    end
+    raise "Invalid rate argument #{arg.inspect}"
+  end
+end

data/lib/polyphony/extensions/io.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+class ::IO
+  def read_watcher
+    @read_watcher ||= EV::IO.new(self, :r)
+  end
+
+  def write_watcher
+    @write_watcher ||= EV::IO.new(self, :w)
+  end
+
+  def stop_watchers
+    @read_watcher&.stop
+    @write_watcher&.stop
+  end
+
+  NO_EXCEPTION = { exception: false }.freeze
+
+  def read(max = 8192, outbuf = nil)
+    outbuf ||= (@read_buffer ||= +'')
+    loop do
+      result = read_nonblock(max, outbuf, NO_EXCEPTION)
+      case result
+      when nil            then raise IOError
+      when :wait_readable then read_watcher.await
+      else                return result
+      end
+    end
+  ensure
+    @read_watcher&.stop
+  end
+
+  def write(data)
+    loop do
+      result = write_nonblock(data, NO_EXCEPTION)
+      case result
+      when nil            then raise IOError
+      when :wait_writable then write_watcher.await
+      else
+        (result == data.bytesize) ? (return result) : (data = data[result..-1])
+      end
+    end
+  ensure
+    @write_watcher&.stop
+  end
+
+  def write_list(*list)
+    list.each do |data|
+      loop do
+        result = write_nonblock(data, NO_EXCEPTION)
+        case result
+        when nil            then raise IOError
+        when :wait_writable then write_watcher.await
+        else
+          (result == data.bytesize) ? (break result) : (data = data[result..-1])
+        end
+      end
+    end
+  ensure
+    @write_watcher&.stop
+  end
+end

data/lib/polyphony/extensions/kernel.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+CancelScope = import('../core/cancel_scope')
+Coroutine   = import('../core/coroutine')
+Exceptions  = import('../core/exceptions')
+Supervisor  = import('../core/supervisor')
+Throttler   = import('../core/throttler')
+
+# Fiber extensions
+class ::Fiber
+  attr_writer :cancelled
+  attr_accessor :next_job, :coroutine
+
+  def cancelled?
+    @cancelled
+  end
+
+  def root?
+    @root
+  end
+
+  def schedule(value = nil)
+    EV.schedule_fiber(self, value)
+  end
+
+  def set_root!
+    @root = true
+  end
+
+  def self.root
+    @@root
+  end
+
+  @@root = Fiber.current
+  @@root.set_root!
+
+  # Associate a (pseudo-)coroutine with the main fiber
+  current.coroutine = Coroutine.new(Fiber.current)
+end
+
+class ::Exception
+  SANITIZE_RE = /lib\/polyphony/.freeze
+  SANITIZE_PROC = proc  { |l| l !~ SANITIZE_RE }
+
+  def cleanup_backtrace(caller = nil)
+    combined = caller ? backtrace + caller : backtrace
+    set_backtrace(combined.select(&SANITIZE_PROC))
+  end
+end
+
+# Kernel extensions (methods available to all objects)
+module ::Kernel
+  def after(duration, &block)
+    EV::Timer.new(freq, 0).start(&block)
+  end
+
+  def async(sym = nil, &block)
+    if sym
+      async_decorate(is_a?(Class) ? self : singleton_class, sym)
+    else
+      Coroutine.new(&block)
+    end
+  end
+
+  # Converts a regular method into an async method, i.e. a method that returns a
+  # proc that eventually executes the original code.
+  # @param receiver [Object] object receiving the method call
+  # @param sym [Symbol] method name
+  # @return [void]
+  def async_decorate(receiver, sym)
+    sync_sym = :"sync_#{sym}"
+    receiver.alias_method(sync_sym, sym)
+    receiver.define_method(sym) do |*args, &block|
+      Coroutine.new { send(sync_sym, *args, &block) }
+    end
+  end
+
+  def cancel_after(duration, &block)
+    CancelScope.new(timeout: duration, mode: :cancel).(&block)
+  end
+
+  def every(freq, &block)
+    EV::Timer.new(freq, freq).start(&block)
+  end
+
+  def move_on_after(duration, &block)
+    CancelScope.new(timeout: duration).(&block)
+  end
+
+  class Pulser
+    def initialize(freq)
+      fiber = Fiber.current
+      @timer = EV::Timer.new(freq, freq)
+      @timer.start { fiber.transfer freq }
+    end
+
+    def await
+      suspend
+    rescue Exception => e
+      @timer.stop
+      raise e
+    end
+
+    def stop
+      @timer.stop
+    end
+  end
+
+  def pulse(freq)
+    Pulser.new(freq)
+  end
+
+  def receive
+    Fiber.current.coroutine.receive
+  end
+
+  alias_method :sync_sleep, :sleep
+  def sleep(duration)
+    timer = EV::Timer.new(duration, 0)
+    timer.await
+  ensure
+    timer.stop
+  end
+
+  def spawn(proc = nil, &block)
+    if proc.is_a?(Coroutine)
+      proc.run
+    else
+      Coroutine.new(&(block || proc)).run
+    end
+  end
+
+  def supervise(&block)
+    Supervisor.new.await(&block)
+  end
+
+  # @@reactor_fiber = Fiber.root
+
+  # def suspend
+  #   result = @@reactor_fiber.transfer
+  #   result.is_a?(Exception) ? raise(result) : result
+  # end
+
+  def throttled_loop(rate, &block)
+    throttler = Throttler.new(rate)
+    loop do
+      throttler.(&block)
+    end
+  end
+
+  def throttle(rate)
+    Throttler.new(rate)
+  end
+
+  def timeout(duration, opts = {}, &block)
+    CancelScope.new(opts.merge(timeout: duration)).(&block)
+  end
+end
+