polyphony 0.43.9 → 0.45.1

data/examples/io/{xx-system.rb → system.rb}

@@ -7,5 +7,5 @@ timer = spin do
   throttled_loop(5) { STDOUT << '.' }
 end
 
-puts system('ruby -e "sleep 1; puts :done; STDOUT.close"')
+puts system('ruby -e "puts :sleeping; STDOUT.flush; sleep 1; puts :done"')
 timer.stop

data/examples/io/tunnel.rb

@@ -3,6 +3,11 @@
 require 'bundler/setup'
 require 'polyphony'
 
+if ARGV.size < 2
+  puts "Usage: ruby examples/tunnel.rb <port1> <port2>"
+  exit
+end
+
 Ports = ARGV[0..1]
 EndPoints = []
 
@@ -24,7 +29,7 @@ def endpoint_loop(idx, peer_idx)
     conn.binmode
     EndPoints[idx] = conn
     log "Client connected on port #{port} (#{conn.remote_address.inspect})"
-    while data = conn.readpartial(8192)
+    conn.read_loop do |data|
       peer = EndPoints[peer_idx]
       if peer
         peer << data

data/examples/performance/fiber_transfer.rb

@@ -6,7 +6,8 @@ class Fiber
   attr_accessor :next
 end
 
-# This program shows how the performance 
+# This program shows how the performance of Fiber.transfer degrades as the fiber
+# count increases
 
 def run(num_fibers)
   count = 0

data/examples/performance/fs_read.rb

@@ -2,7 +2,7 @@
 
 require 'bundler/setup'
 require 'polyphony'
-require 'polyphony/fs'
+require 'polyphony/adapters/fs'
 
 def raw_read_file(x)
   t0 = Time.now
@@ -14,7 +14,7 @@ def threaded_read_file(x, y)
   t0 = Time.now
   threads = []
   y.times do
-    threads << Thread.new { x.times { IO.orig_read(PATH) } }
+    threads << Thread.new { x.times { IO.orig_read(__FILE__) } }
   end
   threads.each(&:join)
   puts "threaded_read_file: #{Time.now - t0}"
@@ -22,11 +22,10 @@ end
 
 def thread_pool_read_file(x, y)
   t0 = Time.now
-  supervise do |s|
-    y.times do
-      s.spin { x.times { IO.read(PATH) } }
-    end
+  y.times do
+    spin { x.times { IO.read(__FILE__) } }
   end
+  Fiber.current.await_all_children
   puts "thread_pool_read_file: #{Time.now - t0}"
 end
 

data/examples/{io/xx-switch.rb → performance/switch.rb}

@@ -12,4 +12,5 @@ end
 t0 = Time.now
 X.times { f.transfer }
 dt = Time.now - t0
-puts "#{X / dt.to_f}/s"
+puts "#{X / dt.to_f}/s"
+puts fs.size

data/examples/performance/thread-vs-fiber/{xx-httparty_multi.rb → httparty_multi.rb}

@@ -21,11 +21,10 @@ end
 t0 = Time.now
 results = []
 move_on_after(3) do
-  supervise do |s|
-    10.times do
-      s.spin { get_time(results) }
-    end
+  10.times do
+    spin { get_time(results) }
   end
+  supervise
   puts 'done'
 end
 

data/examples/performance/thread-vs-fiber/polyphony_mt_server.rb

@@ -24,7 +24,7 @@ def handle_client(socket)
   parser.on_message_complete = proc do |env|
     reqs << Object.new # parser
   end
-  while (data = socket.readpartial(8192)) do
+  socket.read_loop do |data|
     parser << data
     while (req = reqs.shift)
       handle_request(socket, req)

data/examples/performance/thread-vs-fiber/polyphony_server.rb

@@ -13,7 +13,7 @@ def handle_client(socket)
   parser.on_message_complete = proc do |env|
     reqs << Object.new # parser
   end
-  while (data = socket.readpartial(8192)) do
+  socket.read_loop |data|
     parser << data
     while (req = reqs.shift)
       handle_request(socket, req)

data/examples/performance/thread-vs-fiber/polyphony_server_read_loop.rb

@@ -37,7 +37,7 @@ spin do
   server = TCPServer.open('0.0.0.0', 1234)
   puts "listening on port 1234"
 
-  Thread.current.agent.accept_loop(server) do |client|
+  Thread.current.backend.accept_loop(server) do |client|
     spin { handle_client(client) }
   end
   # loop do

data/examples/performance/thread-vs-fiber/threaded_server.rb

@@ -11,11 +11,7 @@ def handle_client(client)
       headers = "Content-Length: #{data.bytesize}\r\n"
       client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
     end
-    loop do
-      while data = client.readpartial(8192) rescue nil
-        parser << data
-      end
-    end
+    client.read_loop { |data| parser << data }
     client.close
   end
 end

data/examples/performance/thread_pool_perf.rb

@@ -10,7 +10,7 @@ def lengthy_op
   # Digest::SHA256.digest(IO.read('doc/Promise.html'))
 end
 
-X = 100
+X = 10000
 
 def compare_performance
   t0 = Time.now
@@ -35,20 +35,19 @@ def compare_performance
 
     acc = 0
     count = 0
-    10.times do |_i|
+    1.times do |_i|
       t0 = Time.now
-      supervise do |s|
-        X.times do
-          s.spin { Polyphony::ThreadPool.process { lengthy_op } }
-        end
+      X.times do
+        spin { Polyphony::ThreadPool.process { lengthy_op } }
       end
+      Fiber.current.await_all_children
       thread_pool_perf = X / (Time.now - t0)
       acc += thread_pool_perf
       count += 1
     end
     avg_perf = acc / count
     puts format(
-      'avg thread pool performance: %g (X %0.2f)',
+      'spin X thread pool performance: %g (X %0.2f)',
       avg_perf,
       avg_perf / native_perf
     )

data/ext/polyphony/backend.h

@@ -0,0 +1,40 @@
+#ifndef BACKEND_H
+#define BACKEND_H
+
+#include "ruby.h"
+
+// backend interface function signatures 
+
+// VALUE LibevBackend_accept(VALUE self, VALUE sock);
+// VALUE LibevBackend_accept_loop(VALUE self, VALUE sock);
+// VALUE LibevBackend_connect(VALUE self, VALUE sock, VALUE host, VALUE port);
+// VALUE LibevBackend_finalize(VALUE self);
+// VALUE LibevBackend_post_fork(VALUE self);
+// VALUE LibevBackend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof);
+// VALUE LibevBackend_read_loop(VALUE self, VALUE io);
+// VALUE LibevBackend_sleep(VALUE self, VALUE duration);
+// VALUE LibevBackend_wait_io(VALUE self, VALUE io, VALUE write);
+// VALUE LibevBackend_wait_pid(VALUE self, VALUE pid);
+// VALUE LibevBackend_write(int argc, VALUE *argv, VALUE self);
+
+typedef VALUE (* backend_pending_count_t)(VALUE self);
+typedef VALUE (*backend_poll_t)(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue);
+typedef VALUE (* backend_ref_t)(VALUE self);
+typedef int (* backend_ref_count_t)(VALUE self);
+typedef void (* backend_reset_ref_count_t)(VALUE self);
+typedef VALUE (* backend_unref_t)(VALUE self);
+typedef VALUE (* backend_wait_event_t)(VALUE self, VALUE raise_on_exception);
+typedef VALUE (* backend_wakeup_t)(VALUE self);
+
+typedef struct backend_interface {
+  backend_pending_count_t   pending_count;
+  backend_poll_t            poll;
+  backend_ref_t             ref;
+  backend_ref_count_t       ref_count;
+  backend_reset_ref_count_t reset_ref_count;
+  backend_unref_t           unref;
+  backend_wait_event_t      wait_event;
+  backend_wakeup_t          wakeup;
+} backend_interface_t;
+
+#endif /* BACKEND_H */

data/ext/polyphony/event.c

@@ -64,13 +64,13 @@ VALUE Event_await(VALUE self) {
   if (event->waiting_fiber != Qnil)
     rb_raise(rb_eRuntimeError, "Event is already awaited by another fiber");
 
-  VALUE agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
   event->waiting_fiber = rb_fiber_current();
-  VALUE switchpoint_result = LibevAgent_wait_event(agent, Qnil);
+  VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
   event->waiting_fiber = Qnil;
 
   TEST_RESUME_EXCEPTION(switchpoint_result);
-  RB_GC_GUARD(agent);
+  RB_GC_GUARD(backend);
   RB_GC_GUARD(switchpoint_result);
 
   return switchpoint_result;

data/ext/polyphony/extconf.rb

@@ -17,4 +17,4 @@ $defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
 CONFIG["optflags"] << " -fno-strict-aliasing" unless RUBY_PLATFORM =~ /mswin/
 
 dir_config "polyphony_ext"
-create_makefile "polyphony_ext"
+create_makefile "polyphony_ext"

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

@@ -3,164 +3,163 @@
 #include <sys/uio.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
 
-VALUE cLibevAgent = Qnil;
 VALUE cTCPSocket;
 
-struct LibevAgent_t {
+typedef struct LibevBackend_t {
   struct ev_loop *ev_loop;
   struct ev_async break_async;
   int running;
   int ref_count;
   int run_no_wait_count;
-};
+} LibevBackend_t;
 
-static size_t LibevAgent_size(const void *ptr) {
-  return sizeof(struct LibevAgent_t);
+static size_t LibevBackend_size(const void *ptr) {
+  return sizeof(LibevBackend_t);
 }
 
-static const rb_data_type_t LibevAgent_type = {
+static const rb_data_type_t LibevBackend_type = {
     "Libev",
-    {0, 0, LibevAgent_size,},
+    {0, 0, LibevBackend_size,},
     0, 0, RUBY_TYPED_FREE_IMMEDIATELY
 };
 
-static VALUE LibevAgent_allocate(VALUE klass) {
-  struct LibevAgent_t *agent = ALLOC(struct LibevAgent_t);
-  
-  return TypedData_Wrap_Struct(klass, &LibevAgent_type, agent);
+static VALUE LibevBackend_allocate(VALUE klass) {
+  LibevBackend_t *backend = ALLOC(LibevBackend_t);
+
+  return TypedData_Wrap_Struct(klass, &LibevBackend_type, backend);
 }
 
-#define GetLibevAgent(obj, agent) \
-  TypedData_Get_Struct((obj), struct LibevAgent_t, &LibevAgent_type, (agent))
+#define GetLibevBackend(obj, backend) \
+  TypedData_Get_Struct((obj), LibevBackend_t, &LibevBackend_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 LibevAgent_initialize(VALUE self) {
-  struct LibevAgent_t *agent;
+static VALUE LibevBackend_initialize(VALUE self) {
+  LibevBackend_t *backend;
   VALUE thread = rb_thread_current();
   int is_main_thread = (thread == rb_thread_main());
 
-  GetLibevAgent(self, agent);
-  agent->ev_loop = is_main_thread ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
+  GetLibevBackend(self, backend);
+  backend->ev_loop = is_main_thread ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
 
-  ev_async_init(&agent->break_async, break_async_callback);
-  ev_async_start(agent->ev_loop, &agent->break_async);
-  ev_unref(agent->ev_loop); // don't count the break_async watcher
+  ev_async_init(&backend->break_async, break_async_callback);
+  ev_async_start(backend->ev_loop, &backend->break_async);
+  ev_unref(backend->ev_loop); // don't count the break_async watcher
 
-  agent->running = 0;
-  agent->ref_count = 0;
-  agent->run_no_wait_count = 0;
+  backend->running = 0;
+  backend->ref_count = 0;
+  backend->run_no_wait_count = 0;
 
   return Qnil;
 }
 
-VALUE LibevAgent_finalize(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
+VALUE LibevBackend_finalize(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
-   ev_async_stop(agent->ev_loop, &agent->break_async);
+   ev_async_stop(backend->ev_loop, &backend->break_async);
 
-  if (!ev_is_default_loop(agent->ev_loop)) ev_loop_destroy(agent->ev_loop);
+  if (!ev_is_default_loop(backend->ev_loop)) ev_loop_destroy(backend->ev_loop);
 
   return self;
 }
 
-VALUE LibevAgent_post_fork(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
-
-  if (!ev_is_default_loop(agent->ev_loop)) {
-    // post_fork is called only for the main thread of the forked process. If
-    // the forked process was forked from a thread other than the main one,
-    // we remove the old non-default ev_loop and use the default one instead.
-    ev_loop_destroy(agent->ev_loop);
-    agent->ev_loop = EV_DEFAULT;
-  }
+VALUE LibevBackend_post_fork(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
-  ev_loop_fork(agent->ev_loop);
+  // 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
+  // default one, as post_fork is called only from the main thread of the forked
+  // process. That way we don't need to call ev_loop_fork, since the loop is
+  // always a fresh one.
+  ev_loop_destroy(backend->ev_loop);
+  backend->ev_loop = EV_DEFAULT;
 
   return self;
 }
 
-VALUE LibevAgent_ref(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
+VALUE LibevBackend_ref(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
-  agent->ref_count++;
-  return self;  
+  backend->ref_count++;
+  return self;
 }
 
-VALUE LibevAgent_unref(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
+VALUE LibevBackend_unref(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
-  agent->ref_count--;
-  return self;  
+  backend->ref_count--;
+  return self;
 }
 
-int LibevAgent_ref_count(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
+int LibevBackend_ref_count(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
-  return agent->ref_count;
+  return backend->ref_count;
 }
 
-void LibevAgent_reset_ref_count(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
+void LibevBackend_reset_ref_count(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
-  agent->ref_count = 0;
+  backend->ref_count = 0;
 }
 
-VALUE LibevAgent_pending_count(VALUE self) {
+VALUE LibevBackend_pending_count(VALUE self) {
   int count;
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
-  count = ev_pending_count(agent->ev_loop);
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
+  count = ev_pending_count(backend->ev_loop);
   return INT2NUM(count);
 }
 
-VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue) {
+VALUE LibevBackend_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue) {
   int is_nowait = nowait == Qtrue;
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
   if (is_nowait) {
     long runnable_count = Queue_len(queue);
-    agent->run_no_wait_count++;
-    if (agent->run_no_wait_count < runnable_count || agent->run_no_wait_count < 10)
+    backend->run_no_wait_count++;
+    if (backend->run_no_wait_count < runnable_count || backend->run_no_wait_count < 10)
       return self;
   }
 
-  agent->run_no_wait_count = 0;
-  
-  FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
-  agent->running = 1;
-  ev_run(agent->ev_loop, is_nowait ? EVRUN_NOWAIT : EVRUN_ONCE);
-  agent->running = 0;
-  FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
+  backend->run_no_wait_count = 0;
+
+  COND_TRACE(2, SYM_fiber_ev_loop_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);
 
   return self;
 }
 
-VALUE LibevAgent_break(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
+VALUE LibevBackend_wakeup(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
 
-  if (agent->running) {
+  if (backend->running) {
     // 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
     // should be called from the same thread (from within the ev_loop), using an
     // `ev_async` allows us to interrupt the event loop across threads.
-    ev_async_send(agent->ev_loop, &agent->break_async);
+    ev_async_send(backend->ev_loop, &backend->break_async);
     return Qtrue;
   }
 
@@ -239,40 +238,47 @@ struct libev_io {
   VALUE fiber;
 };
 
-void LibevAgent_io_callback(EV_P_ ev_io *w, int revents)
+void LibevBackend_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(struct LibevAgent_t *agent) {
+inline VALUE libev_await(LibevBackend_t *backend) {
   VALUE ret;
-  agent->ref_count++;
+  backend->ref_count++;
   ret = Thread_switch_fiber(rb_thread_current());
-  agent->ref_count--;
+  backend->ref_count--;
   RB_GC_GUARD(ret);
   return ret;
 }
 
-VALUE libev_agent_await(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
-  return libev_await(agent);
-}
-
-VALUE libev_io_wait(struct LibevAgent_t *agent, struct libev_io *watcher, rb_io_t *fptr, int flags) {
+VALUE libev_wait_fd_with_watcher(LibevBackend_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, LibevAgent_io_callback, fptr->fd, flags);
+    ev_io_init(&watcher->io, LibevBackend_io_callback, fd, events);
   }
-  ev_io_start(agent->ev_loop, &watcher->io);
-  switchpoint_result = libev_await(agent);
-  ev_io_stop(agent->ev_loop, &watcher->io);
+  ev_io_start(backend->ev_loop, &watcher->io);
 
+  switchpoint_result = libev_await(backend);
+
+  ev_io_stop(backend->ev_loop, &watcher->io);
   RB_GC_GUARD(switchpoint_result);
-  return switchpoint_result;  
+  return switchpoint_result;
+}
+
+VALUE libev_wait_fd(LibevBackend_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);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
 }
 
 VALUE libev_snooze() {
@@ -289,24 +295,23 @@ ID ID_ivar_is_nonblocking;
 // 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
-  return rb_w32_set_nonblock(fptr->fd);
+  rb_w32_set_nonblock(fptr->fd);
 #elif defined(F_GETFL)
-  VALUE is_nonblocking = rb_ivar_get(io, ID_ivar_is_nonblocking);
-  if (is_nonblocking == Qnil) {
-    rb_ivar_set(io, ID_ivar_is_nonblocking, Qtrue);
-    int oflags = fcntl(fptr->fd, F_GETFL);
-    if (oflags == -1) return;
-    if (oflags & O_NONBLOCK) return;
-    oflags |= O_NONBLOCK;
-    fcntl(fptr->fd, F_SETFL, oflags);
-  }
+  int oflags = fcntl(fptr->fd, F_GETFL);
+  if ((oflags == -1) && (oflags & O_NONBLOCK)) return;
+  oflags |= O_NONBLOCK;
+  fcntl(fptr->fd, F_SETFL, oflags);
 #endif
-  return;
 }
 
-VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
-  struct LibevAgent_t *agent;
+VALUE LibevBackend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
+  LibevBackend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
@@ -318,13 +323,13 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
   int read_to_eof = RTEST(to_eof);
   VALUE underlying_io = rb_iv_get(io, "@io");
 
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
   io_set_nonblock(fptr, io);
   watcher.fiber = Qnil;
-  
+
   OBJ_TAINT(str);
 
   // Apparently after reopening a closed file, the file position is not reset,
@@ -341,12 +346,14 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
     if (n < 0) {
       int e = errno;
       if (e != EWOULDBLOCK && e != EAGAIN) rb_syserr_fail(e, strerror(e));
-      
-      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
       switchpoint_result = libev_snooze();
+
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
       if (n == 0) break; // EOF
@@ -355,7 +362,7 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
 
       if (total == len) {
         if (!dynamic_len) break;
-      
+
         rb_str_resize(str, total);
         rb_str_modify_expand(str, len);
         buf = RSTRING_PTR(str) + total;
@@ -365,20 +372,21 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
       else buf += n;
     }
   }
-  if (total == 0) return Qnil;
 
   io_set_read_length(str, total, shrinkable);
   io_enc_str(str, fptr);
-  
+
+  if (total == 0) return Qnil;
+
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
   return str;
 error:
-  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+  return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
+VALUE LibevBackend_read_loop(VALUE self, VALUE io) {
 
   #define PREPARE_STR() { \
     str = Qnil; \
@@ -395,7 +403,7 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
     PREPARE_STR(); \
   }
 
-  struct LibevAgent_t *agent;
+  LibevBackend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE str;
@@ -408,7 +416,7 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
 
   PREPARE_STR();
 
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
@@ -430,22 +438,17 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
       switchpoint_result = libev_snooze();
-      if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
-      if (n == 0) break; // EOF      
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
+      if (n == 0) break; // EOF
       total = n;
       YIELD_STR();
-      Fiber_make_runnable(rb_fiber_current(), Qnil);
-      switchpoint_result = Thread_switch_fiber(rb_thread_current());
-      if (TEST_EXCEPTION(switchpoint_result)) {
-        goto error;
-      }
     }
   }
 
@@ -455,11 +458,11 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
 
   return io;
 error:
-  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+  return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
-  struct LibevAgent_t *agent;
+VALUE LibevBackend_write(VALUE self, VALUE io, VALUE str) {
+  LibevBackend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
@@ -470,7 +473,7 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
 
   underlying_io = rb_iv_get(io, "@io");
   if (underlying_io != Qnil) io = underlying_io;
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
   watcher.fiber = Qnil;
@@ -480,7 +483,9 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
     if (n < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
-      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -491,6 +496,7 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
 
   if (watcher.fiber == Qnil) {
     switchpoint_result = libev_snooze();
+
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -499,11 +505,11 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
 
   return INT2NUM(len);
 error:
-  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+  return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
-  struct LibevAgent_t *agent;
+VALUE LibevBackend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
+  LibevBackend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
@@ -516,7 +522,7 @@ VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
 
   underlying_io = rb_iv_get(io, "@io");
   if (underlying_io != Qnil) io = underlying_io;
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
   watcher.fiber = Qnil;
@@ -536,7 +542,8 @@ VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -559,6 +566,7 @@ VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   }
   if (watcher.fiber == Qnil) {
     switchpoint_result = libev_snooze();
+
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
@@ -569,23 +577,23 @@ VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   return INT2NUM(total_written);
 error:
   free(iov);
-  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+  return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevAgent_write_m(int argc, VALUE *argv, VALUE self) {
+VALUE LibevBackend_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) ?
-    LibevAgent_write(self, argv[0], argv[1]) :
-    LibevAgent_writev(self, argv[0], argc - 1, argv + 1);                    
+    LibevBackend_write(self, argv[0], argv[1]) :
+    LibevBackend_writev(self, argv[0], argc - 1, argv + 1);
 }
 
 ///////////////////////////////////////////////////////////////////////////
 
-VALUE LibevAgent_accept(VALUE self, VALUE sock) {
-  struct LibevAgent_t *agent;
+VALUE LibevBackend_accept(VALUE self, VALUE sock) {
+  LibevBackend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   int fd;
@@ -595,7 +603,7 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
   VALUE underlying_sock = rb_iv_get(sock, "@io");
   if (underlying_sock != Qnil) sock = underlying_sock;
 
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
   GetOpenFile(sock, fptr);
   io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
@@ -605,13 +613,15 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
       VALUE socket;
       rb_io_t *fp;
       switchpoint_result = libev_snooze();
+
       if (TEST_EXCEPTION(switchpoint_result)) {
         close(fd); // close fd since we're raising an exception
         goto error;
@@ -625,7 +635,7 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
       rb_io_ascii8bit_binmode(socket);
       io_set_nonblock(fp, socket);
       rb_io_synchronized(fp);
-      
+
       // if (rsock_do_not_reverse_lookup) {
 	    //   fp->mode |= FMODE_NOREVLOOKUP;
       // }
@@ -635,11 +645,11 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
   RB_GC_GUARD(switchpoint_result);
   return Qnil;
 error:
-  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+  return RAISE_EXCEPTION(switchpoint_result);
 }
 
-VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
-  struct LibevAgent_t *agent;
+VALUE LibevBackend_accept_loop(VALUE self, VALUE sock) {
+  LibevBackend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
   int fd;
@@ -650,7 +660,7 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
   VALUE underlying_sock = rb_iv_get(sock, "@io");
   if (underlying_sock != Qnil) sock = underlying_sock;
 
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
   GetOpenFile(sock, fptr);
   io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
@@ -661,17 +671,19 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
       rb_io_t *fp;
       switchpoint_result = libev_snooze();
+
       if (TEST_EXCEPTION(switchpoint_result)) {
         close(fd); // close fd since we're raising an exception
         goto error;
       }
-    
+
       socket = rb_obj_alloc(cTCPSocket);
       MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
@@ -691,72 +703,58 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
   RB_GC_GUARD(switchpoint_result);
   return Qnil;
 error:
-  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
-}
-
-// VALUE LibevAgent_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
-//   struct LibevAgent_t *agent;
-//   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");
-//   if (underlying_sock != Qnil) sock = underlying_sock;
-
-//   GetLibevAgent(self, agent);
-//   GetOpenFile(sock, fptr);
-//   io_set_nonblock(fptr, sock);
-//   watcher.fiber = Qnil;
-
-//   addr.sin_family = AF_INET; 
-//   addr.sin_addr.s_addr = inet_addr(host_buf);
-//   addr.sin_port = htons(NUM2INT(port));   
-
-//   while (1) {
-//     int result = connect(fptr->fd, &addr, sizeof(addr));
-//     if (result < 0) {
-//       int e = errno;
-//       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
-
-//       switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
-//       if (TEST_EXCEPTION(switchpoint_result)) goto error;
-//     }
-//     else {
-//       switchpoint_result = libev_snooze();
-//       if (TEST_EXCEPTION(switchpoint_result)) goto error;
-
-//       return sock;
-//     }
-//   }
-//   RB_GC_GUARD(switchpoint_result);
-//   return Qnil;
-// error:
-//   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
-// }
-
-VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
-  struct LibevAgent_t *agent;
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE LibevBackend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
+  LibevBackend_t *backend;
   struct libev_io watcher;
   rb_io_t *fptr;
+  struct sockaddr_in addr;
+  char *host_buf = StringValueCStr(host);
   VALUE switchpoint_result = Qnil;
-  int events = RTEST(write) ? EV_WRITE : EV_READ;
+  VALUE underlying_sock = rb_iv_get(sock, "@io");
+  if (underlying_sock != Qnil) sock = underlying_sock;
 
+  GetLibevBackend(self, backend);
+  GetOpenFile(sock, fptr);
+  io_set_nonblock(fptr, sock);
+  watcher.fiber = Qnil;
+
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = inet_addr(host_buf);
+  addr.sin_port = htons(NUM2INT(port));
+
+  int result = connect(fptr->fd, (struct sockaddr *)&addr, sizeof(addr));
+  if (result < 0) {
+    int e = errno;
+    if (e != EINPROGRESS) rb_syserr_fail(e, strerror(e));
+
+    switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+  else {
+    switchpoint_result = libev_snooze();
+
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+  RB_GC_GUARD(switchpoint_result);
+  return sock;
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE LibevBackend_wait_io(VALUE self, VALUE io, VALUE write) {
+  LibevBackend_t *backend;
+  rb_io_t *fptr;
+  int events = RTEST(write) ? EV_WRITE : EV_READ;
   VALUE underlying_io = rb_iv_get(io, "@io");
-  GetLibevAgent(self, agent);
   if (underlying_io != Qnil) io = underlying_io;
+  GetLibevBackend(self, backend);
   GetOpenFile(io, fptr);
-  
-  watcher.fiber = rb_fiber_current();
-  ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, events);
-  ev_io_start(agent->ev_loop, &watcher.io);
-  switchpoint_result = libev_await(agent);
-  ev_io_stop(agent->ev_loop, &watcher.io);
-  
-  TEST_RESUME_EXCEPTION(switchpoint_result);
-  RB_GC_GUARD(watcher.fiber);
-  RB_GC_GUARD(switchpoint_result);
-  return switchpoint_result;
+
+  return libev_wait_fd(backend, fptr->fd, events, 1);
 }
 
 struct libev_timer {
@@ -764,26 +762,25 @@ struct libev_timer {
   VALUE fiber;
 };
 
-void LibevAgent_timer_callback(EV_P_ ev_timer *w, int revents)
+void LibevBackend_timer_callback(EV_P_ ev_timer *w, int revents)
 {
   struct libev_timer *watcher = (struct libev_timer *)w;
   Fiber_make_runnable(watcher->fiber, Qnil);
 }
 
-VALUE LibevAgent_sleep(VALUE self, VALUE duration) {
-  struct LibevAgent_t *agent;
+VALUE LibevBackend_sleep(VALUE self, VALUE duration) {
+  LibevBackend_t *backend;
   struct libev_timer watcher;
   VALUE switchpoint_result = Qnil;
 
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
   watcher.fiber = rb_fiber_current();
-  ev_timer_init(&watcher.timer, LibevAgent_timer_callback, NUM2DBL(duration), 0.);
-  ev_timer_start(agent->ev_loop, &watcher.timer);
-
-  switchpoint_result = libev_await(agent);
+  ev_timer_init(&watcher.timer, LibevBackend_timer_callback, NUM2DBL(duration), 0.);
+  ev_timer_start(backend->ev_loop, &watcher.timer);
 
-  ev_timer_stop(agent->ev_loop, &watcher.timer);
+  switchpoint_result = libev_await(backend);
 
+  ev_timer_stop(backend->ev_loop, &watcher.timer);
   TEST_RESUME_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
@@ -795,7 +792,7 @@ struct libev_child {
   VALUE fiber;
 };
 
-void LibevAgent_child_callback(EV_P_ ev_child *w, int revents)
+void LibevBackend_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?
@@ -805,78 +802,88 @@ void LibevAgent_child_callback(EV_P_ ev_child *w, int revents)
   Fiber_make_runnable(watcher->fiber, status);
 }
 
-VALUE LibevAgent_waitpid(VALUE self, VALUE pid) {
-  struct LibevAgent_t *agent;
+VALUE LibevBackend_waitpid(VALUE self, VALUE pid) {
+  LibevBackend_t *backend;
   struct libev_child watcher;
   VALUE switchpoint_result = Qnil;
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
 
   watcher.fiber = rb_fiber_current();
-  ev_child_init(&watcher.child, LibevAgent_child_callback, NUM2INT(pid), 0);
-  ev_child_start(agent->ev_loop, &watcher.child);
-  
-  switchpoint_result = libev_await(agent);
-  ev_child_stop(agent->ev_loop, &watcher.child);
+  ev_child_init(&watcher.child, LibevBackend_child_callback, NUM2INT(pid), 0);
+  ev_child_start(backend->ev_loop, &watcher.child);
+
+  switchpoint_result = libev_await(backend);
 
+  ev_child_stop(backend->ev_loop, &watcher.child);
   TEST_RESUME_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
 }
 
-struct ev_loop *LibevAgent_ev_loop(VALUE self) {
-  struct LibevAgent_t *agent;
-  GetLibevAgent(self, agent);
-  return agent->ev_loop;
+struct ev_loop *LibevBackend_ev_loop(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
+  return backend->ev_loop;
 }
 
-void LibevAgent_async_callback(EV_P_ ev_async *w, int revents) { }
+void LibevBackend_async_callback(EV_P_ ev_async *w, int revents) { }
 
-VALUE LibevAgent_wait_event(VALUE self, VALUE raise) {
-  struct LibevAgent_t *agent;
-  struct ev_async async;
+VALUE LibevBackend_wait_event(VALUE self, VALUE raise) {
+  LibevBackend_t *backend;
   VALUE switchpoint_result = Qnil;
-  GetLibevAgent(self, agent);
+  GetLibevBackend(self, backend);
+
+  struct ev_async async;
 
-  ev_async_init(&async, LibevAgent_async_callback);
-  ev_async_start(agent->ev_loop, &async);
-  
-  switchpoint_result = libev_await(agent);
-  ev_async_stop(agent->ev_loop, &async);
+  ev_async_init(&async, LibevBackend_async_callback);
+  ev_async_start(backend->ev_loop, &async);
 
+  switchpoint_result = libev_await(backend);
+
+  ev_async_stop(backend->ev_loop, &async);
   if (RTEST(raise)) TEST_RESUME_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
 }
 
-void Init_LibevAgent() {
+void Init_LibevBackend() {
   rb_require("socket");
   cTCPSocket = rb_const_get(rb_cObject, rb_intern("TCPSocket"));
 
-  cLibevAgent = rb_define_class_under(mPolyphony, "LibevAgent", rb_cData);
-  rb_define_alloc_func(cLibevAgent, LibevAgent_allocate);
+  VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
+  rb_define_alloc_func(cBackend, LibevBackend_allocate);
 
-  rb_define_method(cLibevAgent, "initialize", LibevAgent_initialize, 0);
-  rb_define_method(cLibevAgent, "finalize", LibevAgent_finalize, 0);
-  rb_define_method(cLibevAgent, "post_fork", LibevAgent_post_fork, 0);
-  rb_define_method(cLibevAgent, "pending_count", LibevAgent_pending_count, 0);
+  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(cLibevAgent, "ref", LibevAgent_ref, 0);
-  rb_define_method(cLibevAgent, "unref", LibevAgent_unref, 0);
+  rb_define_method(cBackend, "ref", LibevBackend_ref, 0);
+  rb_define_method(cBackend, "unref", LibevBackend_unref, 0);
 
-  rb_define_method(cLibevAgent, "poll", LibevAgent_poll, 3);
-  rb_define_method(cLibevAgent, "break", LibevAgent_break, 0);
+  rb_define_method(cBackend, "poll", LibevBackend_poll, 3);
+  rb_define_method(cBackend, "break", LibevBackend_wakeup, 0);
 
-  rb_define_method(cLibevAgent, "read", LibevAgent_read, 4);
-  rb_define_method(cLibevAgent, "read_loop", LibevAgent_read_loop, 1);
-  rb_define_method(cLibevAgent, "write", LibevAgent_write_m, -1);
-  rb_define_method(cLibevAgent, "accept", LibevAgent_accept, 1);
-  rb_define_method(cLibevAgent, "accept_loop", LibevAgent_accept_loop, 1);
-  // rb_define_method(cLibevAgent, "connect", LibevAgent_accept, 3);
-  rb_define_method(cLibevAgent, "wait_io", LibevAgent_wait_io, 2);
-  rb_define_method(cLibevAgent, "sleep", LibevAgent_sleep, 1);
-  rb_define_method(cLibevAgent, "waitpid", LibevAgent_waitpid, 1);
-  rb_define_method(cLibevAgent, "wait_event", LibevAgent_wait_event, 1);
+  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);
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
+
+  __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;
 }