polyphony 0.45.5 → 0.47.2

data/ext/polyphony/backend_io_uring_context.c

@@ -0,0 +1,74 @@
+#include <stdlib.h>
+#include "ruby.h"
+#include "polyphony.h"
+#include "backend_io_uring_context.h"
+
+const char *op_type_to_str(enum op_type type) {
+  switch (type) {
+  case OP_READ: return "READ";
+  case OP_WRITEV: return "WRITEV";
+  case OP_WRITE: return "WRITE";
+  case OP_RECV: return "RECV";
+  case OP_SEND: return "SEND";
+  case OP_TIMEOUT: return "TIMEOUT";
+  case OP_POLL: return "POLL";
+  case OP_ACCEPT: return "ACCEPT";
+  case OP_CONNECT: return "CONNECT";
+  default: return "";
+  };
+}
+
+void context_store_initialize(op_context_store_t *store) {
+  store->last_id = 0;
+  store->available = NULL;
+  store->taken = NULL;
+}
+
+inline op_context_t *context_store_acquire(op_context_store_t *store, enum op_type type) {
+  op_context_t *ctx = store->available;
+  if (ctx) {
+    if (ctx->next) ctx->next->prev = NULL;
+    store->available = ctx->next;
+  }
+  else {
+    ctx = malloc(sizeof(op_context_t));
+  }
+  ctx->id = (++store->last_id);
+  
+  ctx->prev = NULL;
+  ctx->next = store->taken;
+  if (store->taken) store->taken->prev = ctx;
+  store->taken = ctx;
+
+  ctx->type = type;
+  ctx->fiber = rb_fiber_current();
+  ctx->resume_value = Qnil;
+  ctx->completed = 0;
+  ctx->result = 0;
+
+  return ctx;
+}
+
+inline void context_store_release(op_context_store_t *store, op_context_t *ctx) {
+  if (ctx->next) ctx->next->prev = ctx->prev;
+  if (ctx->prev) ctx->prev->next = ctx->next;
+  if (store->taken == ctx) store->taken = ctx->next;
+
+  ctx->prev = NULL;
+  ctx->next = store->available;
+  if (ctx->next) ctx->next->prev = ctx;
+  store->available = ctx;
+}
+
+void context_store_free(op_context_store_t *store) {
+  while (store->available) {
+    op_context_t *next = store->available->next;
+    free(store->available);
+    store->available = next;
+  }
+  while (store->taken) {
+    op_context_t *next = store->taken->next;
+    free(store->taken);
+    store->taken = next;
+  }
+}

data/ext/polyphony/backend_io_uring_context.h

@@ -0,0 +1,53 @@
+#ifndef BACKEND_IO_URING_CONTEXT_H
+#define BACKEND_IO_URING_CONTEXT_H
+
+#include "ruby.h"
+
+enum op_type {
+  OP_NONE,
+  OP_READ,
+  OP_WRITEV,
+  OP_WRITE,
+  OP_RECV,
+  OP_SEND,
+  OP_TIMEOUT,
+  OP_POLL,
+  OP_ACCEPT,
+  OP_CONNECT
+};
+
+typedef struct op_context {
+  struct op_context *prev;
+  struct op_context *next;
+  enum op_type      type: 16;
+  int               completed : 16;
+  int               id;
+  int               result;
+  VALUE             fiber;
+  VALUE             resume_value;
+} op_context_t;
+
+typedef struct op_context_store {
+  int           last_id;
+  op_context_t *available;
+  op_context_t *taken;
+} op_context_store_t;
+
+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);
+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; \
+  } \
+}
+
+#endif /* BACKEND_IO_URING_CONTEXT_H */

data/ext/polyphony/{libev_backend.c → backend_libev.c}

@@ -1,3 +1,5 @@
+#ifdef POLYPHONY_BACKEND_LIBEV
+
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
@@ -5,50 +7,77 @@
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
+#include <stdnoreturn.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
+#include "ruby/io.h"
 
 VALUE cTCPSocket;
+VALUE SYM_libev;
+
+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 LibevBackend_t {
+typedef struct Backend_t {
   struct ev_loop *ev_loop;
   struct ev_async break_async;
   int running;
   int ref_count;
   int run_no_wait_count;
-} LibevBackend_t;
+} Backend_t;
 
-static size_t LibevBackend_size(const void *ptr) {
-  return sizeof(LibevBackend_t);
+static size_t Backend_size(const void *ptr) {
+  return sizeof(Backend_t);
 }
 
-static const rb_data_type_t LibevBackend_type = {
-    "Libev",
-    {0, 0, LibevBackend_size,},
+static const rb_data_type_t Backend_type = {
+    "LibevBackend",
+    {0, 0, Backend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-static VALUE LibevBackend_allocate(VALUE klass) {
-  LibevBackend_t *backend = ALLOC(LibevBackend_t);
+static VALUE Backend_allocate(VALUE klass) {
+  Backend_t *backend = ALLOC(Backend_t);
 
-  return TypedData_Wrap_Struct(klass, &LibevBackend_type, backend);
+  return TypedData_Wrap_Struct(klass, &Backend_type, backend);
 }
 
-#define GetLibevBackend(obj, backend) \
-  TypedData_Get_Struct((obj), LibevBackend_t, &LibevBackend_type, (backend))
+#define GetBackend(obj, backend) \
+  TypedData_Get_Struct((obj), Backend_t, &Backend_type, (backend))
 
 void break_async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, int revents) {
   // This callback does nothing, the break async is used solely for breaking out
   // of a *blocking* event loop (waking it up) in a thread-safe, signal-safe manner
 }
 
-static VALUE LibevBackend_initialize(VALUE self) {
-  LibevBackend_t *backend;
+static VALUE Backend_initialize(VALUE self) {
+  Backend_t *backend;
   VALUE thread = rb_thread_current();
   int is_main_thread = (thread == rb_thread_main());
 
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   backend->ev_loop = is_main_thread ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
 
   ev_async_init(&backend->break_async, break_async_callback);
@@ -62,9 +91,9 @@ static VALUE LibevBackend_initialize(VALUE self) {
   return Qnil;
 }
 
-VALUE LibevBackend_finalize(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+VALUE Backend_finalize(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
    ev_async_stop(backend->ev_loop, &backend->break_async);
 
@@ -73,9 +102,9 @@ VALUE LibevBackend_finalize(VALUE self) {
   return self;
 }
 
-VALUE LibevBackend_post_fork(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+VALUE Backend_post_fork(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
   // After fork there may be some watchers still active left over from the
   // parent, so we destroy the loop, even if it's the default one, then use the
@@ -88,48 +117,48 @@ VALUE LibevBackend_post_fork(VALUE self) {
   return self;
 }
 
-VALUE LibevBackend_ref(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+VALUE Backend_ref(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
   backend->ref_count++;
   return self;
 }
 
-VALUE LibevBackend_unref(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+VALUE Backend_unref(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
   backend->ref_count--;
   return self;
 }
 
-int LibevBackend_ref_count(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+int Backend_ref_count(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
   return backend->ref_count;
 }
 
-void LibevBackend_reset_ref_count(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+void Backend_reset_ref_count(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
   backend->ref_count = 0;
 }
 
-VALUE LibevBackend_pending_count(VALUE self) {
+VALUE Backend_pending_count(VALUE self) {
   int count;
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+  Backend_t *backend;
+  GetBackend(self, backend);
   count = ev_pending_count(backend->ev_loop);
   return INT2NUM(count);
 }
 
-VALUE LibevBackend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
+VALUE Backend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE runqueue) {
   int is_nowait = nowait == Qtrue;
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+  Backend_t *backend;
+  GetBackend(self, backend);
 
   if (is_nowait) {
     backend->run_no_wait_count++;
@@ -141,18 +170,18 @@ VALUE LibevBackend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE run
 
   backend->run_no_wait_count = 0;
 
-  COND_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
+  COND_TRACE(2, SYM_fiber_event_poll_enter, current_fiber);
   backend->running = 1;
   ev_run(backend->ev_loop, is_nowait ? EVRUN_NOWAIT : EVRUN_ONCE);
   backend->running = 0;
-  COND_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
+  COND_TRACE(2, SYM_fiber_event_poll_leave, current_fiber);
 
   return self;
 }
 
-VALUE LibevBackend_wakeup(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
+VALUE Backend_wakeup(VALUE self) {
+  Backend_t *backend;
+  GetBackend(self, backend);
 
   if (backend->running) {
     // Since the loop will run until at least one event has occurred, we signal
@@ -167,152 +196,51 @@ VALUE LibevBackend_wakeup(VALUE self) {
   return Qnil;
 }
 
-#include "polyphony.h"
 #include "../libev/ev.h"
 
-//////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////
-// the following is copied verbatim from the Ruby source code (io.c)
-struct io_internal_read_struct {
-    int fd;
-    int nonblock;
-    void *buf;
-    size_t capa;
-};
-
-#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 (NIL_P(*str)) {
-    *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
-static 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);
-  }
-}
-
-static 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;
-}
-
-//////////////////////////////////////////////////////////////////////
-//////////////////////////////////////////////////////////////////////
+#include "backend_common.h"
 
 struct libev_io {
   struct ev_io io;
   VALUE fiber;
 };
 
-void LibevBackend_io_callback(EV_P_ ev_io *w, int revents)
+void Backend_io_callback(EV_P_ ev_io *w, int revents)
 {
   struct libev_io *watcher = (struct libev_io *)w;
   Fiber_make_runnable(watcher->fiber, Qnil);
 }
 
-inline VALUE libev_await(LibevBackend_t *backend) {
-  VALUE ret;
-  backend->ref_count++;
-  ret = Thread_switch_fiber(rb_thread_current());
-  backend->ref_count--;
-  RB_GC_GUARD(ret);
-  return ret;
-}
-
-VALUE libev_wait_fd_with_watcher(LibevBackend_t *backend, int fd, struct libev_io *watcher, int events) {
+VALUE libev_wait_fd_with_watcher(Backend_t *backend, int fd, struct libev_io *watcher, int events) {
   VALUE switchpoint_result;
 
   if (watcher->fiber == Qnil) {
     watcher->fiber = rb_fiber_current();
-    ev_io_init(&watcher->io, LibevBackend_io_callback, fd, events);
+    ev_io_init(&watcher->io, Backend_io_callback, fd, events);
   }
   ev_io_start(backend->ev_loop, &watcher->io);
 
-  switchpoint_result = libev_await(backend);
+  switchpoint_result = backend_await(backend);
 
   ev_io_stop(backend->ev_loop, &watcher->io);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
 }
 
-VALUE libev_wait_fd(LibevBackend_t *backend, int fd, int events, int raise_exception) {
+VALUE libev_wait_fd(Backend_t *backend, int fd, int events, int raise_exception) {
   struct libev_io watcher;
   VALUE switchpoint_result = Qnil;
   watcher.fiber = Qnil;
 
   switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, events);
 
-  if (raise_exception) TEST_RESUME_EXCEPTION(switchpoint_result);
+  if (raise_exception) RAISE_IF_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
 }
 
-VALUE libev_snooze() {
-  Fiber_make_runnable(rb_fiber_current(), Qnil);
-  return Thread_switch_fiber(rb_thread_current());
-}
-
-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
-}
-
-VALUE LibevBackend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
-  LibevBackend_t *backend;
+VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
+  Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
@@ -322,26 +250,17 @@ VALUE LibevBackend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_
   long total = 0;
   VALUE switchpoint_result = Qnil;
   int read_to_eof = RTEST(to_eof);
-  VALUE underlying_io = rb_iv_get(io, "@io");
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
   io_set_nonblock(fptr, io);
+  rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
-
   OBJ_TAINT(str);
 
-  // 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;
-  }
-
   while (1) {
     ssize_t n = read(fptr->fd, buf, len - total);
     if (n < 0) {
@@ -353,7 +272,7 @@ VALUE LibevBackend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      switchpoint_result = libev_snooze();
+      switchpoint_result = backend_snooze();
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
@@ -387,24 +306,12 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevBackend_read_loop(VALUE self, VALUE io) {
-
-  #define PREPARE_STR() { \
-    str = Qnil; \
-    shrinkable = io_setstrbuf(&str, len); \
-    buf = RSTRING_PTR(str); \
-    total = 0; \
-    OBJ_TAINT(str); \
-  }
-
-  #define YIELD_STR() { \
-    io_set_read_length(str, total, shrinkable); \
-    io_enc_str(str, fptr); \
-    rb_yield(str); \
-    PREPARE_STR(); \
-  }
+VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
+  return Backend_read(self, io, str, length, Qnil);
+}
 
-  LibevBackend_t *backend;
+VALUE Backend_read_loop(VALUE self, VALUE io) {
+  Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE str;
@@ -413,26 +320,18 @@ VALUE LibevBackend_read_loop(VALUE self, VALUE io) {
   int shrinkable;
   char *buf;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io = rb_iv_get(io, "@io");
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
-  PREPARE_STR();
+  READ_LOOP_PREPARE_STR();
 
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
   io_set_nonblock(fptr, io);
+  rectify_io_file_pos(fptr);
   watcher.fiber = Qnil;
 
-  // 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;
-  }
-
   while (1) {
     ssize_t n = read(fptr->fd, buf, len);
     if (n < 0) {
@@ -443,13 +342,13 @@ VALUE LibevBackend_read_loop(VALUE self, VALUE io) {
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      switchpoint_result = libev_snooze();
+      switchpoint_result = backend_snooze();
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
       if (n == 0) break; // EOF
       total = n;
-      YIELD_STR();
+      READ_LOOP_YIELD_STR();
     }
   }
 
@@ -462,8 +361,8 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevBackend_write(VALUE self, VALUE io, VALUE str) {
-  LibevBackend_t *backend;
+VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
+  Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
@@ -472,11 +371,12 @@ VALUE LibevBackend_write(VALUE self, VALUE io, VALUE str) {
   long len = RSTRING_LEN(str);
   long left = len;
 
-  underlying_io = rb_iv_get(io, "@io");
+  underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
+  io_set_nonblock(fptr, io);
   watcher.fiber = Qnil;
 
   while (left > 0) {
@@ -496,7 +396,7 @@ VALUE LibevBackend_write(VALUE self, VALUE io, VALUE str) {
   }
 
   if (watcher.fiber == Qnil) {
-    switchpoint_result = libev_snooze();
+    switchpoint_result = backend_snooze();
 
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
@@ -509,8 +409,8 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevBackend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
-  LibevBackend_t *backend;
+VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
+  Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
@@ -521,11 +421,12 @@ VALUE LibevBackend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   struct iovec *iov_ptr = 0;
   int iov_count = argc;
 
-  underlying_io = rb_iv_get(io, "@io");
+  underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
+  io_set_nonblock(fptr, io);
   watcher.fiber = Qnil;
 
   iov = malloc(iov_count * sizeof(struct iovec));
@@ -541,7 +442,10 @@ VALUE LibevBackend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     ssize_t n = writev(fptr->fd, iov_ptr, iov_count);
     if (n < 0) {
       int e = errno;
-      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+      if ((e != EWOULDBLOCK && e != EAGAIN)) {
+        free(iov);
+        rb_syserr_fail(e, strerror(e));
+      }
 
       switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
 
@@ -566,8 +470,7 @@ VALUE LibevBackend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     }
   }
   if (watcher.fiber == Qnil) {
-    switchpoint_result = libev_snooze();
-
+    switchpoint_result = backend_snooze();
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -581,30 +484,28 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevBackend_write_m(int argc, VALUE *argv, VALUE self) {
+VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
   if (argc < 2)
     // TODO: raise ArgumentError
     rb_raise(rb_eRuntimeError, "(wrong number of arguments (expected 2 or more))");
 
   return (argc == 2) ?
-    LibevBackend_write(self, argv[0], argv[1]) :
-    LibevBackend_writev(self, argv[0], argc - 1, argv + 1);
+    Backend_write(self, argv[0], argv[1]) :
+    Backend_writev(self, argv[0], argc - 1, argv + 1);
 }
 
-///////////////////////////////////////////////////////////////////////////
-
-VALUE LibevBackend_accept(VALUE self, VALUE sock) {
-  LibevBackend_t *backend;
+VALUE Backend_accept(VALUE self, VALUE sock) {
+  Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   int fd;
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_sock = rb_iv_get(sock, "@io");
+  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
   if (underlying_sock != Qnil) sock = underlying_sock;
 
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   GetOpenFile(sock, fptr);
   io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
@@ -621,7 +522,7 @@ VALUE LibevBackend_accept(VALUE self, VALUE sock) {
     else {
       VALUE socket;
       rb_io_t *fp;
-      switchpoint_result = libev_snooze();
+      switchpoint_result = backend_snooze();
 
       if (TEST_EXCEPTION(switchpoint_result)) {
         close(fd); // close fd since we're raising an exception
@@ -649,8 +550,8 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevBackend_accept_loop(VALUE self, VALUE sock) {
-  LibevBackend_t *backend;
+VALUE Backend_accept_loop(VALUE self, VALUE sock) {
+  Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   int fd;
@@ -658,10 +559,10 @@ VALUE LibevBackend_accept_loop(VALUE self, VALUE sock) {
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
   VALUE socket = Qnil;
-  VALUE underlying_sock = rb_iv_get(sock, "@io");
+  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
   if (underlying_sock != Qnil) sock = underlying_sock;
 
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   GetOpenFile(sock, fptr);
   io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
@@ -678,7 +579,7 @@ VALUE LibevBackend_accept_loop(VALUE self, VALUE sock) {
     }
     else {
       rb_io_t *fp;
-      switchpoint_result = libev_snooze();
+      switchpoint_result = backend_snooze();
 
       if (TEST_EXCEPTION(switchpoint_result)) {
         close(fd); // close fd since we're raising an exception
@@ -707,17 +608,17 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevBackend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
-  LibevBackend_t *backend;
+VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
+  Backend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   struct sockaddr_in addr;
   char *host_buf = StringValueCStr(host);
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_sock = rb_iv_get(sock, "@io");
+  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
   if (underlying_sock != Qnil) sock = underlying_sock;
 
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   GetOpenFile(sock, fptr);
   io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
@@ -736,7 +637,7 @@ VALUE LibevBackend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
   else {
-    switchpoint_result = libev_snooze();
+    switchpoint_result = backend_snooze();
 
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
@@ -746,13 +647,13 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevBackend_wait_io(VALUE self, VALUE io, VALUE write) {
-  LibevBackend_t *backend;
+VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
+  Backend_t *backend;
   rb_io_t *fptr;
   int events = RTEST(write) ? EV_WRITE : EV_READ;
-  VALUE underlying_io = rb_iv_get(io, "@io");
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
   if (underlying_io != Qnil) io = underlying_io;
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   GetOpenFile(io, fptr);
 
   return libev_wait_fd(backend, fptr->fd, events, 1);
@@ -763,128 +664,237 @@ struct libev_timer {
   VALUE fiber;
 };
 
-void LibevBackend_timer_callback(EV_P_ ev_timer *w, int revents)
+void Backend_timer_callback(EV_P_ ev_timer *w, int revents)
 {
   struct libev_timer *watcher = (struct libev_timer *)w;
   Fiber_make_runnable(watcher->fiber, Qnil);
 }
 
-VALUE LibevBackend_sleep(VALUE self, VALUE duration) {
-  LibevBackend_t *backend;
+VALUE Backend_sleep(VALUE self, VALUE duration) {
+  Backend_t *backend;
   struct libev_timer watcher;
   VALUE switchpoint_result = Qnil;
 
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
   watcher.fiber = rb_fiber_current();
-  ev_timer_init(&watcher.timer, LibevBackend_timer_callback, NUM2DBL(duration), 0.);
+  ev_timer_init(&watcher.timer, Backend_timer_callback, NUM2DBL(duration), 0.);
   ev_timer_start(backend->ev_loop, &watcher.timer);
 
-  switchpoint_result = libev_await(backend);
+  switchpoint_result = backend_await(backend);
 
   ev_timer_stop(backend->ev_loop, &watcher.timer);
-  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RAISE_IF_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
   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;
 };
 
-void LibevBackend_child_callback(EV_P_ ev_child *w, int revents)
+void Backend_child_callback(EV_P_ ev_child *w, int revents)
 {
   struct libev_child *watcher = (struct libev_child *)w;
-  int exit_status = w->rstatus >> 8; // weird, why should we do this?
+  int exit_status = WEXITSTATUS(w->rstatus);
   VALUE status;
 
   status = rb_ary_new_from_args(2, INT2NUM(w->rpid), INT2NUM(exit_status));
   Fiber_make_runnable(watcher->fiber, status);
 }
 
-VALUE LibevBackend_waitpid(VALUE self, VALUE pid) {
-  LibevBackend_t *backend;
+VALUE Backend_waitpid(VALUE self, VALUE pid) {
+  Backend_t *backend;
   struct libev_child watcher;
   VALUE switchpoint_result = Qnil;
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
 
   watcher.fiber = rb_fiber_current();
-  ev_child_init(&watcher.child, LibevBackend_child_callback, NUM2INT(pid), 0);
+  ev_child_init(&watcher.child, Backend_child_callback, NUM2INT(pid), 0);
   ev_child_start(backend->ev_loop, &watcher.child);
 
-  switchpoint_result = libev_await(backend);
+  switchpoint_result = backend_await(backend);
 
   ev_child_stop(backend->ev_loop, &watcher.child);
-  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RAISE_IF_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
 }
 
-struct ev_loop *LibevBackend_ev_loop(VALUE self) {
-  LibevBackend_t *backend;
-  GetLibevBackend(self, backend);
-  return backend->ev_loop;
-}
-
-void LibevBackend_async_callback(EV_P_ ev_async *w, int revents) { }
+void Backend_async_callback(EV_P_ ev_async *w, int revents) { }
 
-VALUE LibevBackend_wait_event(VALUE self, VALUE raise) {
-  LibevBackend_t *backend;
+VALUE Backend_wait_event(VALUE self, VALUE raise) {
+  Backend_t *backend;
   VALUE switchpoint_result = Qnil;
-  GetLibevBackend(self, backend);
+  GetBackend(self, backend);
 
   struct ev_async async;
 
-  ev_async_init(&async, LibevBackend_async_callback);
+  ev_async_init(&async, Backend_async_callback);
   ev_async_start(backend->ev_loop, &async);
 
-  switchpoint_result = libev_await(backend);
+  switchpoint_result = backend_await(backend);
 
   ev_async_stop(backend->ev_loop, &async);
-  if (RTEST(raise)) TEST_RESUME_EXCEPTION(switchpoint_result);
+  if (RTEST(raise)) RAISE_IF_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
 }
 
-void Init_LibevBackend() {
+VALUE Backend_kind(VALUE self) {
+  return SYM_libev;
+}
+
+void Init_Backend() {
+  ev_set_allocator(xrealloc);
+
   rb_require("socket");
   cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
 
   VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
-  rb_define_alloc_func(cBackend, LibevBackend_allocate);
-
-  rb_define_method(cBackend, "initialize", LibevBackend_initialize, 0);
-  rb_define_method(cBackend, "finalize", LibevBackend_finalize, 0);
-  rb_define_method(cBackend, "post_fork", LibevBackend_post_fork, 0);
-  rb_define_method(cBackend, "pending_count", LibevBackend_pending_count, 0);
-
-  rb_define_method(cBackend, "ref", LibevBackend_ref, 0);
-  rb_define_method(cBackend, "unref", LibevBackend_unref, 0);
-
-  rb_define_method(cBackend, "poll", LibevBackend_poll, 3);
-  rb_define_method(cBackend, "break", LibevBackend_wakeup, 0);
-
-  rb_define_method(cBackend, "read", LibevBackend_read, 4);
-  rb_define_method(cBackend, "read_loop", LibevBackend_read_loop, 1);
-  rb_define_method(cBackend, "write", LibevBackend_write_m, -1);
-  rb_define_method(cBackend, "accept", LibevBackend_accept, 1);
-  rb_define_method(cBackend, "accept_loop", LibevBackend_accept_loop, 1);
-  rb_define_method(cBackend, "connect", LibevBackend_connect, 3);
-  rb_define_method(cBackend, "wait_io", LibevBackend_wait_io, 2);
-  rb_define_method(cBackend, "sleep", LibevBackend_sleep, 1);
-  rb_define_method(cBackend, "waitpid", LibevBackend_waitpid, 1);
-  rb_define_method(cBackend, "wait_event", LibevBackend_wait_event, 1);
+  rb_define_alloc_func(cBackend, Backend_allocate);
+
+  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, "pending_count", Backend_pending_count, 0);
+
+  rb_define_method(cBackend, "ref", Backend_ref, 0);
+  rb_define_method(cBackend, "unref", Backend_unref, 0);
+
+  rb_define_method(cBackend, "poll", Backend_poll, 3);
+  rb_define_method(cBackend, "break", Backend_wakeup, 0);
+
+  rb_define_method(cBackend, "read", Backend_read, 4);
+  rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
+  rb_define_method(cBackend, "write", Backend_write_m, -1);
+  rb_define_method(cBackend, "accept", Backend_accept, 1);
+  rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 1);
+  rb_define_method(cBackend, "connect", Backend_connect, 3);
+  rb_define_method(cBackend, "recv", Backend_recv, 3);
+  rb_define_method(cBackend, "recv_loop", Backend_read_loop, 1);
+  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);
+
+  rb_define_method(cBackend, "kind", Backend_kind, 0);
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
+  SYM_libev = ID2SYM(rb_intern("libev"));
 
-  __BACKEND__.pending_count   = LibevBackend_pending_count;
-  __BACKEND__.poll            = LibevBackend_poll;
-  __BACKEND__.ref             = LibevBackend_ref;
-  __BACKEND__.ref_count       = LibevBackend_ref_count;
-  __BACKEND__.reset_ref_count = LibevBackend_reset_ref_count;
-  __BACKEND__.unref           = LibevBackend_unref;
-  __BACKEND__.wait_event      = LibevBackend_wait_event;
-  __BACKEND__.wakeup          = LibevBackend_wakeup;
+  __BACKEND__.pending_count   = Backend_pending_count;
+  __BACKEND__.poll            = Backend_poll;
+  __BACKEND__.ref             = Backend_ref;
+  __BACKEND__.ref_count       = Backend_ref_count;
+  __BACKEND__.reset_ref_count = Backend_reset_ref_count;
+  __BACKEND__.unref           = Backend_unref;
+  __BACKEND__.wait_event      = Backend_wait_event;
+  __BACKEND__.wakeup          = Backend_wakeup;
 }
+
+#endif // POLYPHONY_BACKEND_LIBEV