polyphony 0.43.4 → 0.43.10

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-happy-eyeballs.rb

@@ -1,37 +1,36 @@
 # frozen_string_literal: true
 
-# idea taken from the example given in trio:
-# https://www.youtube.com/watch?v=oLkfnc_UMcE
-
-require 'bundler/setup'
 require 'polyphony'
 
-def try_connect(target, supervisor)
-  puts "trying #{target[2]}"
-  socket = Polyphony::Net.tcp_connect(target[2], 80)
-  # connection successful
-  supervisor.stop([target[2], socket])
+def try_connect(ip_address, port, supervisor)
+  puts "trying #{ip_address}"
+  sleep rand * 0.2
+  socket = TCPSocket.new(ip_address, port)
+  puts "connected to #{ip_address}"
+  supervisor.schedule [ip_address, socket]
 rescue IOError, SystemCallError
   # ignore error
 end
 
-def happy_eyeballs(hostname, port, max_wait_time: 0.025)
+def happy_eyeballs(hostname, port, max_wait_time: 0.010)
   targets = Socket.getaddrinfo(hostname, port, :INET, :STREAM)
   t0 = Time.now
-  cancel_after(5) do
-    success = supervise do |supervisor|
-      targets.each_with_index do |t, idx|
-        sleep(max_wait_time) if idx > 0
-        supervisor.spin { try_connect(t, supervisor) }
-      end
-    end
-    if success
-      puts format('success: %s (%.3fs)', success[0], Time.now - t0)
-    else
-      puts "timed out (#{Time.now - t0}s)"
+  fibers = []
+  supervisor = Fiber.current
+  spin do
+    targets.each do |t|
+      spin { try_connect(t[2], t[1], supervisor) }
+      sleep(max_wait_time)
     end
+    suspend
+  end
+  target, socket = move_on_after(5) { suspend }
+  supervisor.shutdown_all_children
+  if target
+    puts format('success: %s (%.3fs)', target, Time.now - t0)
+  else
+    puts 'timed out'
   end
 end
 
-# Let's try it out:
 happy_eyeballs('debian.org', 'https')

data/examples/io/xx-zip.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'zlib'
+
+i, o = IO.pipe
+
+w = Zlib::GzipWriter.new(o)
+
+s = (1..1000).map { (65 + rand(26)).chr }.join
+puts "full length: #{s.bytesize}"
+w << s
+w.close
+o.close
+
+
+z = i.read
+puts "zipped length: #{z.bytesize}"

data/examples/performance/fiber_transfer.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'fiber'
+
+class Fiber
+  attr_accessor :next
+end
+
+# This program shows how the performance 
+
+def run(num_fibers)
+  count = 0
+
+  GC.disable
+
+  first = nil
+  last = nil
+  supervisor = Fiber.current
+  num_fibers.times do
+    fiber = Fiber.new do
+      loop do
+        count += 1
+        if count == 1_000_000
+          supervisor.transfer
+        else
+          Fiber.current.next.transfer
+        end
+      end
+    end
+    first ||= fiber
+    last.next = fiber if last
+    last = fiber
+  end
+
+  last.next = first
+  
+  t0 = Time.now
+  first.transfer
+  elapsed = Time.now - t0
+
+  puts "fibers: #{num_fibers} count: #{count} rate: #{count / elapsed}"
+  GC.start
+end
+
+run(100)
+run(1000)
+run(10000)

data/examples/performance/messaging.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+X = 1_000_000
+
+GC.disable
+
+count = 0
+
+pong = spin_loop do
+  msg, ping = receive
+  count += 1
+  ping << 'pong'
+end
+
+ping = spin do
+  X.times do
+    pong << ['ping', Fiber.current]
+    msg = receive
+    count += 1
+  end
+end
+
+t0 = Time.now
+ping.await
+dt = Time.now - t0
+puts format('message rate: %d/s', (X / dt))

data/examples/performance/multi_snooze.rb

@@ -5,19 +5,20 @@ require 'polyphony'
 
 def bm(fibers, iterations)
   count = 0
-  t0 = Time.now
-  supervise do |s|
-    fibers.times do
-      s.spin do
-        iterations.times do
-          snooze
-          count += 1
-        end
+  t_pre = Time.now
+  fibers.times do
+    spin do
+      iterations.times do
+        snooze
+        count += 1
       end
     end
   end
+  t0 = Time.now
+  Fiber.current.await_all_children
   dt = Time.now - t0
-  puts "#{[fibers, iterations].inspect} count: #{count} #{count / dt.to_f}/s"
+  puts "#{[fibers, iterations].inspect} setup: #{t0 - t_pre}s count: #{count} #{count / dt.to_f}/s"
+  Thread.current.run_queue_trace
 end
 
 GC.disable
@@ -27,5 +28,6 @@ bm(10, 100_000)
 bm(100, 10_000)
 bm(1_000, 1_000)
 bm(10_000, 100)
+
 # bm(100_000,    10)
 # bm(1_000_000,   1)

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,39 @@
+#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_ref(VALUE self);
+// VALUE LibevAgent_sleep(VALUE self, VALUE duration);
+// VALUE LibevAgent_unref(VALUE self);
+// 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 int (* agent_ref_count_t)(VALUE self);
+typedef void (* agent_reset_ref_count_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_count_t       ref_count;
+  agent_reset_ref_count_t reset_ref_count;
+  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,10 +1,14 @@
 #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 {
@@ -130,7 +134,7 @@ VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue
   GetLibevAgent(self, agent);
 
   if (is_nowait) {
-    long runnable_count = RARRAY_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,7 +151,7 @@ VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue
   return self;
 }
 
-VALUE LibevAgent_break(VALUE self) {
+VALUE LibevAgent_wakeup(VALUE self) {
   struct LibevAgent_t *agent;
   GetLibevAgent(self, agent);
 
@@ -277,6 +281,31 @@ 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;
   struct libev_io watcher;
@@ -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() { \
@@ -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);
@@ -418,12 +464,12 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
   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;
 
-  VALUE underlying_io = rb_iv_get(io, "@io");
+  underlying_io = rb_iv_get(io, "@io");
   if (underlying_io != Qnil) io = underlying_io;
   GetLibevAgent(self, agent);
   io = rb_io_get_write_io(io);
@@ -435,19 +481,20 @@ 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);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      switchpoint_result = libev_snooze();
-      if (TEST_EXCEPTION(switchpoint_result)) goto error;
-
       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);
 
@@ -456,6 +503,86 @@ error:
   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
 
+VALUE LibevAgent_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
+  struct LibevAgent_t *agent;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  long total_length = 0;
+  long total_written = 0;
+  struct iovec *iov = 0;
+  struct iovec *iov_ptr = 0;
+  int iov_count = argc;
+
+  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;
+
+  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 (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 {
+      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;
+        }
+      }
+    }
+  }
+  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);
+
+  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) {
@@ -471,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);
@@ -497,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) {
@@ -526,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) {
@@ -552,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);
@@ -568,46 +695,41 @@ 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_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));
+
+  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 LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
   struct LibevAgent_t *agent;
@@ -655,6 +777,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);
@@ -703,31 +826,60 @@ struct ev_loop *LibevAgent_ev_loop(VALUE self) {
   return agent->ev_loop;
 }
 
+void LibevAgent_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 switchpoint_result = Qnil;
+  GetLibevAgent(self, agent);
+
+  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, 2);
-  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__.wakeup          = LibevAgent_wakeup;
+  __AGENT__.pending_count   = LibevAgent_pending_count;
+  __AGENT__.poll            = LibevAgent_poll;
+  __AGENT__.ref_count       = LibevAgent_ref_count;
+  __AGENT__.reset_ref_count = LibevAgent_reset_ref_count;
+  __AGENT__.wait_event      = LibevAgent_wait_event;
 }