polyphony 0.43.6 → 0.44.0

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

@@ -1,23 +1,26 @@
 #include <netdb.h>
 #include <sys/socket.h>
 #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 LibevAgent_t {
   struct ev_loop *ev_loop;
   struct ev_async break_async;
   int running;
   int ref_count;
   int run_no_wait_count;
-};
+} LibevAgent_t;
 
 static size_t LibevAgent_size(const void *ptr) {
-  return sizeof(struct LibevAgent_t);
+  return sizeof(LibevAgent_t);
 }
 
 static const rb_data_type_t LibevAgent_type = {
@@ -27,13 +30,13 @@ static const rb_data_type_t LibevAgent_type = {
 };
 
 static VALUE LibevAgent_allocate(VALUE klass) {
-  struct LibevAgent_t *agent = ALLOC(struct LibevAgent_t);
+  LibevAgent_t *agent = ALLOC(LibevAgent_t);
   
   return TypedData_Wrap_Struct(klass, &LibevAgent_type, agent);
 }
 
 #define GetLibevAgent(obj, agent) \
-  TypedData_Get_Struct((obj), struct LibevAgent_t, &LibevAgent_type, (agent))
+  TypedData_Get_Struct((obj), LibevAgent_t, &LibevAgent_type, (agent))
 
 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
@@ -41,7 +44,7 @@ void break_async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, in
 }
 
 static VALUE LibevAgent_initialize(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   VALUE thread = rb_thread_current();
   int is_main_thread = (thread == rb_thread_main());
 
@@ -60,7 +63,7 @@ static VALUE LibevAgent_initialize(VALUE self) {
 }
 
 VALUE LibevAgent_finalize(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
    ev_async_stop(agent->ev_loop, &agent->break_async);
@@ -71,24 +74,22 @@ VALUE LibevAgent_finalize(VALUE self) {
 }
 
 VALUE LibevAgent_post_fork(VALUE self) {
-  struct LibevAgent_t *agent;
+  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;
-  }
-
-  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(agent->ev_loop);
+  agent->ev_loop = EV_DEFAULT;
 
   return self;
 }
 
 VALUE LibevAgent_ref(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   agent->ref_count++;
@@ -96,7 +97,7 @@ VALUE LibevAgent_ref(VALUE self) {
 }
 
 VALUE LibevAgent_unref(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   agent->ref_count--;
@@ -104,14 +105,14 @@ VALUE LibevAgent_unref(VALUE self) {
 }
 
 int LibevAgent_ref_count(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   return agent->ref_count;
 }
 
 void LibevAgent_reset_ref_count(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   agent->ref_count = 0;
@@ -119,7 +120,7 @@ void LibevAgent_reset_ref_count(VALUE self) {
 
 VALUE LibevAgent_pending_count(VALUE self) {
   int count;
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
   count = ev_pending_count(agent->ev_loop);
   return INT2NUM(count);
@@ -127,11 +128,11 @@ VALUE LibevAgent_pending_count(VALUE self) {
 
 VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue) {
   int is_nowait = nowait == Qtrue;
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   if (is_nowait) {
-    long runnable_count = LibevQueue_len(queue);
+    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)
       return self;
@@ -139,17 +140,17 @@ VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue
 
   agent->run_no_wait_count = 0;
   
-  FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
+  COND_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_leave, current_fiber);
 
   return self;
 }
 
-VALUE LibevAgent_break(VALUE self) {
-  struct LibevAgent_t *agent;
+VALUE LibevAgent_wakeup(VALUE self) {
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   if (agent->running) {
@@ -243,7 +244,7 @@ void LibevAgent_io_callback(EV_P_ ev_io *w, int revents)
   Fiber_make_runnable(watcher->fiber, Qnil);
 }
 
-inline VALUE libev_await(struct LibevAgent_t *agent) {
+inline VALUE libev_await(LibevAgent_t *agent) {
   VALUE ret;
   agent->ref_count++;
   ret = Thread_switch_fiber(rb_thread_current());
@@ -253,12 +254,12 @@ inline VALUE libev_await(struct LibevAgent_t *agent) {
 }
 
 VALUE libev_agent_await(VALUE self) {
-  struct LibevAgent_t *agent;
+  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_io_wait(LibevAgent_t *agent, struct libev_io *watcher, rb_io_t *fptr, int flags) {
   VALUE switchpoint_result;
 
   if (watcher->fiber == Qnil) {
@@ -278,8 +279,33 @@ VALUE libev_snooze() {
   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) {
+#ifdef _WIN32
+  return 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);
+  }
+#endif
+  return;
+}
+
 VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
@@ -295,11 +321,20 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, io);
   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) {
@@ -339,7 +374,7 @@ 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) {
@@ -349,6 +384,7 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
     shrinkable = io_setstrbuf(&str, len); \
     buf = RSTRING_PTR(str); \
     total = 0; \
+    OBJ_TAINT(str); \
   }
 
   #define YIELD_STR() { \
@@ -358,7 +394,7 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
     PREPARE_STR(); \
   }
 
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE str;
@@ -375,10 +411,17 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
   if (underlying_io != Qnil) io = underlying_io;
   GetOpenFile(io, fptr);
   rb_io_check_byte_readable(fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, io);
   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);
@@ -411,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;
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
@@ -455,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;
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
@@ -525,7 +568,7 @@ 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) {
@@ -541,7 +584,7 @@ VALUE LibevAgent_write_m(int argc, VALUE *argv, VALUE self) {
 ///////////////////////////////////////////////////////////////////////////
 
 VALUE LibevAgent_accept(VALUE self, VALUE sock) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   int fd;
@@ -553,7 +596,7 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
 
   GetLibevAgent(self, agent);
   GetOpenFile(sock, fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
   while (1) {
     fd = accept(fptr->fd, &addr, &len);
@@ -579,7 +622,7 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      rb_io_set_nonblock(fp);
+      io_set_nonblock(fp, socket);
       rb_io_synchronized(fp);
       
       // if (rsock_do_not_reverse_lookup) {
@@ -591,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;
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   int fd;
@@ -608,7 +651,7 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
 
   GetLibevAgent(self, agent);
   GetOpenFile(sock, fptr);
-  rb_io_set_nonblock(fptr);
+  io_set_nonblock(fptr, sock);
   watcher.fiber = Qnil;
 
   while (1) {
@@ -634,7 +677,7 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
       rb_io_ascii8bit_binmode(socket);
-      rb_io_set_nonblock(fp);
+      io_set_nonblock(fp, socket);
       rb_io_synchronized(fp);
 
       rb_yield(socket);
@@ -647,74 +690,72 @@ 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);
-//   rb_io_set_nonblock(fptr);
-//   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);
-// }
+  return RAISE_EXCEPTION(switchpoint_result);
+}
 
-VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
-  struct LibevAgent_t *agent;
+VALUE LibevAgent_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
+  LibevAgent_t *agent;
   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);
+  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(agent, &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(LibevAgent_t *agent, 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_init(&watcher.io, LibevAgent_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);
   
-  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 LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
+  LibevAgent_t *agent;
+  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;
+  GetLibevAgent(self, agent);
+  GetOpenFile(io, fptr);
+  
+  return libev_wait_fd(agent, fptr->fd, events, 1);
+}
+
 struct libev_timer {
   struct ev_timer timer;
   VALUE fiber;
@@ -727,7 +768,7 @@ void LibevAgent_timer_callback(EV_P_ ev_timer *w, int revents)
 }
 
 VALUE LibevAgent_sleep(VALUE self, VALUE duration) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   struct libev_timer watcher;
   VALUE switchpoint_result = Qnil;
 
@@ -737,6 +778,7 @@ VALUE LibevAgent_sleep(VALUE self, VALUE duration) {
   ev_timer_start(agent->ev_loop, &watcher.timer);
 
   switchpoint_result = libev_await(agent);
+
   ev_timer_stop(agent->ev_loop, &watcher.timer);
 
   TEST_RESUME_EXCEPTION(switchpoint_result);
@@ -761,7 +803,7 @@ void LibevAgent_child_callback(EV_P_ ev_child *w, int revents)
 }
 
 VALUE LibevAgent_waitpid(VALUE self, VALUE pid) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   struct libev_child watcher;
   VALUE switchpoint_result = Qnil;
   GetLibevAgent(self, agent);
@@ -780,36 +822,67 @@ VALUE LibevAgent_waitpid(VALUE self, VALUE pid) {
 }
 
 struct ev_loop *LibevAgent_ev_loop(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
   return agent->ev_loop;
 }
 
+void LibevAgent_async_callback(EV_P_ ev_async *w, int revents) { }
+
+VALUE LibevAgent_wait_event(VALUE self, VALUE raise) {
+  LibevAgent_t *agent;
+  VALUE switchpoint_result = Qnil;
+  GetLibevAgent(self, agent);
+
+  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);
+
+  if (RTEST(raise)) TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
+}
+
 void Init_LibevAgent() {
   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);
-
-  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(cLibevAgent, "ref", LibevAgent_ref, 0);
-  rb_define_method(cLibevAgent, "unref", LibevAgent_unref, 0);
-
-  rb_define_method(cLibevAgent, "poll", LibevAgent_poll, 3);
-  rb_define_method(cLibevAgent, "break", LibevAgent_break, 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);
+  VALUE cAgent = rb_define_class_under(mPolyphony, "Agent", rb_cData);
+  rb_define_alloc_func(cAgent, LibevAgent_allocate);
+
+  rb_define_method(cAgent, "initialize", LibevAgent_initialize, 0);
+  rb_define_method(cAgent, "finalize", LibevAgent_finalize, 0);
+  rb_define_method(cAgent, "post_fork", LibevAgent_post_fork, 0);
+  rb_define_method(cAgent, "pending_count", LibevAgent_pending_count, 0);
+
+  rb_define_method(cAgent, "ref", LibevAgent_ref, 0);
+  rb_define_method(cAgent, "unref", LibevAgent_unref, 0);
+
+  rb_define_method(cAgent, "poll", LibevAgent_poll, 3);
+  rb_define_method(cAgent, "break", LibevAgent_wakeup, 0);
+
+  rb_define_method(cAgent, "read", LibevAgent_read, 4);
+  rb_define_method(cAgent, "read_loop", LibevAgent_read_loop, 1);
+  rb_define_method(cAgent, "write", LibevAgent_write_m, -1);
+  rb_define_method(cAgent, "accept", LibevAgent_accept, 1);
+  rb_define_method(cAgent, "accept_loop", LibevAgent_accept_loop, 1);
+  rb_define_method(cAgent, "connect", LibevAgent_connect, 3);
+  rb_define_method(cAgent, "wait_io", LibevAgent_wait_io, 2);
+  rb_define_method(cAgent, "sleep", LibevAgent_sleep, 1);
+  rb_define_method(cAgent, "waitpid", LibevAgent_waitpid, 1);
+  rb_define_method(cAgent, "wait_event", LibevAgent_wait_event, 1);
+
+  ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
+
+  __AGENT__.pending_count   = LibevAgent_pending_count;
+  __AGENT__.poll            = LibevAgent_poll;
+  __AGENT__.ref             = LibevAgent_ref;
+  __AGENT__.ref_count       = LibevAgent_ref_count;
+  __AGENT__.reset_ref_count = LibevAgent_reset_ref_count;
+  __AGENT__.unref           = LibevAgent_unref;
+  __AGENT__.wait_event      = LibevAgent_wait_event;
+  __AGENT__.wakeup          = LibevAgent_wakeup;
 }