polyphony 0.52.0 → 0.55.0

data/ext/polyphony/backend_io_uring_context.c

@@ -1,4 +1,5 @@
 #include <stdlib.h>
+#include <assert.h>
 #include "ruby.h"
 #include "polyphony.h"
 #include "backend_io_uring_context.h"
@@ -10,10 +11,12 @@ const char *op_type_to_str(enum op_type type) {
   case OP_WRITE: return "WRITE";
   case OP_RECV: return "RECV";
   case OP_SEND: return "SEND";
+  case OP_SPLICE: return "SPLICE";
   case OP_TIMEOUT: return "TIMEOUT";
   case OP_POLL: return "POLL";
   case OP_ACCEPT: return "ACCEPT";
   case OP_CONNECT: return "CONNECT";
+  case OP_CHAIN: return "CHAIN";
   default: return "";
   };
 }
@@ -34,6 +37,7 @@ inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_ty
     ctx = malloc(sizeof(op_context_t));
   }
   ctx->id = (++store->last_id);
+  // printf("acquire %d (%s)\n", ctx->id, op_type_to_str(type));
   
   ctx->prev = NULL;
   ctx->next = store->taken;
@@ -43,13 +47,21 @@ 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->ref_count = 2;
   ctx->result = 0;
 
   return ctx;
 }
 
-inline void context_store_release(op_context_store_t *store, op_context_t *ctx) {
+// returns true if ctx was released
+inline int context_store_release(op_context_store_t *store, op_context_t *ctx) {
+  // printf("release %d (%s, ref_count: %d)\n", ctx->id, op_type_to_str(ctx->type), ctx->ref_count);
+
+  assert(ctx->ref_count);
+  
+  ctx->ref_count--;
+  if (ctx->ref_count) return 0;
+
   if (ctx->next) ctx->next->prev = ctx->prev;
   if (ctx->prev) ctx->prev->next = ctx->next;
   if (store->taken == ctx) store->taken = ctx->next;
@@ -58,6 +70,7 @@ inline void context_store_release(op_context_store_t *store, op_context_t *ctx)
   ctx->next = store->available;
   if (ctx->next) ctx->next->prev = ctx;
   store->available = ctx;
+  return 1;
 }
 
 void context_store_free(op_context_store_t *store) {

data/ext/polyphony/backend_io_uring_context.h

@@ -10,17 +10,19 @@ enum op_type {
   OP_WRITE,
   OP_RECV,
   OP_SEND,
+  OP_SPLICE,
   OP_TIMEOUT,
   OP_POLL,
   OP_ACCEPT,
-  OP_CONNECT
+  OP_CONNECT,
+  OP_CHAIN
 };
 
 typedef struct op_context {
   struct op_context *prev;
   struct op_context *next;
   enum op_type      type: 16;
-  int               completed : 16;
+  unsigned int      ref_count : 16;         
   int               id;
   int               result;
   VALUE             fiber;
@@ -37,17 +39,16 @@ const char *op_type_to_str(enum op_type type);
 
 void context_store_initialize(op_context_store_t *store);
 op_context_t *context_store_acquire(op_context_store_t *store, enum op_type type);
-void context_store_release(op_context_store_t *store, op_context_t *ctx);
+int context_store_release(op_context_store_t *store, op_context_t *ctx);
 void context_store_free(op_context_store_t *store);
 
-#define OP_CONTEXT_ACQUIRE(store, op_type) context_store_acquire(store, op_type)
-#define OP_CONTEXT_RELEASE(store, ctx) { \
-  if (ctx->completed) {\
-    context_store_release(store, ctx); \
-  } \
-  else { \
-    ctx->completed = 1; \
-  } \
+inline unsigned int OP_CONTEXT_RELEASE(op_context_store_t *store, op_context_t *ctx) {
+  int completed = !ctx->ref_count;
+  if (ctx->ref_count)
+    ctx->ref_count -= 1;
+  else
+    context_store_release(store, ctx);
+  return completed;
 }
 
 #endif /* BACKEND_IO_URING_CONTEXT_H */

data/ext/polyphony/backend_libev.c

@@ -38,11 +38,15 @@ thread.
 
 #ifdef POLYPHONY_BACKEND_LIBEV
 
+#ifdef POLYPHONY_LINUX
+#define _GNU_SOURCE 1
+#endif
+
+#include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <unistd.h>
-#include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdnoreturn.h>
@@ -54,6 +58,9 @@ thread.
 #include "ruby/io.h"
 
 VALUE SYM_libev;
+VALUE SYM_send;
+VALUE SYM_splice;
+VALUE SYM_write;
 
 ID ID_ivar_is_nonblocking;
 
@@ -83,7 +90,6 @@ 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;
@@ -138,7 +144,6 @@ static VALUE Backend_initialize(VALUE self) {
 
   backend->currently_polling = 0;
   backend->pending_count = 0;
-  backend->poll_no_wait_count = 0;
 
   return Qnil;
 }
@@ -177,23 +182,12 @@ unsigned int Backend_pending_count(VALUE self) {
 }
 
 VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
-  int is_nowait = nowait == Qtrue;
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (is_nowait) {
-    backend->poll_no_wait_count++;
-    if (backend->poll_no_wait_count < 10) return self;
-
-    long runnable_count = Runqueue_len(runqueue);
-    if (backend->poll_no_wait_count < runnable_count) return self;
-  }
-
-  backend->poll_no_wait_count = 0;
-
   COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
   backend->currently_polling = 1;
-  ev_run(backend->ev_loop, is_nowait ? EVRUN_NOWAIT : EVRUN_ONCE);
+  ev_run(backend->ev_loop, nowait == Qtrue ? EVRUN_NOWAIT : EVRUN_ONCE);
   backend->currently_polling = 0;
   COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
 
@@ -769,6 +763,118 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+#ifdef POLYPHONY_LINUX
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len;
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_set_nonblock(src_fptr, src);
+
+  underlying_io = rb_ivar_get(dest, ID_ivar_io);
+  if (underlying_io != Qnil) dest = underlying_io;
+  dest = rb_io_get_write_io(dest);
+  GetOpenFile(dest, dest_fptr);
+  io_set_nonblock(dest_fptr, dest);
+
+  watcher.fiber = Qnil;
+  while (1) {
+    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    if (len < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      break;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(len);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len;
+  int total = 0;
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_set_nonblock(src_fptr, src);
+
+  underlying_io = rb_ivar_get(dest, ID_ivar_io);
+  if (underlying_io != Qnil) dest = underlying_io;
+  dest = rb_io_get_write_io(dest);
+  GetOpenFile(dest, dest_fptr);
+  io_set_nonblock(dest_fptr, dest);
+
+  watcher.fiber = Qnil;
+  while (1) {
+    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    if (len < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else if (len == 0) {
+      break;
+    }
+    else {
+      total += len;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(total);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+#endif
+
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -981,6 +1087,31 @@ VALUE Backend_kind(VALUE self) {
   return SYM_libev;
 }
 
+VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
+  VALUE result = Qnil;
+  if (argc == 0) return result;
+
+  for (int i = 0; i < argc; i++) {
+    VALUE op = argv[i];
+    VALUE op_type = RARRAY_AREF(op, 0);
+    VALUE op_len = RARRAY_LEN(op);
+
+    if (op_type == SYM_write && op_len == 3)
+      result = Backend_write(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2));
+    else if (op_type == SYM_send && op_len == 4)
+      result = Backend_send(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    #ifdef POLYPHONY_LINUX
+    else if (op_type == SYM_splice && op_len == 4)
+      result = Backend_splice(self, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    #endif
+    else
+      rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
+  }
+  
+  RB_GC_GUARD(result);
+  return result;
+}
+
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
@@ -993,30 +1124,40 @@ void Init_Backend() {
 
   rb_define_method(cBackend, "poll", Backend_poll, 3);
   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, "read", Backend_read, 4);
-  rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
-  rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
-  rb_define_method(cBackend, "write", Backend_write_m, -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, "feed_loop", Backend_feed_loop, 3);
+  rb_define_method(cBackend, "read", Backend_read, 4);
+  rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
   rb_define_method(cBackend, "recv", Backend_recv, 3);
   rb_define_method(cBackend, "recv_loop", Backend_read_loop, 1);
   rb_define_method(cBackend, "recv_feed_loop", Backend_feed_loop, 3);
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 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);
+
+  #ifdef POLYPHONY_LINUX
+  rb_define_method(cBackend, "splice", Backend_splice, 3);
+  rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
+  #endif
+
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
-  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
-
-  rb_define_method(cBackend, "kind", Backend_kind, 0);
+  rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
+  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "write", Backend_write_m, -1);
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   SYM_libev = ID2SYM(rb_intern("libev"));
+
+  SYM_send = ID2SYM(rb_intern("send"));
+  SYM_splice = ID2SYM(rb_intern("splice"));
+  SYM_write = ID2SYM(rb_intern("write"));
 }
 
 #endif // POLYPHONY_BACKEND_LIBEV

data/ext/polyphony/extconf.rb

@@ -6,8 +6,9 @@ require 'mkmf'
 use_liburing = false
 use_pidfd_open = false
 force_use_libev = ENV['POLYPHONY_USE_LIBEV'] != nil
+linux = RUBY_PLATFORM =~ /linux/
 
-if RUBY_PLATFORM =~ /linux/ && `uname -sr` =~ /Linux 5\.([\d+])/
+if linux && `uname -sr` =~ /Linux 5\.([\d+])/
   kernel_minor_version = $1.gsub('.', '').to_i
   use_liburing = !force_use_libev && kernel_minor_version >= 6
   use_pidfd_open = kernel_minor_version >= 3
@@ -20,6 +21,7 @@ if use_liburing
   $CFLAGS << " -Wno-pointer-arith"
 else
   $defs << "-DPOLYPHONY_BACKEND_LIBEV"
+  $defs << "-DPOLYPHONY_LINUX" if linux
   $defs << '-DEV_USE_LINUXAIO'     if have_header('linux/aio_abi.h')
   $defs << '-DEV_USE_SELECT'       if have_header('sys/select.h')
   $defs << '-DEV_USE_POLL'         if have_type('port_event_t', 'poll.h')

data/ext/polyphony/polyphony.c

@@ -46,8 +46,6 @@ VALUE Polyphony_trace(VALUE self, VALUE enabled) {
   return Qnil;
 }
 
-#define BACKEND() (rb_ivar_get(rb_thread_current(), ID_ivar_backend))
-
 VALUE Polyphony_backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
   return Backend_accept(BACKEND(), server_socket, socket_class);
 }
@@ -96,6 +94,14 @@ VALUE Polyphony_backend_sleep(VALUE self, VALUE duration) {
   return Backend_sleep(BACKEND(), duration);
 }
 
+VALUE Polyphony_backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  return Backend_splice(BACKEND(), src, dest, maxlen);
+}
+
+VALUE Polyphony_backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize) {
+  return Backend_splice_to_eof(BACKEND(), src, dest, chunksize);
+}
+
 VALUE Polyphony_backend_timeout(int argc,VALUE *argv, VALUE self) {
   return Backend_timeout(argc, argv, BACKEND());
 }
@@ -138,6 +144,8 @@ void Init_Polyphony() {
   rb_define_singleton_method(mPolyphony, "backend_send", Polyphony_backend_send, 3);
   rb_define_singleton_method(mPolyphony, "backend_sendv", Polyphony_backend_sendv, 3);
   rb_define_singleton_method(mPolyphony, "backend_sleep", Polyphony_backend_sleep, 1);
+  rb_define_singleton_method(mPolyphony, "backend_splice", Polyphony_backend_splice, 3);
+  rb_define_singleton_method(mPolyphony, "backend_splice_to_eof", Polyphony_backend_splice_to_eof, 3);
   rb_define_singleton_method(mPolyphony, "backend_timeout", Polyphony_backend_timeout, -1);
   rb_define_singleton_method(mPolyphony, "backend_timer_loop", Polyphony_backend_timer_loop, 1);
   rb_define_singleton_method(mPolyphony, "backend_wait_event", Polyphony_backend_wait_event, 1);

data/ext/polyphony/polyphony.h

@@ -31,6 +31,8 @@
 // Fiber#transfer
 #define FIBER_TRANSFER(fiber, value) rb_funcall(fiber, ID_transfer, 1, value)
 
+#define BACKEND() (rb_ivar_get(rb_thread_current(), ID_ivar_backend))
+
 extern VALUE mPolyphony;
 extern VALUE cQueue;
 extern VALUE cEvent;
@@ -88,6 +90,7 @@ int Runqueue_index_of(VALUE self, VALUE fiber);
 void Runqueue_clear(VALUE self);
 long Runqueue_len(VALUE self);
 int Runqueue_empty_p(VALUE self);
+int Runqueue_should_poll_nonblocking(VALUE self);
 
 #ifdef POLYPHONY_BACKEND_LIBEV
 #define Backend_recv_loop Backend_read_loop
@@ -108,6 +111,8 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
 VALUE Backend_send(VALUE self, VALUE io, VALUE msg, VALUE flags);
 VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
 VALUE Backend_sleep(VALUE self, VALUE duration);
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen);
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize);
 VALUE Backend_timeout(int argc,VALUE *argv, VALUE self);
 VALUE Backend_timer_loop(VALUE self, VALUE interval);
 VALUE Backend_wait_event(VALUE self, VALUE raise);