polyphony 0.54.0 → 0.59

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"
@@ -15,6 +16,7 @@ const char *op_type_to_str(enum op_type type) {
   case OP_POLL: return "POLL";
   case OP_ACCEPT: return "ACCEPT";
   case OP_CONNECT: return "CONNECT";
+  case OP_CHAIN: return "CHAIN";
   default: return "";
   };
 }
@@ -35,7 +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 %p %d (%s)\n", ctx, ctx->id, op_type_to_str(type));
   ctx->prev = NULL;
   ctx->next = store->taken;
   if (store->taken) store->taken->prev = ctx;
@@ -44,13 +46,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 %p %d (%s, ref_count: %d)\n", ctx, 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;
@@ -59,6 +69,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

@@ -14,14 +14,15 @@ enum op_type {
   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;
@@ -38,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

@@ -42,7 +42,6 @@ thread.
 #define _GNU_SOURCE 1
 #endif
 
-#include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
@@ -52,58 +51,45 @@ thread.
 #include <stdnoreturn.h>
 #include <sys/types.h>
 #include <sys/wait.h>
+#include <fcntl.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
 #include "ruby/io.h"
 
+#include "../libev/ev.h"
+#include "backend_common.h"
+
 VALUE SYM_libev;
 VALUE SYM_send;
 VALUE SYM_splice;
 VALUE SYM_write;
 
-ID ID_ivar_is_nonblocking;
-
-// Since we need to ensure that fd's are non-blocking before every I/O
-// operation, here we improve upon Ruby's rb_io_set_nonblock by caching the
-// "nonblock" state in an instance variable. Calling rb_ivar_get on every read
-// is still much cheaper than doing a fcntl syscall on every read! Preliminary
-// benchmarks (with a "hello world" HTTP server) show throughput is improved
-// by 10-13%.
-inline void io_set_nonblock(rb_io_t *fptr, VALUE io) {
-  VALUE is_nonblocking = rb_ivar_get(io, ID_ivar_is_nonblocking);
-  if (is_nonblocking == Qtrue) return;
-
-  rb_ivar_set(io, ID_ivar_is_nonblocking, Qtrue);
-
-#ifdef _WIN32
-  rb_w32_set_nonblock(fptr->fd);
-#elif defined(F_GETFL)
-  int oflags = fcntl(fptr->fd, F_GETFL);
-  if ((oflags == -1) && (oflags & O_NONBLOCK)) return;
-  oflags |= O_NONBLOCK;
-  fcntl(fptr->fd, F_SETFL, oflags);
-#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 ev_loop *ev_loop;
   struct ev_async break_async;
 } Backend_t;
 
+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);
 }
 
 static const rb_data_type_t Backend_type = {
     "LibevBackend",
-    {0, 0, Backend_size,},
+    {Backend_mark, Backend_free, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
@@ -134,6 +120,8 @@ static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
   
   GetBackend(self, backend);
+
+  backend_base_initialize(&backend->base);
   backend->ev_loop = libev_new_loop();
 
   // start async watcher used for breaking a poll op (from another thread)
@@ -143,10 +131,6 @@ static VALUE Backend_initialize(VALUE self) {
   // block when no other watcher is active
   ev_unref(backend->ev_loop);
 
-  backend->currently_polling = 0;
-  backend->pending_count = 0;
-  backend->poll_no_wait_count = 0;
-
   return Qnil;
 }
 
@@ -176,42 +160,45 @@ VALUE Backend_post_fork(VALUE self) {
   return self;
 }
 
-unsigned int Backend_pending_count(VALUE self) {
+inline VALUE Backend_poll(VALUE self, VALUE blocking) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  return backend->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) {
-  int is_nowait = nowait == Qtrue;
+inline void Backend_schedule_fiber(VALUE thread, VALUE self, VALUE fiber, VALUE value, int prioritize) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (is_nowait) {
-    backend->poll_no_wait_count++;
-    if (backend->poll_no_wait_count < 10) return self;
+  backend_base_schedule_fiber(thread, self, &backend->base, fiber, value, prioritize);
+}
 
-    long runnable_count = Runqueue_len(runqueue);
-    if (backend->poll_no_wait_count < runnable_count) return self;
-  }
+inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
-  backend->poll_no_wait_count = 0;
+  runqueue_delete(&backend->base.runqueue, fiber);  
+}
 
-  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);
-  backend->currently_polling = 0;
-  COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
+inline VALUE Backend_switch_fiber(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
-  return self;
+  return backend_base_switch_fiber(self, &backend->base);
 }
 
 VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  if (backend->currently_polling) {
+  if (backend->base.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
@@ -224,9 +211,16 @@ VALUE Backend_wakeup(VALUE self) {
   return Qnil;
 }
 
-#include "../libev/ev.h"
+inline struct backend_stats Backend_stats(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
-#include "backend_common.h"
+  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;
@@ -248,7 +242,7 @@ VALUE libev_wait_fd_with_watcher(Backend_t *backend, int fd, struct libev_io *wa
   }
   ev_io_start(backend->ev_loop, &watcher->io);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_io_stop(backend->ev_loop, &watcher->io);
   RB_GC_GUARD(switchpoint_result);
@@ -284,7 +278,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
   OBJ_TAINT(str);
@@ -301,7 +295,6 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
     }
     else {
       switchpoint_result = backend_snooze();
-
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
       if (n == 0) break; // EOF
@@ -356,7 +349,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
 
@@ -408,7 +401,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
 
@@ -456,7 +449,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   watcher.fiber = Qnil;
 
   while (left > 0) {
@@ -506,7 +499,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   watcher.fiber = Qnil;
 
   iov = malloc(iov_count * sizeof(struct iovec));
@@ -587,7 +580,7 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
 
   GetBackend(self, backend);
   GetOpenFile(server_socket, fptr);
-  io_set_nonblock(fptr, server_socket);
+  io_verify_blocking_mode(fptr, server_socket, Qfalse);
   watcher.fiber = Qnil;
   while (1) {
     fd = accept(fptr->fd, &addr, &len);
@@ -615,7 +608,7 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      io_set_nonblock(fp, socket);
+      io_verify_blocking_mode(fp, socket, Qfalse);
       rb_io_synchronized(fp);
 
       // if (rsock_do_not_reverse_lookup) {
@@ -644,7 +637,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
 
   GetBackend(self, backend);
   GetOpenFile(server_socket, fptr);
-  io_set_nonblock(fptr, server_socket);
+  io_verify_blocking_mode(fptr, server_socket, Qfalse);
   watcher.fiber = Qnil;
 
   while (1) {
@@ -672,7 +665,7 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      io_set_nonblock(fp, socket);
+      io_verify_blocking_mode(fp, socket, Qfalse);
       rb_io_synchronized(fp);
 
       rb_yield(socket);
@@ -700,7 +693,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
 
   GetBackend(self, backend);
   GetOpenFile(sock, fptr);
-  io_set_nonblock(fptr, sock);
+  io_verify_blocking_mode(fptr, sock, Qfalse);
   watcher.fiber = Qnil;
 
   addr.sin_family = AF_INET;
@@ -743,7 +736,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
-  io_set_nonblock(fptr, io);
+  io_verify_blocking_mode(fptr, io, Qfalse);
   watcher.fiber = Qnil;
 
   while (left > 0) {
@@ -776,10 +769,63 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+struct libev_rw_ctx {
+  int ref_count;
+  VALUE fiber;
+};
+
+struct libev_ref_count_io {
+  struct ev_io io;
+  struct libev_rw_ctx *ctx;
+};
+
+struct libev_rw_io {
+  struct libev_ref_count_io r;
+  struct libev_ref_count_io w;
+  struct libev_rw_ctx ctx;
+};
+
+void Backend_rw_io_callback(EV_P_ ev_io *w, int revents)
+{
+  struct libev_ref_count_io *watcher = (struct libev_ref_count_io *)w;
+  int ref_count = watcher->ctx->ref_count--;
+  if (!ref_count)
+    Fiber_make_runnable(watcher->ctx->fiber, Qnil);
+}
+
+VALUE libev_wait_rw_fd_with_watcher(Backend_t *backend, int r_fd, int w_fd, struct libev_rw_io *watcher) {
+  VALUE switchpoint_result = Qnil;
+
+  if (watcher->ctx.fiber == Qnil) watcher->ctx.fiber = rb_fiber_current();
+  watcher->ctx.ref_count = 0;
+  if (r_fd != -1) {
+    ev_io_init(&watcher->r.io, Backend_rw_io_callback, r_fd, EV_READ);
+    ev_io_start(backend->ev_loop, &watcher->r.io);
+    watcher->r.ctx = &watcher->ctx;
+    watcher->ctx.ref_count++;
+  }
+  if (w_fd != -1) {
+    ev_io_init(&watcher->w.io, Backend_rw_io_callback, w_fd, EV_WRITE);
+    ev_io_start(backend->ev_loop, &watcher->w.io);
+    watcher->w.ctx = &watcher->ctx;
+    watcher->ctx.ref_count++;
+  }
+
+  switchpoint_result = backend_await((struct Backend_base *)backend);
+
+  if (r_fd != -1) ev_io_stop(backend->ev_loop, &watcher->r.io);
+  if (w_fd != -1) ev_io_stop(backend->ev_loop, &watcher->w.io);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
+}
+
+
+
+
 #ifdef POLYPHONY_LINUX
 VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
-  struct libev_io watcher;
+  struct libev_rw_io watcher;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_io;
   rb_io_t *src_fptr;
@@ -791,25 +837,22 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   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);
+  io_verify_blocking_mode(src_fptr, src, Qfalse);
 
   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);
+  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
-  watcher.fiber = Qnil;
+  watcher.ctx.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);
+      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, dest_fptr->fd, &watcher);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -817,12 +860,12 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
     }
   }
 
-  if (watcher.fiber == Qnil) {
+  if (watcher.ctx.fiber == Qnil) {
     switchpoint_result = backend_snooze();
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
-  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(watcher.ctx.fiber);
   RB_GC_GUARD(switchpoint_result);
 
   return INT2NUM(len);
@@ -832,7 +875,7 @@ error:
 
 VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
-  struct libev_io watcher;
+  struct libev_rw_io watcher;
   VALUE switchpoint_result = Qnil;
   VALUE underlying_io;
   rb_io_t *src_fptr;
@@ -845,25 +888,22 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   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);
+  io_verify_blocking_mode(src_fptr, src, Qfalse);
 
   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);
+  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
 
-  watcher.fiber = Qnil;
+  watcher.ctx.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);
+      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, dest_fptr->fd, &watcher);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else if (len == 0) {
@@ -874,6 +914,157 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
     }
   }
 
+  if (watcher.ctx.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.ctx.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(total);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+#endif
+
+VALUE Backend_fake_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 = NUM2INT(maxlen);
+  VALUE str = rb_str_new(0, len);
+  char *buf = RSTRING_PTR(str);
+  int left = 0;
+  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_verify_blocking_mode(src_fptr, src, Qfalse);
+
+  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, Qfalse);
+
+  watcher.fiber = Qnil;
+  
+  while (1) {
+    ssize_t n = read(src_fptr->fd, buf, len);
+    if (n < 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;
+    }
+    else {
+      total = left = n;
+      break;
+    }
+  }
+
+  while (left > 0) {
+    ssize_t n = write(dest_fptr->fd, buf, left);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      buf += n;
+      left -= n;
+    }
+  }
+
+  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);
+  RB_GC_GUARD(str);
+
+  return INT2NUM(total);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE Backend_fake_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 = NUM2INT(maxlen);
+  VALUE str = rb_str_new(0, len);
+  char *buf = RSTRING_PTR(str);
+  int left = 0;
+  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_verify_blocking_mode(src_fptr, src, Qfalse);
+
+  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, Qfalse);
+
+  watcher.fiber = Qnil;
+
+  while (1) { 
+    char *ptr = buf;
+    while (1) {
+      ssize_t n = read(src_fptr->fd, ptr, len);
+      if (n < 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;
+      }
+      else if (n == 0) goto done;
+      else {
+        total += n;
+        left = n;
+        break;
+      }
+    }
+
+    while (left > 0) {
+      ssize_t n = write(dest_fptr->fd, ptr, left);
+      if (n < 0) {
+        int e = errno;
+        if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+        switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+        if (TEST_EXCEPTION(switchpoint_result)) goto error;
+      }
+      else {
+        ptr += n;
+        left -= n;
+      }
+    }
+  }
+
+done:
   if (watcher.fiber == Qnil) {
     switchpoint_result = backend_snooze();
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
@@ -881,12 +1072,12 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
+  RB_GC_GUARD(str);
 
   return INT2NUM(total);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
-#endif
 
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
@@ -921,7 +1112,7 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
   ev_timer_init(&watcher.timer, Backend_timer_callback, NUM2DBL(duration), 0.);
   ev_timer_start(backend->ev_loop, &watcher.timer);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_timer_stop(backend->ev_loop, &watcher.timer);
   RAISE_IF_EXCEPTION(switchpoint_result);
@@ -949,7 +1140,7 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     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);
+    switchpoint_result = backend_await((struct Backend_base *)backend);
     ev_timer_stop(backend->ev_loop, &watcher.timer);
     RAISE_IF_EXCEPTION(switchpoint_result);
     RB_GC_GUARD(switchpoint_result);
@@ -1066,7 +1257,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   ev_child_init(&watcher.child, Backend_child_callback, NUM2INT(pid), 0);
   ev_child_start(backend->ev_loop, &watcher.child);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_child_stop(backend->ev_loop, &watcher.child);
   RAISE_IF_EXCEPTION(switchpoint_result);
@@ -1088,7 +1279,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
   ev_async_init(&async, Backend_async_callback);
   ev_async_start(backend->ev_loop, &async);
 
-  switchpoint_result = backend_await(backend);
+  switchpoint_result = backend_await((struct Backend_base *)backend);
 
   ev_async_stop(backend->ev_loop, &async);
   if (RTEST(raise)) RAISE_IF_EXCEPTION(switchpoint_result);
@@ -1113,10 +1304,8 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
       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");
   }
@@ -1125,6 +1314,179 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
   return 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;
+}
+
+inline int splice_chunks_write(Backend_t *backend, int fd, VALUE str, struct libev_rw_io *watcher, VALUE *result) {
+  char *buf = RSTRING_PTR(str);
+  int len = RSTRING_LEN(str);
+  int left = len;
+  while (left > 0) {
+    ssize_t n = write(fd, buf, left);
+    if (n < 0) {
+      int err = errno;
+      if ((err != EWOULDBLOCK && err != EAGAIN)) return err;
+
+      *result = libev_wait_rw_fd_with_watcher(backend, -1, fd, watcher);
+      if (TEST_EXCEPTION(*result)) return -1;
+    }
+    else {
+      buf += n;
+      left -= n;
+    }
+  }
+  return 0;
+}
+
+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 result = Qnil;
+
+  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, Qfalse);
+
+  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, Qfalse);
+
+  struct libev_rw_io watcher;
+  watcher.ctx.fiber = Qnil;
+  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;
+  }
+
+  fcntl(pipefd[0], F_SETFL, O_NONBLOCK);
+  fcntl(pipefd[1], F_SETFL, O_NONBLOCK);
+
+  if (prefix != Qnil) {
+    int err = splice_chunks_write(backend, dest_fptr->fd, prefix, &watcher, &result);
+    if (err == -1) goto error; else if (err) goto syscallerror;
+  }
+  while (1) {
+    int chunk_len;
+    // splice to pipe
+    while (1) {
+      chunk_len = splice(src_fptr->fd, 0, pipefd[1], 0, maxlen, 0);
+      if (chunk_len < 0) {
+        err = errno;
+        if (err != EWOULDBLOCK && err != EAGAIN) goto syscallerror;
+
+        result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, pipefd[1], &watcher);
+        if (TEST_EXCEPTION(result)) goto error;
+      }
+      else {
+        break;
+      }
+    }
+    if (chunk_len == 0) break;
+    
+    total += chunk_len;
+    chunk_len_value = INT2NUM(chunk_len);
+
+    if (chunk_prefix != Qnil) {
+      VALUE str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
+      int err = splice_chunks_write(backend, dest_fptr->fd, str, &watcher, &result);
+      if (err == -1) goto error; else if (err) goto syscallerror;
+    }
+
+    int left = chunk_len;
+    while (1) {
+      int n = splice(pipefd[0], 0, dest_fptr->fd, 0, left, 0);
+      if (n < 0) {
+        err = errno;
+        if (err != EWOULDBLOCK && err != EAGAIN) goto syscallerror;
+
+        result = libev_wait_rw_fd_with_watcher(backend, pipefd[0], dest_fptr->fd, &watcher);
+        if (TEST_EXCEPTION(result)) goto error;
+      }
+      else {
+        left -= n;
+        if (left == 0) break;
+      }
+    }
+
+    if (chunk_postfix != Qnil) {
+      VALUE str = (TYPE(chunk_postfix) == T_STRING) ? chunk_postfix : rb_funcall(chunk_postfix, ID_call, 1, chunk_len_value);
+      int err = splice_chunks_write(backend, dest_fptr->fd, str, &watcher, &result);
+      if (err == -1) goto error; else if (err) goto syscallerror;
+    }
+  }
+
+  if (postfix != Qnil) {
+    int err = splice_chunks_write(backend, dest_fptr->fd, postfix, &watcher, &result);
+    if (err == -1) goto error; else if (err) goto syscallerror;
+  }
+
+  if (watcher.ctx.fiber == Qnil) {
+    result = backend_snooze();
+    if (TEST_EXCEPTION(result)) goto error;
+  }
+  RB_GC_GUARD(str);
+  RB_GC_GUARD(chunk_len_value);
+  RB_GC_GUARD(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(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);
 
@@ -1134,11 +1496,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);
@@ -1156,6 +1523,9 @@ void Init_Backend() {
   #ifdef POLYPHONY_LINUX
   rb_define_method(cBackend, "splice", Backend_splice, 3);
   rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
+  #else
+  rb_define_method(cBackend, "splice", Backend_fake_splice, 3);
+  rb_define_method(cBackend, "splice_to_eof", Backend_fake_splice_to_eof, 3);
   #endif
 
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
@@ -1165,7 +1535,6 @@ void Init_Backend() {
   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"));