polyphony 0.13

data/ext/ev/extconf.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "rubygems"
+
+require "mkmf"
+
+have_header("unistd.h")
+
+$defs << "-DEV_USE_SELECT"       if have_header("sys/select.h")
+$defs << "-DEV_USE_POLL"         if have_type("port_event_t", "poll.h")
+$defs << "-DEV_USE_EPOLL"        if have_header("sys/epoll.h")
+$defs << "-DEV_USE_KQUEUE"       if have_header("sys/event.h") && have_header("sys/queue.h")
+$defs << "-DEV_USE_PORT"         if have_type("port_event_t", "port.h")
+$defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
+
+CONFIG["optflags"] << " -fno-strict-aliasing"
+
+dir_config "ev_ext"
+create_makefile "ev_ext"

data/lib/polyphony.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'modulation/gem'
+
+export_default :Polyphony
+
+Polyphony = import('./polyphony/core')
+Exceptions = import('./polyphony/core/exceptions')
+
+module Polyphony
+  Cancel        = Exceptions::Cancel
+  MoveOn        = Exceptions::MoveOn
+
+  auto_import(
+    Channel:      './polyphony/core/channel',
+    Coroutine:    './polyphony/core/coroutine',
+    Sync:         './polyphony/core/sync',
+    Thread:       './polyphony/core/thread',
+    ThreadPool:   './polyphony/core/thread_pool',
+  
+    FS:           './polyphony/fs',
+    Net:          './polyphony/net',
+    ResourcePool: './polyphony/resource_pool',
+    Supervisor:   './polyphony/supervisor'
+  )
+end

data/lib/polyphony/core.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+export_default :Core
+
+require 'fiber'
+require_relative '../ev_ext'
+
+import('./extensions/kernel')
+FiberPool = import('./core/fiber_pool')
+
+# Core module, containing async and reactor methods
+module Core
+  def self.trap(sig, ref = false, &callback)
+    sig = Signal.list[sig.to_s.upcase] if sig.is_a?(Symbol)
+    watcher = EV::Signal.new(sig, &callback)
+    EV.unref unless ref
+    watcher
+  end
+
+  def self.fork(&block)
+    EV.break
+    pid = Kernel.fork do
+      FiberPool.reset!
+      EV.post_fork
+      Fiber.current.coroutine = Coroutine.new(Fiber.current)
+
+      block.()
+
+      # We cannot simply depend on the at_exit block (see below) to yield to the
+      # reactor fiber. Doing that will raise a FiberError complaining: "fiber
+      # called across stack rewinding barrier". Apparently this is a bug in
+      # Ruby, so the workaround is to yield just before exiting.
+      suspend
+    end
+    EV.restart
+    pid
+  end
+end
+
+at_exit do
+  # in most cases, by the main fiber is done there are still pending or other
+  # or asynchronous operations going on. If the reactor loop is not done, we
+  # suspend the root fiber until it is done
+  suspend if $__reactor_fiber__.alive?
+end

data/lib/polyphony/core/async.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+export :async_decorate, :call_proc_with_optional_block
+
+Coroutine = import('./coroutine')
+FiberPool = import('./fiber_pool')
+
+# 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
+
+# Calls a proc with a block if both are given. Otherwise, call the first
+# non-nil proc. This allows syntax such as:
+#
+#     # in fact, the call to #nexus returns a proc which takes a block
+#     await nexus { ... }
+#
+# @param proc [Proc] proc A
+# @param block [Proc] proc B
+# @return [any] return value of proc invocation
+def call_proc_with_optional_block(proc, block)
+  if proc && block
+    proc.call(&block)
+  else
+    (proc || block).call
+  end
+end

data/lib/polyphony/core/cancel_scope.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+export_default :CancelScope
+
+require 'fiber'
+
+Exceptions = import('./exceptions')
+
+# A cancellation scope that can be used to cancel an asynchronous task
+class CancelScope
+  def initialize(opts = {})
+    @opts = opts
+    @error_class = @opts[:mode] == :cancel ? Exceptions::Cancel : Exceptions::MoveOn
+  end
+
+  def cancel!
+    @cancelled = true
+    @fiber.cancelled = true
+    @fiber.transfer @error_class.new(self, @opts[:value])
+  end
+
+  def start_timeout
+    @timeout = EV::Timer.new(@opts[:timeout], 0)
+    @timeout.start { cancel! }
+  end
+
+  def reset_timeout
+    @timeout.reset
+  end
+
+  def disable
+    @timeout&.stop
+  end
+
+  def call
+    start_timeout if @opts[:timeout]
+    @fiber = Fiber.current
+    @fiber.cancelled = nil
+    yield self
+  rescue Exceptions::MoveOn => e
+    e.scope == self ? e.value : raise(e)
+  ensure
+    @timeout&.stop
+    protect(&@when_cancelled) if @cancelled && @when_cancelled
+  end
+
+  def when_cancelled(&block)
+    @when_cancelled = block
+  end
+
+  def cancelled?
+    @cancelled
+  end
+
+  def protect(&block)
+    @fiber.cancelled = false
+    block.()
+  ensure
+    @fiber.cancelled = @cancelled
+  end
+end

data/lib/polyphony/core/channel.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+export_default :Channel
+
+Exceptions = import('./exceptions')
+
+class Channel
+  def initialize
+    @payload_queue = []
+    @waiting_queue = []
+  end
+
+  def close
+    stop = Exceptions::MoveOn.new
+    @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
+  end
+
+  def <<(o)
+    if @waiting_queue.empty?
+      @payload_queue << o
+    else
+      @waiting_queue.shift&.schedule(o)
+    end
+    EV.snooze
+  end
+
+  def receive
+    EV.ref
+    if @payload_queue.empty?
+      @waiting_queue << Fiber.current
+    else
+      payload = @payload_queue.shift
+      Fiber.current.schedule(payload)
+    end
+    suspend
+  ensure
+    EV.unref
+  end
+end

data/lib/polyphony/core/coroutine.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+export_default :Coroutine
+
+import('../extensions/kernel')
+
+FiberPool   = import('./fiber_pool')
+Exceptions  = import('./exceptions')
+
+# Encapsulates an asynchronous task
+class Coroutine
+  attr_reader :result, :fiber
+
+
+  def initialize(fiber = nil, &block)
+    @fiber = fiber
+    @block = block
+  end
+
+  def run(&block2)
+    @caller = caller if Exceptions.debug
+
+    @fiber = FiberPool.spawn do
+      @fiber.coroutine = self
+      @result = (@block || block2).call(self)
+    rescue Exceptions::MoveOn, Exceptions::Stop => e
+      @result = e.value
+    rescue Exception => e
+      e.cleanup_backtrace(@caller) if Exceptions.debug
+      @result = e
+    ensure
+      @fiber.coroutine = nil
+      @fiber = nil
+      @awaiting_fiber&.schedule @result
+      @when_done&.()
+
+      # if result is an error and nobody's waiting on us, we need to raise it
+      raise @result if @result.is_a?(Exception) && !@awaiting_fiber
+    end
+
+    @ran = true
+    @fiber.schedule
+    self
+  end
+
+  def <<(o)
+    @mailbox ||= []
+    @mailbox << o
+    @fiber&.schedule if @receive_waiting
+    EV.snooze
+  end
+
+  def receive
+    EV.ref
+    @receive_waiting = true
+    @fiber&.schedule if @mailbox && @mailbox.size > 0
+    suspend
+    @mailbox.shift
+  ensure
+    EV.unref
+    @receive_waiting = nil
+  end
+
+  def running?
+    @fiber
+  end
+
+  # Kernel.await expects the given argument / block to be a callable, so #call
+  # in fact waits for the coroutine to finish
+  def await
+    run unless @ran
+    if @fiber
+      @awaiting_fiber = Fiber.current
+      suspend
+    else
+      @result
+    end
+  ensure
+    # if awaiting was interrupted and the coroutine is still running, we need to stop it
+    if @fiber
+      @fiber&.schedule(Exceptions::MoveOn.new)
+      suspend
+    end
+  end
+
+  def when_done(&block)
+    @when_done = block
+  end
+
+  def resume(value = nil)
+    @fiber&.schedule(value)
+  end
+
+  def interrupt(value = Exceptions::MoveOn.new)
+    @fiber&.schedule(value)
+  end
+  alias_method :stop, :interrupt
+
+  def cancel!
+    interrupt(Exceptions::Cancel.new)
+  end
+
+  def self.current
+    Fiber.current.coroutine
+  end
+end

data/lib/polyphony/core/exceptions.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+export :CoroutineInterrupt, :MoveOn, :Stop, :Cancel, :debug, :debug=
+
+class CoroutineInterrupt < ::Exception
+  attr_reader :scope, :value
+
+  def initialize(scope = nil, value = nil)
+    @scope = scope
+    @value = value
+  end
+end
+
+class Stop < CoroutineInterrupt; end
+class MoveOn < CoroutineInterrupt; end
+class Cancel < CoroutineInterrupt; end
+
+def debug
+  @debug
+end
+
+def debug=(value)
+  @debug = value
+end

data/lib/polyphony/core/fiber_pool.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+export  :available,
+        :checked_out,
+        :reset!,
+        :size,
+        :spawn
+
+require 'fiber'
+
+# Array of available fibers
+@pool = []
+
+# Array of fibers in use
+@checked_out = {}
+
+# Fiber count
+@count = 0
+
+# Returns number of available fibers in pool
+# @return [Integer] available fibers count
+def available
+  @pool.size
+end
+
+def checked_out
+  @checked_out.size
+end
+
+# Returns size of fiber pool (including currently used fiber)
+# @return [Integer] fiber pool size
+def size
+  @count
+end
+
+def downsize
+  return if @count < 5
+  max_available = @count >= 5 ? @count / 5 : 2
+  if @pool.count > max_available
+    @pool.slice!(max_available, 50).each { |f| f.transfer :stop }
+  end
+end
+
+@downsize_timer = EV::Timer.new(5, 5)
+@downsize_timer.start { downsize }
+EV.unref
+
+# Invokes the given block using a fiber taken from the fiber pool. If the pool
+# is exhausted, a new fiber will be created.
+# @return [Fiber]
+def spawn(&block)
+  fiber = @pool.empty? ? new_fiber : @pool.shift
+  fiber.next_job = block
+  fiber
+end
+
+def reset!
+  @count = 0
+  @pool = []
+  @checked_out = {}
+end
+
+# Creates a new fiber to be added to the pool
+# @return [Fiber] new fiber
+def new_fiber
+  Fiber.new { fiber_loop }
+end
+
+# Runs a job-processing loop inside the current fiber
+# @return [void]
+def fiber_loop
+  fiber = Fiber.current
+  @count += 1
+  error = nil
+  loop do
+    job, fiber.next_job = fiber.next_job, nil
+    @checked_out[fiber] = true
+    fiber.cancelled = nil
+    
+    job&.(fiber)
+
+    @pool << fiber
+    @checked_out.delete(fiber)
+    break if suspend == :stop
+  end
+rescue => e
+  # uncaught error
+  error = e
+ensure
+  @pool.delete(self)
+  @checked_out.delete(fiber)
+  @count -= 1
+
+  # We need to explicitly transfer control to reactor fiber, otherwise it will
+  # be transferred to the main fiber, which would normally be blocking on 
+  # something
+  $__reactor_fiber__.transfer unless error
+end