polyphony 0.47.2 → 0.48.0

data/ext/polyphony/backend_libev.c

@@ -13,7 +13,6 @@
 #include "../libev/ev.h"
 #include "ruby/io.h"
 
-VALUE cTCPSocket;
 VALUE SYM_libev;
 
 ID ID_ivar_is_nonblocking;
@@ -41,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) {
@@ -84,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;
 }
@@ -117,42 +119,11 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-VALUE Backend_ref(VALUE self) {
+unsigned int Backend_pending_count(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) {
-  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) {
@@ -161,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;
@@ -183,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
@@ -494,7 +465,7 @@ VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
     Backend_writev(self, argv[0], argc - 1, argv + 1);
 }
 
-VALUE Backend_accept(VALUE self, VALUE sock) {
+VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
@@ -502,12 +473,12 @@ VALUE Backend_accept(VALUE self, VALUE sock) {
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
-  if (underlying_sock != Qnil) sock = underlying_sock;
+  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
+  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
   GetBackend(self, backend);
-  GetOpenFile(sock, fptr);
-  io_set_nonblock(fptr, sock);
+  GetOpenFile(server_socket, fptr);
+  io_set_nonblock(fptr, server_socket);
   watcher.fiber = Qnil;
   while (1) {
     fd = accept(fptr->fd, &addr, &len);
@@ -529,7 +500,7 @@ VALUE Backend_accept(VALUE self, VALUE sock) {
         goto error;
       }
 
-      socket = rb_obj_alloc(cTCPSocket);
+      socket = rb_obj_alloc(socket_class);
       MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
       fp->fd = fd;
@@ -550,7 +521,7 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE Backend_accept_loop(VALUE self, VALUE sock) {
+VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
   Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
@@ -559,12 +530,12 @@ VALUE Backend_accept_loop(VALUE self, VALUE sock) {
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
   VALUE socket = Qnil;
-  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
-  if (underlying_sock != Qnil) sock = underlying_sock;
+  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
+  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
   GetBackend(self, backend);
-  GetOpenFile(sock, fptr);
-  io_set_nonblock(fptr, sock);
+  GetOpenFile(server_socket, fptr);
+  io_set_nonblock(fptr, server_socket);
   watcher.fiber = Qnil;
 
   while (1) {
@@ -586,7 +557,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE sock) {
         goto error;
       }
 
-      socket = rb_obj_alloc(cTCPSocket);
+      socket = rb_obj_alloc(socket_class);
       MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
       fp->fd = fd;
@@ -849,19 +820,12 @@ VALUE Backend_kind(VALUE self) {
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
-  rb_require("socket");
-  cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
-
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
   rb_define_alloc_func(cBackend, Backend_allocate);
 
   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);
@@ -869,8 +833,8 @@ void Init_Backend() {
   rb_define_method(cBackend, "read", Backend_read, 4);
   rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
   rb_define_method(cBackend, "write", Backend_write_m, -1);
-  rb_define_method(cBackend, "accept", Backend_accept, 1);
-  rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 1);
+  rb_define_method(cBackend, "accept", Backend_accept, 2);
+  rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
   rb_define_method(cBackend, "connect", Backend_connect, 3);
   rb_define_method(cBackend, "recv", Backend_recv, 3);
   rb_define_method(cBackend, "recv_loop", Backend_read_loop, 1);
@@ -886,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/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/core/global_api.rb

@@ -53,13 +53,21 @@ module Polyphony
       Fiber.current.spin(tag, caller, &block)
     end
 
-    def spin_loop(tag = nil, rate: nil, &block)
-      if rate
+    def spin_loop(tag = nil, rate: nil, interval: nil, &block)
+      if rate || interval
         Fiber.current.spin(tag, caller) do
-          throttled_loop(rate, &block)
+          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
 
@@ -73,17 +81,8 @@ module Polyphony
       end.await
     end
 
-    def every(interval)
-      next_time = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC) + interval
-      loop do
-        now = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
-        Thread.current.backend.sleep(next_time - now)
-        yield
-        loop do
-          next_time += interval
-          break if next_time > now
-        end
-      end
+    def every(interval, &block)
+      Thread.current.backend.timer_loop(interval, &block)
     end
 
     def move_on_after(interval, with_value: nil, &block)
@@ -142,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