polyphony 0.41 → 0.42

data/docs/getting-started/tutorial.md

@@ -1,13 +1,20 @@
 ---
 layout: page
 title: Tutorial
-nav_order: 2
 parent: Getting Started
-permalink: /getting-started/tutorial/
-prev_title: Installing Polyphony
-next_title: Concurrency the Easy Way
+nav_order: 3
+---
+
+# Tutorial
+{: .no_toc }
+
+## Table of contents
+{: .no_toc .text-delta }
+
+- TOC
+{:toc}
+
 ---
-# Polyphony: a Tutorial
 
 Polyphony is a new Ruby library aimed at making writing concurrent Ruby apps
 easy and fun. In this article, we'll introduce Polyphony's fiber-based
@@ -116,7 +123,7 @@ suspend # The main fiber suspends, waiting for all other work to finish
   sleep 1 # The sleeper fiber goes to sleep
     Gyro::Timer.new(1, 0).await # A timer event watcher is setup and yields
       Thread.current.switch_fiber # Polyphony looks for other runnable fibers
-        Thread.current.selector.run # With no work left, the event loop is ran
+        Thread.current.agent.poll # With no work left, the event loop is ran
           fiber.schedule # The timer event fires, scheduling the sleeper fiber
   # <= The sleep method returns
   puts "Woke up"
@@ -218,7 +225,7 @@ this by setting up a timeout fiber that cancels the fiber dealing with the conne
 def handle_client(client)
   timeout = cancel_after(10)
   while (data = client.gets)
-    timeout.reset
+    timeout.restart
     client << data
   end
 rescue Polyphony::Cancel
@@ -230,18 +237,19 @@ ensure
 end
 ```
 
-The cancel scope is initialized with a timeout of 10 seconds. Any blocking
-operation ocurring within the cancel scope will be interrupted once 10 seconds
-have elapsed. In order to keep the connection alive while the client is active,
-we call `scope.reset_timeout` each time data is received from the client, and
-thus reset the cancel scope timer.
-
-In addition, we use an `ensure` block to make sure the client connection is
-closed, whether or not it was interrupted by the cancel scope timer. The habit
-of always cleaning up using `ensure` in the face of potential interruptions is a
-fundamental element of using Polyphony correctly. This makes your code robust,
-even in a highly chaotic concurrent execution environment where tasks can be
-interrupted at any time.
+The call to `#cancel_after` spins up a new fiber that will sleep for 10 seconds,
+then cancel its parent. The call to `client.gets` blocks until new data is
+available. If no new data is available, the `timeout` fiber will finish
+sleeping, and then cancel the client handling fiber by raising a
+`Polyphony::Cancel` exception. However, if new data is received, the `timeout`
+fiber is restarted, causing to begin sleeping again for 10 seconds. If the
+client has closed the connection, or some other exception occurs, the `timeout`
+fiber is automatically stopped as it is a child of the client handling fiber.
+
+The habit of always cleaning up using `ensure` in the face of potential
+interruptions is a fundamental element of using Polyphony correctly. This makes
+your code robust, even in a highly chaotic concurrent execution environment
+where tasks can be started, restarted and interrupted at any time.
 
 ## Implementing graceful shutdown
 

data/docs/index.md

@@ -53,7 +53,7 @@ adapters are being developed.
 * Natural, sequential programming style that makes it easy to reason about
   concurrent code.
 * Abstractions and constructs for controlling the execution of concurrent code:
-  supervisors, cancel scopes, throttling, resource pools etc.
+  supervisors, throttling, resource pools etc.
 * Code can use native networking classes and libraries, growing support for
   third-party gems such as `pg` and `redis`.
 * Use stdlib classes such as `TCPServer` and `TCPSocket` and `Net::HTTP`.

data/docs/main-concepts/concurrency.md

@@ -130,16 +130,11 @@ Polyphony also provides several methods and constructs for controlling multiple
 fibers. Methods like `cancel_after` and `move_on_after` allow interrupting a
 fiber that's blocking on any arbitrary operation.
 
-Cancel scopes \(borrowed from the brilliant Python library
-[Trio](https://trio.readthedocs.io/en/stable/)\) allows cancelling ongoing
-operations for any reason with more control over cancelling behaviour.
-
 Some other constructs offered by Polyphony:
 
 * `Mutex` - a mutex used to synchronize access to a single shared resource.
 * `ResourcePool` - used for synchronizing access to a limited amount of shared 
   resources, for example a pool of database connections.
-
 * `Throttler` - used for throttling repeating operations, for example throttling
   access to a shared resource, or throttling incoming requests.
 

data/docs/main-concepts/design-principles.md

@@ -143,18 +143,8 @@ library. Polyphony's design is based on the following principles:
   end
   ```
 
-- Concurrency primitives should allow creating higher-order concurrent 
-  constructs through composition. This is done primarily through supervisors and
-  cancel scopes:
-
-  ```ruby
-  # wait for multiple fibers
-  supervise { |s|
-    clients.each { |client|
-      s.spin { client.puts 'Elvis has left the chatroom' }
-    }
-  }
-  ```
+- Concurrency primitives should allow creating higher-order concurrent
+  constructs through composition.
 
 - The entire design should embrace fibers. There should be no callback-based
   asynchronous APIs.

data/docs/main-concepts/index.md

@@ -0,0 +1,9 @@
+---
+layout: page
+title: Main Concepts
+has_children: true
+nav_order: 3
+---
+
+# Main Concepts
+{: .no_toc }

data/examples/core/01-spinning-up-fibers.rb

@@ -14,4 +14,5 @@ end
 spin { nap(:a, 1) }
 spin { nap(:b, 2) }
 
+# Calling suspend will block until all child fibers have terminated
 suspend

data/examples/core/03-interrupting.rb

@@ -18,7 +18,8 @@ ensure
 end
 
 # The Kernel#cancel_after interrupts a blocking operation by raising a
-# Polyphony::Cancel exception after the given timeout
+# Polyphony::Cancel exception after the given timeout. If not rescued, the
+# exception is propagated up the fiber hierarchy
 spin do
   # cancel after 1 second
   cancel_after(1) { nap(:cancel, 2) }
@@ -26,6 +27,8 @@ rescue Polyphony::Cancel => e
   puts "got exception: #{e}"
 end
 
+# The Kernel#move_on_after interrupts a blocking operation by raising a
+# Polyphony::MoveOn exception, which is silently swallowed by the fiber
 spin do
   # move on after 1 second
   move_on_after(1) do

data/examples/core/04-handling-signals.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+# trap('TERM') do
+#   Polyphony.emit_signal_exception(::SystemExit)
+# end
+
+# trap('INT') do
+#   Polyphony.emit_signal_exception(::Interrupt)
+# end
+
+puts "go to sleep"
+begin
+  sleep
+ensure
+  puts "done sleeping"
+end

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

@@ -35,23 +35,11 @@ def handle_request(client, parser)
   client.write "HTTP/1.1 #{status_code}\r\n#{headers}\r\n#{data}"
 end
 
-spin do
-  server = TCPServer.open('0.0.0.0', 1234)
-  puts "listening on port 1234"
+server = TCPServer.open('0.0.0.0', 1234)
+puts "pid #{Process.pid}"
+puts "listening on port 1234"
 
-  loop do
-    client = server.accept
-    spin { handle_client(client) }
-  end
-ensure
-  server&.close
+loop do
+  client = server.accept
+  spin { handle_client(client) }
 end
-
-# every(1) {
-#   stats = Thread.current.fiber_scheduling_stats
-#   stats[:connection_count] = $connection_count
-#   puts "#{Time.now} #{stats}"
-# }
-
-puts "pid #{Process.pid}"
-suspend

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'http/parser'
+
+$connection_count = 0
+
+def handle_client(socket)
+  $connection_count += 1
+  parser = Http::Parser.new
+  reqs = []
+  parser.on_message_complete = proc do |env|
+    reqs << Object.new # parser
+  end
+  Thread.current.agent.read_loop(socket) do |data|
+    parser << data
+    while (req = reqs.shift)
+      handle_request(socket, req)
+    end
+  end
+rescue IOError, SystemCallError => e
+  # do nothing
+ensure
+  $connection_count -= 1
+  socket&.close
+end
+
+def handle_request(client, parser)
+  status_code = "200 OK"
+  data = "Hello world!\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
+
+spin do
+  server = TCPServer.open('0.0.0.0', 1234)
+  puts "listening on port 1234"
+
+  Thread.current.agent.accept_loop(server) do |client|
+    spin { handle_client(client) }
+  end
+  # loop do
+  #   client = server.accept
+  #   spin { handle_client(client) }
+  # end
+ensure
+  server&.close
+end
+
+# every(1) {
+#   stats = Thread.current.fiber_scheduling_stats
+#   stats[:connection_count] = $connection_count
+#   puts "#{Time.now} #{stats}"
+# }
+
+puts "pid #{Process.pid}"
+suspend

data/examples/performance/xx-array.rb

@@ -0,0 +1,11 @@
+X = ARGV[0] ? ARGV[0].to_i : 10
+a = (1..X).to_a
+
+Y = 1_000_000
+t0 = Time.now
+Y.times do
+  i = a.shift
+  a.push i
+end
+
+puts "rate: #{Y / (Time.now - t0)}"

data/examples/performance/xx-fiber-switch.rb

@@ -0,0 +1,9 @@
+X = 1_000_000
+f = Fiber.new do
+  loop { Fiber.yield }
+end
+
+t0 = Time.now
+X.times { f.resume }
+dt = Time.now - t0
+puts "#{X / dt.to_f}/s"

data/examples/performance/xx-snooze.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+require 'polyphony'
+
+Y = ARGV[0] ? ARGV[0].to_i : 1
+
+count = 0
+Y.times do
+  spin { loop { count += 1; snooze } }
+end
+
+t0 = Time.now
+sleep 10
+elapsed = Time.now - t0
+rate = count / elapsed
+puts "concurrency: #{Y} rate: #{rate} switchpoints per second"

data/ext/polyphony/fiber.c

@@ -68,10 +68,7 @@ void Fiber_make_runnable(VALUE fiber, VALUE value) {
     Thread_schedule_fiber(thread, fiber, value);
   }
   else {
-    VALUE caller;
     rb_warn("No thread set for fiber (fiber, value, caller):");
-    caller = rb_funcall(rb_cObject, rb_intern("caller"), 0);
-    INSPECT(3, fiber, value, caller);
   }
 }
 

data/ext/polyphony/libev_agent.c

@@ -9,6 +9,7 @@ struct LibevAgent_t {
   struct ev_loop *ev_loop;
   struct ev_async break_async;
   int running;
+  int ref_count;
   int run_no_wait_count;
 };
 
@@ -49,6 +50,7 @@ static VALUE LibevAgent_initialize(VALUE self) {
   ev_unref(agent->ev_loop); // don't count the break_async watcher
 
   agent->running = 0;
+  agent->ref_count = 0;
   agent->run_no_wait_count = 0;
 
   return Qnil;
@@ -82,6 +84,36 @@ VALUE LibevAgent_post_fork(VALUE self) {
   return self;
 }
 
+VALUE LibevAgent_ref(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+  agent->ref_count++;
+  return self;  
+}
+
+VALUE LibevAgent_unref(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+  agent->ref_count--;
+  return self;  
+}
+
+int LibevAgent_ref_count(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+  return agent->ref_count;
+}
+
+void LibevAgent_reset_ref_count(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+
+  agent->ref_count = 0;
+}
+
 VALUE LibevAgent_pending_count(VALUE self) {
   int count;
   struct LibevAgent_t *agent;
@@ -143,6 +175,8 @@ struct io_internal_read_struct {
     size_t capa;
 };
 
+#define StringValue(v) rb_string_value(&(v))
+
 int io_setstrbuf(VALUE *str, long len) {
   #ifdef _WIN32
     len = (len + 1) & ~1L;	/* round up for wide char */
@@ -206,6 +240,21 @@ static 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) {
+  VALUE ret;
+  agent->ref_count++;
+  ret = Thread_switch_fiber(rb_thread_current());
+  agent->ref_count--;
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+VALUE libev_agent_await(VALUE self) {
+  struct LibevAgent_t *agent;
+  GetLibevAgent(self, agent);
+  return libev_await(agent);
+}
+
 VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof) {
   struct LibevAgent_t *agent;
   struct libev_io watcher;
@@ -245,10 +294,11 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
           ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, EV_READ);
         }
         ev_io_start(agent->ev_loop, &watcher.io);
-        switchpoint_result = Polyphony_switchpoint();
+        switchpoint_result = libev_await(agent);
         ev_io_stop(agent->ev_loop, &watcher.io);
-        if (TEST_EXCEPTION(switchpoint_result))
+        if (TEST_EXCEPTION(switchpoint_result)) {
           goto error;
+        }
       }
       else
         rb_syserr_fail(e, strerror(e));
@@ -256,6 +306,14 @@ VALUE LibevAgent_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eo
     }
   }
 
+  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 (total == 0) return Qnil;
 
   io_set_read_length(str, total, shrinkable);
@@ -269,6 +327,86 @@ error:
   return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
 }
 
+VALUE LibevAgent_read_loop(VALUE self, VALUE io) {
+
+  #define PREPARE_STR() { \
+    str = Qnil; \
+    shrinkable = io_setstrbuf(&str, len); \
+    buf = RSTRING_PTR(str); \
+    total = 0; \
+  }
+
+  #define YIELD_STR() { \
+    io_set_read_length(str, total, shrinkable); \
+    io_enc_str(str, fptr); \
+    rb_yield(str); \
+    PREPARE_STR(); \
+  }
+
+  struct LibevAgent_t *agent;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE str;
+  int total;
+  int len = 8192;
+  int shrinkable;
+  char *buf;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io = rb_iv_get(io, "@io");
+
+  PREPARE_STR();
+
+  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 (1) {
+    int n = read(fptr->fd, buf, len);
+    if (n == 0)
+      break;
+    if (n > 0) {
+      total = n;
+      YIELD_STR();
+      Fiber_make_runnable(rb_fiber_current(), Qnil);
+      switchpoint_result = Thread_switch_fiber(rb_thread_current());
+      if (TEST_EXCEPTION(switchpoint_result)) {
+        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);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return io;
+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;
@@ -289,19 +427,21 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
   while (left > 0) {
     int result = write(fptr->fd, buf, left);
     if (result < 0) {
-      if (errno == EAGAIN) {
+      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 = Polyphony_switchpoint();
+        switchpoint_result = libev_await(agent);
         ev_io_stop(agent->ev_loop, &watcher.io);
         if (TEST_EXCEPTION(switchpoint_result))
           goto error;
       }
       else {
-        // report error
+        rb_syserr_fail(e, strerror(e));
+        // rb_syserr_fail_path(e, fptr->pathv);
         
       }
     }
@@ -311,6 +451,14 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
     }
   }
 
+  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;
+    }
+  }
+
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
@@ -321,16 +469,6 @@ error:
 
 ///////////////////////////////////////////////////////////////////////////
 
-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;
@@ -339,6 +477,8 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   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);
@@ -354,7 +494,7 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
           ev_io_init(&watcher.io, LibevAgent_io_callback, fptr->fd, EV_READ);
         }
         ev_io_start(agent->ev_loop, &watcher.io);
-        switchpoint_result = Polyphony_switchpoint();
+        switchpoint_result = libev_await(agent);
         ev_io_stop(agent->ev_loop, &watcher.io);
 
         TEST_RESUME_EXCEPTION(switchpoint_result);
@@ -375,16 +515,86 @@ VALUE LibevAgent_accept(VALUE self, VALUE sock) {
       rb_io_ascii8bit_binmode(connection);
       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 Qnil;
 }
 
+VALUE LibevAgent_accept_loop(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;
+  VALUE connection = 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;
+
+  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 = libev_await(agent);
+        ev_io_stop(agent->ev_loop, &watcher.io);
+
+        TEST_RESUME_EXCEPTION(switchpoint_result);
+      }
+      else
+        rb_syserr_fail(e, strerror(e));
+        // rb_syserr_fail_path(e, fptr->pathv);
+    }
+    else {
+      rb_io_t *fp;
+      connection = rb_obj_alloc(cTCPSocket);
+      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);
+
+      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_GC_GUARD(connection);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+}
+
 VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
   struct LibevAgent_t *agent;
   struct libev_io watcher;
@@ -400,7 +610,7 @@ VALUE LibevAgent_wait_io(VALUE self, VALUE io, VALUE write) {
   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();
+  switchpoint_result = libev_await(agent);
   ev_io_stop(agent->ev_loop, &watcher.io);
   
   TEST_RESUME_EXCEPTION(switchpoint_result);
@@ -430,7 +640,7 @@ VALUE LibevAgent_sleep(VALUE self, VALUE duration) {
   ev_timer_init(&watcher.timer, LibevAgent_timer_callback, NUM2DBL(duration), 0.);
   ev_timer_start(agent->ev_loop, &watcher.timer);
 
-  switchpoint_result = Polyphony_switchpoint();
+  switchpoint_result = libev_await(agent);
   ev_timer_stop(agent->ev_loop, &watcher.timer);
 
   TEST_RESUME_EXCEPTION(switchpoint_result);
@@ -464,7 +674,7 @@ VALUE LibevAgent_waitpid(VALUE self, VALUE pid) {
   ev_child_init(&watcher.child, LibevAgent_child_callback, NUM2INT(pid), 0);
   ev_child_start(agent->ev_loop, &watcher.child);
   
-  switchpoint_result = Polyphony_switchpoint();
+  switchpoint_result = libev_await(agent);
   ev_child_stop(agent->ev_loop, &watcher.child);
 
   TEST_RESUME_EXCEPTION(switchpoint_result);
@@ -491,12 +701,17 @@ void Init_LibevAgent() {
   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, "wait_io", LibevAgent_wait_io, 2);
   rb_define_method(cLibevAgent, "sleep", LibevAgent_sleep, 1);
   rb_define_method(cLibevAgent, "waitpid", LibevAgent_waitpid, 1);