polyphony 0.47.5 → 0.49.2

data/ext/polyphony/backend_libev.c

@@ -40,11 +40,14 @@ inline void io_set_nonblock(rb_io_t *fptr, VALUE io) {
 }
 
 typedef struct Backend_t {
+  // common fields
+  unsigned int        currently_polling;
+  unsigned int        pending_count;
+  unsigned int        poll_no_wait_count;
+
+  // implementation-specific fields
   struct ev_loop *ev_loop;
   struct ev_async break_async;
-  int running;
-  int ref_count;
-  int run_no_wait_count;
 } Backend_t;
 
 static size_t Backend_size(const void *ptr) {
@@ -83,9 +86,9 @@ static VALUE Backend_initialize(VALUE self) {
   ev_async_start(backend->ev_loop, &backend->break_async);
   ev_unref(backend->ev_loop); // don't count the break_async watcher
 
-  backend->running = 0;
-  backend->ref_count = 0;
-  backend->run_no_wait_count = 0;
+  backend->currently_polling = 0;
+  backend->pending_count = 0;
+  backend->poll_no_wait_count = 0;
 
   return Qnil;
 }
@@ -116,42 +119,11 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-VALUE Backend_ref(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  backend->ref_count++;
-  return self;
-}
-
-VALUE Backend_unref(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  backend->ref_count--;
-  return self;
-}
-
-int Backend_ref_count(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  return backend->ref_count;
-}
-
-void Backend_reset_ref_count(VALUE self) {
+unsigned int Backend_pending_count(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  backend->ref_count = 0;
-}
-
-VALUE Backend_pending_count(VALUE self) {
-  int count;
-  Backend_t *backend;
-  GetBackend(self, backend);
-  count = ev_pending_count(backend->ev_loop);
-  return INT2NUM(count);
+  return backend->pending_count;
 }
 
 VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
@@ -160,19 +132,19 @@ VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue
   GetBackend(self, backend);
 
   if (is_nowait) {
-    backend->run_no_wait_count++;
-    if (backend->run_no_wait_count < 10) return self;
+    backend->poll_no_wait_count++;
+    if (backend->poll_no_wait_count < 10) return self;
 
     long runnable_count = Runqueue_len(runqueue);
-    if (backend->run_no_wait_count < runnable_count) return self;
+    if (backend->poll_no_wait_count < runnable_count) return self;
   }
 
-  backend->run_no_wait_count = 0;
+  backend->poll_no_wait_count = 0;
 
   COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
-  backend->running = 1;
+  backend->currently_polling = 1;
   ev_run(backend->ev_loop, is_nowait ? EVRUN_NOWAIT : EVRUN_ONCE);
-  backend->running = 0;
+  backend->currently_polling = 0;
   COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
 
   return self;
@@ -182,7 +154,7 @@ VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (backend->running) {
+  if (backend->currently_polling) {
     // Since the loop will run until at least one event has occurred, we signal
     // the selector's associated async watcher, which will cause the ev loop to
     // return. In contrast to using `ev_break` to break out of the loop, which
@@ -854,10 +826,6 @@ void Init_Backend() {
   rb_define_method(cBackend, "initialize", Backend_initialize, 0);
   rb_define_method(cBackend, "finalize", Backend_finalize, 0);
   rb_define_method(cBackend, "post_fork", Backend_post_fork, 0);
-  rb_define_method(cBackend, "pending_count", Backend_pending_count, 0);
-
-  rb_define_method(cBackend, "ref", Backend_ref, 0);
-  rb_define_method(cBackend, "unref", Backend_unref, 0);
 
   rb_define_method(cBackend, "poll", Backend_poll, 3);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
@@ -882,15 +850,6 @@ void Init_Backend() {
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   SYM_libev = ID2SYM(rb_intern("libev"));
-
-  __BACKEND__.pending_count   = Backend_pending_count;
-  __BACKEND__.poll            = Backend_poll;
-  __BACKEND__.ref             = Backend_ref;
-  __BACKEND__.ref_count       = Backend_ref_count;
-  __BACKEND__.reset_ref_count = Backend_reset_ref_count;
-  __BACKEND__.unref           = Backend_unref;
-  __BACKEND__.wait_event      = Backend_wait_event;
-  __BACKEND__.wakeup          = Backend_wakeup;
 }
 
 #endif // POLYPHONY_BACKEND_LIBEV

data/ext/polyphony/event.c

@@ -66,7 +66,7 @@ VALUE Event_await(VALUE self) {
 
   VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
   event->waiting_fiber = rb_fiber_current();
-  VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+  VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
   event->waiting_fiber = Qnil;
 
   RAISE_IF_EXCEPTION(switchpoint_result);

data/ext/polyphony/polyphony.c

@@ -22,8 +22,6 @@ ID ID_R;
 ID ID_W;
 ID ID_RW;
 
-backend_interface_t backend_interface;
-
 VALUE Polyphony_snooze(VALUE self) {
   VALUE ret;
   VALUE fiber = rb_fiber_current();

data/ext/polyphony/polyphony.h

@@ -4,7 +4,6 @@
 #include <execinfo.h>
 
 #include "ruby.h"
-#include "backend.h"
 #include "runqueue_ring_buffer.h"
 
 // debugging
@@ -32,9 +31,6 @@
 // Fiber#transfer
 #define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
 
-extern backend_interface_t backend_interface;
-#define __BACKEND__ (backend_interface)
-
 extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
@@ -92,6 +88,11 @@ void Runqueue_clear(VALUE self);
 long Runqueue_len(VALUE self);
 int Runqueue_empty_p(VALUE self);
 
+unsigned int Backend_pending_count(VALUE self);
+VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue);
+VALUE Backend_wait_event(VALUE self, VALUE raise_on_exception);
+VALUE Backend_wakeup(VALUE self);
+
 VALUE Thread_schedule_fiber(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_schedule_fiber_with_priority(VALUE thread, VALUE fiber, VALUE value);
 VALUE Thread_switch_fiber(VALUE thread);

data/ext/polyphony/queue.c

@@ -86,7 +86,7 @@ inline void capped_queue_block_push(Queue_t *queue) {
     if (queue->capacity > queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
     ring_buffer_push(&queue->push_queue, fiber);
-    switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+    switchpoint_result = Backend_wait_event(backend, Qnil);
     ring_buffer_delete(&queue->push_queue, fiber);
 
     RAISE_IF_EXCEPTION(switchpoint_result);
@@ -131,7 +131,7 @@ VALUE Queue_shift(VALUE self) {
     if (queue->values.count) Fiber_make_runnable(fiber, Qnil);
 
     ring_buffer_push(&queue->shift_queue, fiber);
-    VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+    VALUE switchpoint_result = Backend_wait_event(backend, Qnil);
     ring_buffer_delete(&queue->shift_queue, fiber);
 
     RAISE_IF_EXCEPTION(switchpoint_result);

data/ext/polyphony/thread.c

@@ -17,16 +17,6 @@ static VALUE Thread_setup_fiber_scheduling(VALUE self) {
   return self;
 }
 
-int Thread_fiber_ref_count(VALUE self) {
-  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  return NUM2INT(__BACKEND__.ref_count(backend));
-}
-
-inline void Thread_fiber_reset_ref_count(VALUE self) {
-  VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  __BACKEND__.reset_ref_count(backend);
-}
-
 static VALUE SYM_scheduled_fibers;
 static VALUE SYM_pending_watchers;
 
@@ -39,7 +29,7 @@ static VALUE Thread_fiber_scheduling_stats(VALUE self) {
   long scheduled_count = Runqueue_len(runqueue);
   rb_hash_aset(stats, SYM_scheduled_fibers, INT2NUM(scheduled_count));
 
-  pending_count = __BACKEND__.pending_count(backend);
+  pending_count = Backend_pending_count(backend);
   rb_hash_aset(stats, SYM_pending_watchers, INT2NUM(pending_count));
 
   return stats;
@@ -64,7 +54,7 @@ void schedule_fiber(VALUE self, VALUE fiber, VALUE value, int prioritize) {
       // happen, not knowing that it there's already a fiber ready to run in its
       // run queue.
       VALUE backend = rb_ivar_get(self,ID_ivar_backend);
-      __BACKEND__.wakeup(backend);
+      Backend_wakeup(backend);
     }
   }
 }
@@ -84,25 +74,24 @@ VALUE Thread_switch_fiber(VALUE self) {
   VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
   runqueue_entry next;
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
-  int ref_count;
-  int backend_was_polled = 0;
+  unsigned int pending_count = Backend_pending_count(backend);
+  unsigned int backend_was_polled = 0;
 
   if (__tracing_enabled__ && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
     TRACE(2, SYM_fiber_switchpoint, current_fiber);
 
-  ref_count = __BACKEND__.ref_count(backend);
   while (1) {
     next = Runqueue_shift(runqueue);
     if (next.fiber != Qnil) {
-      if (backend_was_polled == 0 && ref_count > 0) {
+      if (!backend_was_polled && pending_count) {
         // this prevents event starvation in case the run queue never empties
-        __BACKEND__.poll(backend, Qtrue, current_fiber, runqueue);
+        Backend_poll(backend, Qtrue, current_fiber, runqueue);
       }
       break;
     }
-    if (ref_count == 0) break;
+    if (pending_count == 0) break;
 
-    __BACKEND__.poll(backend, Qnil, current_fiber, runqueue);
+    Backend_poll(backend, Qnil, current_fiber, runqueue);
     backend_was_polled = 1;
   }
 
@@ -118,20 +107,13 @@ VALUE Thread_switch_fiber(VALUE self) {
     next.value : FIBER_TRANSFER(next.fiber, next.value);
 }
 
-VALUE Thread_reset_fiber_scheduling(VALUE self) {
-  VALUE queue = rb_ivar_get(self, ID_ivar_runqueue);
-  Runqueue_clear(queue);
-  Thread_fiber_reset_ref_count(self);
-  return self;
-}
-
 VALUE Thread_fiber_schedule_and_wakeup(VALUE self, VALUE fiber, VALUE resume_obj) {
   VALUE backend = rb_ivar_get(self, ID_ivar_backend);
   if (fiber != Qnil) {
     Thread_schedule_fiber_with_priority(self, fiber, resume_obj);
   }
 
-  if (__BACKEND__.wakeup(backend) == Qnil) {
+  if (Backend_wakeup(backend) == Qnil) {
     // we're not inside the ev_loop, so we just do a switchpoint
     Thread_switch_fiber(self);
   }
@@ -146,7 +128,6 @@ VALUE Thread_debug(VALUE self) {
 
 void Init_Thread() {
   rb_define_method(rb_cThread, "setup_fiber_scheduling", Thread_setup_fiber_scheduling, 0);
-  rb_define_method(rb_cThread, "reset_fiber_scheduling", Thread_reset_fiber_scheduling, 0);
   rb_define_method(rb_cThread, "fiber_scheduling_stats", Thread_fiber_scheduling_stats, 0);
   rb_define_method(rb_cThread, "schedule_and_wakeup", Thread_fiber_schedule_and_wakeup, 2);
 

data/lib/polyphony.rb

@@ -14,6 +14,7 @@ Thread.current.backend = Polyphony::Backend.new
 require_relative './polyphony/core/global_api'
 require_relative './polyphony/core/resource_pool'
 require_relative './polyphony/core/sync'
+require_relative './polyphony/core/timer'
 require_relative './polyphony/net'
 require_relative './polyphony/adapters/process'
 
@@ -43,7 +44,7 @@ module Polyphony
       rescue SystemExit
         # fall through to ensure
       rescue Exception => e
-        warn e.full_message
+        STDERR << e.full_message
         exit!
       ensure
         exit_forked_process

data/lib/polyphony/adapters/postgres.rb

@@ -11,7 +11,7 @@ module ::PG
 
   def self.connect_async(conn)
     socket_io = conn.socket_io
-    loop do
+    while true
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED   then raise Error, conn.error_message
@@ -23,7 +23,7 @@ module ::PG
   end
 
   def self.connect_sync(conn)
-    loop do
+    while true
       res = conn.connect_poll
       case res
       when PGRES_POLLING_FAILED
@@ -96,7 +96,7 @@ class ::PG::Connection
   def wait_for_notify(timeout = nil, &block)
     return move_on_after(timeout) { wait_for_notify(&block) } if timeout
 
-    loop do
+    while true
       Thread.current.backend.wait_io(socket_io, false)
       consume_input
       notice = notifies

data/lib/polyphony/adapters/process.rb

@@ -24,6 +24,8 @@ module Polyphony
       def kill_and_await(sig, pid)
         ::Process.kill(sig, pid)
         Thread.current.backend.waitpid(pid)
+      rescue Errno::ERSCH
+        # ignore
       end
     end
   end

data/lib/polyphony/core/global_api.rb

@@ -59,7 +59,15 @@ module Polyphony
           throttled_loop(rate: rate, interval: interval, &block)
         end
       else
-        Fiber.current.spin(tag, caller) { loop(&block) }
+        spin_looped_block(tag, caller, block)
+      end
+    end
+
+    def spin_looped_block(tag, caller, block)
+      Fiber.current.spin(tag, caller) do
+        block.call while true
+      rescue LocalJumpError, StopIteration
+        # break called or StopIteration raised
       end
     end
 
@@ -133,8 +141,12 @@ module Polyphony
       if opts[:count]
         opts[:count].times { |_i| throttler.(&block) }
       else
-        loop { throttler.(&block) }
+        while true
+          throttler.(&block)
+        end
       end
+    rescue LocalJumpError, StopIteration
+      # break called or StopIteration raised
     ensure
       throttler&.stop
     end

data/lib/polyphony/core/thread_pool.rb

@@ -45,7 +45,9 @@ module Polyphony
     end
 
     def thread_loop
-      loop { run_queued_task }
+      while true
+        run_queued_task
+      end
     end
 
     def run_queued_task

data/lib/polyphony/core/throttler.rb

@@ -15,7 +15,7 @@ module Polyphony
       Thread.current.backend.sleep(delta) if delta > 0
       yield self
 
-      loop do
+      while true
         @next_time += @min_dt
         break if @next_time > now
       end

data/lib/polyphony/core/timer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Polyphony
+  # Implements a common timer for running multiple timeouts
+  class Timer
+    def initialize(resolution:)
+      @fiber = spin_loop(interval: resolution) { update }
+      @timeouts = {}
+    end
+
+    def stop
+      @fiber.stop
+    end
+  
+    def cancel_after(duration, with_exception: Polyphony::Cancel)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        duration: duration,
+        target_stamp: Time.now + duration,
+        exception: with_exception
+      }
+      yield
+    ensure
+      @timeouts.delete(fiber)
+    end
+
+    def move_on_after(duration, with_value: nil)
+      fiber = Fiber.current
+      @timeouts[fiber] = {
+        duration: duration,
+        target_stamp: Time.now + duration,
+        value: with_value
+      }
+      yield
+    rescue Polyphony::MoveOn => e
+      e.value
+    ensure
+      @timeouts.delete(fiber)
+    end
+  
+    def reset
+      record = @timeouts[Fiber.current]
+      return unless record
+  
+      record[:target_stamp] = Time.now + record[:duration]
+    end
+  
+    private
+
+    def timeout_exception(record)
+      case (exception = record[:exception])
+      when Class then exception.new
+      when Array then exception[0].new(exception[1])
+      when nil then Polyphony::MoveOn.new(record[:value])
+      else RuntimeError.new(exception)
+      end
+    end
+
+    def update
+      now = Time.now
+      # elapsed = nil
+      @timeouts.each do |fiber, record|
+        next if record[:target_stamp] > now
+
+        exception = timeout_exception(record)
+        # (elapsed ||= []) << fiber
+        fiber.schedule exception
+      end
+      # elapsed&.each { |f| @timeouts.delete(f) }
+    end
+  end
+end