polyphony 0.19 → 0.20

data/ext/libev/ev_poll.c

@@ -1,7 +1,7 @@
 /*
  * libev poll fd activity backend
  *
- * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2016,2019 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -41,10 +41,12 @@
 
 inline_size
 void
-pollidx_init (int *base, int count)
+array_needsize_pollidx (int *base, int offset, int count)
 {
-  /* consider using memset (.., -1, ...), which is practically guaranteed
-   * to work on all systems implementing poll */
+  /* using memset (.., -1, ...) is tempting, we we try
+   * to be ultraportable
+   */
+  base += offset;
   while (count--)
     *base++ = -1;
 }
@@ -57,14 +59,14 @@ poll_modify (EV_P_ int fd, int oev, int nev)
   if (oev == nev)
     return;
 
-  array_needsize (int, pollidxs, pollidxmax, fd + 1, pollidx_init);
+  array_needsize (int, pollidxs, pollidxmax, fd + 1, array_needsize_pollidx);
 
   idx = pollidxs [fd];
 
   if (idx < 0) /* need to allocate a new pollfd */
     {
       pollidxs [fd] = idx = pollcnt++;
-      array_needsize (struct pollfd, polls, pollmax, pollcnt, EMPTY2);
+      array_needsize (struct pollfd, polls, pollmax, pollcnt, array_needsize_noinit);
       polls [idx].fd = fd;
     }
 
@@ -108,14 +110,17 @@ poll_poll (EV_P_ ev_tstamp timeout)
   else
     for (p = polls; res; ++p)
       {
-        assert (("libev: poll() returned illegal result, broken BSD kernel?", p < polls + pollcnt));
+        assert (("libev: poll returned illegal result, broken BSD kernel?", p < polls + pollcnt));
 
         if (expect_false (p->revents)) /* this expect is debatable */
           {
             --res;
 
             if (expect_false (p->revents & POLLNVAL))
-              fd_kill (EV_A_ p->fd);
+              {
+                assert (("libev: poll found invalid fd in poll set", 0));
+                fd_kill (EV_A_ p->fd);
+              }
             else
               fd_event (
                 EV_A_

data/ext/libev/ev_port.c

@@ -1,7 +1,7 @@
 /*
  * libev solaris event port backend
  *
- * Copyright (c) 2007,2008,2009,2010,2011 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2019 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -69,7 +69,10 @@ port_associate_and_check (EV_P_ int fd, int ev)
   )
     {
       if (errno == EBADFD)
-        fd_kill (EV_A_ fd);
+        {
+          assert (("libev: port_associate found invalid fd", errno != EBADFD));
+          fd_kill (EV_A_ fd);
+        }
       else
         ev_syserr ("(libev) port_associate");
     }

data/ext/libev/ev_vars.h

@@ -1,7 +1,7 @@
 /*
  * loop member variable declarations
  *
- * Copyright (c) 2007,2008,2009,2010,2011,2012,2013 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008,2009,2010,2011,2012,2013,2019 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -107,6 +107,17 @@ VARx(int, epoll_epermcnt)
 VARx(int, epoll_epermmax)
 #endif
 
+#if EV_USE_LINUXAIO || EV_GENWRAP
+VARx(aio_context_t, linuxaio_ctx)
+VARx(int, linuxaio_iteration)
+VARx(struct aniocb **, linuxaio_iocbps)
+VARx(int, linuxaio_iocbpmax)
+VARx(struct iocb **, linuxaio_submits)
+VARx(int, linuxaio_submitcnt)
+VARx(int, linuxaio_submitmax)
+VARx(ev_io, linuxaio_epoll_w)
+#endif
+
 #if EV_USE_KQUEUE || EV_GENWRAP
 VARx(pid_t, kqueue_fd_pid)
 VARx(struct kevent *, kqueue_changes)
@@ -195,8 +206,8 @@ VARx(unsigned int, loop_depth) /* #ev_run enters - #ev_run leaves */
 
 VARx(void *, userdata)
 /* C++ doesn't support the ev_loop_callback typedef here. stinks. */
-VAR (release_cb, void (*release_cb)(EV_P) EV_THROW)
-VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_THROW)
+VAR (release_cb, void (*release_cb)(EV_P) EV_NOEXCEPT)
+VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_NOEXCEPT)
 VAR (invoke_cb , ev_loop_callback invoke_cb)
 #endif
 

data/ext/libev/ev_wrap.h

@@ -50,6 +50,14 @@
 #define kqueue_eventmax ((loop)->kqueue_eventmax)
 #define kqueue_events ((loop)->kqueue_events)
 #define kqueue_fd_pid ((loop)->kqueue_fd_pid)
+#define linuxaio_ctx ((loop)->linuxaio_ctx)
+#define linuxaio_epoll_w ((loop)->linuxaio_epoll_w)
+#define linuxaio_iocbpmax ((loop)->linuxaio_iocbpmax)
+#define linuxaio_iocbps ((loop)->linuxaio_iocbps)
+#define linuxaio_iteration ((loop)->linuxaio_iteration)
+#define linuxaio_submitcnt ((loop)->linuxaio_submitcnt)
+#define linuxaio_submitmax ((loop)->linuxaio_submitmax)
+#define linuxaio_submits ((loop)->linuxaio_submits)
 #define loop_count ((loop)->loop_count)
 #define loop_depth ((loop)->loop_depth)
 #define loop_done ((loop)->loop_done)
@@ -149,6 +157,14 @@
 #undef kqueue_eventmax
 #undef kqueue_events
 #undef kqueue_fd_pid
+#undef linuxaio_ctx
+#undef linuxaio_epoll_w
+#undef linuxaio_iocbpmax
+#undef linuxaio_iocbps
+#undef linuxaio_iteration
+#undef linuxaio_submitcnt
+#undef linuxaio_submitmax
+#undef linuxaio_submits
 #undef loop_count
 #undef loop_depth
 #undef loop_done

data/lib/polyphony.rb

@@ -5,60 +5,24 @@ require 'modulation/gem'
 export_default :Polyphony
 
 require 'fiber'
-require_relative './ev_ext'
-import('./polyphony/extensions/kernel')
-import('./polyphony/extensions/io')
+require_relative './gyro_ext'
 
+import './polyphony/extensions/core'
+import './polyphony/extensions/io'
+
+# Main Polyphony API
 module Polyphony
-  exceptions = import('./polyphony/core/exceptions')
+  exceptions = import './polyphony/core/exceptions'
   Cancel        = exceptions::Cancel
   MoveOn        = exceptions::MoveOn
 
-  Coprocess = import('./polyphony/core/coprocess')
-  FiberPool = import('./polyphony/core/fiber_pool')
-  Net       = import('./polyphony/net')
-
+  Coprocess = import './polyphony/core/coprocess'
+  Net       = import './polyphony/net'
 
-  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.coprocess = Coprocess.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
-  
-  def self.debug
-    @debug
-  end
-  
-  def self.debug=(value)
-    @debug = value
-  end
-  
   auto_import(
     CancelScope:  './polyphony/core/cancel_scope',
     Channel:      './polyphony/core/channel',
-    # Coprocess:    './polyphony/core/coprocess',
     FS:           './polyphony/fs',
-    # Net:          './polyphony/net',
     ResourcePool: './polyphony/core/resource_pool',
     Supervisor:   './polyphony/core/supervisor',
     Sync:         './polyphony/core/sync',
@@ -66,11 +30,43 @@ module Polyphony
     ThreadPool:   './polyphony/core/thread_pool',
     Websocket:    './polyphony/websocket'
   )
-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?
+  class << self
+    def trap(sig, ref = false, &callback)
+      sig = Signal.list[sig.to_s.upcase] if sig.is_a?(Symbol)
+      watcher = Gyro::Signal.new(sig, &callback)
+      Gyro.unref unless ref
+      watcher
+    end
+
+    def fork(&block)
+      Gyro.break
+      pid = Kernel.fork do
+        setup_forked_process
+        block.()
+
+        # We cannot simply depend on the at_exit block (see polyphony/auto_run)
+        # 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
+      Gyro.restart
+      pid
+    end
+
+    def reset!
+      Fiber.root.scheduled_value = nil
+      Gyro.restart
+    end
+
+    private
+
+    def setup_forked_process
+      Gyro.post_fork
+      Fiber.set_root_fiber
+      Fiber.current.coprocess = Coprocess.new(Fiber.current)
+    end
+  end
 end

data/lib/polyphony/auto_run.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative '../polyphony'
+
+at_exit do
+  repl = (Pry.current rescue nil) || (IRB.CurrentContext rescue nil)
+
+  # in most cases, once the root fiber is done there are still pending
+  # operations going on. If the reactor loop is not done, we suspend the root
+  # fiber until it is done
+  suspend if $__reactor_fiber__&.alive? && !repl
+end

data/lib/polyphony/core/cancel_scope.rb

@@ -8,19 +8,23 @@ Exceptions = import('./exceptions')
 
 # A cancellation scope that can be used to cancel an asynchronous task
 class CancelScope
-  def initialize(opts = {})
+  def initialize(opts = {}, &block)
     @opts = opts
-    @error_class = @opts[:mode] == :cancel ? Exceptions::Cancel : Exceptions::MoveOn
+    call(&block) if block
+  end
+
+  def 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])
+    @fiber.transfer error_class.new(self, @opts[:value])
   end
 
   def start_timeout
-    @timeout = EV::Timer.new(@opts[:timeout], 0)
+    @timeout = Gyro::Timer.new(@opts[:timeout], 0)
     @timeout.start { cancel! }
   end
 
@@ -41,11 +45,11 @@ class CancelScope
     e.scope == self ? e.value : raise(e)
   ensure
     @timeout&.stop
-    protect(&@when_cancelled) if @cancelled && @when_cancelled
+    protect(&@on_cancel) if @cancelled && @on_cancel
   end
 
-  def when_cancelled(&block)
-    @when_cancelled = block
+  def on_cancel(&block)
+    @on_cancel = block
   end
 
   def cancelled?

data/lib/polyphony/core/channel.rb

@@ -4,6 +4,8 @@ export_default :Channel
 
 Exceptions = import('./exceptions')
 
+# Implements a unidirectional communication channel along the lines of Go
+# (buffered) channels.
 class Channel
   def initialize
     @payload_queue = []
@@ -15,25 +17,30 @@ class Channel
     @waiting_queue.slice(0..-1).each { |f| f.schedule(stop) }
   end
 
-  def <<(o)
+  def <<(value)
     if @waiting_queue.empty?
-      @payload_queue << o
+      @payload_queue << value
     else
-      @waiting_queue.shift&.schedule(o)
+      @waiting_queue.shift&.schedule(value)
     end
     snooze
   end
 
   def receive
-    EV.ref
+    Gyro.ref
     if @payload_queue.empty?
       @waiting_queue << Fiber.current
+      suspend
     else
-      payload = @payload_queue.shift
-      Fiber.current.schedule(payload)
+      receive_from_queue
     end
-    suspend
   ensure
-    EV.unref
+    Gyro.unref
   end
-end
+
+  def receive_from_queue
+    payload = @payload_queue.shift
+    snooze
+    payload
+  end
+end

data/lib/polyphony/core/coprocess.rb

@@ -2,72 +2,116 @@
 
 export_default :Coprocess
 
-import('../extensions/kernel')
-
-FiberPool   = import('./fiber_pool')
-Exceptions  = import('./exceptions')
+import '../extensions/core'
+Exceptions = import './exceptions'
 
 # Encapsulates an asynchronous task
 class Coprocess
-  attr_reader :result, :fiber
+  # inter-coprocess message passing
+  module Messaging
+    def <<(value)
+      if @receive_waiting && @fiber
+        @fiber&.schedule value
+      else
+        @queued_messages ||= []
+        @queued_messages << value
+      end
+      snooze
+    end
+
+    def receive
+      if !@queued_messages || @queued_messages&.empty?
+        wait_for_message
+      else
+        value = @queued_messages.shift
+        snooze
+        value
+      end
+    end
+
+    def wait_for_message
+      Gyro.ref
+      @receive_waiting = true
+      suspend
+    ensure
+      Gyro.unref
+      @receive_waiting = nil
+    end
+  end
+
+  include Messaging
+
+  @@list = {}
 
+  def self.list
+    @@list
+  end
+
+  def self.count
+    @@list.size
+  end
+
+  attr_reader :result, :fiber
 
   def initialize(fiber = nil, &block)
     @fiber = fiber
     @block = block
   end
 
-  def run(&block2)
-    @caller = caller if Exceptions.debug
-
-    @fiber = FiberPool.run do
-      @fiber.coprocess = 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.coprocess = 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
+  def run
+    @calling_fiber = Fiber.current
 
-    @ran = true
+    @fiber = Fiber.new { execute }
     @fiber.schedule
+    @ran = true
     self
   end
 
-  def <<(o)
-    @mailbox ||= []
-    @mailbox << o
-    @fiber&.schedule if @receive_waiting
-    snooze
+  def execute
+    # uncaught_exception = nil
+    @@list[@fiber] = self
+    @fiber.coprocess = self
+    @result = @block.call(self)
+  rescue Exceptions::MoveOn => e
+    @result = e.value
+  rescue Exception => e
+    uncaught_exception = true
+    @result = e
+  ensure
+    finish_execution(uncaught_exception)
   end
 
-  def receive
-    EV.ref
-    @receive_waiting = true
-    @fiber&.schedule if @mailbox && @mailbox.size > 0
-    suspend
-    @mailbox.shift
-  ensure
-    EV.unref
-    @receive_waiting = nil
+  def finish_execution(uncaught_exception)
+    @@list.delete(@fiber)
+    @fiber.coprocess = nil
+    @fiber = nil
+    @awaiting_fiber&.schedule @result
+    @when_done&.()
+
+    return unless uncaught_exception && !@awaiting_fiber
+
+    # 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.transfer @result
   end
 
-  def running?
+  def alive?
     @fiber
   end
 
   # Kernel.await expects the given argument / block to be a callable, so #call
   # in fact waits for the coprocess to finish
   def await
+    await_coprocess_result
+  ensure
+    # If the awaiting fiber has been transferred an exception, the awaited fiber
+    # might still be running, so we need to stop it
+    @fiber&.schedule(Exceptions::MoveOn.new)
+  end
+  alias_method :join, :await
+
+  def await_coprocess_result
     run unless @ran
     if @fiber
       @awaiting_fiber = Fiber.current
@@ -75,30 +119,36 @@ class Coprocess
     else
       @result
     end
-  ensure
-    # if awaiting was interrupted and the coprocess is still running, we need to stop it
-    if @fiber
-      @fiber&.schedule(Exceptions::MoveOn.new)
-      suspend
-    end
   end
-  alias_method :join, :await
 
   def when_done(&block)
     @when_done = block
   end
 
   def resume(value = nil)
-    @fiber&.schedule(value)
+    return unless @fiber
+
+    @fiber.schedule(value)
+    snooze
   end
 
   def interrupt(value = nil)
-    @fiber&.schedule(Exceptions::MoveOn.new(nil, value))
+    return unless @fiber
+
+    @fiber.schedule(Exceptions::MoveOn.new(nil, value))
+    snooze
   end
   alias_method :stop, :interrupt
 
+  def transfer(value = nil)
+    @fiber&.schedule(value)
+  end
+
   def cancel!
-    @fiber&.schedule(Exceptions::Cancel.new)
+    return unless @fiber
+
+    @fiber.schedule(Exceptions::Cancel.new)
+    snooze
   end
 
   def self.current