polyphony 0.47.5.1 → 0.50.0

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/fiber.c

@@ -101,7 +101,8 @@ VALUE Fiber_await(VALUE self) {
   }
   rb_hash_aset(waiting_fibers, fiber, Qtrue);
 
-  result = Thread_switch_fiber(rb_thread_current());
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  result = Backend_wait_event(backend, Qnil);
 
   rb_hash_delete(waiting_fibers, fiber);
   RAISE_IF_EXCEPTION(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;
@@ -88,10 +84,16 @@ void Runqueue_push(VALUE self, VALUE fiber, VALUE value, int reschedule);
 void Runqueue_unshift(VALUE self, VALUE fiber, VALUE value, int reschedule);
 runqueue_entry Runqueue_shift(VALUE self);
 void Runqueue_delete(VALUE self, VALUE fiber);
+int Runqueue_index_of(VALUE self, VALUE fiber);
 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/runqueue.c

@@ -74,6 +74,12 @@ void Runqueue_delete(VALUE self, VALUE fiber) {
   runqueue_ring_buffer_delete(&runqueue->entries, fiber);
 }
 
+int Runqueue_index_of(VALUE self, VALUE fiber) {
+  Runqueue_t *runqueue;
+  GetRunqueue(self, runqueue);
+  return runqueue_ring_buffer_index_of(&runqueue->entries, fiber);
+}
+
 void Runqueue_clear(VALUE self) {
   Runqueue_t *runqueue;
   GetRunqueue(self, runqueue);

data/ext/polyphony/runqueue_ring_buffer.c

@@ -80,6 +80,15 @@ void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber) {
   }
 }
 
+int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber) {
+  for (unsigned int i = 0; i < buffer->count; i++) {
+    unsigned int idx = (buffer->head + i) % buffer->size;
+    if (buffer->entries[idx].fiber == fiber)
+      return i;
+  }
+  return -1;
+}
+
 void runqueue_ring_buffer_clear(runqueue_ring_buffer *buffer) {
   buffer->count = buffer->head = buffer->tail = 0;
 }

data/ext/polyphony/runqueue_ring_buffer.h

@@ -27,5 +27,6 @@ void runqueue_ring_buffer_unshift(runqueue_ring_buffer *buffer, VALUE fiber, VAL
 void runqueue_ring_buffer_push(runqueue_ring_buffer *buffer, VALUE fiber, VALUE value);
 
 void runqueue_ring_buffer_delete(runqueue_ring_buffer *buffer, VALUE fiber);
+int runqueue_ring_buffer_index_of(runqueue_ring_buffer *buffer, VALUE fiber);
 
 #endif /* RUNQUEUE_RING_BUFFER_H */

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,11 +54,23 @@ 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);
     }
   }
 }
 
+VALUE Thread_fiber_scheduling_index(VALUE self, VALUE fiber) {
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+
+  return INT2NUM(Runqueue_index_of(runqueue, fiber));
+}
+
+VALUE Thread_fiber_unschedule(VALUE self, VALUE fiber) {
+  VALUE runqueue = rb_ivar_get(self, ID_ivar_runqueue);
+  Runqueue_delete(runqueue, fiber);
+  return self;
+}
+
 VALUE Thread_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
   schedule_fiber(self, fiber, value, 0);
   return self;
@@ -84,25 +86,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 +119,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 +140,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);
 
@@ -154,6 +147,8 @@ void Init_Thread() {
   rb_define_method(rb_cThread, "schedule_fiber_with_priority",
     Thread_schedule_fiber_with_priority, 2);
   rb_define_method(rb_cThread, "switch_fiber", Thread_switch_fiber, 0);
+  rb_define_method(rb_cThread, "fiber_scheduling_index", Thread_fiber_scheduling_index, 1);
+  rb_define_method(rb_cThread, "fiber_unschedule", Thread_fiber_unschedule, 1);
 
   rb_define_method(rb_cThread, "debug!", Thread_debug, 0);
 

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/exceptions.rb

@@ -13,6 +13,7 @@ module Polyphony
     def initialize(value = nil)
       @caller_backtrace = caller
       @value = value
+      super
     end
   end
 

data/lib/polyphony/core/global_api.rb

@@ -29,7 +29,7 @@ module Polyphony
       spin do
         sleep interval
         exception = cancel_exception(with_exception)
-        exception.__raising_fiber__ = nil
+        exception.raising_fiber = nil
         fiber.schedule exception
       end
     end
@@ -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