polyphony 0.41 → 0.43.3

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

@@ -6,7 +6,11 @@ permalink: /
 next_title: Installing Polyphony
 ---
 
-# Polyphony - fine-grained concurrency for Ruby
+# Polyphony
+{:.text-center .logo-title}
+
+## Fine-grained concurrency for Ruby
+{:.text-center .logo-title}
 
 Polyphony is a library for building concurrent applications in Ruby. Polyphony
 implements a comprehensive
@@ -53,7 +57,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/adapters/concurrent-ruby.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+require 'concurrent'
+
+puts "Hello, concurrent-ruby"
+
+# this program should not hang with concurrent-ruby 1.1.6 (see issue #22)

data/examples/adapters/redis_blpop.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony/adapters/redis'
+# require 'redis'
+
+redis = Redis.new(host: ENV['REDISHOST'] || 'localhost')
+
+redis.lpush("queue_key", "omgvalue")
+puts "len: #{redis.llen("queue_key")}"
+result = redis.blpop("queue_key")
+puts result.inspect

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/core/xx-daemon.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'polyphony'
+
+Exception.__disable_sanitized_backtrace__ = true
+
+puts "pid: #{Process.pid}"
+
+Process.daemon(true, true)
+
+Polyphony::ThreadPool.process do
+  puts "Hello world from pid #{Process.pid}"
+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
+  socket.read_loop 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

@@ -1,6 +1,8 @@
+#include <netdb.h>
+#include <sys/socket.h>
+
 #include "polyphony.h"
 #include "../libev/ev.h"
-#include <sys/socket.h>
 
 VALUE cLibevAgent = Qnil;
 VALUE cTCPSocket;
@@ -9,6 +11,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 +52,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 +86,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;
@@ -96,7 +130,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 = RARRAY_LEN(queue);
     agent->run_no_wait_count++;
     if (agent->run_no_wait_count < runnable_count || agent->run_no_wait_count < 10)
       return self;
@@ -143,6 +177,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 */
@@ -200,17 +236,52 @@ 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);
 }
 
+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 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 len = NUM2INT(length);
   int shrinkable = io_setstrbuf(&str, len);
   char *buf = RSTRING_PTR(str);
   long total = 0;
@@ -228,32 +299,25 @@ 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) {
+    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 = 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;
@@ -269,6 +333,78 @@ 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;
+  long total;
+  long 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) {
+    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);
+      switchpoint_result = Thread_switch_fiber(rb_thread_current());
+      if (TEST_EXCEPTION(switchpoint_result)) {
+        goto error;
+      }
+    }
+  }
+
+  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;
@@ -276,8 +412,8 @@ VALUE LibevAgent_write(VALUE self, VALUE io, VALUE str) {
   VALUE switchpoint_result = Qnil;
 
   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");
   if (underlying_io != Qnil) io = underlying_io;
@@ -287,27 +423,20 @@ 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) {
-      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
-        
-      }
+    ssize_t n = write(fptr->fd, buf, left);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      buf += result;
-      left -= result;
+      switchpoint_result = libev_snooze();
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      buf += n;
+      left -= n;
     }
   }
 
@@ -321,16 +450,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 +458,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);
@@ -348,43 +469,138 @@ 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 = 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);
+      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 {
-      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;
       // }
+      return socket;
+    }
+  }
+  RB_GC_GUARD(switchpoint_result);
+  return Qnil;
+error:
+  return rb_funcall(rb_mKernel, ID_raise, 1, switchpoint_result);
+}
 
-      return connection;
+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 socket = 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)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_io_wait(agent, &watcher, fptr, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      rb_io_t *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(socket);
+      rb_io_set_nonblock(fp);
+      rb_io_synchronized(fp);
+
+      rb_yield(socket);
+      socket = Qnil;
     }
   }
+
+  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;
@@ -400,7 +616,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);
@@ -414,7 +630,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);
@@ -430,7 +646,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);
@@ -444,7 +660,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?
@@ -464,7 +680,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 +707,18 @@ 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, "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);