polyphony 0.13 → 0.14

data/ext/ev/child.c

@@ -0,0 +1,169 @@
+#include "ev.h"
+
+struct EV_Child {
+  struct  ev_child ev_child;
+  int     active;
+  int     pid;
+  VALUE   self;
+  VALUE   callback;
+  VALUE   fiber;
+};
+
+static VALUE mEV = Qnil;
+static VALUE cEV_Child = Qnil;
+
+/* Allocator/deallocator */
+static VALUE EV_Child_allocate(VALUE klass);
+static void EV_Child_mark(void *ptr);
+static void EV_Child_free(void *ptr);
+static size_t EV_Child_size(const void *ptr);
+
+/* Methods */
+static VALUE EV_Child_initialize(VALUE self, VALUE pid);
+
+static VALUE EV_Child_start(VALUE self);
+static VALUE EV_Child_stop(VALUE self);
+static VALUE EV_Child_await(VALUE self);
+
+void EV_Child_callback(ev_loop *ev_loop, struct ev_child *child, int revents);
+
+/* Child encapsulates an child watcher */
+void Init_EV_Child() {
+  mEV = rb_define_module("EV");
+  cEV_Child = rb_define_class_under(mEV, "Child", rb_cData);
+  rb_define_alloc_func(cEV_Child, EV_Child_allocate);
+
+  rb_define_method(cEV_Child, "initialize", EV_Child_initialize, 1);
+  rb_define_method(cEV_Child, "start", EV_Child_start, 0);
+  rb_define_method(cEV_Child, "stop", EV_Child_stop, 0);
+  rb_define_method(cEV_Child, "await", EV_Child_await, 0);
+}
+
+static const rb_data_type_t EV_Child_type = {
+    "EV_Child",
+    {EV_Child_mark, EV_Child_free, EV_Child_size,},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE EV_Child_allocate(VALUE klass) {
+  struct EV_Child *child = (struct EV_Child *)xmalloc(sizeof(struct EV_Child));
+  return TypedData_Wrap_Struct(klass, &EV_Child_type, child);
+}
+
+static void EV_Child_mark(void *ptr) {
+  struct EV_Child *child = ptr;
+  if (child->callback != Qnil) {
+    rb_gc_mark(child->callback);
+  }
+  if (child->fiber != Qnil) {
+    rb_gc_mark(child->fiber);
+  }
+}
+
+static void EV_Child_free(void *ptr) {
+  struct EV_Child *child = ptr;
+  if (child->active) {
+    ev_child_stop(EV_DEFAULT, &child->ev_child);
+  }
+  xfree(child);
+}
+
+static size_t EV_Child_size(const void *ptr) {
+  return sizeof(struct EV_Child);
+}
+
+#define GetEV_Child(obj, child) \
+  TypedData_Get_Struct((obj), struct EV_Child, &EV_Child_type, (child))
+
+static VALUE EV_Child_initialize(VALUE self, VALUE pid) {
+  struct EV_Child *child;
+
+  GetEV_Child(self, child);
+
+  child->self     = self;
+  child->callback = Qnil;
+  child->fiber    = Qnil;
+  child->pid      = NUM2INT(pid);
+  child->active   = 0;
+  
+  ev_child_init(&child->ev_child, EV_Child_callback, child->pid, 0);
+
+  return Qnil;
+}
+
+void EV_Child_callback(ev_loop *ev_loop, struct ev_child *ev_child, int revents) {
+  VALUE fiber;
+  VALUE resume_value;
+  struct EV_Child *child = (struct EV_Child*)ev_child;
+  resume_value = INT2NUM(child->pid);
+
+  child->active = 0;
+  ev_child_stop(EV_DEFAULT, ev_child);
+  EV_del_watcher_ref(child->self);
+
+  if (child->fiber != Qnil) {
+    fiber = child->fiber;
+    child->fiber = Qnil;
+    SCHEDULE_FIBER(fiber, 1, resume_value);
+  }
+  else if (child->callback != Qnil) {
+    rb_funcall(child->callback, ID_call, 1, resume_value);
+  }
+}
+
+static VALUE EV_Child_start(VALUE self) {
+  struct EV_Child *child;
+  GetEV_Child(self, child);
+
+  if (rb_block_given_p()) {
+    child->callback = rb_block_proc();
+  }
+
+  if (!child->active) {
+    ev_child_start(EV_DEFAULT, &child->ev_child);
+    child->active = 1;
+    EV_add_watcher_ref(self);
+  }
+
+  return self;
+}
+
+static VALUE EV_Child_stop(VALUE self) {
+  struct EV_Child *child;
+  GetEV_Child(self, child);
+
+  if (child->active) {
+    ev_child_stop(EV_DEFAULT, &child->ev_child);
+    child->active = 0;
+    EV_del_watcher_ref(self);
+  }
+
+  return self;
+}
+
+static VALUE EV_Child_await(VALUE self) {
+  struct EV_Child *child;
+  VALUE ret;
+  
+  GetEV_Child(self, child);
+
+  child->fiber = rb_fiber_current();
+  child->active = 1;
+  ev_child_start(EV_DEFAULT, &child->ev_child);
+  EV_add_watcher_ref(self);
+
+  ret = YIELD_TO_REACTOR();
+
+  // fiber is resumed, check if resumed value is an exception
+  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
+    if (child->active) {
+      child->active = 0;
+      ev_child_stop(EV_DEFAULT, &child->ev_child);
+    }
+    return rb_funcall(ret, ID_raise, 1, ret);
+  }
+  else {
+    return ret;
+  }
+}

data/ext/ev/ev.h

@@ -0,0 +1,32 @@
+#ifndef RUBY_EV_H
+#define RUBY_EV_H
+
+#include "ruby.h"
+#include "ruby/io.h"
+#include "libev.h"
+
+void EV_add_watcher_ref(VALUE obj);
+void EV_del_watcher_ref(VALUE obj);
+void EV_async_free(void *p);
+
+#define SCHEDULE_FIBER(obj, args...) rb_funcall(obj, ID_transfer, args)
+#define YIELD_TO_REACTOR() rb_funcall(EV_reactor_fiber, ID_transfer, 0)
+
+extern VALUE EV_reactor_fiber;
+extern VALUE EV_root_fiber;
+
+extern ID ID_call;
+extern ID ID_caller;
+extern ID ID_clear;
+extern ID ID_each;
+extern ID ID_inspect;
+extern ID ID_raise;
+extern ID ID_read_watcher;
+extern ID ID_scheduled_value;
+extern ID ID_transfer;
+extern ID ID_write_watcher;
+extern ID ID_R;
+extern ID ID_W;
+extern ID ID_RW;
+
+#endif /* RUBY_EV_H */

data/ext/ev/ev_ext.c

@@ -0,0 +1,20 @@
+#include "ev.h"
+#include "../libev/ev.c"
+
+void Init_EV();
+void Init_EV_Async();
+void Init_EV_Child();
+void Init_EV_IO();
+void Init_EV_Signal();
+void Init_EV_Timer();
+
+void Init_ev_ext() {
+  ev_set_allocator(xrealloc);
+
+  Init_EV();
+  Init_EV_Async();
+  Init_EV_Child();
+  Init_EV_IO();
+  Init_EV_Signal();
+  Init_EV_Timer();
+}

data/ext/ev/ev_module.c

@@ -0,0 +1,222 @@
+#include "ev.h"
+
+static VALUE mEV = Qnil;
+
+static VALUE EV_run(VALUE self);
+static VALUE EV_break(VALUE self);
+static VALUE EV_restart(VALUE self);
+static VALUE EV_rerun(VALUE self);
+
+static VALUE EV_ref(VALUE self);
+static VALUE EV_unref(VALUE self);
+
+static VALUE EV_next_tick(VALUE self);
+static VALUE EV_snooze(VALUE self);
+static VALUE EV_post_fork(VALUE self);
+
+static VALUE EV_suspend(VALUE self);
+static VALUE EV_schedule_fiber(VALUE self, VALUE fiber, VALUE value);
+
+static VALUE watcher_refs;
+static VALUE next_tick_procs;
+
+static struct ev_timer next_tick_timer;
+static int next_tick_active;
+void EV_next_tick_callback(ev_loop *ev_loop, struct ev_timer *timer, int revents);
+
+VALUE EV_reactor_fiber;
+VALUE EV_root_fiber;
+
+ID ID_call;
+ID ID_caller;
+ID ID_clear;
+ID ID_each;
+ID ID_inspect;
+ID ID_raise;
+ID ID_read_watcher;
+ID ID_scheduled_value;
+ID ID_transfer;
+ID ID_write_watcher;
+ID ID_R;
+ID ID_W;
+ID ID_RW;
+
+void Init_EV() {
+  mEV = rb_define_module("EV");
+
+  rb_define_singleton_method(mEV, "break", EV_break, 0);
+  rb_define_singleton_method(mEV, "restart", EV_restart, 0);
+  rb_define_singleton_method(mEV, "rerun", EV_rerun, 0);
+  rb_define_singleton_method(mEV, "ref", EV_ref, 0);
+  rb_define_singleton_method(mEV, "unref", EV_unref, 0);
+  rb_define_singleton_method(mEV, "next_tick", EV_next_tick, 0);
+  rb_define_singleton_method(mEV, "snooze", EV_snooze, 0);
+  rb_define_singleton_method(mEV, "post_fork", EV_post_fork, 0);
+  rb_define_singleton_method(mEV, "schedule_fiber", EV_schedule_fiber, 2);
+
+  rb_define_method(rb_mKernel, "suspend", EV_suspend, 0);
+
+  ID_call                 = rb_intern("call");
+  ID_caller               = rb_intern("caller");
+  ID_clear                = rb_intern("clear");
+  ID_each                 = rb_intern("each");
+  ID_inspect              = rb_intern("inspect");
+  ID_raise                = rb_intern("raise");
+  ID_read_watcher         = rb_intern("read_watcher");
+  ID_scheduled_value      = rb_intern("@scheduled_value");
+  ID_transfer             = rb_intern("transfer");
+  ID_write_watcher        = rb_intern("write_watcher");
+  ID_R                    = rb_intern("r");
+  ID_W                    = rb_intern("w");
+  ID_RW                   = rb_intern("rw");
+
+  EV_root_fiber = rb_fiber_current();
+  EV_reactor_fiber = rb_fiber_new(EV_run, Qnil);
+  rb_gv_set("__reactor_fiber__", EV_reactor_fiber);
+  
+
+  watcher_refs = rb_hash_new();
+  rb_global_variable(&watcher_refs);
+
+  next_tick_procs = rb_ary_new();
+  rb_global_variable(&next_tick_procs);
+
+  ev_timer_init(&next_tick_timer, EV_next_tick_callback, 0., 0.);
+  next_tick_active = 0;
+}
+
+static VALUE EV_run(VALUE self) {
+  ev_run(EV_DEFAULT, 0);
+  rb_gv_set("__reactor_fiber__", Qnil);
+  return Qnil;
+}
+
+static VALUE EV_break(VALUE self) {
+  // make sure reactor fiber is alive
+  if (!RTEST(rb_fiber_alive_p(EV_reactor_fiber))) {
+    return Qnil;
+  }
+
+  ev_break(EV_DEFAULT, EVBREAK_ALL);
+  return YIELD_TO_REACTOR();
+}
+
+static VALUE EV_restart(VALUE self) {
+  EV_reactor_fiber = rb_fiber_new(EV_run, Qnil);
+  rb_gv_set("__reactor_fiber__", EV_reactor_fiber);
+  return Qnil;
+}
+
+static VALUE EV_rerun(VALUE self) {
+  EV_break(self);
+  EV_restart(self);
+  return Qnil;
+}
+
+static VALUE EV_ref(VALUE self) {
+  ev_ref(EV_DEFAULT);
+  return Qnil;
+}
+
+static VALUE EV_unref(VALUE self) {
+  ev_unref(EV_DEFAULT);
+  return Qnil;
+}
+
+void EV_add_watcher_ref(VALUE obj) {
+  rb_hash_aset(watcher_refs, rb_obj_id(obj), obj);
+}
+
+void EV_del_watcher_ref(VALUE obj) {
+  rb_hash_delete(watcher_refs, rb_obj_id(obj));
+}
+
+static VALUE EV_next_tick(VALUE self) {
+  VALUE proc = rb_block_proc();
+  if (RTEST(proc)) {
+    rb_ary_push(next_tick_procs, proc);
+    if (!next_tick_active) {
+      next_tick_active = 1;
+      ev_timer_start(EV_DEFAULT, &next_tick_timer);
+    }
+  }
+  return Qnil;
+}
+
+static VALUE EV_snooze(VALUE self) {
+  VALUE ret;
+  VALUE fiber = rb_fiber_current();
+
+  rb_ary_push(next_tick_procs, fiber);
+  if (!next_tick_active) {
+    next_tick_active = 1;
+    ev_timer_start(EV_DEFAULT, &next_tick_timer);
+  }
+
+  ret = YIELD_TO_REACTOR();
+  
+  // fiber is resumed, check if resumed value is an exception
+  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
+    rb_ary_delete(next_tick_procs, fiber);
+    return rb_funcall(ret, ID_raise, 1, ret);
+  }
+  else {
+    return ret;
+  }
+}
+
+static VALUE EV_post_fork(VALUE self) {
+  ev_loop_fork(EV_DEFAULT);
+  
+  EV_reactor_fiber = rb_fiber_new(EV_run, Qnil);
+  rb_gv_set("__reactor_fiber__", EV_reactor_fiber);
+  EV_root_fiber = rb_fiber_current();
+
+  return Qnil;
+}
+
+VALUE EV_next_tick_caller(VALUE proc, VALUE data, int argc, VALUE* argv) {
+  if (rb_obj_is_proc(proc)) {
+    rb_funcall(proc, ID_call, 1, Qtrue);
+  }
+  else {
+    SCHEDULE_FIBER(proc, 1, rb_ivar_get(proc, ID_scheduled_value));
+  }
+  return Qnil;
+}
+
+void EV_next_tick_callback(ev_loop *ev_loop, struct ev_timer *timer, int revents) {
+  VALUE scheduled_procs = rb_ary_dup(next_tick_procs);
+  rb_funcall(next_tick_procs, ID_clear, 0);
+  rb_block_call(scheduled_procs, ID_each, 0, NULL, EV_next_tick_caller, Qnil);
+  if (rb_array_len(next_tick_procs) > 0) {
+    ev_timer_start(EV_DEFAULT, &next_tick_timer);
+  } else {
+    next_tick_active = 0;
+  }
+}
+
+static VALUE EV_suspend(VALUE self) {
+  // make sure reactor fiber is alive
+  if (!RTEST(rb_fiber_alive_p(EV_reactor_fiber))) {
+    return Qnil;
+  }
+
+  VALUE ret = YIELD_TO_REACTOR();
+
+  // fiber is resumed, check if resumed value is an exception
+  return RTEST(rb_obj_is_kind_of(ret, rb_eException)) ? 
+    rb_funcall(ret, ID_raise, 1, ret) : ret;
+}
+
+static VALUE EV_schedule_fiber(VALUE self, VALUE fiber, VALUE value) {
+  rb_ivar_set(fiber, ID_scheduled_value, value);
+
+  rb_ary_push(next_tick_procs, fiber);
+  if (!next_tick_active) {
+    next_tick_active = 1;
+    ev_timer_start(EV_DEFAULT, &next_tick_timer);
+  }
+
+  return Qnil;
+}

data/ext/ev/io.c

@@ -0,0 +1,405 @@
+#include "ev.h"
+
+#ifdef GetReadFile
+# define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
+#else
+# define FPTR_TO_FD(fptr) fptr->fd
+#endif /* GetReadFile */
+
+struct EV_IO {
+  struct  ev_io ev_io;
+  int     active;
+  int     event_mask;
+  VALUE   callback;
+  VALUE   fiber;
+};
+
+static VALUE mEV = Qnil;
+static VALUE cEV_IO = Qnil;
+
+static VALUE EV_IO_allocate(VALUE klass);
+static void EV_IO_mark(void *ptr);
+static void EV_IO_free(void *ptr);
+static size_t EV_IO_size(const void *ptr);
+
+static VALUE EV_IO_initialize(VALUE self, VALUE io, VALUE event_mask);
+
+static VALUE EV_IO_start(VALUE self);
+static VALUE EV_IO_stop(VALUE self);
+static VALUE EV_IO_await(VALUE self);
+
+void EV_IO_callback(ev_loop *ev_loop, struct ev_io *io, int revents);
+
+static int EV_IO_symbol2event_mask(VALUE sym);
+
+static VALUE IO_read(int argc, VALUE *argv, VALUE io);
+static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io);
+static VALUE IO_write(int argc, VALUE *argv, VALUE io);
+
+void Init_EV_IO() {
+  mEV = rb_define_module("EV");
+  cEV_IO = rb_define_class_under(mEV, "IO", rb_cData);
+  rb_define_alloc_func(cEV_IO, EV_IO_allocate);
+
+  rb_define_method(cEV_IO, "initialize", EV_IO_initialize, 2);
+  rb_define_method(cEV_IO, "start", EV_IO_start, 0);
+  rb_define_method(cEV_IO, "stop", EV_IO_stop, 0);
+  rb_define_method(cEV_IO, "await", EV_IO_await, 0);
+
+  VALUE cIO = rb_const_get(rb_cObject, rb_intern("IO"));
+  rb_define_method(cIO, "read", IO_read, -1);
+  rb_define_method(cIO, "readpartial", IO_readpartial, -1);
+  rb_define_method(cIO, "write", IO_write, -1);
+  rb_define_method(cIO, "write_nonblock", IO_write, -1);
+  rb_define_method(cIO, "<<", IO_write, -1);
+}
+
+static const rb_data_type_t EV_IO_type = {
+    "EV_IO",
+    {EV_IO_mark, EV_IO_free, EV_IO_size,},
+    0, 0,
+    RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static VALUE EV_IO_allocate(VALUE klass) {
+  struct EV_IO *io = (struct EV_IO *)xmalloc(sizeof(struct EV_IO));
+
+  return TypedData_Wrap_Struct(klass, &EV_IO_type, io);
+}
+
+static void EV_IO_mark(void *ptr) {
+  struct EV_IO *io = ptr;
+  if (io->callback != Qnil) {
+    rb_gc_mark(io->callback);
+  }
+  if (io->fiber != Qnil) {
+    rb_gc_mark(io->fiber);
+  }
+}
+
+static void EV_IO_free(void *ptr) {
+  struct EV_IO *io = ptr;
+  ev_io_stop(EV_DEFAULT, &io->ev_io);
+  xfree(io);
+}
+
+static size_t EV_IO_size(const void *ptr) {
+  return sizeof(struct EV_IO);
+}
+
+static const char * S_IO = "IO";
+static const char * S_to_io = "to_io";
+
+#define GetEV_IO(obj, io) TypedData_Get_Struct((obj), struct EV_IO, &EV_IO_type, (io))
+
+static VALUE EV_IO_initialize(VALUE self, VALUE io_obj, VALUE event_mask) {
+  struct EV_IO *io;
+  rb_io_t *fptr;
+
+  GetEV_IO(self, io);
+
+  io->event_mask = EV_IO_symbol2event_mask(event_mask);
+  io->callback = Qnil;
+  io->fiber = Qnil;
+  io->active = 0;
+
+  GetOpenFile(rb_convert_type(io_obj, T_FILE, S_IO, S_to_io), fptr);
+  ev_io_init(&io->ev_io, EV_IO_callback, FPTR_TO_FD(fptr), io->event_mask);
+
+  return Qnil;
+}
+
+void EV_IO_callback(ev_loop *ev_loop, struct ev_io *ev_io, int revents) {
+  VALUE fiber;
+  struct EV_IO *io = (struct EV_IO*)ev_io;
+
+  if (io->fiber != Qnil) {
+    ev_io_stop(EV_DEFAULT, ev_io);
+    io->active = 0;
+    fiber = io->fiber;
+    io->fiber = Qnil;
+    SCHEDULE_FIBER(fiber, 0);
+  }
+  else if (io->callback != Qnil) {
+    rb_funcall(io->callback, ID_call, 1, INT2NUM(revents));
+  }
+  else {
+    ev_io_stop(EV_DEFAULT, ev_io);
+  }
+}
+
+static VALUE EV_IO_start(VALUE self) {
+  struct EV_IO *io;
+  GetEV_IO(self, io);
+
+  if (rb_block_given_p()) {
+    io->callback = rb_block_proc();
+  }
+
+  if (!io->active) {
+    ev_io_start(EV_DEFAULT, &io->ev_io);
+    io->active = 1;
+  }
+
+  return self;
+}
+
+static VALUE EV_IO_stop(VALUE self) {
+  struct EV_IO *io;
+  GetEV_IO(self, io);
+
+  if (io->active) {
+    ev_io_stop(EV_DEFAULT, &io->ev_io);
+    io->active = 0;
+  }
+
+  return self;
+}
+
+static VALUE EV_IO_await(VALUE self) {
+  struct EV_IO *io;
+  VALUE ret;
+  
+  GetEV_IO(self, io);
+
+  io->fiber = rb_fiber_current();
+  io->active = 1;
+  ev_io_start(EV_DEFAULT, &io->ev_io);
+  ret = YIELD_TO_REACTOR();
+
+  // make sure io watcher is stopped
+  if (io->active) {
+    io->active = 0;
+    ev_io_stop(EV_DEFAULT, &io->ev_io);
+  }
+
+  // fiber is resumed, check if resumed value is an exception
+  if (RTEST(rb_obj_is_kind_of(ret, rb_eException))) {
+    return rb_funcall(ret, ID_raise, 1, ret);
+  }
+  else {
+    return Qnil;
+  }
+}
+
+static int EV_IO_symbol2event_mask(VALUE sym) {
+  ID sym_id;
+
+  if (NIL_P(sym)) {
+    return 0;
+  }
+
+  sym_id = SYM2ID(sym);
+
+  if(sym_id == ID_R) {
+    return EV_READ;
+  } else if(sym_id == ID_W) {
+    return EV_WRITE;
+  } else if(sym_id == ID_RW) {
+    return EV_READ | EV_WRITE;
+  } else {
+    rb_raise(rb_eArgError, "invalid interest type %s (must be :r, :w, or :rw)",
+      RSTRING_PTR(rb_funcall(sym, ID_inspect, 0)));
+  }
+}
+
+//////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////
+// 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;
+};
+
+static 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);
+  }
+}
+
+static 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 VALUE IO_read(int argc, VALUE *argv, VALUE io) {
+  long len = argc == 1 ? NUM2LONG(argv[0]) : 8192;
+
+  rb_io_t *fptr;
+  long n;
+  int shrinkable;
+  VALUE read_watcher = Qnil;
+
+  if (len < 0) {
+    rb_raise(rb_eArgError, "negative length %ld given", len);
+  }
+
+  VALUE str = argc >= 2 ? argv[1] : Qnil;
+
+  shrinkable = io_setstrbuf(&str, len);
+  OBJ_TAINT(str);
+  GetOpenFile(io, fptr);
+  rb_io_check_byte_readable(fptr);
+
+  if (len == 0)
+  	return str;
+  
+  char *buf = RSTRING_PTR(str);
+  long total = 0;
+
+  while (1) {
+    n = read(fptr->fd, buf, len);
+    if (n < 0) {
+      int e = errno;
+      if ((e == EWOULDBLOCK || e == EAGAIN)) {
+        if (read_watcher == Qnil)
+          read_watcher = rb_funcall(io, ID_read_watcher, 0);
+        EV_IO_await(read_watcher);
+      }
+      else
+        rb_syserr_fail(e, strerror(e));
+        // rb_syserr_fail_path(e, fptr->pathv);
+    }
+    else if (n == 0)
+      break;
+    else {
+      total = total + n;
+      buf += n;
+      len -= n;
+      if (len == 0)
+        break;
+    }
+  }
+
+  io_set_read_length(str, total, shrinkable);
+
+  if (total == 0)
+    return Qnil;
+
+  return str;
+}
+
+static VALUE IO_readpartial(int argc, VALUE *argv, VALUE io) {
+  long len = argc == 1 ? NUM2LONG(argv[0]) : 8192;
+
+  rb_io_t *fptr;
+  long n;
+  int shrinkable;
+  VALUE read_watcher = Qnil;
+
+  if (len < 0) {
+    rb_raise(rb_eArgError, "negative length %ld given", len);
+  }
+
+  VALUE str = argc >= 2 ? argv[1] : Qnil;
+
+  shrinkable = io_setstrbuf(&str, len);
+  OBJ_TAINT(str);
+  GetOpenFile(io, fptr);
+  rb_io_check_byte_readable(fptr);
+
+  if (len == 0)
+  	return str;
+
+  while (1) {
+    n = read(fptr->fd, RSTRING_PTR(str), len);
+    if (n < 0) {
+      int e = errno;
+      if ((e == EWOULDBLOCK || e == EAGAIN)) {
+        if (read_watcher == Qnil)
+          read_watcher = rb_funcall(io, ID_read_watcher, 0);
+        EV_IO_await(read_watcher);
+      }
+      else
+        rb_syserr_fail(e, strerror(e));
+        // rb_syserr_fail_path(e, fptr->pathv);
+    }
+    else
+      break;
+  }
+
+  io_set_read_length(str, n, shrinkable);
+
+  if (n == 0)
+    return Qnil;
+
+  return str;
+}
+
+static VALUE IO_write(int argc, VALUE *argv, VALUE io) {
+  long i;
+  long n;
+  long total = 0;
+  rb_io_t *fptr;
+
+  io = rb_io_get_write_io(io);
+  VALUE write_watcher = Qnil;
+
+  GetOpenFile(io, fptr);
+  rb_io_check_writable(fptr);
+  rb_io_set_nonblock(fptr);
+
+  for (i = 0; i < argc; i++) {
+    VALUE str = argv[i];
+    if (!RB_TYPE_P(str, T_STRING))
+	    str = rb_obj_as_string(str);
+    char *buf = RSTRING_PTR(str);
+    long len = RSTRING_LEN(str);
+    RB_GC_GUARD(str);
+    while (1) {
+      n = write(fptr->fd, buf, len);
+
+      if (n < 0) {
+        int e = errno;
+        if (e == EWOULDBLOCK || e == EAGAIN) {
+          if (write_watcher == Qnil)
+            write_watcher = rb_funcall(io, ID_write_watcher, 0);
+          EV_IO_await(write_watcher);
+        }
+        else {
+          rb_syserr_fail(e, strerror(e));
+          // rb_syserr_fail_path(e, fptr->pathv);
+        }
+      }
+      else {
+        total += n;
+        if (n < len) {
+          buf += n;
+          len -= n;
+        }
+        else break;
+      }
+    }
+  }
+
+  return LONG2FIX(total);
+}