polyphony 0.43.1 → 0.43.6

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/mem-usage.rb

@@ -4,47 +4,53 @@ def mem_usage
   `ps -o rss #{$$}`.split.last.to_i
 end
 
-def calculate_fiber_memory_cost(count)
+def calculate_memory_cost(name, count, &block)
+  GC.enable
+  ObjectSpace.garbage_collect
+  sleep 0.5
   GC.disable
   rss0 = mem_usage
-  count.times { Fiber.new { sleep 1 } }
+  count0 = ObjectSpace.count_objects[:TOTAL] - ObjectSpace.count_objects[:FREE]
+  a = []
+  count.times { a << block.call }
   rss1 = mem_usage
-  GC.start
+  count1 = ObjectSpace.count_objects[:TOTAL] - ObjectSpace.count_objects[:FREE]
+  p [count0, count1]
+  # sleep 0.5
   cost = (rss1 - rss0).to_f / count
+  count_delta = (count1 - count0) / count
 
-  puts "fiber memory cost: #{cost}KB"
+  puts "#{name} rss cost: #{cost}KB     object count: #{count_delta}"
 end
 
-calculate_fiber_memory_cost(10000)
-
-def calculate_thread_memory_cost(count)
-  GC.disable
-  rss0 = mem_usage
-  count.times { Thread.new { sleep 1 } }
-  sleep 0.5
-  rss1 = mem_usage
-  sleep 0.5
-  GC.start
-  cost = (rss1 - rss0).to_f / count
+f = Fiber.new { |f| f.transfer }
+f.transfer Fiber.current
 
-  puts "thread memory cost: #{cost}KB"
+calculate_memory_cost('fiber', 10000) do
+  f = Fiber.new { |f| f.transfer :foo }
+  f.transfer Fiber.current
+  f
 end
 
-calculate_thread_memory_cost(500)
+t = Thread.new { sleep 1}
+t.kill
+t.join
+
+calculate_memory_cost('thread', 500) do
+  t = Thread.new { sleep 1 }
+  sleep 0.001
+  t
+end
+(Thread.list - [Thread.current]).each(&:kill).each(&:join)
 
 require 'bundler/setup'
 require 'polyphony'
 
-def calculate_extended_fiber_memory_cost(count)
-  GC.disable
-  rss0 = mem_usage
-  count.times { spin { :foo } }
-  snooze
-  rss1 = mem_usage
-  GC.start
-  cost = (rss1 - rss0).to_f / count
+f = spin { sleep 0.1 }
+f.await
 
-  puts "extended fiber memory cost: #{cost}KB"
+calculate_memory_cost('polyphony fiber', 10000) do
+  f = spin { :foo }
+  f.await
+  f
 end
-
-calculate_extended_fiber_memory_cost(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/libev_agent.c

@@ -1,6 +1,9 @@
+#include <netdb.h>
+#include <sys/socket.h>
+#include <sys/uio.h>
+
 #include "polyphony.h"
 #include "../libev/ev.h"
-#include <sys/socket.h>
 
 VALUE cLibevAgent = Qnil;
 VALUE cTCPSocket;
@@ -128,7 +131,7 @@ VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue
   GetLibevAgent(self, agent);
 
   if (is_nowait) {
-    int runnable_count = RARRAY_LEN(queue);
+    long runnable_count = LibevQueue_len(queue);
     agent->run_no_wait_count++;
     if (agent->run_no_wait_count < runnable_count || agent->run_no_wait_count < 10)
       return self;
@@ -234,7 +237,7 @@ struct libev_io {
   VALUE fiber;
 };
 
-static void LibevAgent_io_callback(EV_P_ ev_io *w, int revents)
+void LibevAgent_io_callback(EV_P_ ev_io *w, int revents)
 {
   struct libev_io *watcher = (struct libev_io *)w;
   Fiber_make_runnable(watcher->fiber, Qnil);
@@ -255,11 +258,32 @@ VALUE libev_agent_await(VALUE self) {
   return libev_await(agent);
 }
 
+VALUE libev_io_wait(struct LibevAgent_t *agent, 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_start(agent->ev_loop, &watcher->io);
+  switchpoint_result = libev_await(agent);
+  ev_io_stop(agent->ev_loop, &watcher->io);
+
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;  
+}
+
+VALUE libev_snooze() {
+  Fiber_make_runnable(rb_fiber_current(), Qnil);
+  return Thread_switch_fiber(rb_thread_current());
+}
+
 VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
   struct LibevAgent_t *agent;
   struct libev_io watcher;
   rb_io_t *fptr;
-  int len = NUM2INT(length);
+  long dynamic_len = length == Qnil;
+  long len = dynamic_len ? 4096 : NUM2INT(length);
   int shrinkable = io_setstrbuf(&str, len);
   char *buf = RSTRING_PTR(str);
   long total = 0;
@@ -276,44 +300,35 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
   
   OBJ_TAINT(str);
 
-  while (len > 0) {
-    int n = read(fptr->fd, buf, len);
-    if (n == 0)
-      break;
-    if (n > 0) {
-      total = total + n;
-      buf += n;
-      len -= n;
-      if (!read_to_eof || (len == 0)) break;
-    }
-    else {
+  while (1) {
+    ssize_t n = read(fptr->fd, buf, len - total);
+    if (n < 0) {
       int e = errno;
-      if ((e == EWOULDBLOCK || e == EAGAIN)) {
-        if (watcher.fiber == Qnil) {
-          watcher.fiber = rb_fiber_current();
-          ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, EV_READ);
-        }
-        ev_io_start(agent->ev_loop, &watcher.io);
-        switchpoint_result = libev_await(agent);
-        ev_io_stop(agent->ev_loop, &watcher.io);
-        if (TEST_EXCEPTION(switchpoint_result)) {
-          goto error;
-        }
-      }
-      else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
+      if (e != EWOULDBLOCK && e != EAGAIN) rb_syserr_fail(e, strerror(e));
+      
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
-  }
+    else {
+      switchpoint_result = libev_snooze();
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
-  if (watcher.fiber == Qnil) {
-    Fiber_make_runnable(rb_fiber_current(), Qnil);
-    switchpoint_result = Thread_switch_fiber(rb_thread_current());
-    if (TEST_EXCEPTION(switchpoint_result)) {
-      goto error;
+      if (n == 0) break; // EOF
+      total = total + n;
+      if (!read_to_eof) break;
+
+      if (total == len) {
+        if (!dynamic_len) break;
+      
+        rb_str_resize(str, total);
+        rb_str_modify_expand(str, len);
+        buf = RSTRING_PTR(str) + total;
+        shrinkable = 0;
+        len += len;
+      }
+      else buf += n;
     }
   }
-
   if (total == 0) return Qnil;
 
   io_set_read_length(str, total, shrinkable);
@@ -347,8 +362,8 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
   struct libev_io watcher;
   rb_io_t *fptr;
   VALUE str;
-  int total;
-  int len = 8192;
+  long total;
+  long len = 8192;
   int shrinkable;
   char *buf;
   VALUE switchpoint_result = Qnil;
@@ -366,10 +381,20 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
   OBJ_TAINT(str);
 
   while (1) {
-    int n = read(fptr->fd, buf, len);
-    if (n == 0)
-      break;
-    if (n > 0) {
+    ssize_t n = read(fptr->fd, buf, len);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      switchpoint_result = libev_snooze();
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      if (n == 0) break; // EOF      
+
       total = n;
       YIELD_STR();
       Fiber_make_runnable(rb_fiber_current(), Qnil);
@@ -378,24 +403,6 @@ VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
         goto error;
       }
     }
-    else {
-      int e = errno;
-      if ((e == EWOULDBLOCK || e == EAGAIN)) {
-        if (watcher.fiber == Qnil) {
-          watcher.fiber = rb_fiber_current();
-          ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, EV_READ);
-        }
-        ev_io_start(agent->ev_loop, &watcher.io);
-        switchpoint_result = libev_await(agent);
-        ev_io_stop(agent->ev_loop, &watcher.io);
-        if (TEST_EXCEPTION(switchpoint_result)) {
-          goto error;
-        }
-      }
-      else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
-    }
   }
 
   RB_GC_GUARD(str);
@@ -412,12 +419,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);
-  int len = RSTRING_LEN(str);
-  int left = len;
+  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);
@@ -425,38 +432,22 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
   watcher.fiber = Qnil;
 
   while (left > 0) {
-    int result = write(fptr->fd, buf, left);
-    if (result < 0) {
+    ssize_t n = write(fptr->fd, buf, left);
+    if (n < 0) {
       int e = errno;
-      if (e == EAGAIN) {
-        if (watcher.fiber == Qnil) {
-          watcher.fiber = rb_fiber_current();
-          ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, EV_WRITE);
-        }
-        ev_io_start(agent->ev_loop, &watcher.io);
-        switchpoint_result = libev_await(agent);
-        ev_io_stop(agent->ev_loop, &watcher.io);
-        if (TEST_EXCEPTION(switchpoint_result))
-          goto error;
-      }
-      else {
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
-        
-      }
+      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 += result;
-      left -= result;
+      buf += n;
+      left -= n;
     }
   }
 
   if (watcher.fiber == Qnil) {
-    Fiber_make_runnable(rb_fiber_current(), Qnil);
-    switchpoint_result = Thread_switch_fiber(rb_thread_current());
-    if (TEST_EXCEPTION(switchpoint_result)) {
-      goto error;
-    }
+    switchpoint_result = libev_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
 
   RB_GC_GUARD(watcher.fiber);
@@ -467,6 +458,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) {
@@ -488,50 +559,39 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
     fd = accept(fptr->fd, &addr, &len);
     if (fd < 0) {
       int e = errno;
-      if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (watcher.fiber == Qnil) {
-          watcher.fiber = rb_fiber_current();
-          ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, EV_READ);
-        }
-        ev_io_start(agent->ev_loop, &watcher.io);
-        switchpoint_result = libev_await(agent);
-        ev_io_stop(agent->ev_loop, &watcher.io);
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-        TEST_RESUME_EXCEPTION(switchpoint_result);
-        RB_GC_GUARD(watcher.fiber);
-        RB_GC_GUARD(switchpoint_result);
-      }
-      else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      VALUE connection = rb_obj_alloc(cTCPSocket);
+      VALUE socket;
       rb_io_t *fp;
-      MakeOpenFile(connection, fp);
+      switchpoint_result = libev_snooze();
+      if (TEST_EXCEPTION(switchpoint_result)) {
+        close(fd); // close fd since we're raising an exception
+        goto error;
+      }
+
+      socket = rb_obj_alloc(cTCPSocket);
+      MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
-      rb_io_ascii8bit_binmode(connection);
+      rb_io_ascii8bit_binmode(socket);
       rb_io_set_nonblock(fp);
       rb_io_synchronized(fp);
       
       // if (rsock_do_not_reverse_lookup) {
 	    //   fp->mode |= FMODE_NOREVLOOKUP;
       // }
-
-      if (watcher.fiber == Qnil) {
-        Fiber_make_runnable(rb_fiber_current(), Qnil);
-        switchpoint_result = Thread_switch_fiber(rb_thread_current());
-        if (TEST_EXCEPTION(switchpoint_result)) {
-          return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
-        }
-      }
-
-      return connection;
+      return socket;
     }
   }
+  RB_GC_GUARD(switchpoint_result);
   return Qnil;
+error:
+  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
 
 VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
@@ -542,7 +602,7 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
-  VALUE connection = Qnil;
+  VALUE socket = Qnil;
   VALUE underlying_sock = rb_iv_get(sock, "@io");
   if (underlying_sock != Qnil) sock = underlying_sock;
 
@@ -555,46 +615,82 @@ VALUE LibevAgent_accept_loop(VALUE self, VALUE sock) {
     fd = accept(fptr->fd, &addr, &len);
     if (fd < 0) {
       int e = errno;
-      if (e == EWOULDBLOCK || e == EAGAIN) {
-        if (watcher.fiber == Qnil) {
-          watcher.fiber = rb_fiber_current();
-          ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, EV_READ);
-        }
-        ev_io_start(agent->ev_loop, &watcher.io);
-        switchpoint_result = libev_await(agent);
-        ev_io_stop(agent->ev_loop, &watcher.io);
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-        TEST_RESUME_EXCEPTION(switchpoint_result);
-      }
-      else
-        rb_syserr_fail(e, strerror(e));
-        // rb_syserr_fail_path(e, fptr->pathv);
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
       rb_io_t *fp;
-      connection = rb_obj_alloc(cTCPSocket);
-      MakeOpenFile(connection, fp);
+      switchpoint_result = libev_snooze();
+      if (TEST_EXCEPTION(switchpoint_result)) {
+        close(fd); // close fd since we're raising an exception
+        goto error;
+      }
+    
+      socket = rb_obj_alloc(cTCPSocket);
+      MakeOpenFile(socket, fp);
       rb_update_max_fd(fd);
       fp->fd = fd;
       fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
-      rb_io_ascii8bit_binmode(connection);
+      rb_io_ascii8bit_binmode(socket);
       rb_io_set_nonblock(fp);
       rb_io_synchronized(fp);
 
-      rb_yield(connection);
-      connection = Qnil;
-      
-      Fiber_make_runnable(rb_fiber_current(), Qnil);
-      switchpoint_result = Thread_switch_fiber(rb_thread_current());
-      TEST_RESUME_EXCEPTION(switchpoint_result);
+      rb_yield(socket);
+      socket = Qnil;
     }
   }
 
-  RB_GC_GUARD(connection);
+  RB_GC_GUARD(socket);
   RB_GC_GUARD(watcher.fiber);
   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);
+// }
+
 VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
   struct LibevAgent_t *agent;
   struct libev_io watcher;
@@ -624,7 +720,7 @@ struct libev_timer {
   VALUE fiber;
 };
 
-static void LibevAgent_timer_callback(EV_P_ ev_timer *w, int revents)
+void LibevAgent_timer_callback(EV_P_ ev_timer *w, int revents)
 {
   struct libev_timer *watcher = (struct libev_timer *)w;
   Fiber_make_runnable(watcher->fiber, Qnil);
@@ -654,7 +750,7 @@ struct libev_child {
   VALUE fiber;
 };
 
-static void LibevAgent_child_callback(EV_P_ ev_child *w, int revents)
+void LibevAgent_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?
@@ -709,9 +805,10 @@ void Init_LibevAgent() {
 
   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, "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);