polyphony 0.46.0 → 0.47.3

data/examples/performance/thread_switch.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+class Fiber
+  attr_accessor :next
+end
+
+# This program shows how the performance of Fiber.transfer degrades as the fiber
+# count increases
+
+def run(num_threads)
+  count = 0
+
+  GC.start
+  GC.disable
+
+  threads = []
+  t0 = Time.now
+  limit = 10_000_000 / num_threads
+  num_threads.times do
+    threads << Thread.new do
+      individual_count = 0
+      loop do
+        individual_count += 1
+        count += 1
+        break if individual_count == limit
+      end
+    end
+  end
+
+  threads.each(&:join)
+  elapsed = Time.now - t0
+
+  puts "threads: #{num_threads} count: #{count} rate: #{count / elapsed}"
+rescue Exception => e
+  puts "Stopped at #{count} threads"
+  p e
+end
+
+run(100)
+run(1000)
+run(10000)
+run(100000)

data/ext/polyphony/backend_common.h

@@ -1,3 +1,5 @@
+#include <time.h>
+
 #include "ruby.h"
 #include "ruby/io.h"
 
@@ -107,3 +109,21 @@ inline void rectify_io_file_pos(rb_io_t *fptr) {
     fptr->rbuf.len = 0;
   }
 }
+
+inline double current_time() {
+  struct timespec ts;
+  clock_gettime(CLOCK_MONOTONIC, &ts);
+  long long ns = ts.tv_sec;
+  ns = ns * 1000000000 + ts.tv_nsec;
+  double t = ns;
+  return t / 1e9;
+}
+
+inline VALUE backend_timeout_exception(VALUE exception) {
+  if (RTEST(rb_obj_is_kind_of(exception, rb_cArray)))
+    return rb_funcall(rb_ary_entry(exception, 0), ID_new, 1, rb_ary_entry(exception, 1));
+  else if (RTEST(rb_obj_is_kind_of(exception, rb_cClass)))
+    return rb_funcall(exception, ID_new, 0);
+  else
+    return rb_funcall(rb_eRuntimeError, ID_new, 1, exception);
+}

data/ext/polyphony/backend_io_uring.c

@@ -7,18 +7,18 @@
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
-
-#include "polyphony.h"
-#include "../liburing/liburing.h"
-#include "ruby/thread.h"
-#include "backend_io_uring_context.h"
-
+#include <stdnoreturn.h>
 #include <poll.h>
 #include <sys/types.h>
 #include <sys/eventfd.h>
 #include <sys/wait.h>
 #include <errno.h>
 
+#include "polyphony.h"
+#include "../liburing/liburing.h"
+#include "ruby/thread.h"
+#include "backend_io_uring_context.h"
+
 #ifndef __NR_pidfd_open
 #define __NR_pidfd_open 434   /* System call # on most architectures */
 #endif
@@ -171,7 +171,7 @@ void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *bac
     // otherwise, we mark it as completed, schedule the fiber and let it deal
     // with releasing the context
     ctx->completed = 1;
-    if (ctx->result != -ECANCELED) Fiber_make_runnable(ctx->fiber, Qnil);
+    if (ctx->result != -ECANCELED) Fiber_make_runnable(ctx->fiber, ctx->resume_value);
   }
 }
 
@@ -304,6 +304,7 @@ int io_uring_backend_defer_submit_and_await(
 
   if (value_ptr) (*value_ptr) = switchpoint_result;
   RB_GC_GUARD(switchpoint_result);
+  RB_GC_GUARD(ctx->fiber);
   return ctx->result;
 }
 
@@ -773,29 +774,137 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   return self;
 }
 
-VALUE Backend_sleep(VALUE self, VALUE duration) {
-  Backend_t *backend;
-  struct io_uring_sqe *sqe;
+inline struct __kernel_timespec double_to_timespec(double duration) {
   double duration_integral;
-  double duration_fraction = modf(NUM2DBL(duration), &duration_integral);
+  double duration_fraction = modf(duration, &duration_integral);
   struct __kernel_timespec ts;
-
-  GetBackend(self, backend);
-  sqe = io_uring_get_sqe(&backend->ring);
   ts.tv_sec = duration_integral;
 	ts.tv_nsec = floor(duration_fraction * 1000000000);
+  return ts;
+}
+
+inline struct __kernel_timespec duration_to_timespec(VALUE duration) {
+  return double_to_timespec(NUM2DBL(duration));
+}
+
+// returns true if completed, 0 otherwise
+int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
+  struct __kernel_timespec ts = double_to_timespec(duration);
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   
-  VALUE resume_value = Qnil;
   op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
   io_uring_prep_timeout(sqe, &ts, 0, 0);
 
-  io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+  io_uring_backend_defer_submit_and_await(backend, sqe, ctx, resume_value);
   OP_CONTEXT_RELEASE(&backend->store, ctx);
+  return ctx->completed;
+}
+
+VALUE Backend_sleep(VALUE self, VALUE duration) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  VALUE resume_value = Qnil;
+  io_uring_backend_submit_timeout_and_await(backend, NUM2DBL(duration), &resume_value);
   RAISE_IF_EXCEPTION(resume_value);
   RB_GC_GUARD(resume_value);
   return resume_value;
 }
 
+VALUE Backend_timer_loop(VALUE self, VALUE interval) {
+  Backend_t *backend;
+  double interval_d = NUM2DBL(interval);
+  GetBackend(self, backend);
+  double next_time = 0.;
+
+  while (1) {
+    double now = current_time();
+    if (next_time == 0.) next_time = current_time() + interval_d;
+    double sleep_duration = next_time - now;
+    if (sleep_duration < 0) sleep_duration = 0;
+    
+    VALUE resume_value = Qnil;
+    int completed = io_uring_backend_submit_timeout_and_await(backend, sleep_duration, &resume_value);
+    RAISE_IF_EXCEPTION(resume_value);
+    if (!completed) return resume_value;
+    RB_GC_GUARD(resume_value);
+
+    rb_yield(Qnil);
+
+    while (1) {
+      next_time += interval_d;
+      if (next_time > now) break;
+    }
+  }
+}
+
+VALUE Backend_timeout_safe(VALUE arg) {
+  return rb_yield(arg);
+}
+
+VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
+  return exception;
+}
+
+VALUE Backend_timeout_ensure_safe(VALUE arg) {
+  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
+}
+
+struct Backend_timeout_ctx {
+  Backend_t *backend;
+  op_context_t *ctx;
+};
+
+VALUE Backend_timeout_ensure(VALUE arg) {
+    struct Backend_timeout_ctx *timeout_ctx = (struct Backend_timeout_ctx *)arg;
+    if (!timeout_ctx->ctx->completed) {
+    timeout_ctx->ctx->result = -ECANCELED;
+
+    // op was not completed, so we need to cancel it
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&timeout_ctx->backend->ring);
+    io_uring_prep_cancel(sqe, timeout_ctx->ctx, 0);
+    timeout_ctx->backend->pending_sqes = 0;
+    io_uring_submit(&timeout_ctx->backend->ring);
+  }
+  OP_CONTEXT_RELEASE(&timeout_ctx->backend->store, timeout_ctx->ctx);
+  return Qnil;
+}
+
+VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
+  VALUE duration;
+  VALUE exception;
+  VALUE move_on_value = Qnil;
+  rb_scan_args(argc, argv, "21", &duration, &exception, &move_on_value);
+  
+  struct __kernel_timespec ts = duration_to_timespec(duration);
+  Backend_t *backend;
+  GetBackend(self, backend);
+  VALUE result = Qnil;
+  VALUE timeout = rb_funcall(cTimeoutException, ID_new, 0);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  
+  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
+  ctx->resume_value = timeout;
+  io_uring_prep_timeout(sqe, &ts, 0, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  io_uring_backend_defer_submit(backend);
+
+  struct Backend_timeout_ctx timeout_ctx = {backend, ctx};
+  result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
+
+  if (result == timeout) {
+    if (exception == Qnil) return move_on_value;
+    RAISE_EXCEPTION(backend_timeout_exception(exception));
+  }
+
+  RAISE_IF_EXCEPTION(result);
+  RB_GC_GUARD(result);
+  RB_GC_GUARD(timeout);
+  return result;
+}
+
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
   Backend_t *backend;
   int pid_int = NUM2INT(pid);
@@ -864,6 +973,8 @@ void Init_Backend() {
   rb_define_method(cBackend, "connect", Backend_connect, 3);
   rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
+  rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
+  rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
 

data/ext/polyphony/backend_io_uring_context.c

@@ -42,6 +42,7 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
 
   ctx->type = type;
   ctx->fiber = rb_fiber_current();
+  ctx->resume_value = Qnil;
   ctx->completed = 0;
   ctx->result = 0;
 

data/ext/polyphony/backend_io_uring_context.h

@@ -24,6 +24,7 @@ typedef struct op_context {
   int               id;
   int               result;
   VALUE             fiber;
+  VALUE             resume_value;
 } op_context_t;
 
 typedef struct op_context_store {

data/ext/polyphony/backend_libev.c

@@ -7,6 +7,7 @@
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <stdnoreturn.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
@@ -688,6 +689,105 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
   return switchpoint_result;
 }
 
+noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
+  Backend_t *backend;
+  struct libev_timer watcher;
+  double interval_d = NUM2DBL(interval);
+
+  GetBackend(self, backend);
+  watcher.fiber = rb_fiber_current();
+
+  double next_time = 0.;
+
+  while (1) {
+    double now = current_time();
+    if (next_time == 0.) next_time = current_time() + interval_d;
+    double sleep_duration = next_time - now;
+    if (sleep_duration < 0) sleep_duration = 0;
+    
+    VALUE switchpoint_result = Qnil;    
+    ev_timer_init(&watcher.timer, Backend_timer_callback, sleep_duration, 0.);
+    ev_timer_start(backend->ev_loop, &watcher.timer);
+    switchpoint_result = backend_await(backend);
+    ev_timer_stop(backend->ev_loop, &watcher.timer);
+    RAISE_IF_EXCEPTION(switchpoint_result);
+    RB_GC_GUARD(switchpoint_result);
+
+    rb_yield(Qnil);
+
+    while (1) {
+      next_time += interval_d;
+      if (next_time > now) break;
+    }
+  }
+}
+
+VALUE Backend_timeout_safe(VALUE arg) {
+  return rb_yield(arg);
+}
+
+VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
+  return exception;
+}
+
+VALUE Backend_timeout_ensure_safe(VALUE arg) {
+  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
+}
+
+struct libev_timeout {
+  struct ev_timer timer;
+  VALUE fiber;
+  VALUE resume_value;
+};
+
+struct Backend_timeout_ctx {
+  Backend_t *backend;
+  struct libev_timeout *watcher;
+};
+
+VALUE Backend_timeout_ensure(VALUE arg) {
+  struct Backend_timeout_ctx *timeout_ctx = (struct Backend_timeout_ctx *)arg;
+  ev_timer_stop(timeout_ctx->backend->ev_loop, &(timeout_ctx->watcher->timer));
+  return Qnil;
+}
+
+void Backend_timeout_callback(EV_P_ ev_timer *w, int revents)
+{
+  struct libev_timeout *watcher = (struct libev_timeout *)w;
+  Fiber_make_runnable(watcher->fiber, watcher->resume_value);
+}
+
+VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
+  VALUE duration;
+  VALUE exception;
+  VALUE move_on_value = Qnil;
+  rb_scan_args(argc, argv, "21", &duration, &exception, &move_on_value);
+
+  Backend_t *backend;
+  struct libev_timeout watcher;
+  VALUE result = Qnil;
+  VALUE timeout = rb_funcall(cTimeoutException, ID_new, 0);
+
+  GetBackend(self, backend);
+  watcher.fiber = rb_fiber_current();
+  watcher.resume_value = timeout;
+  ev_timer_init(&watcher.timer, Backend_timeout_callback, NUM2DBL(duration), 0.);
+  ev_timer_start(backend->ev_loop, &watcher.timer);
+
+  struct Backend_timeout_ctx timeout_ctx = {backend, &watcher};
+  result = rb_ensure(Backend_timeout_ensure_safe, Qnil, Backend_timeout_ensure, (VALUE)&timeout_ctx);
+  
+  if (result == timeout) {
+    if (exception == Qnil) return move_on_value;
+    RAISE_EXCEPTION(backend_timeout_exception(exception));
+  }
+
+  RAISE_IF_EXCEPTION(result);
+  RB_GC_GUARD(result);
+  RB_GC_GUARD(timeout);
+  return result;
+}
+
 struct libev_child {
   struct ev_child child;
   VALUE fiber;
@@ -777,6 +877,8 @@ void Init_Backend() {
   rb_define_method(cBackend, "send", Backend_write, 2);
   rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
+  rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
+  rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
 

data/ext/polyphony/fiber.c

@@ -21,7 +21,7 @@ VALUE SYM_fiber_terminate;
 
 static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
   VALUE arg = (argc == 0) ? Qnil : argv[0];
-  VALUE ret = rb_funcall(self, ID_transfer, 1, arg);
+  VALUE ret = FIBER_TRANSFER(self, arg);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
@@ -42,10 +42,6 @@ inline VALUE Fiber_auto_watcher(VALUE self) {
 void Fiber_make_runnable(VALUE fiber, VALUE value) {
   VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
   if (thread == Qnil) {
-    INSPECT("Fiber with no thread", fiber);
-    TRACE_CALLER();
-    TRACE_C_STACK();
-    exit(-1);
     rb_raise(rb_eRuntimeError, "No thread set for fiber");
     // rb_warn("No thread set for fiber");
     return;
@@ -57,7 +53,6 @@ void Fiber_make_runnable(VALUE fiber, VALUE value) {
 void Fiber_make_runnable_with_priority(VALUE fiber, VALUE value) {
   VALUE thread = rb_ivar_get(fiber, ID_ivar_thread);
   if (thread == Qnil) {
-    INSPECT("Fiber with no thread", fiber);
     rb_raise(rb_eRuntimeError, "No thread set for fiber");
     // rb_warn("No thread set for fiber");
     return;
@@ -133,6 +128,15 @@ VALUE Fiber_receive(VALUE self) {
   return Queue_shift(mailbox);  
 }
 
+VALUE Fiber_mailbox(VALUE self) {
+  VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
+  if (mailbox == Qnil) {
+    mailbox = rb_funcall(cQueue, ID_new, 0);
+    rb_ivar_set(self, ID_ivar_mailbox, mailbox);
+  }
+  return mailbox;
+}
+
 VALUE Fiber_receive_all_pending(VALUE self) {
   VALUE mailbox = rb_ivar_get(self, ID_ivar_mailbox);
   return (mailbox == Qnil) ? rb_ary_new() : Queue_shift_all(mailbox);
@@ -151,9 +155,9 @@ void Init_Fiber() {
 
   rb_define_method(cFiber, "<<", Fiber_send, 1);
   rb_define_method(cFiber, "send", Fiber_send, 1);
-
   rb_define_method(cFiber, "receive", Fiber_receive, 0);
   rb_define_method(cFiber, "receive_all_pending", Fiber_receive_all_pending, 0);
+  rb_define_method(cFiber, "mailbox", Fiber_mailbox, 0);
 
   SYM_dead = ID2SYM(rb_intern("dead"));
   SYM_running = ID2SYM(rb_intern("running"));