polyphony 0.40 → 0.41

data/docs/main-concepts/extending.md

@@ -5,7 +5,7 @@ nav_order: 4
 parent: Main Concepts
 permalink: /main-concepts/extending/
 prev_title: Exception Handling
-next_title: Design Principles
+next_title: The Design of Polyphony
 ---
 # Extending Polyphony
 

data/examples/core/xx-agent.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+class Test
+  def test_sleep
+    puts "going to sleep"
+    sleep 1
+    puts "done sleeping"
+  end
+  
+  def test_spin
+    spin {
+      10.times {
+        STDOUT << '.'
+        sleep 0.1
+      }
+    }
+    
+    puts "going to sleep\n"
+    sleep 1
+    puts 'woke up'
+  end
+  
+  def test_file
+    f = File.open(__FILE__, 'r')
+    puts Thread.current.agent.read(f, +'', 10000, true)
+    
+    Thread.current.agent.write(STDOUT, "Write something: ")
+    str = +''
+    Thread.current.agent.read(STDIN, str, 5, false)
+    puts str
+  end
+  
+  def test_fork
+    pid = fork do
+      Thread.current.agent.post_fork
+      puts 'child going to sleep'
+      sleep 1
+      puts 'child done sleeping'
+      exit(42)
+    end
+    
+    puts "Waiting for pid #{pid}"
+    result = Thread.current.agent.waitpid(pid)
+    puts "Done waiting"
+    p result
+  end
+  
+  def test_async
+    async = Polyphony::Event.new
+    
+    spin {
+      puts "signaller starting"
+      sleep 1
+      puts "signal"
+      async.signal(:foo)
+    }
+    
+    puts "awaiting event"
+    p async.await
+  end
+  
+  def test_queue
+    q = Gyro::Queue.new
+    spin {
+      10.times {
+        q << Time.now.to_f
+        sleep 0.2
+      }
+      q << :STOP
+    }
+    
+    loop do
+      value = q.shift
+      break if value == :STOP
+      
+      p value
+    end
+  end
+  
+  def test_thread
+    t = Thread.new do
+      puts "thread going to sleep"
+      sleep 0.2
+      puts "thread done sleeping"
+    end
+    
+    t.await
+  end
+end
+
+t = Test.new
+
+t.methods.select { |m| m =~ /^test_/ }.each do |m|
+  puts '*' * 40
+  puts m
+  t.send(m)
+end

data/examples/core/xx-sleeping.rb

@@ -5,13 +5,21 @@ require 'polyphony'
 
 Exception.__disable_sanitized_backtrace__ = true
 
-spin {
-  10.times {
-    STDOUT << '.'
-    sleep 0.1
-  }
-}
+# spin {
+#   10.times {
+#     STDOUT << '.'
+#     sleep 0.1
+#   }
+# }
 
 puts 'going to sleep...'
 sleep 1
 puts 'woke up'
+
+counter = 0
+t = Polyphony::Throttler.new(5)
+t.process do
+  p counter
+  counter += 1
+  t.stop if counter > 5
+end

data/examples/io/xx-irb.rb

@@ -2,7 +2,7 @@
 
 require 'bundler/setup'
 require 'irb'
-require 'polyphony/irb'
+require 'polyphony/adapters/irb'
 
 $counter = 0
 timer = spin do

data/examples/performance/thread-vs-fiber/polyphony_mt_server.rb

@@ -20,22 +20,22 @@ end
 
 def handle_client(socket)
   parser = Http::Parser.new
-  req = nil
+  reqs = []
   parser.on_message_complete = proc do |env|
-    req = parser
+    reqs << Object.new # parser
   end
   while (data = socket.readpartial(8192)) do
     parser << data
-    if req
+    while (req = reqs.shift)
       handle_request(socket, req)
       req = nil
-      snooze
+      # snooze
     end
   end
 rescue IOError, SystemCallError => e
   # do nothing
 ensure
-  socket.close rescue nil
+  socket&.close
   parser.reset!
 end
 
@@ -46,13 +46,14 @@ def handle_request(client, parser)
   client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
-$incoming = Gyro::Queue.new
+$incoming = Polyphony::Queue.new
 
 $threads = (1..4).map {
   Thread.new {
     Thread.current.setup_fiber_scheduling
     loop {
       conn = $incoming.pop
+      puts "#{Thread.current.inspect} pop #{conn.inspect}"
       spin { handle_client(conn) }
     }
   }

data/examples/performance/thread-vs-fiber/polyphony_server.rb

@@ -4,21 +4,10 @@ require 'bundler/setup'
 require 'polyphony'
 require 'http/parser'
 
-class Http::Parser
-  def setup_async
-    self.on_message_complete = proc { @request_complete = true }
-  end
-
-  def parse(data)
-    self << data
-    return nil unless @request_complete
-
-    @request_complete = nil
-    self
-  end
-end
+$connection_count = 0
 
 def handle_client(socket)
+  $connection_count += 1
   parser = Http::Parser.new
   reqs = []
   parser.on_message_complete = proc do |env|
@@ -29,20 +18,20 @@ def handle_client(socket)
     while (req = reqs.shift)
       handle_request(socket, req)
       req = nil
-      # snooze
+      snooze
     end
   end
 rescue IOError, SystemCallError => e
   # do nothing
 ensure
-  socket.close rescue nil
-  parser.reset!
+  $connection_count -= 1
+  socket&.close
 end
 
 def handle_request(client, parser)
-  status_code = 200
+  status_code = "200 OK"
   data = "Hello world!\n"
-  headers = "Content-Length: #{data.bytesize}\r\n"
+  headers = "Content-Type: text/plain\r\nContent-Length: #{data.bytesize}\r\n"
   client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
@@ -53,16 +42,16 @@ spin do
   loop do
     client = server.accept
     spin { handle_client(client) }
-    # snooze
   end
+ensure
+  server&.close
 end
 
-spin do
-  loop do
-    sleep 1
-    puts "#{Time.now} #{Thread.current.fiber_scheduling_stats}"
-  end
-end
+# every(1) {
+#   stats = Thread.current.fiber_scheduling_stats
+#   stats[:connection_count] = $connection_count
+#   puts "#{Time.now} #{stats}"
+# }
 
 puts "pid #{Process.pid}"
 suspend

data/ext/{gyro → polyphony}/extconf.rb

@@ -16,5 +16,5 @@ $defs << "-DHAVE_SYS_RESOURCE_H" if have_header("sys/resource.h")
 
 CONFIG["optflags"] << " -fno-strict-aliasing" unless RUBY_PLATFORM =~ /mswin/
 
-dir_config "gyro_ext"
-create_makefile "gyro_ext"
+dir_config "polyphony_ext"
+create_makefile "polyphony_ext"

data/ext/{gyro → polyphony}/fiber.c

@@ -1,8 +1,7 @@
-#include "gyro.h"
+#include "polyphony.h"
 
 ID ID_fiber_trace;
-ID ID_ivar_auto_async;
-ID ID_ivar_auto_io;
+ID ID_ivar_auto_watcher;
 ID ID_trace_ev_loop_enter;
 ID ID_trace_ev_loop_leave;
 ID ID_trace_run;
@@ -10,6 +9,8 @@ ID ID_trace_runnable;
 ID ID_trace_terminate;
 ID ID_trace_wait;
 
+VALUE cEvent = Qnil;
+
 VALUE SYM_dead;
 VALUE SYM_running;
 VALUE SYM_runnable;
@@ -32,22 +33,18 @@ static VALUE Fiber_safe_transfer(int argc, VALUE *argv, VALUE self) {
   return ret;
 }
 
-inline VALUE Fiber_auto_async(VALUE self) {
-  VALUE async = rb_ivar_get(self, ID_ivar_auto_async);
-  if (async == Qnil) {
-    async = rb_funcall(cGyro_Async, ID_new, 0);
-    rb_ivar_set(self, ID_ivar_auto_async, async);
+inline VALUE Fiber_auto_watcher(VALUE self) {
+  VALUE watcher;
+  if (cEvent == Qnil) {
+    cEvent = rb_const_get(mPolyphony, rb_intern("Event"));
   }
-  return async;
-}
 
-inline VALUE Fiber_auto_io(VALUE self) {
-  VALUE io = rb_ivar_get(self, ID_ivar_auto_io);
-  if (io == Qnil) {
-    io = rb_funcall(cGyro_IO, ID_new, 2, Qnil, Qnil);
-    rb_ivar_set(self, ID_ivar_auto_io, io);
+  watcher = rb_ivar_get(self, ID_ivar_auto_watcher);
+  if (watcher == Qnil) {
+    watcher = rb_funcall(cEvent, ID_new, 0);
+    rb_ivar_set(self, ID_ivar_auto_watcher, watcher);
   }
-  return io;
+  return watcher;
 }
 
 static VALUE Fiber_schedule(int argc, VALUE *argv, VALUE self) {
@@ -80,12 +77,10 @@ void Fiber_make_runnable(VALUE fiber, VALUE value) {
 
 void Init_Fiber() {
   VALUE cFiber = rb_const_get(rb_cObject, rb_intern("Fiber"));
-  rb_define_method(cFiber, "auto_async", Fiber_auto_async, 0);
   rb_define_method(cFiber, "safe_transfer", Fiber_safe_transfer, -1);
   rb_define_method(cFiber, "schedule", Fiber_schedule, -1);
   rb_define_method(cFiber, "state", Fiber_state, 0);
-
-  ID_ivar_auto_async = rb_intern("@auto_async");
+  rb_define_method(cFiber, "auto_watcher", Fiber_auto_watcher, 0);
 
   SYM_dead = ID2SYM(rb_intern("dead"));
   SYM_running = ID2SYM(rb_intern("running"));
@@ -97,6 +92,7 @@ void Init_Fiber() {
   rb_global_variable(&SYM_waiting);
 
   ID_fiber_trace          = rb_intern("__fiber_trace__");
+  ID_ivar_auto_watcher    = rb_intern("@auto_watcher");
 
   SYM_fiber_create        = ID2SYM(rb_intern("fiber_create"));
   SYM_fiber_ev_loop_enter = ID2SYM(rb_intern("fiber_ev_loop_enter"));

data/ext/polyphony/libev_agent.c

@@ -0,0 +1,503 @@
+#include "polyphony.h"
+#include "../libev/ev.h"
+#include <sys/socket.h>
+
+VALUE cLibevAgent = Qnil;
+VALUE cTCPSocket;
+
+struct LibevAgent_t {
+  struct ev_loop *ev_loop;
+  struct ev_async break_async;
+  int running;
+  int run_no_wait_count;
+};
+
+static size_t LibevAgent_size(const void *ptr) {
+  return sizeof(struct LibevAgent_t);
+}
+
+static const rb_data_type_t LibevAgent_type = {
+    "Libev",
+    {0, 0, LibevAgent_size,},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+static VALUE LibevAgent_allocate(VALUE klass) {
+  struct LibevAgent_t *agent = ALLOC(struct LibevAgent_t);
+  
+  return TypedData_Wrap_Struct(klass, &LibevAgent_type, agent);
+}
+
+#define GetLibevAgent(obj, agent) \
+  TypedData_Get_Struct((obj), struct 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
+  // of a *blocking* event loop (waking it up) in a thread-safe, signal-safe manner
+}
+
+static VALUE LibevAgent_initialize(VALUE self) {
+  struct LibevAgent_t *agent;
+  VALUE thread = rb_thread_current();
+  int is_main_thread = (thread == rb_thread_main());
+
+  GetLibevAgent(self, agent);
+  agent->ev_loop = is_main_thread ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
+
+  ev_async_init(&agent->break_async, break_async_callback);
+  ev_async_start(agent->ev_loop, &agent->break_async);
+  ev_unref(agent->ev_loop); // don't count the break_async watcher
+
+  agent->running = 0;
+  agent->run_no_wait_count = 0;
+
+  return Qnil;
+}
+
+VALUE LibevAgent_finalize(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+   ev_async_stop(agent->ev_loop, &agent->break_async);
+
+  if (!ev_is_default_loop(agent->ev_loop)) ev_loop_destroy(agent->ev_loop);
+
+  return self;
+}
+
+VALUE LibevAgent_post_fork(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+  if (!ev_is_default_loop(agent->ev_loop)) {
+    // post_fork is called only for the main thread of the forked process. If
+    // the forked process was forked from a thread other than the main one,
+    // we remove the old non-default ev_loop and use the default one instead.
+    ev_loop_destroy(agent->ev_loop);
+    agent->ev_loop = EV_DEFAULT;
+  }
+
+  ev_loop_fork(agent->ev_loop);
+
+  return self;
+}
+
+VALUE LibevAgent_pending_count(VALUE self) {
+  int count;
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+  count = ev_pending_count(agent->ev_loop);
+  return INT2NUM(count);
+}
+
+VALUE LibevAgent_poll(VALUE self, VALUE nowait, VALUE current_fiber, VALUE queue) {
+  int is_nowait = nowait == Qtrue;
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+  if (is_nowait) {
+    int runnable_count = RARRAY_LEN(queue);
+    agent->run_no_wait_count++;
+    if (agent->run_no_wait_count < runnable_count || agent->run_no_wait_count < 10)
+      return self;
+  }
+
+  agent->run_no_wait_count = 0;
+  
+  FIBER_TRACE(2, SYM_fiber_ev_loop_enter, current_fiber);
+  agent->running = 1;
+  ev_run(agent->ev_loop, is_nowait ? EVRUN_NOWAIT : EVRUN_ONCE);
+  agent->running = 0;
+  FIBER_TRACE(2, SYM_fiber_ev_loop_leave, current_fiber);
+
+  return self;
+}
+
+VALUE LibevAgent_break(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+  if (agent->running) {
+    // Since the loop will run until at least one event has occurred, we signal
+    // the selector's associated async watcher, which will cause the ev loop to
+    // return. In contrast to using `ev_break` to break out of the loop, which
+    // should be called from the same thread (from within the ev_loop), using an
+    // `ev_async` allows us to interrupt the event loop across threads.
+    ev_async_send(agent->ev_loop, &agent->break_async);
+    return Qtrue;
+  }
+
+  return Qnil;
+}
+
+#include "polyphony.h"
+#include "../libev/ev.h"
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+// the following is copied verbatim from the Ruby source code (io.c)
+struct io_internal_read_struct {
+    int fd;
+    int nonblock;
+    void *buf;
+    size_t capa;
+};
+
+int io_setstrbuf(VALUE *str, long len) {
+  #ifdef _WIN32
+    len = (len + 1) & ~1L;	/* round up for wide char */
+  #endif
+  if (NIL_P(*str)) {
+    *str = rb_str_new(0, len);
+    return 1;
+  }
+  else {
+    VALUE s = StringValue(*str);
+    long clen = RSTRING_LEN(s);
+    if (clen >= len) {
+      rb_str_modify(s);
+      return 0;
+    }
+    len -= clen;
+  }
+  rb_str_modify_expand(*str, len);
+  return 0;
+}
+
+#define MAX_REALLOC_GAP 4096
+static void io_shrink_read_string(VALUE str, long n) {
+  if (rb_str_capacity(str) - n > MAX_REALLOC_GAP) {
+    rb_str_resize(str, n);
+  }
+}
+
+void io_set_read_length(VALUE str, long n, int shrinkable) {
+  if (RSTRING_LEN(str) != n) {
+    rb_str_modify(str);
+    rb_str_set_len(str, n);
+    if (shrinkable) io_shrink_read_string(str, n);
+  }
+}
+
+static rb_encoding* io_read_encoding(rb_io_t *fptr) {
+    if (fptr->encs.enc) {
+	return fptr->encs.enc;
+    }
+    return rb_default_external_encoding();
+}
+
+VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
+    OBJ_TAINT(str);
+    rb_enc_associate(str, io_read_encoding(fptr));
+    return str;
+}
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+
+struct libev_io {
+  struct ev_io io;
+  VALUE fiber;
+};
+
+static 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);
+}
+
+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);
+  int shrinkable = io_setstrbuf(&str, len);
+  char *buf = RSTRING_PTR(str);
+  long total = 0;
+  VALUE switchpoint_result = Qnil;
+  int read_to_eof = RTEST(to_eof);
+  VALUE underlying_io = rb_iv_get(io, "@io");
+
+  GetLibevAgent(self, agent);
+  if (underlying_io != Qnil) io = underlying_io;
+  GetOpenFile(io, fptr);
+  rb_io_check_byte_readable(fptr);
+  rb_io_set_nonblock(fptr);
+  watcher.fiber = Qnil;
+  
+  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 {
+      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 = Polyphony_switchpoint();
+        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 (total == 0) return Qnil;
+
+  io_set_read_length(str, total, shrinkable);
+  io_enc_str(str, fptr);
+  
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return str;
+error:
+  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+}
+
+VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
+  struct LibevAgent_t *agent;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE switchpoint_result = Qnil;
+
+  char *buf = StringValuePtr(str);
+  int len = RSTRING_LEN(str);
+  int left = len;
+
+  VALUE 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) {
+    int result = write(fptr->fd, buf, left);
+    if (result < 0) {
+      if (errno == 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 = Polyphony_switchpoint();
+        ev_io_stop(agent->ev_loop, &watcher.io);
+        if (TEST_EXCEPTION(switchpoint_result))
+          goto error;
+      }
+      else {
+        // report error
+        
+      }
+    }
+    else {
+      buf += result;
+      left -= result;
+    }
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(len);
+error:
+  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+}
+
+///////////////////////////////////////////////////////////////////////////
+
+struct rsock_send_arg {
+    int fd, flags;
+    VALUE mesg;
+    struct sockaddr *to;
+    socklen_t tolen;
+};
+
+#define StringValue(v) rb_string_value(&(v))
+#define IS_ADDRINFO(obj) rb_typeddata_is_kind_of((obj), &addrinfo_type)
+
+VALUE LibevAgent_accept(VALUE self, VALUE sock) {
+  struct LibevAgent_t *agent;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  int fd;
+  struct sockaddr addr;
+  socklen_t len = (socklen_t)sizeof addr;
+  VALUE switchpoint_result = Qnil;
+
+  GetLibevAgent(self, agent);
+  GetOpenFile(sock, fptr);
+  rb_io_set_nonblock(fptr);
+  watcher.fiber = Qnil;
+  while (1) {
+    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 = Polyphony_switchpoint();
+        ev_io_stop(agent->ev_loop, &watcher.io);
+
+        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);
+    }
+    else {
+      VALUE connection = rb_obj_alloc(cTCPSocket);
+      rb_io_t *fp;
+      MakeOpenFile(connection, fp);
+      rb_update_max_fd(fd);
+      fp->fd = fd;
+      fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
+      rb_io_ascii8bit_binmode(connection);
+      rb_io_set_nonblock(fp);
+      rb_io_synchronized(fp);
+      // if (rsock_do_not_reverse_lookup) {
+	    //   fp->mode |= FMODE_NOREVLOOKUP;
+      // }
+
+      return connection;
+    }
+  }
+  return Qnil;
+}
+
+VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
+  struct LibevAgent_t *agent;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE switchpoint_result = Qnil;
+  int events = RTEST(write) ? EV_WRITE : EV_READ;
+
+  VALUE underlying_io = rb_iv_get(io, "@io");
+  GetLibevAgent(self, agent);
+  if (underlying_io != Qnil) io = underlying_io;
+  GetOpenFile(io, fptr);
+  
+  watcher.fiber = rb_fiber_current();
+  ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, events);
+  ev_io_start(agent->ev_loop, &watcher.io);
+  switchpoint_result = Polyphony_switchpoint();
+  ev_io_stop(agent->ev_loop, &watcher.io);
+  
+  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
+}
+
+struct libev_timer {
+  struct ev_timer timer;
+  VALUE fiber;
+};
+
+static 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);
+}
+
+VALUE LibevAgent_sleep(VALUE self, VALUE duration) {
+  struct LibevAgent_t *agent;
+  struct libev_timer watcher;
+  VALUE switchpoint_result = Qnil;
+
+  GetLibevAgent(self, agent);
+  watcher.fiber = rb_fiber_current();
+  ev_timer_init(&watcher.timer, LibevAgent_timer_callback, NUM2DBL(duration), 0.);
+  ev_timer_start(agent->ev_loop, &watcher.timer);
+
+  switchpoint_result = Polyphony_switchpoint();
+  ev_timer_stop(agent->ev_loop, &watcher.timer);
+
+  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
+}
+
+struct libev_child {
+  struct ev_child child;
+  VALUE fiber;
+};
+
+static 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?
+  VALUE status;
+
+  status = rb_ary_new_from_args(2, INT2NUM(w->rpid), INT2NUM(exit_status));
+  Fiber_make_runnable(watcher->fiber, status);
+}
+
+VALUE LibevAgent_waitpid(VALUE self, VALUE pid) {
+  struct LibevAgent_t *agent;
+  struct libev_child watcher;
+  VALUE switchpoint_result = Qnil;
+  GetLibevAgent(self, agent);
+
+  watcher.fiber = rb_fiber_current();
+  ev_child_init(&watcher.child, LibevAgent_child_callback, NUM2INT(pid), 0);
+  ev_child_start(agent->ev_loop, &watcher.child);
+  
+  switchpoint_result = Polyphony_switchpoint();
+  ev_child_stop(agent->ev_loop, &watcher.child);
+
+  TEST_RESUME_EXCEPTION(switchpoint_result);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+  return switchpoint_result;
+}
+
+struct ev_loop *LibevAgent_ev_loop(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+  return agent->ev_loop;
+}
+
+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, "poll", LibevAgent_poll, 3);
+  rb_define_method(cLibevAgent, "break", LibevAgent_break, 0);
+
+  rb_define_method(cLibevAgent, "read", LibevAgent_read, 4);
+  rb_define_method(cLibevAgent, "write", LibevAgent_write, 2);
+  rb_define_method(cLibevAgent, "accept", LibevAgent_accept, 1);
+  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);
+}