polyphony 0.43.5 → 0.43.11

data/examples/xx-spin.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+puts "pid: #{Process.pid}"
+GC.disable
+
+def mem_usage
+  # orig_backtick('ps -o rss #{$$}').split.last.to_i
+  `ps -o rss #{$$}`.split.last.to_i
+end
+
+f = File.open('spin.log', 'w+')
+
+m0 = mem_usage
+
+X = ARGV[0] ? ARGV[0].to_i : 10
+STDOUT.orig_write "Starting #{X} fibers...\n"
+t0 = Time.now
+x = nil
+X.times do |i|
+  spin { p i; suspend }
+end
+
+suspend
+f.close
+t1 = Time.now
+m1 = mem_usage
+rate = X / (t1 - t0)
+mem_cost = (m1 - m0) / X.to_f
+STDOUT.orig_write("#{ { time: t1 - t0, spin_rate: rate, fiber_mem_cost: mem_cost }.inspect }\n")

data/ext/polyphony/agent.h

@@ -0,0 +1,41 @@
+#ifndef AGENT_H
+#define AGENT_H
+
+#include "ruby.h"
+
+// agent interface function signatures 
+
+// VALUE LibevAgent_accept(VALUE self, VALUE sock);
+// VALUE LibevAgent_accept_loop(VALUE self, VALUE sock);
+// VALUE libev_agent_await(VALUE self);
+// VALUE LibevAgent_connect(VALUE self, VALUE sock, VALUE host, VALUE port);
+// VALUE LibevAgent_finalize(VALUE self);
+// VALUE LibevAgent_post_fork(VALUE self);
+// VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof);
+// VALUE LibevAgent_read_loop(VALUE self, VALUE io);
+// VALUE LibevAgent_sleep(VALUE self, VALUE duration);
+// VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write);
+// VALUE LibevAgent_wait_pid(VALUE self, VALUE pid);
+// VALUE LibevAgent_write(int argc, VALUE *argv, VALUE self);
+
+typedef VALUE (* agent_pending_count_t)(VALUE self);
+typedef VALUE (*agent_poll_t)(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue);
+typedef VALUE (* agent_ref_t)(VALUE self);
+typedef int (* agent_ref_count_t)(VALUE self);
+typedef void (* agent_reset_ref_count_t)(VALUE self);
+typedef VALUE (* agent_unref_t)(VALUE self);
+typedef VALUE (* agent_wait_event_t)(VALUE self, VALUE raise_on_exception);
+typedef VALUE (* agent_wakeup_t)(VALUE self);
+
+typedef struct agent_interface {
+  agent_pending_count_t   pending_count;
+  agent_poll_t            poll;
+  agent_ref_t             ref;
+  agent_ref_count_t       ref_count;
+  agent_reset_ref_count_t reset_ref_count;
+  agent_unref_t           unref;
+  agent_wait_event_t      wait_event;
+  agent_wakeup_t          wakeup;
+} agent_interface_t;
+
+#endif /* AGENT_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 agent = rb_ivar_get(rb_thread_current(), ID_ivar_agent);
+  event->waiting_fiber = rb_fiber_current();
+  VALUE switchpoint_result = __AGENT__.wait_event(agent, Qnil);
+  event->waiting_fiber = Qnil;
+
+  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(agent);
+  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/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,22 +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 = {
@@ -26,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
@@ -40,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());
 
@@ -59,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);
@@ -70,7 +74,7 @@ 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)) {
@@ -87,7 +91,7 @@ VALUE LibevAgent_post_fork(VALUE self) {
 }
 
 VALUE LibevAgent_ref(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   agent->ref_count++;
@@ -95,7 +99,7 @@ VALUE LibevAgent_ref(VALUE self) {
 }
 
 VALUE LibevAgent_unref(VALUE self) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
   agent->ref_count--;
@@ -103,14 +107,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;
@@ -118,7 +122,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);
@@ -126,11 +130,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;
@@ -147,8 +151,8 @@ VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue
   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) {
@@ -242,7 +246,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());
@@ -252,12 +256,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) {
@@ -277,8 +281,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;
@@ -294,11 +323,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) {
@@ -348,6 +386,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() { \
@@ -357,7 +396,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;
@@ -374,10 +413,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);
@@ -413,20 +459,62 @@ error:
   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
 
-VALUE LibevAgent_write(int argc, VALUE *argv, VALUE self) {
-  struct LibevAgent_t *agent;
+VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
+  LibevAgent_t *agent;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  char *buf = StringValuePtr(str);
+  long len = RSTRING_LEN(str);
+  long left = len;
+
+  underlying_io = rb_iv_get(io, "@io");
+  if (underlying_io != Qnil) io = underlying_io;
+  GetLibevAgent(self, agent);
+  io = rb_io_get_write_io(io);
+  GetOpenFile(io, fptr);
+  watcher.fiber = Qnil;
+
+  while (left > 0) {
+    ssize_t n = write(fptr->fd, buf, left);
+    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);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      buf += n;
+      left -= n;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = libev_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(len);
+error:
+  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+}
+
+VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
-  VALUE io;
   VALUE underlying_io;
+  long total_length = 0;
   long total_written = 0;
-  int arg_idx = 1;
+  struct iovec *iov = 0;
+  struct iovec *iov_ptr = 0;
+  int iov_count = argc;
 
-  if (argc < 2)
-    rb_raise(rb_eRuntimeError, "(wrong number of arguments (expected 2 or more))");
-  
-  io = argv[0];
   underlying_io = rb_iv_get(io, "@io");
   if (underlying_io != Qnil) io = underlying_io;
   GetLibevAgent(self, agent);
@@ -434,30 +522,42 @@ VALUE LibevAgent_write(int argc, VALUE *argv, VALUE self) {
   GetOpenFile(io, fptr);
   watcher.fiber = Qnil;
 
-  while (arg_idx < argc) {
-    VALUE str = argv[arg_idx];
-    char *buf = StringValuePtr(str);
-    long len = RSTRING_LEN(str);
-    long left = len;
+  iov = malloc(iov_count * sizeof(struct iovec));
+  for (int i = 0; i < argc; i++) {
+    VALUE str = argv[i];
+    iov[i].iov_base = StringValuePtr(str);
+    iov[i].iov_len = RSTRING_LEN(str);
+    total_length += iov[i].iov_len;
+  }
+  iov_ptr = iov;
 
-    while (left > 0) {
-      ssize_t n = write(fptr->fd, buf, left);
-      if (n < 0) {
-        int e = errno;
-        if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+  while (1) {
+    ssize_t n = writev(fptr->fd, iov_ptr, iov_count);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-        switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
-        if (TEST_EXCEPTION(switchpoint_result)) goto error;
-      }
-      else {
-        buf += n;
-        left -= n;
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      total_written += n;
+      if (total_written == total_length) break;
+
+      while (n > 0) {
+        if ((size_t) n < iov_ptr[0].iov_len) {
+          iov_ptr[0].iov_base = (char *) iov_ptr[0].iov_base + n;
+          iov_ptr[0].iov_len -= n;
+          n = 0;
+        }
+        else {
+          n -= iov_ptr[0].iov_len;
+          iov_ptr += 1;
+          iov_count -= 1;
+        }
       }
     }
-    total_written += len;
-    arg_idx++;
   }
-
   if (watcher.fiber == Qnil) {
     switchpoint_result = libev_snooze();
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
@@ -466,15 +566,27 @@ VALUE LibevAgent_write(int argc, VALUE *argv, VALUE self) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
+  free(iov);
   return INT2NUM(total_written);
 error:
+  free(iov);
   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
 
+VALUE LibevAgent_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);                    
+}
+
 ///////////////////////////////////////////////////////////////////////////
 
 VALUE LibevAgent_accept(VALUE self, VALUE sock) {
-  struct LibevAgent_t *agent;
+  LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
   int fd;
@@ -486,7 +598,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);
@@ -512,7 +624,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) {
@@ -528,7 +640,7 @@ error:
 }
 
 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;
@@ -541,7 +653,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) {
@@ -567,7 +679,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);
@@ -583,71 +695,69 @@ 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);
-// }
-
-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 rb_funcall(rb_mKernel, ID_raise, 1, 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;
@@ -660,7 +770,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;
 
@@ -670,6 +780,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);
@@ -694,7 +805,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);
@@ -713,36 +824,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, -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;
 }