polyphony 0.54.0 → 0.59

data/ext/polyphony/backend_common.h

@@ -1,17 +1,42 @@
-#include <time.h>
+#ifndef BACKEND_COMMON_H
+#define BACKEND_COMMON_H
 
 #include "ruby.h"
 #include "ruby/io.h"
+#include "runqueue.h"
 
+struct backend_stats {
+  int scheduled_fibers;
+  int waiting_fibers;
+  int pending_ops;
+};
 
-#ifdef POLYPHONY_USE_PIDFD_OPEN
-#ifndef __NR_pidfd_open
-#define __NR_pidfd_open 434   /* System call # on most architectures */
-#endif
+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_proc;
+  VALUE trace_proc;
+};
 
-static int pidfd_open(pid_t pid, unsigned int flags) {
-  return syscall(__NR_pidfd_open, pid, flags);
-}
+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);
 #endif
 
 //////////////////////////////////////////////////////////////////////
@@ -26,75 +51,19 @@ struct io_internal_read_struct {
 
 #define StringValue(v) rb_string_value(&(v))
 
-int io_setstrbuf(VALUE *str, long len) {
-  #ifdef _WIN32
-    len = (len + 1) & ~1L;	/* round up for wide char */
-  #endif
-  if (*str == Qnil) {
-    *str = rb_str_new(0, len);
-    return 1;
-  }
-  else {
-    VALUE s = StringValue(*str);
-    long clen = RSTRING_LEN(s);
-    if (clen >= len) {
-      rb_str_modify(s);
-      return 0;
-    }
-    len -= clen;
-  }
-  rb_str_modify_expand(*str, len);
-  return 0;
-}
-
-#define MAX_REALLOC_GAP 4096
-
-inline void io_shrink_read_string(VALUE str, long n) {
-  if (rb_str_capacity(str) - n > MAX_REALLOC_GAP) {
-    rb_str_resize(str, n);
-  }
-}
-
-void io_set_read_length(VALUE str, long n, int shrinkable) {
-  if (RSTRING_LEN(str) != n) {
-    rb_str_modify(str);
-    rb_str_set_len(str, n);
-    if (shrinkable) io_shrink_read_string(str, n);
-  }
-}
-
-inline rb_encoding* io_read_encoding(rb_io_t *fptr) {
-    if (fptr->encs.enc) {
-	return fptr->encs.enc;
-    }
-    return rb_default_external_encoding();
-}
-
-VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
-    OBJ_TAINT(str);
-    rb_enc_associate(str, io_read_encoding(fptr));
-    return str;
-}
+int io_setstrbuf(VALUE *str, long len);
+void io_shrink_read_string(VALUE str, long n);
+void io_set_read_length(VALUE str, long n, int shrinkable);
+rb_encoding* io_read_encoding(rb_io_t *fptr);
+VALUE io_enc_str(VALUE str, rb_io_t *fptr);
 
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 
-inline VALUE backend_await(Backend_t *backend) {
-  VALUE ret;
-  backend->pending_count++;
-  ret = Thread_switch_fiber(rb_thread_current());
-  backend->pending_count--;
-  RB_GC_GUARD(ret);
-  return ret;
-}
-
-inline VALUE backend_snooze() {
-  Fiber_make_runnable(rb_fiber_current(), Qnil);
-  return Thread_switch_fiber(rb_thread_current());
-}
+VALUE backend_await(struct Backend_base *backend);
+VALUE backend_snooze();
 
 // macros for doing read loops
-
 #define READ_LOOP_PREPARE_STR() { \
   str = Qnil; \
   shrinkable = io_setstrbuf(&str, len); \
@@ -117,63 +86,13 @@ inline VALUE backend_snooze() {
   READ_LOOP_PREPARE_STR(); \
 }
 
-inline void rectify_io_file_pos(rb_io_t *fptr) {
-  // Apparently after reopening a closed file, the file position is not reset,
-  // which causes the read to fail. Fortunately we can use fptr->rbuf.len to
-  // find out if that's the case.
-  // See: https://github.com/digital-fabric/polyphony/issues/30
-  if (fptr->rbuf.len > 0) {
-    lseek(fptr->fd, -fptr->rbuf.len, SEEK_CUR);
-    fptr->rbuf.len = 0;
-  }
-}
-
-inline double current_time() {
-  struct timespec ts;
-  clock_gettime(CLOCK_MONOTONIC, &ts);
-  long long ns = ts.tv_sec;
-  ns = ns * 1e9 + ts.tv_nsec;
-  double t = ns;
-  return t / 1e9;
-}
-
-inline VALUE backend_timeout_exception(VALUE exception) {
-  if (rb_obj_is_kind_of(exception, rb_cArray) == Qtrue)
-    return rb_funcall(rb_ary_entry(exception, 0), ID_new, 1, rb_ary_entry(exception, 1));
-  else if (rb_obj_is_kind_of(exception, rb_cClass) == Qtrue)
-    return rb_funcall(exception, ID_new, 0);
-  else
-    return rb_funcall(rb_eRuntimeError, ID_new, 1, exception);
-}
+void rectify_io_file_pos(rb_io_t *fptr);
+double current_time();
+VALUE backend_timeout_exception(VALUE exception);
+VALUE Backend_timeout_ensure_safe(VALUE arg);
+VALUE Backend_timeout_ensure_safe(VALUE arg);
+VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags);
+void backend_run_idle_tasks(struct Backend_base *base);
+void io_verify_blocking_mode(rb_io_t *fptr, VALUE io, VALUE blocking);
 
-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);
-}
-
-static VALUE empty_string = Qnil;
-
-VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
-  switch (RARRAY_LEN(ary)) {
-  case 0:
-    return Qnil;
-  case 1:
-    return Backend_send(self, io, RARRAY_AREF(ary, 0), flags);
-  default:
-    if (empty_string == Qnil) {
-      empty_string = rb_str_new_literal("");
-      rb_global_variable(&empty_string);
-    }
-    VALUE joined = rb_ary_join(ary, empty_string);
-    VALUE result = Backend_send(self, io, joined, flags);
-    RB_GC_GUARD(joined);
-    return result;
-  }
-}
+#endif /* BACKEND_COMMON_H */

data/ext/polyphony/backend_io_uring.c

@@ -4,7 +4,6 @@
 #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>
@@ -19,39 +18,21 @@
 #include "backend_io_uring_context.h"
 #include "ruby/thread.h"
 #include "ruby/io.h"
+#include "backend_common.h"
 
 VALUE SYM_io_uring;
+VALUE SYM_send;
+VALUE SYM_splice;
+VALUE SYM_write;
 
 #ifdef POLYPHONY_UNSET_NONBLOCK
-ID ID_ivar_is_nonblocking;
-
-// One of the changes introduced in Ruby 3.0 as part of the work on the
-// FiberScheduler interface is that all created sockets are marked as
-// non-blocking. This prevents the io_uring backend from working correctly,
-// since it will return an EAGAIN error just like a normal syscall. So here
-// instead of setting O_NONBLOCK (which is required for the libev backend), we
-// unset it.
-inline void io_unset_nonblock(rb_io_t *fptr, VALUE io) {
-  VALUE is_nonblocking = rb_ivar_get(io, ID_ivar_is_nonblocking);
-  if (is_nonblocking == Qfalse) return;
-
-  rb_ivar_set(io, ID_ivar_is_nonblocking, Qfalse);
-
-  int oflags = fcntl(fptr->fd, F_GETFL);
-  if ((oflags == -1) && (oflags & O_NONBLOCK)) return;
-  oflags &= !O_NONBLOCK;
-  fcntl(fptr->fd, F_SETFL, oflags);
-}
+#define io_unset_nonblock(fptr, io) io_verify_blocking_mode(fptr, io, Qtrue)
 #else
-// NOP
 #define io_unset_nonblock(fptr, io)
 #endif
 
 typedef struct Backend_t {
-  // common fields
-  unsigned int        currently_polling;
-  unsigned int        pending_count;
-  unsigned int        poll_no_wait_count;
+  struct Backend_base base;
 
   // implementation-specific fields
   struct io_uring     ring;
@@ -61,7 +42,15 @@ typedef struct Backend_t {
   int                 event_fd;
 } Backend_t;
 
-#include "backend_common.h"
+static void Backend_mark(void *ptr) {
+  Backend_t *backend = ptr;
+  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) {
   return sizeof(Backend_t);
@@ -69,7 +58,7 @@ static size_t Backend_size(const void *ptr) {
 
 static const rb_data_type_t Backend_type = {
     "IOUringBackend",
-    {0, 0, Backend_size,},
+    {Backend_mark, Backend_free, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -86,9 +75,7 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  backend->currently_polling = 0;
-  backend->pending_count = 0;
-  backend->poll_no_wait_count = 0;
+  backend_base_initialize(&backend->base);
   backend->pending_sqes = 0;
   backend->prepared_limit = 2048;
 
@@ -116,21 +103,13 @@ VALUE Backend_post_fork(VALUE self) {
   io_uring_queue_exit(&backend->ring);
   io_uring_queue_init(backend->prepared_limit, &backend->ring, 0);
   context_store_free(&backend->store);
-  backend->currently_polling = 0;
-  backend->pending_count = 0;
-  backend->poll_no_wait_count = 0;
+  backend->base.currently_polling = 0;
+  backend->base.pending_count = 0;
   backend->pending_sqes = 0;
 
   return self;
 }
 
-unsigned int Backend_pending_count(VALUE self) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  return backend->pending_count;
-}
-
 typedef struct poll_context {
   struct io_uring     *ring;
   struct io_uring_cqe *cqe;
@@ -154,18 +133,11 @@ static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe,
   op_context_t *ctx = io_uring_cqe_get_data(cqe);
   if (!ctx) return;
 
+  // printf("cqe ctx %p id: %d result: %d (%s, ref_count: %d)\n", ctx, ctx->id, cqe->res, op_type_to_str(ctx->type), ctx->ref_count);
   ctx->result = cqe->res;
-
-  if (ctx->completed)
-    // already marked as deleted as result of fiber resuming before op
-    // completion, so we can release the context
-    context_store_release(&backend->store, ctx);
-  else {
-    // 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, ctx->resume_value);
-  }
+  if (ctx->ref_count == 2 && ctx->result != -ECANCELED && ctx->fiber)
+    Fiber_make_runnable(ctx->fiber, ctx->resume_value);
+  context_store_release(&backend->store, ctx);
 }
 
 // adapted from io_uring_peek_batch_cqe in queue.c 
@@ -205,48 +177,70 @@ void io_uring_backend_poll(Backend_t *backend) {
     io_uring_submit(&backend->ring);
   }
 
-  backend->currently_polling = 1;
+  backend->base.currently_polling = 1;
   rb_thread_call_without_gvl(io_uring_backend_poll_without_gvl, (void *)&poll_ctx, RUBY_UBF_IO, 0);
-  backend->currently_polling = 0;
+  backend->base.currently_polling = 0;
   if (poll_ctx.result < 0) return;
 
   io_uring_backend_handle_completion(poll_ctx.cqe, 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->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;
-
-  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);
 
-  if (backend->currently_polling) {
+  if (backend->base.currently_polling) {
     // Since we're currently blocking while waiting for a completion, we add a
     // NOP which would cause the io_uring_enter syscall to return
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
@@ -277,16 +271,17 @@ int io_uring_backend_defer_submit_and_await(
 {
   VALUE switchpoint_result = Qnil;
 
-  io_uring_sqe_set_data(sqe, ctx);
-  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  if (sqe) {
+    io_uring_sqe_set_data(sqe, ctx);
+    io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  }
   io_uring_backend_defer_submit(backend);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
-  if (!ctx->completed) {
+  if (ctx->ref_count > 1) {
+    // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
-
-    // op was not completed, so we need to cancel it
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_cancel(sqe, ctx, 0);
     backend->pending_sqes = 0;
@@ -300,7 +295,7 @@ int io_uring_backend_defer_submit_and_await(
 }
 
 VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_POLL);
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_POLL);
   VALUE resumed_value = Qnil;
 
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
@@ -332,14 +327,14 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_READ);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, buffer_size - total, -1);
 
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -393,14 +388,14 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_READ);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
     
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -440,14 +435,14 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_READ);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
     
     ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -483,14 +478,14 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
 
   while (left > 0) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_WRITE);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
-    io_uring_prep_write(sqe, fptr->fd, buf, left, -1);
+    io_uring_prep_write(sqe, fptr->fd, buf, left, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
     
     if (result < 0)
@@ -532,17 +527,17 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_WRITEV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITEV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_writev(sqe, fptr->fd, iov_ptr, iov_count, -1);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     if (TEST_EXCEPTION(resume_value)) {
       free(iov);
       RAISE_EXCEPTION(resume_value);
     }
-    if (!ctx->completed) {
+    if (!completed) {
       free(iov);
       return resume_value;
     }
@@ -605,14 +600,14 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len - total, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -652,14 +647,14 @@ VALUE Backend_recv_loop(VALUE self, VALUE io) {
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -698,14 +693,14 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -741,14 +736,14 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
 
   while (left > 0) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_SEND);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (result < 0)
@@ -775,14 +770,14 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
 
   while (1) {
     VALUE resume_value = Qnil;
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_ACCEPT);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_ACCEPT);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_accept(sqe, fptr->fd, &addr, &len, 0);
     
     int fd = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
     RB_GC_GUARD(resume_value);
 
     if (fd < 0)
@@ -846,14 +841,14 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
   VALUE resume_value = Qnil;
 
   while (1) {
-    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_SPLICE);
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
     io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    int completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
-    if (!ctx->completed) return resume_value;
+    if (!completed) return resume_value;
 
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
@@ -897,13 +892,13 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   addr.sin_port = htons(NUM2INT(port));
 
   VALUE resume_value = Qnil;
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_CONNECT);
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_CONNECT);
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   io_uring_prep_connect(sqe, fptr->fd, (struct sockaddr *)&addr, sizeof(addr));
   int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
-  OP_CONTEXT_RELEASE(&backend->store, ctx);
+  int completed = context_store_release(&backend->store, ctx);
   RAISE_IF_EXCEPTION(resume_value);
-  if (!ctx->completed) return resume_value;
+  if (!completed) return resume_value;
   RB_GC_GUARD(resume_value);
   
   if (result < 0) rb_syserr_fail(-result, strerror(-result));
@@ -943,12 +938,10 @@ int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duratio
   struct __kernel_timespec ts = double_to_timespec(duration);
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
+  op_context_t *ctx = context_store_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);
-  OP_CONTEXT_RELEASE(&backend->store, ctx);
-  return ctx->completed;
+  return context_store_release(&backend->store, ctx);
 }
 
 VALUE Backend_sleep(VALUE self, VALUE duration) {
@@ -996,7 +989,7 @@ struct Backend_timeout_ctx {
 
 VALUE Backend_timeout_ensure(VALUE arg) {
     struct Backend_timeout_ctx *timeout_ctx = (struct Backend_timeout_ctx *)arg;
-    if (!timeout_ctx->ctx->completed) {
+    if (timeout_ctx->ctx->ref_count) {
     timeout_ctx->ctx->result = -ECANCELED;
 
     // op was not completed, so we need to cancel it
@@ -1005,7 +998,7 @@ VALUE Backend_timeout_ensure(VALUE arg) {
     timeout_ctx->backend->pending_sqes = 0;
     io_uring_submit(&timeout_ctx->backend->ring);
   }
-  OP_CONTEXT_RELEASE(&timeout_ctx->backend->store, timeout_ctx->ctx);
+  context_store_release(&timeout_ctx->backend->store, timeout_ctx->ctx);
   return Qnil;
 }
 
@@ -1023,7 +1016,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
 
   struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
   
-  op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_TIMEOUT);
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_sqe_set_data(sqe, ctx);
@@ -1091,6 +1084,321 @@ VALUE Backend_kind(VALUE self) {
   return SYM_io_uring;
 }
 
+struct io_uring_sqe *Backend_chain_prepare_write(Backend_t *backend, VALUE io, VALUE str) {
+  rb_io_t *fptr;
+  VALUE underlying_io;
+
+  underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+  io = rb_io_get_write_io(io);
+  GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
+
+  char *buf = StringValuePtr(str);
+  long len = RSTRING_LEN(str);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_write(sqe, fptr->fd, buf, len, 0);
+  return sqe;
+}
+
+struct io_uring_sqe *Backend_chain_prepare_send(Backend_t *backend, VALUE io, VALUE str, VALUE flags) {
+  rb_io_t *fptr;
+  VALUE underlying_io;
+
+  underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+  io = rb_io_get_write_io(io);
+  GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
+
+  char *buf = StringValuePtr(str);
+  long len = RSTRING_LEN(str);
+  int flags_int = NUM2INT(flags);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_send(sqe, fptr->fd, buf, len, flags_int);
+  return sqe;
+}
+
+struct io_uring_sqe *Backend_chain_prepare_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE maxlen) {
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  VALUE underlying_io;
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_unset_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_unset_nonblock(dest_fptr, dest);
+
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
+  return sqe;
+}
+
+VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
+  VALUE resume_value = Qnil;
+  unsigned int sqe_count = 0;
+  struct io_uring_sqe *last_sqe = 0;
+  Backend_t *backend;
+  GetBackend(self, backend);
+  if (argc == 0) return resume_value;
+
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_CHAIN);
+  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) {
+      last_sqe = Backend_chain_prepare_write(backend, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2));
+    }
+    else if (op_type == SYM_send && op_len == 4)
+      last_sqe = Backend_chain_prepare_send(backend, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    else if (op_type == SYM_splice && op_len == 4)
+      last_sqe = Backend_chain_prepare_splice(backend, RARRAY_AREF(op, 1), RARRAY_AREF(op, 2), RARRAY_AREF(op, 3));
+    else {
+      if (sqe_count) {
+        io_uring_sqe_set_data(last_sqe, ctx);
+        io_uring_sqe_set_flags(last_sqe, IOSQE_ASYNC);
+
+        ctx->ref_count = sqe_count;
+        ctx->result = -ECANCELED;
+        struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+        io_uring_prep_cancel(sqe, ctx, 0);
+        backend->pending_sqes = 0;
+        io_uring_submit(&backend->ring);
+      }
+      else {
+        ctx->ref_count = 1;
+        context_store_release(&backend->store, ctx);
+      }
+      rb_raise(rb_eRuntimeError, "Invalid op specified or bad op arity");
+    }
+    
+    io_uring_sqe_set_data(last_sqe, ctx);
+    unsigned int flags = (i == argc - 1) ? IOSQE_ASYNC : IOSQE_ASYNC & IOSQE_IO_LINK;
+    io_uring_sqe_set_flags(last_sqe, flags);
+    sqe_count++;
+  }
+
+  ctx->ref_count = sqe_count + 1;
+  io_uring_backend_defer_submit(backend);
+  resume_value = backend_await((struct Backend_base *)backend);
+  int result = ctx->result;
+  int completed = context_store_release(&backend->store, ctx);
+  if (!completed) {
+    // op was not completed (an exception was raised), so we need to cancel it
+    ctx->result = -ECANCELED;
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_cancel(sqe, ctx, 0);
+    backend->pending_sqes = 0;
+    io_uring_submit(&backend->ring);
+    RAISE_IF_EXCEPTION(resume_value);
+    return resume_value;
+  }
+  
+  RB_GC_GUARD(resume_value);
+  return INT2NUM(result);
+}
+
+VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend->base.idle_gc_period = NUM2DBL(period);
+  backend->base.idle_gc_last_time = current_time();
+  return self;
+}
+
+VALUE Backend_idle_proc_set(VALUE self, VALUE block) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend->base.idle_proc = block;
+  return self;
+}
+
+inline VALUE Backend_run_idle_tasks(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  backend_run_idle_tasks(&backend->base);
+  return self;
+}
+
+static inline void splice_chunks_prep_write(op_context_t *ctx, struct io_uring_sqe *sqe, int fd, VALUE str) {
+  char *buf = RSTRING_PTR(str);
+  int len = RSTRING_LEN(str);
+  io_uring_prep_write(sqe, fd, buf, len, 0);
+  // io_uring_prep_send(sqe, fd, buf, len, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+}
+
+static inline void splice_chunks_prep_splice(op_context_t *ctx, struct io_uring_sqe *sqe, int src, int dest, int maxlen) {
+  io_uring_prep_splice(sqe, src, -1, dest, -1, maxlen, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+}
+
+static inline void splice_chunks_get_sqe(
+  Backend_t *backend,
+  op_context_t **ctx,
+  struct io_uring_sqe **sqe,
+  enum op_type type
+)
+{
+  if (*ctx) {
+    if (*sqe) (*sqe)->flags |= IOSQE_IO_LINK;
+    (*ctx)->ref_count++;
+  }
+  else
+    *ctx = context_store_acquire(&backend->store, type);
+  (*sqe) = io_uring_get_sqe(&backend->ring);
+}
+
+static inline void splice_chunks_cancel(Backend_t *backend, op_context_t *ctx) {
+  ctx->result = -ECANCELED;
+  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  io_uring_prep_cancel(sqe, ctx, 0);
+  backend->pending_sqes = 0;
+  io_uring_submit(&backend->ring);
+}
+
+static inline int splice_chunks_await_ops(
+  Backend_t *backend,
+  op_context_t **ctx,
+  int *result,
+  VALUE *switchpoint_result
+)
+{
+  int res = io_uring_backend_defer_submit_and_await(backend, 0, *ctx, switchpoint_result);
+  if (result) (*result) = res;
+  int completed = context_store_release(&backend->store, *ctx);
+  if (!completed) {
+    splice_chunks_cancel(backend, *ctx);
+    if (TEST_EXCEPTION(*switchpoint_result)) return 1;
+  }
+  *ctx = 0;
+  return 0;
+}
+
+#define SPLICE_CHUNKS_AWAIT_OPS(backend, ctx, result, switchpoint_result) \
+  if (splice_chunks_await_ops(backend, ctx, result, switchpoint_result)) goto error;
+
+VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VALUE postfix, VALUE chunk_prefix, VALUE chunk_postfix, VALUE chunk_size) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+  int total = 0;
+  int err = 0;
+  VALUE switchpoint_result = Qnil;
+  op_context_t *ctx = 0;
+  struct io_uring_sqe *sqe = 0;
+
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+
+  VALUE underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_verify_blocking_mode(src_fptr, src, Qtrue);
+
+  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_verify_blocking_mode(dest_fptr, dest, Qtrue);
+
+  int maxlen = NUM2INT(chunk_size);
+  VALUE str = Qnil;
+  VALUE chunk_len_value = Qnil;
+
+  int pipefd[2] = { -1, -1 };
+  if (pipe(pipefd) == -1) {
+    err = errno;
+    goto syscallerror;
+  }
+
+  if (prefix != Qnil) {
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+    splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, prefix);
+  }
+
+  while (1) {
+    int chunk_len;
+    VALUE chunk_prefix_str = Qnil;
+    VALUE chunk_postfix_str = Qnil;
+
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
+    splice_chunks_prep_splice(ctx, sqe, src_fptr->fd, pipefd[1], maxlen);
+    
+    SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, &chunk_len, &switchpoint_result);
+    if (chunk_len == 0) break;
+    
+    total += chunk_len;
+    chunk_len_value = INT2NUM(chunk_len);
+
+
+    if (chunk_prefix != Qnil) {
+      chunk_prefix_str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
+      splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+      splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_prefix_str);
+    }
+
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
+    splice_chunks_prep_splice(ctx, sqe, pipefd[0], dest_fptr->fd, chunk_len);
+
+    if (chunk_postfix != Qnil) {
+      chunk_postfix_str = (TYPE(chunk_postfix) == T_STRING) ? chunk_postfix : rb_funcall(chunk_postfix, ID_call, 1, chunk_len_value);
+      splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+      splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_postfix_str);
+    }
+
+    RB_GC_GUARD(chunk_prefix_str);
+    RB_GC_GUARD(chunk_postfix_str);
+  }
+
+  if (postfix != Qnil) {
+    splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
+    splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, postfix);
+  }
+  if (ctx) {
+    SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, 0, &switchpoint_result);
+  }
+
+  RB_GC_GUARD(str);
+  RB_GC_GUARD(chunk_len_value);
+  RB_GC_GUARD(switchpoint_result);
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  return INT2NUM(total);
+syscallerror:
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  rb_syserr_fail(err, strerror(err));
+error:
+  if (pipefd[0] != -1) close(pipefd[0]);
+  if (pipefd[1] != -1) close(pipefd[1]);
+  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);
@@ -1098,10 +1406,16 @@ 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_proc=", Backend_idle_proc_set, 1);
+  rb_define_method(cBackend, "splice_chunks", Backend_splice_chunks, 7);
 
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
@@ -1130,6 +1444,9 @@ void Init_Backend() {
   #endif
 
   SYM_io_uring = ID2SYM(rb_intern("io_uring"));
+  SYM_send = ID2SYM(rb_intern("send"));
+  SYM_splice = ID2SYM(rb_intern("splice"));
+  SYM_write = ID2SYM(rb_intern("write"));
 }
 
 #endif // POLYPHONY_BACKEND_LIBURING