polyphony 0.43.8 → 0.45.0

data/docs/getting-started/tutorial.md

@@ -123,7 +123,7 @@ suspend # The main fiber suspends, waiting for all other work to finish
   sleep 1 # The sleeper fiber goes to sleep
     Gyro::Timer.new(1, 0).await # A timer event watcher is setup and yields
       Thread.current.switch_fiber # Polyphony looks for other runnable fibers
-        Thread.current.agent.poll # With no work left, the event loop is ran
+        Thread.current.backend.poll # With no work left, the event loop is ran
           fiber.schedule # The timer event fires, scheduling the sleeper fiber
   # <= The sleep method returns
   puts "Woke up"

data/examples/adapters/sequel_mysql.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/sequel'
+require 'polyphony/adapters/mysql2'
+
+time_printer = spin do
+  last = Time.now
+  throttled_loop(10) do
+    now = Time.now
+    puts now - last
+    last = now
+  end
+end
+
+db = Sequel.connect('mysql2://localhost/test')
+
+x = 10_000
+t0 = Time.now
+x.times { db.execute('select 1 as test') }
+puts "query rate: #{x / (Time.now - t0)} reqs/s"
+
+time_printer.stop

data/examples/adapters/sequel_mysql_pool.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/sequel'
+require 'polyphony/adapters/mysql2'
+
+CONCURRENCY = ARGV.first ? ARGV.first.to_i : 1000
+puts "concurrency: #{CONCURRENCY}"
+
+db = Sequel.connect(
+  'mysql2://localhost/test',
+  max_connections: 100,
+  preconnect: true
+)
+
+t0 = Time.now
+count = 0
+
+fibers = Array.new(CONCURRENCY) do
+  spin do
+    loop do
+      db.execute('select sleep(0.001) as test')
+      count += 1
+    end
+  end
+end
+
+sleep 0.1
+fibers.first.terminate # Interrupt mid-query
+
+sleep 2
+puts "query rate: #{count / (Time.now - t0)} reqs/s"
+fibers.each(&:interrupt)

data/examples/core/{xx-agent.rb → xx-backend.rb}

@@ -27,17 +27,17 @@ class Test
   
   def test_file
     f = File.open(__FILE__, 'r')
-    puts Thread.current.agent.read(f, +'', 10000, true)
+    puts Thread.current.backend.read(f, +'', 10000, true)
     
-    Thread.current.agent.write(STDOUT, "Write something: ")
+    Thread.current.backend.write(STDOUT, "Write something: ")
     str = +''
-    Thread.current.agent.read(STDIN, str, 5, false)
+    Thread.current.backend.read(STDIN, str, 5, false)
     puts str
   end
   
   def test_fork
     pid = fork do
-      Thread.current.agent.post_fork
+      Thread.current.backend.post_fork
       puts 'child going to sleep'
       sleep 1
       puts 'child done sleeping'
@@ -45,7 +45,7 @@ class Test
     end
     
     puts "Waiting for pid #{pid}"
-    result = Thread.current.agent.waitpid(pid)
+    result = Thread.current.backend.waitpid(pid)
     puts "Done waiting"
     p result
   end

data/examples/core/xx-channels.rb

@@ -2,10 +2,12 @@
 
 require 'bundler/setup'
 require 'polyphony'
+require 'polyphony/core/channel'
 
 def echo(cin, cout)
   puts 'start echoer'
   while (msg = cin.receive)
+    puts "echoer received #{msg}"
     cout << "you said: #{msg}"
   end
 ensure
@@ -20,7 +22,7 @@ spin do
   puts 'start receiver'
   while (msg = chan2.receive)
     puts msg
-    $main.resume if msg =~ /world/
+    $main.schedule if msg =~ /world/
   end
 ensure
   puts 'receiver stopped'
@@ -42,4 +44,4 @@ $main = spin do
   puts "done #{Time.now - t0}"
 end
 
-suspend
+$main.await

data/examples/core/xx-using-a-mutex.rb

@@ -2,6 +2,7 @@
 
 require 'bundler/setup'
 require 'polyphony'
+require 'polyphony/core/sync'
 
 def loop_it(number, lock)
   loop do
@@ -13,7 +14,7 @@ def loop_it(number, lock)
   end
 end
 
-lock = Polyphony::Sync::Mutex.new
+lock = Polyphony::Mutex.new
 spin { loop_it(1, lock) }
 spin { loop_it(2, lock) }
 spin { loop_it(3, lock) }

data/examples/io/xx-pry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'polyphony/adapters/readline'
+require 'pry'
+
+$counter = 0
+timer = spin do
+  throttled_loop(5) do
+    $counter += 1
+  end
+end
+
+at_exit { timer.stop }
+
+puts 'try typing $counter to see the counter incremented in the background'
+binding.pry

data/examples/io/xx-rack_server.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'http/parser'
+require 'rack'
+
+module RackAdapter
+  class << self
+    def run(app)
+      ->(socket, req) { respond(socket, req, app.(env(req))) }
+    end
+
+    def env(req)
+      {}
+    end
+    
+    def respond(socket, request, (status_code, headers, body))
+      body = body.join
+      headers = "Content-Type: text/plain\r\nContent-Length: #{body.bytesize}\r\n"
+      socket.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{body}"
+    end
+  end
+end
+
+$connection_count = 0
+
+def handle_client(socket, &handler)
+  $connection_count += 1
+  parser = Http::Parser.new
+  reqs = []
+  parser.on_message_complete = proc do |env|
+    reqs << Object.new # parser
+  end
+  socket.read_loop do |data|
+    parser << data
+    while (req = reqs.shift)
+      handler.call(socket, req)
+      req = nil
+    end
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+ensure
+  $connection_count -= 1
+  socket&.close
+end
+
+def handle_request(client, parser)
+  status_code = "200 OK"
+  data = "Hello world!\n"
+  headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
+  client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
+end
+
+server = TCPServer.open('0.0.0.0', 1234)
+puts "pid #{Process.pid}"
+puts "listening on port 1234"
+
+app = RackAdapter.run(lambda { |env|
+  [
+    200,
+    {"Content-Type" => "text/plain"},
+    ["Hello, world!\n"]
+  ]
+})
+
+loop do
+  client = server.accept
+  spin { handle_client(client, &app) }
+end

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/ext/polyphony/backend.h

@@ -0,0 +1,41 @@
+#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 libev_backend_await(VALUE self);
+// 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

@@ -0,0 +1,86 @@
+#include "polyphony.h"
+#include "ring_buffer.h"
+
+typedef struct event {
+  VALUE waiting_fiber;
+} Event_t;
+
+VALUE cEvent = Qnil;
+
+static void Event_mark(void *ptr) {
+  Event_t *event = ptr;
+  rb_gc_mark(event->waiting_fiber);
+}
+
+static void Event_free(void *ptr) {
+  xfree(ptr);
+}
+
+static size_t Event_size(const void *ptr) {
+  return sizeof(Event_t);
+}
+
+static const rb_data_type_t Event_type = {
+  "Event",
+  {Event_mark, Event_free, Event_size,},
+  0, 0, 0
+};
+
+static VALUE Event_allocate(VALUE klass) {
+  Event_t *event;
+
+  event = ALLOC(Event_t);
+  return TypedData_Wrap_Struct(klass, &Event_type, event);
+}
+
+#define GetEvent(obj, event) \
+  TypedData_Get_Struct((obj), Event_t, &Event_type, (event))
+
+static VALUE Event_initialize(VALUE self) {
+  Event_t *event;
+  GetEvent(self, event);
+
+  event->waiting_fiber = Qnil;
+
+  return self;
+}
+
+VALUE Event_signal(int argc, VALUE *argv, VALUE self) {
+  VALUE value = argc > 0 ? argv[0] : Qnil;
+  Event_t *event;
+  GetEvent(self, event);
+
+  if (event->waiting_fiber != Qnil) {
+    Fiber_make_runnable(event->waiting_fiber, value);
+    event->waiting_fiber = Qnil;
+  }
+  return self;
+}
+
+VALUE Event_await(VALUE self) {
+  Event_t *event;
+  GetEvent(self, event);
+
+  if (event->waiting_fiber != Qnil)
+    rb_raise(rb_eRuntimeError, "Event is already awaited by another fiber");
+
+  VALUE backend = rb_ivar_get(rb_thread_current(), ID_ivar_backend);
+  event->waiting_fiber = rb_fiber_current();
+  VALUE switchpoint_result = __BACKEND__.wait_event(backend, Qnil);
+  event->waiting_fiber = Qnil;
+
+  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(backend);
+  RB_GC_GUARD(switchpoint_result);
+
+  return switchpoint_result;
+}
+
+void Init_Event() {
+  cEvent = rb_define_class_under(mPolyphony, "Event", rb_cData);
+  rb_define_alloc_func(cEvent, Event_allocate);
+
+  rb_define_method(cEvent, "initialize", Event_initialize, 0);
+  rb_define_method(cEvent, "await", Event_await, 0);
+  rb_define_method(cEvent, "signal", Event_signal, -1);
+}

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/fiber.c

@@ -9,8 +9,6 @@ ID ID_trace_runnable;
 ID ID_trace_terminate;
 ID ID_trace_wait;
 
-VALUE cEvent = Qnil;
-
 VALUE SYM_dead;
 VALUE SYM_running;
 VALUE SYM_runnable;
@@ -35,9 +33,6 @@ static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
 
 inline VALUE Fiber_auto_watcher(VALUE self) {
   VALUE watcher;
-  if (cEvent == Qnil) {
-    cEvent = rb_const_get(mPolyphony, rb_intern("Event"));
-  }
 
   watcher = rb_ivar_get(self, ID_ivar_auto_watcher);
   if (watcher == Qnil) {

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);
+static VALUE LibevBackend_allocate(VALUE klass) {
+  LibevBackend_t *backend = ALLOC(LibevBackend_t);
   
-  return TypedData_Wrap_Struct(klass, &LibevAgent_type, agent);
+  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++;
+  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--;
+  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;
+  backend->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);
+  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,37 +238,37 @@ 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_backend_await(VALUE self) {
+  LibevBackend_t *backend;
+  GetLibevBackend(self, backend);
+  return libev_await(backend);
 }
 
-VALUE libev_io_wait(struct LibevAgent_t *agent, struct libev_io *watcher, rb_io_t *fptr, int flags) {
+VALUE libev_io_wait(LibevBackend_t *backend, struct libev_io *watcher, rb_io_t *fptr, int flags) {
   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, fptr->fd, flags);
   }
-  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;  
@@ -305,8 +304,8 @@ inline void io_set_nonblock(rb_io_t *fptr, VALUE io) {
   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,7 +317,7 @@ 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);
@@ -342,7 +341,7 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
       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_io_wait(backend, &watcher, fptr, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -375,10 +374,10 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
 
   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 +394,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 +407,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,7 +429,7 @@ 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_io_wait(backend, &watcher, fptr, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -455,11 +454,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 +469,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 +479,7 @@ 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_io_wait(backend, &watcher, fptr, EV_WRITE);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -499,11 +498,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 +515,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 +535,7 @@ 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_io_wait(backend, &watcher, fptr, EV_WRITE);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -569,23 +568,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 +594,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,7 +604,7 @@ 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_io_wait(backend, &watcher, fptr, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -635,11 +634,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 +649,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,7 +660,7 @@ 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_io_wait(backend, &watcher, fptr, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -691,98 +690,96 @@ 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;
 
-  VALUE underlying_io = rb_iv_get(io, "@io");
-  GetLibevAgent(self, agent);
-  if (underlying_io != Qnil) io = underlying_io;
-  GetOpenFile(io, fptr);
+  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_io_wait(backend, &watcher, fptr, 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 libev_wait_fd(LibevBackend_t *backend, int fd, int events, int raise_exception) {
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
   
   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);
+  ev_io_init(&watcher.io, LibevBackend_io_callback, fd, events);
+  ev_io_start(backend->ev_loop, &watcher.io);
+  switchpoint_result = libev_await(backend);
+  ev_io_stop(backend->ev_loop, &watcher.io);
   
-  TEST_RESUME_EXCEPTION(switchpoint_result);
-  RB_GC_GUARD(watcher.fiber);
+  if (raise_exception) TEST_RESUME_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(switchpoint_result);
   return 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");
+  if (underlying_io != Qnil) io = underlying_io;
+  GetLibevBackend(self, backend);
+  GetOpenFile(io, fptr);
+  
+  return libev_wait_fd(backend, fptr->fd, events, 1);
+}
+
 struct libev_timer {
   struct ev_timer 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);
+  ev_timer_init(&watcher.timer, LibevBackend_timer_callback, NUM2DBL(duration), 0.);
+  ev_timer_start(backend->ev_loop, &watcher.timer);
 
-  switchpoint_result = libev_await(agent);
+  switchpoint_result = libev_await(backend);
 
-  ev_timer_stop(agent->ev_loop, &watcher.timer);
+  ev_timer_stop(backend->ev_loop, &watcher.timer);
 
   TEST_RESUME_EXCEPTION(switchpoint_result);
   RB_GC_GUARD(watcher.fiber);
@@ -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,18 +802,18 @@ 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);
+  ev_child_init(&watcher.child, LibevBackend_child_callback, NUM2INT(pid), 0);
+  ev_child_start(backend->ev_loop, &watcher.child);
   
-  switchpoint_result = libev_await(agent);
-  ev_child_stop(agent->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);
@@ -824,59 +821,68 @@ VALUE LibevAgent_waitpid(VALUE self, VALUE pid) {
   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);
 
-  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);
+  struct ev_async 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;
 }