polyphony 0.58 → 0.59

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8002b8c0e03afa8e915b5ed67d64c1fc288a5fa220dfb2c32d3966a78046eee
-  data.tar.gz: c3a46eeae1f048f4adee9d3130f5dd3593936e843c1874d928f742d1fa83053f
+  metadata.gz: 313e33321df0e375d128a79fccfab98e06183adbdbde7916347f6795f56ca369
+  data.tar.gz: 6428c0516544bdb955fa465bf36c40b9b2f162306f3e5689848ff487f24c4440
 SHA512:
-  metadata.gz: e6681155761daee35b73c9674e69aa505786e576814db0c909028cb576d8609f99bccc79f80b7d06d90c7658747bc2589c9837d3bdb3419782147e573d39f278
-  data.tar.gz: 90197a8db54405ca37492a54a20adf00c85f142af606cad26ad823161825ccf6bd9a414adcbbf3e27eaf93eea1d94a7cbc50a2fb5982ee4ce48969d4378400cd
+  metadata.gz: 40c88f5d1c2aa4307dea78dcf1a2ba8d347ef252e7e56e67d466c291066d39544d051864ccd0138dd94ca0beef7af71f5257052b3556ab0c7294b1b94b517d47
+  data.tar.gz: 109410d6b222846b0c2b3f54061358ef922b57c9b6559c37aec36f27116e7ca389ff51762e988e2e9293a7a1358d97b80ada74daa4e44d7d25c1e5335351d8c6

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.59 2021-06-28
+
+- Redesign tracing mechanism and API - now completely separated from Ruby core
+  trace API
+- Refactor C code - move run queue into backend
+
 ## 0.58 2021-06-25
 
 - Implement `Thread#idle_gc_period`, `#on_idle` (#56)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    polyphony (0.58)
+    polyphony (0.59)
 
 GEM
   remote: https://rubygems.org/

data/ext/polyphony/backend_common.c

@@ -5,12 +5,103 @@
 #include "polyphony.h"
 #include "backend_common.h"
 
-inline void initialize_backend_base(struct Backend_base *base) {
+inline void backend_base_initialize(struct Backend_base *base) {
+  runqueue_initialize(&base->runqueue);
   base->currently_polling = 0;
   base->pending_count = 0;
   base->idle_gc_period = 0;
   base->idle_gc_last_time = 0;
-  base->idle_block = Qnil;
+  base->idle_proc = Qnil;
+  base->trace_proc = Qnil;
+}
+
+inline void backend_base_finalize(struct Backend_base *base) {
+  runqueue_finalize(&base->runqueue);
+}
+
+inline void backend_base_mark(struct Backend_base *base) {
+  if (base->idle_proc != Qnil) rb_gc_mark(base->idle_proc);
+  if (base->trace_proc != Qnil) rb_gc_mark(base->trace_proc);
+  runqueue_mark(&base->runqueue);
+}
+
+VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base) {
+  VALUE current_fiber = rb_fiber_current();
+  runqueue_entry next;
+  unsigned int pending_ops_count = base->pending_count;
+  unsigned int backend_was_polled = 0;
+  unsigned int idle_tasks_run_count = 0;
+
+  if (SHOULD_TRACE(base) && (rb_ivar_get(current_fiber, ID_ivar_running) != Qfalse))
+    TRACE(base, 2, SYM_fiber_switchpoint, current_fiber);
+
+  while (1) {
+    next = runqueue_shift(&base->runqueue);
+    if (next.fiber != Qnil) {
+      // Polling for I/O op completion is normally done when the run queue is
+      // empty, but if the runqueue never empties, we'll never get to process
+      // any event completions. In order to prevent this, an anti-starve
+      // mechanism is employed, under the following conditions:
+      // - a blocking poll was not yet performed
+      // - there are pending blocking operations
+      // - the runqueue has signalled that a non-blocking poll should be
+      //   performed
+      //   - the run queue length high watermark has reached its threshold (currently 128)
+      //   - the run queue switch counter has reached its threshold (currently 64) 
+      if (!backend_was_polled && pending_ops_count && runqueue_should_poll_nonblocking(&base->runqueue)) {
+        // this prevents event starvation in case the run queue never empties
+        Backend_poll(backend, Qnil);
+      }
+      break;
+    }
+    
+    if (!idle_tasks_run_count) {
+      idle_tasks_run_count++;
+      backend_run_idle_tasks(base);
+    }
+    if (pending_ops_count == 0) break;
+    Backend_poll(backend, Qtrue);
+    backend_was_polled = 1;
+  }
+
+  if (next.fiber == Qnil) return Qnil;
+
+  // run next fiber
+  COND_TRACE(base, 3, SYM_fiber_run, next.fiber, next.value);
+
+  rb_ivar_set(next.fiber, ID_ivar_runnable, Qnil);
+  RB_GC_GUARD(next.fiber);
+  RB_GC_GUARD(next.value);
+  return (next.fiber == current_fiber) ?
+    next.value : FIBER_TRANSFER(next.fiber, next.value);
+}
+
+void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_base *base, VALUE fiber, VALUE value, int prioritize) {
+  int already_runnable;
+
+  if (rb_fiber_alive_p(fiber) != Qtrue) return;
+  already_runnable = rb_ivar_get(fiber, ID_ivar_runnable) != Qnil;
+
+  COND_TRACE(base, 3, SYM_fiber_schedule, fiber, value);
+  (prioritize ? runqueue_unshift : runqueue_push)(&base->runqueue, fiber, value, already_runnable);
+  if (!already_runnable) {
+    rb_ivar_set(fiber, ID_ivar_runnable, Qtrue);
+    if (rb_thread_current() != thread) {
+      // If the fiber scheduling is done across threads, we need to make sure the
+      // target thread is woken up in case it is in the middle of running its
+      // event selector. Otherwise it's gonna be stuck waiting for an event to
+      // happen, not knowing that it there's already a fiber ready to run in its
+      // run queue.
+      Backend_wakeup(backend);
+    }
+  }
+}
+
+
+inline void backend_trace(struct Backend_base *base, int argc, VALUE *argv) {
+  if (base->trace_proc == Qnil) return;
+
+  rb_funcallv(base->trace_proc, ID_call, argc, argv);
 }
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
@@ -182,8 +273,8 @@ inline void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking) {
 }
 
 inline void backend_run_idle_tasks(struct Backend_base *base) {
-  if (base->idle_block != Qnil)
-    rb_funcall(base->idle_block, ID_call, 0);
+  if (base->idle_proc != Qnil)
+    rb_funcall(base->idle_proc, ID_call, 0);
 
   if (base->idle_gc_period == 0) return;
 

data/ext/polyphony/backend_common.h

@@ -3,16 +3,37 @@
 
 #include "ruby.h"
 #include "ruby/io.h"
+#include "runqueue.h"
+
+struct backend_stats {
+  int scheduled_fibers;
+  int waiting_fibers;
+  int pending_ops;
+};
 
 struct Backend_base {
+  runqueue_t runqueue;
   unsigned int currently_polling;
   unsigned int pending_count;
   double idle_gc_period;
   double idle_gc_last_time;
-  VALUE idle_block;
+  VALUE idle_proc;
+  VALUE trace_proc;
 };
 
-void initialize_backend_base(struct Backend_base *base);
+void backend_base_initialize(struct Backend_base *base);
+void backend_base_finalize(struct Backend_base *base);
+void backend_base_mark(struct Backend_base *base);
+VALUE backend_base_switch_fiber(VALUE backend, struct Backend_base *base);
+void backend_base_schedule_fiber(VALUE thread, VALUE backend, struct Backend_base *base, VALUE fiber, VALUE value, int prioritize);
+void backend_trace(struct Backend_base *base, int argc, VALUE *argv);
+
+// tracing
+#define SHOULD_TRACE(base) ((base)->trace_proc != Qnil)
+#define TRACE(base, ...)  rb_funcall((base)->trace_proc, ID_call, __VA_ARGS__)
+#define COND_TRACE(base, ...) if (SHOULD_TRACE(base)) { TRACE(base, __VA_ARGS__); }
+
+
 
 #ifdef POLYPHONY_USE_PIDFD_OPEN
 int pidfd_open(pid_t pid, unsigned int flags);

data/ext/polyphony/backend_io_uring.c

@@ -44,8 +44,12 @@ typedef struct Backend_t {
 
 static void Backend_mark(void *ptr) {
   Backend_t *backend = ptr;
-  if (backend->base.idle_block != Qnil)
-    rb_gc_mark(backend->base.idle_block);
+  backend_base_mark(&backend->base);
+}
+
+static void Backend_free(void *ptr) {
+  Backend_t *backend = ptr;
+  backend_base_finalize(&backend->base);
 }
 
 static size_t Backend_size(const void *ptr) {
@@ -54,7 +58,7 @@ static size_t Backend_size(const void *ptr) {
 
 static const rb_data_type_t Backend_type = {
     "IOUringBackend",
-    {Backend_mark, 0, Backend_size,},
+    {Backend_mark, Backend_free, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -71,7 +75,7 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  initialize_backend_base(&backend->base);
+  backend_base_initialize(&backend->base);
   backend->pending_sqes = 0;
   backend->prepared_limit = 2048;
 
@@ -106,13 +110,6 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-unsigned int Backend_pending_count(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  return backend->base.pending_count;
-}
-
 typedef struct poll_context {
   struct io_uring     *ring;
   struct io_uring_cqe *cqe;
@@ -189,24 +186,56 @@ void io_uring_backend_poll(Backend_t *backend) {
   io_uring_cqe_seen(&backend->ring, poll_ctx.cqe);
 }
 
-VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
-  int is_nowait = nowait == Qtrue;
+inline VALUE Backend_poll(VALUE self, VALUE blocking) {
+  int is_blocking = blocking == Qtrue;
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (is_nowait && backend->pending_sqes) {
+  if (!is_blocking && backend->pending_sqes) {
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
   }
 
-  COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
-  if (!is_nowait) io_uring_backend_poll(backend);
+  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_enter, rb_fiber_current());
+  if (is_blocking) io_uring_backend_poll(backend);
   io_uring_backend_handle_ready_cqes(backend);
-  COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
+  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
   
   return self;
 }
 
+inline void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend_base_schedule_fiber(thread, self, &backend->base, fiber, value, prioritize);
+}
+
+inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  runqueue_delete(&backend->base.runqueue, fiber);  
+}
+
+inline VALUE Backend_switch_fiber(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return backend_base_switch_fiber(self, &backend->base);
+}
+
+inline struct backend_stats Backend_stats(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return (struct backend_stats){
+    .scheduled_fibers = runqueue_len(&backend->base.runqueue),
+    .waiting_fibers = 0,
+    .pending_ops = backend->base.pending_count
+  };
+}
+
 VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -1187,10 +1216,10 @@ VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
   return self;
 }
 
-VALUE Backend_idle_block_set(VALUE self, VALUE block) {
+VALUE Backend_idle_proc_set(VALUE self, VALUE block) {
   Backend_t *backend;
   GetBackend(self, backend);
-  backend->base.idle_block = block;
+  backend->base.idle_proc = block;
   return self;
 }
 
@@ -1355,6 +1384,21 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+VALUE Backend_trace(int argc, VALUE *argv, VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend_trace(&backend->base, argc, argv);
+  return self;
+}
+
+VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend->base.trace_proc = block;
+  return self;
+}
+
 void Init_Backend() {
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);
@@ -1362,13 +1406,15 @@ 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, "trace", Backend_trace, -1);
+  rb_define_method(cBackend, "trace_proc=", Backend_trace_proc_set, 1);
 
-  rb_define_method(cBackend, "poll", Backend_poll, 3);
+  rb_define_method(cBackend, "poll", Backend_poll, 1);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
   rb_define_method(cBackend, "kind", Backend_kind, 0);
   rb_define_method(cBackend, "chain", Backend_chain, -1);
   rb_define_method(cBackend, "idle_gc_period=", Backend_idle_gc_period_set, 1);
-  rb_define_method(cBackend, "idle_block=", Backend_idle_block_set, 1);
+  rb_define_method(cBackend, "idle_proc=", Backend_idle_proc_set, 1);
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);

data/ext/polyphony/backend_libev.c

@@ -75,8 +75,12 @@ typedef struct Backend_t {
 
 static void Backend_mark(void *ptr) {
   Backend_t *backend = ptr;
-  if (backend->base.idle_block != Qnil)
-    rb_gc_mark(backend->base.idle_block);
+  backend_base_mark(&backend->base);
+}
+
+static void Backend_free(void *ptr) {
+  Backend_t *backend = ptr;
+  backend_base_finalize(&backend->base);
 }
 
 static size_t Backend_size(const void *ptr) {
@@ -85,7 +89,7 @@ static size_t Backend_size(const void *ptr) {
 
 static const rb_data_type_t Backend_type = {
     "LibevBackend",
-    {Backend_mark, 0, Backend_size,},
+    {Backend_mark, Backend_free, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -117,7 +121,7 @@ static VALUE Backend_initialize(VALUE self) {
   
   GetBackend(self, backend);
 
-  initialize_backend_base(&backend->base);
+  backend_base_initialize(&backend->base);
   backend->ev_loop = libev_new_loop();
 
   // start async watcher used for breaking a poll op (from another thread)
@@ -156,24 +160,38 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-inline unsigned int Backend_pending_count(VALUE self) {
+inline VALUE Backend_poll(VALUE self, VALUE blocking) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  return backend->base.pending_count;
+  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_enter, rb_fiber_current());
+  backend->base.currently_polling = 1;
+  ev_run(backend->ev_loop, blocking == Qtrue ? EVRUN_ONCE : EVRUN_NOWAIT);
+  backend->base.currently_polling = 0;
+  COND_TRACE(&backend->base, 2, SYM_fiber_event_poll_leave, rb_fiber_current());
+
+  return self;
 }
 
-VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
+inline void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
-  backend->base.currently_polling = 1;
-  ev_run(backend->ev_loop, nowait == Qtrue ? EVRUN_NOWAIT : EVRUN_ONCE);
-  backend->base.currently_polling = 0;
-  COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
+  backend_base_schedule_fiber(thread, self, &backend->base, fiber, value, prioritize);
+}
 
-  return self;
+inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  runqueue_delete(&backend->base.runqueue, fiber);  
+}
+
+inline VALUE Backend_switch_fiber(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return backend_base_switch_fiber(self, &backend->base);
 }
 
 VALUE Backend_wakeup(VALUE self) {
@@ -193,6 +211,17 @@ VALUE Backend_wakeup(VALUE self) {
   return Qnil;
 }
 
+inline struct backend_stats Backend_stats(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return (struct backend_stats){
+    .scheduled_fibers = runqueue_len(&backend->base.runqueue),
+    .waiting_fibers = 0,
+    .pending_ops = backend->base.pending_count
+  };
+}
+
 struct libev_io {
   struct ev_io io;
   VALUE fiber;
@@ -1293,10 +1322,10 @@ VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
   return self;
 }
 
-VALUE Backend_idle_block_set(VALUE self, VALUE block) {
+VALUE Backend_idle_proc_set(VALUE self, VALUE block) {
   Backend_t *backend;
   GetBackend(self, backend);
-  backend->base.idle_block = block;
+  backend->base.idle_proc = block;
   return self;
 }
 
@@ -1443,6 +1472,21 @@ error:
   return RAISE_EXCEPTION(result);
 }
 
+VALUE Backend_trace(int argc, VALUE *argv, VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend_trace(&backend->base, argc, argv);
+  return self;
+}
+
+VALUE Backend_trace_proc_set(VALUE self, VALUE block) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  backend->base.trace_proc = block;
+  return self;
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
@@ -1452,13 +1496,15 @@ 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, "trace", Backend_trace, -1);
+  rb_define_method(cBackend, "trace_proc=", Backend_trace_proc_set, 1);
 
-  rb_define_method(cBackend, "poll", Backend_poll, 3);
+  rb_define_method(cBackend, "poll", Backend_poll, 1);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
   rb_define_method(cBackend, "kind", Backend_kind, 0);
   rb_define_method(cBackend, "chain", Backend_chain, -1);
   rb_define_method(cBackend, "idle_gc_period=", Backend_idle_gc_period_set, 1);
-  rb_define_method(cBackend, "idle_block=", Backend_idle_block_set, 1);
+  rb_define_method(cBackend, "idle_proc=", Backend_idle_proc_set, 1);
   rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);