nio4r 0.2.0 → 2.7.5

data/ext/nio4r/selector.c

@@ -4,41 +4,57 @@
  */
 
 #include "nio4r.h"
+#ifdef HAVE_RUBYSIG_H
 #include "rubysig.h"
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+
+#include <assert.h>
+#include <fcntl.h>
 
 static VALUE mNIO = Qnil;
-static VALUE cNIO_Channel  = Qnil;
-static VALUE cNIO_Monitor  = Qnil;
+static VALUE cNIO_Monitor = Qnil;
 static VALUE cNIO_Selector = Qnil;
 
 /* Allocator/deallocator */
 static VALUE NIO_Selector_allocate(VALUE klass);
-static void NIO_Selector_mark(struct NIO_Selector *loop);
+static void NIO_Selector_mark(void *data);
 static void NIO_Selector_shutdown(struct NIO_Selector *selector);
-static void NIO_Selector_free(struct NIO_Selector *loop);
+static void NIO_Selector_free(void *data);
+static size_t NIO_Selector_memsize(const void *data);
 
-/* Methods */
-static VALUE NIO_Selector_initialize(VALUE self);
+/* Class methods */
+static VALUE NIO_Selector_supported_backends(VALUE klass);
+
+/* Instance methods */
+static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE NIO_Selector_backend(VALUE self);
 static VALUE NIO_Selector_register(VALUE self, VALUE selectable, VALUE interest);
 static VALUE NIO_Selector_deregister(VALUE self, VALUE io);
 static VALUE NIO_Selector_is_registered(VALUE self, VALUE io);
 static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self);
-static VALUE NIO_Selector_select_each(int argc, VALUE *argv, VALUE self);
 static VALUE NIO_Selector_wakeup(VALUE self);
 static VALUE NIO_Selector_close(VALUE self);
 static VALUE NIO_Selector_closed(VALUE self);
+static VALUE NIO_Selector_is_empty(VALUE self);
 
 /* Internal functions */
-static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args);
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE arg), VALUE arg);
 static VALUE NIO_Selector_unlock(VALUE lock);
-static VALUE NIO_Selector_register_synchronized(VALUE *args);
-static VALUE NIO_Selector_deregister_synchronized(VALUE *args);
-static VALUE NIO_Selector_select_synchronized(VALUE *args);
-static VALUE NIO_Selector_select_each_synchronized(VALUE *args);
-static int NIO_Selector_fill_ready_buffer(VALUE *args);
-static VALUE NIO_Selector_run_evloop(void *ptr);
+static VALUE NIO_Selector_register_synchronized(VALUE arg);
+static VALUE NIO_Selector_deregister_synchronized(VALUE arg);
+static VALUE NIO_Selector_select_synchronized(VALUE arg);
+static VALUE NIO_Selector_close_synchronized(VALUE arg);
+static VALUE NIO_Selector_closed_synchronized(VALUE arg);
+
+static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout);
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents);
-static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_async *async, int revents);
+static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
 
 /* Default number of slots in the buffer for selected monitors */
 #define INITIAL_READY_BUFFER 32
@@ -47,107 +63,270 @@ static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_asyn
 #define BUSYWAIT_INTERVAL 0.01
 
 /* Selectors wait for events */
-void Init_NIO_Selector()
+void Init_NIO_Selector(void)
 {
     mNIO = rb_define_module("NIO");
-    cNIO_Channel  = rb_define_class_under(mNIO, "Channel",  rb_cObject);
-    cNIO_Monitor  = rb_define_class_under(mNIO, "Monitor",  rb_cObject);
     cNIO_Selector = rb_define_class_under(mNIO, "Selector", rb_cObject);
     rb_define_alloc_func(cNIO_Selector, NIO_Selector_allocate);
 
-    rb_define_method(cNIO_Selector, "initialize", NIO_Selector_initialize, 0);
+    rb_define_singleton_method(cNIO_Selector, "backends", NIO_Selector_supported_backends, 0);
+    rb_define_method(cNIO_Selector, "initialize", NIO_Selector_initialize, -1);
+    rb_define_method(cNIO_Selector, "backend", NIO_Selector_backend, 0);
     rb_define_method(cNIO_Selector, "register", NIO_Selector_register, 2);
     rb_define_method(cNIO_Selector, "deregister", NIO_Selector_deregister, 1);
     rb_define_method(cNIO_Selector, "registered?", NIO_Selector_is_registered, 1);
     rb_define_method(cNIO_Selector, "select", NIO_Selector_select, -1);
-    rb_define_method(cNIO_Selector, "select_each", NIO_Selector_select_each, -1);
     rb_define_method(cNIO_Selector, "wakeup", NIO_Selector_wakeup, 0);
     rb_define_method(cNIO_Selector, "close", NIO_Selector_close, 0);
     rb_define_method(cNIO_Selector, "closed?", NIO_Selector_closed, 0);
+    rb_define_method(cNIO_Selector, "empty?", NIO_Selector_is_empty, 0);
+
+    cNIO_Monitor = rb_define_class_under(mNIO, "Monitor", rb_cObject);
 }
 
+static const rb_data_type_t NIO_Selector_type = {
+    "NIO::Selector",
+    {
+        NIO_Selector_mark,
+        NIO_Selector_free,
+        NIO_Selector_memsize,
+    },
+    0,
+    0,
+    RUBY_TYPED_WB_PROTECTED // Don't free immediately because of shutdown
+};
+
 /* Create the libev event loop and incoming event buffer */
 static VALUE NIO_Selector_allocate(VALUE klass)
 {
-    struct NIO_Selector *selector = (struct NIO_Selector *)xmalloc(sizeof(struct NIO_Selector));
+    struct NIO_Selector *selector;
+    int fds[2];
+
+    /* Use a pipe to implement the wakeup mechanism. I know libev provides
+       async watchers that implement this same behavior, but I'm getting
+       segvs trying to use that between threads, despite claims of thread
+       safety. Pipes are nice and safe to use between threads.
+
+       Note that Java NIO uses this same mechanism */
+    if (pipe(fds) < 0) {
+        rb_sys_fail("pipe");
+    }
+
+    /* Use non-blocking reads/writes during wakeup, in case the buffer is full */
+    if (fcntl(fds[0], F_SETFL, O_NONBLOCK) < 0 || fcntl(fds[1], F_SETFL, O_NONBLOCK) < 0) {
+        rb_sys_fail("fcntl");
+    }
+
+    VALUE obj = TypedData_Make_Struct(klass, struct NIO_Selector, &NIO_Selector_type, selector);
+    /* Defer initializing the loop to #initialize */
+    selector->ev_loop = 0;
 
-    selector->ev_loop = ev_loop_new(0);
     ev_init(&selector->timer, NIO_Selector_timeout_callback);
 
-    ev_async_init(&selector->wakeup, NIO_Selector_wakeup_callback);
-    selector->wakeup.data = (void *)selector;
+    selector->wakeup_reader = fds[0];
+    selector->wakeup_writer = fds[1];
 
-    ev_async_start(selector->ev_loop, &selector->wakeup);
+    ev_io_init(&selector->wakeup, NIO_Selector_wakeup_callback, selector->wakeup_reader, EV_READ);
+    selector->wakeup.data = (void *)selector;
 
-    selector->closed = selector->selecting = selector->ready_count = 0;
-    selector->ready_buffer_size = INITIAL_READY_BUFFER;
-    selector->ready_buffer = (VALUE *)xmalloc(sizeof(VALUE) * INITIAL_READY_BUFFER);
+    selector->closed = selector->selecting = selector->wakeup_fired = selector->ready_count = 0;
+    RB_OBJ_WRITE(obj, &selector->ready_array, Qnil);
+    return obj;
+}
 
-    return Data_Wrap_Struct(klass, NIO_Selector_mark, NIO_Selector_free, selector);
+struct NIO_Selector *NIO_Selector_unwrap(VALUE self)
+{
+    struct NIO_Selector *selector;
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+    return selector;
 }
 
 /* NIO selectors store all Ruby objects in instance variables so mark is a stub */
-static void NIO_Selector_mark(struct NIO_Selector *selector)
+static void NIO_Selector_mark(void *data)
 {
+    struct NIO_Selector *selector = (struct NIO_Selector *)data;
+    if (selector->ready_array != Qnil) {
+        rb_gc_mark(selector->ready_array);
+    }
 }
 
 /* Free a Selector's system resources.
    Called by both NIO::Selector#close and the finalizer below */
 static void NIO_Selector_shutdown(struct NIO_Selector *selector)
 {
-    if(selector->ev_loop) {
-        ev_loop_destroy(selector->ev_loop);
-        selector->ev_loop = 0;
+    if (selector->closed) {
+        return;
     }
 
-    if(selector->closed) {
-        return;
+    close(selector->wakeup_reader);
+    close(selector->wakeup_writer);
+
+    if (selector->ev_loop) {
+        ev_loop_destroy(selector->ev_loop);
+        selector->ev_loop = 0;
     }
 
     selector->closed = 1;
 }
 
 /* Ruby finalizer for selector objects */
-static void NIO_Selector_free(struct NIO_Selector *selector)
+static void NIO_Selector_free(void *data)
 {
+    struct NIO_Selector *selector = (struct NIO_Selector *)data;
     NIO_Selector_shutdown(selector);
-
-    xfree(selector->ready_buffer);
     xfree(selector);
 }
 
+static size_t NIO_Selector_memsize(const void *data)
+{
+    return sizeof(struct NIO_Selector);
+}
+
+/* Return an array of symbols for supported backends */
+static VALUE NIO_Selector_supported_backends(VALUE klass)
+{
+    unsigned int backends = ev_supported_backends();
+    VALUE result = rb_ary_new();
+
+    if (backends & EVBACKEND_EPOLL) {
+        rb_ary_push(result, ID2SYM(rb_intern("epoll")));
+    }
+
+    if (backends & EVBACKEND_POLL) {
+        rb_ary_push(result, ID2SYM(rb_intern("poll")));
+    }
+
+    if (backends & EVBACKEND_KQUEUE) {
+        rb_ary_push(result, ID2SYM(rb_intern("kqueue")));
+    }
+
+    if (backends & EVBACKEND_SELECT) {
+        rb_ary_push(result, ID2SYM(rb_intern("select")));
+    }
+
+    if (backends & EVBACKEND_PORT) {
+        rb_ary_push(result, ID2SYM(rb_intern("port")));
+    }
+
+    if (backends & EVBACKEND_LINUXAIO) {
+        rb_ary_push(result, ID2SYM(rb_intern("linuxaio")));
+    }
+
+    if (backends & EVBACKEND_IOURING) {
+        rb_ary_push(result, ID2SYM(rb_intern("io_uring")));
+    }
+
+    return result;
+}
+
 /* Create a new selector. This is more or less the pure Ruby version
    translated into an MRI cext */
-static VALUE NIO_Selector_initialize(VALUE self)
+static VALUE NIO_Selector_initialize(int argc, VALUE *argv, VALUE self)
 {
+    ID backend_id;
+    VALUE backend;
     VALUE lock;
 
+    struct NIO_Selector *selector;
+    unsigned int flags = 0;
+
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+
+    rb_scan_args(argc, argv, "01", &backend);
+
+    if (backend != Qnil) {
+        if (!rb_ary_includes(NIO_Selector_supported_backends(CLASS_OF(self)), backend)) {
+            rb_raise(rb_eArgError, "unsupported backend: %s", RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
+        }
+
+        backend_id = SYM2ID(backend);
+
+        if (backend_id == rb_intern("epoll")) {
+            flags = EVBACKEND_EPOLL;
+        } else if (backend_id == rb_intern("poll")) {
+            flags = EVBACKEND_POLL;
+        } else if (backend_id == rb_intern("kqueue")) {
+            flags = EVBACKEND_KQUEUE;
+        } else if (backend_id == rb_intern("select")) {
+            flags = EVBACKEND_SELECT;
+        } else if (backend_id == rb_intern("port")) {
+            flags = EVBACKEND_PORT;
+        } else if (backend_id == rb_intern("linuxaio")) {
+            flags = EVBACKEND_LINUXAIO;
+        } else if (backend_id == rb_intern("io_uring")) {
+            flags = EVBACKEND_IOURING;
+        } else {
+            rb_raise(rb_eArgError, "unsupported backend: %s", RSTRING_PTR(rb_funcall(backend, rb_intern("inspect"), 0)));
+        }
+    }
+
+    /* Ensure the selector loop has not yet been initialized */
+    assert(!selector->ev_loop);
+
+    selector->ev_loop = ev_loop_new(flags);
+    if (!selector->ev_loop) {
+        rb_raise(rb_eIOError, "error initializing event loop");
+    }
+
+    ev_io_start(selector->ev_loop, &selector->wakeup);
+
     rb_ivar_set(self, rb_intern("selectables"), rb_hash_new());
+    rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
 
     lock = rb_class_new_instance(0, 0, rb_const_get(rb_cObject, rb_intern("Mutex")));
     rb_ivar_set(self, rb_intern("lock"), lock);
+    rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
 
     return Qnil;
 }
 
+static VALUE NIO_Selector_backend(VALUE self)
+{
+    struct NIO_Selector *selector;
+
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+    if (selector->closed) {
+        rb_raise(rb_eIOError, "selector is closed");
+    }
+
+    switch (ev_backend(selector->ev_loop)) {
+        case EVBACKEND_EPOLL:
+            return ID2SYM(rb_intern("epoll"));
+        case EVBACKEND_POLL:
+            return ID2SYM(rb_intern("poll"));
+        case EVBACKEND_KQUEUE:
+            return ID2SYM(rb_intern("kqueue"));
+        case EVBACKEND_SELECT:
+            return ID2SYM(rb_intern("select"));
+        case EVBACKEND_PORT:
+            return ID2SYM(rb_intern("port"));
+        case EVBACKEND_LINUXAIO:
+            return ID2SYM(rb_intern("linuxaio"));
+        case EVBACKEND_IOURING:
+            return ID2SYM(rb_intern("io_uring"));
+    }
+
+    return ID2SYM(rb_intern("unknown"));
+}
+
 /* Synchronize around a reentrant selector lock */
-static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args)
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE arg), VALUE arg)
 {
     VALUE current_thread, lock_holder, lock;
 
     current_thread = rb_thread_current();
     lock_holder = rb_ivar_get(self, rb_intern("lock_holder"));
 
-    if(lock_holder != rb_thread_current()) {
+    if (lock_holder != current_thread) {
         lock = rb_ivar_get(self, rb_intern("lock"));
-        rb_funcall(lock, rb_intern("lock"), 0, 0);
-        rb_ivar_set(self, rb_intern("lock_holder"), rb_thread_current());
+        rb_funcall(lock, rb_intern("lock"), 0);
+        rb_ivar_set(self, rb_intern("lock_holder"), current_thread);
 
         /* We've acquired the lock, so ensure we unlock it */
-        return rb_ensure(func, (VALUE)args, NIO_Selector_unlock, self);
+        return rb_ensure(func, (VALUE)arg, NIO_Selector_unlock, self);
     } else {
         /* We already hold the selector lock, so no need to unlock it */
-        func(args);
+        return func(arg);
     }
 }
 
@@ -159,39 +338,48 @@ static VALUE NIO_Selector_unlock(VALUE self)
     rb_ivar_set(self, rb_intern("lock_holder"), Qnil);
 
     lock = rb_ivar_get(self, rb_intern("lock"));
-    rb_funcall(lock, rb_intern("unlock"), 0, 0);
+    rb_funcall(lock, rb_intern("unlock"), 0);
+
+    return Qnil;
 }
 
 /* Register an IO object with the selector for the given interests */
 static VALUE NIO_Selector_register(VALUE self, VALUE io, VALUE interests)
 {
     VALUE args[3] = {self, io, interests};
-    return NIO_Selector_synchronize(self, NIO_Selector_register_synchronized, args);
+    return NIO_Selector_synchronize(self, NIO_Selector_register_synchronized, (VALUE)args);
 }
 
 /* Internal implementation of register after acquiring mutex */
-static VALUE NIO_Selector_register_synchronized(VALUE *args)
+static VALUE NIO_Selector_register_synchronized(VALUE _args)
 {
     VALUE self, io, interests, selectables, monitor;
     VALUE monitor_args[3];
+    struct NIO_Selector *selector;
 
+    VALUE *args = (VALUE *)_args;
     self = args[0];
     io = args[1];
     interests = args[2];
 
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+    if (selector->closed) {
+        rb_raise(rb_eIOError, "selector is closed");
+    }
+
     selectables = rb_ivar_get(self, rb_intern("selectables"));
     monitor = rb_hash_lookup(selectables, io);
 
-    if(monitor != Qnil)
+    if (monitor != Qnil)
         rb_raise(rb_eArgError, "this IO is already registered with selector");
 
     /* Create a new NIO::Monitor */
-    monitor_args[0] = self;
-    monitor_args[1] = io;
-    monitor_args[2] = interests;
+    monitor_args[0] = io;
+    monitor_args[1] = interests;
+    monitor_args[2] = self;
 
     monitor = rb_class_new_instance(3, monitor_args, cNIO_Monitor);
-    rb_hash_aset(selectables, io, monitor);
+    rb_hash_aset(selectables, rb_funcall(monitor, rb_intern("io"), 0), monitor);
 
     return monitor;
 }
@@ -200,23 +388,23 @@ static VALUE NIO_Selector_register_synchronized(VALUE *args)
 static VALUE NIO_Selector_deregister(VALUE self, VALUE io)
 {
     VALUE args[2] = {self, io};
-    return NIO_Selector_synchronize(self, NIO_Selector_deregister_synchronized, args);
+    return NIO_Selector_synchronize(self, NIO_Selector_deregister_synchronized, (VALUE)args);
 }
 
 /* Internal implementation of register after acquiring mutex */
-static VALUE NIO_Selector_deregister_synchronized(VALUE *args)
+static VALUE NIO_Selector_deregister_synchronized(VALUE _args)
 {
-    VALUE self, io, interests, selectables, monitor;
-    VALUE monitor_args[3];
+    VALUE self, io, selectables, monitor;
 
+    VALUE *args = (VALUE *)_args;
     self = args[0];
     io = args[1];
 
     selectables = rb_ivar_get(self, rb_intern("selectables"));
     monitor = rb_hash_delete(selectables, io);
 
-    if(monitor != Qnil) {
-        rb_funcall(monitor, rb_intern("close"), 0, 0);
+    if (monitor != Qnil) {
+        rb_funcall(monitor, rb_intern("close"), 1, Qfalse);
     }
 
     return monitor;
@@ -234,165 +422,122 @@ static VALUE NIO_Selector_is_registered(VALUE self, VALUE io)
 /* Select from all registered IO objects */
 static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
 {
-    VALUE timeout, array;
-    VALUE args[2];
+    VALUE timeout;
 
     rb_scan_args(argc, argv, "01", &timeout);
 
-    args[0] = self;
-    args[1] = timeout;
-
-    return NIO_Selector_synchronize(self, NIO_Selector_select_synchronized, args);
-}
-
-/* Select from all registered IO objects */
-static VALUE NIO_Selector_select_each(int argc, VALUE *argv, VALUE self)
-{
-    VALUE timeout, array;
-    VALUE args[2];
-
-    if(!rb_block_given_p()) {
-        rb_raise(rb_eArgError, "no block given");
+    if (timeout != Qnil && NUM2DBL(timeout) < 0) {
+        rb_raise(rb_eArgError, "time interval must be positive");
     }
 
-    rb_scan_args(argc, argv, "01", &timeout);
-
-    args[0] = self;
-    args[1] = timeout;
-
-    return NIO_Selector_synchronize(self, NIO_Selector_select_each_synchronized, args);
+    VALUE args[2] = {self, timeout};
+    return NIO_Selector_synchronize(self, NIO_Selector_select_synchronized, (VALUE)args);
 }
 
 /* Internal implementation of select with the selector lock held */
-static VALUE NIO_Selector_select_synchronized(VALUE *args)
+static VALUE NIO_Selector_select_synchronized(VALUE _args)
 {
+    int ready;
+    VALUE ready_array;
     struct NIO_Selector *selector;
-    int ready = NIO_Selector_fill_ready_buffer(args);
 
-    Data_Get_Struct(args[0], struct NIO_Selector, selector);
+    VALUE *args = (VALUE *)_args;
 
-    if(ready > 0) {
-        return rb_ary_new4(ready, selector->ready_buffer);
-    } else {
-        return Qnil;
+    TypedData_Get_Struct(args[0], struct NIO_Selector, &NIO_Selector_type, selector);
+
+    if (selector->closed) {
+        rb_raise(rb_eIOError, "selector is closed");
     }
-}
 
-/* Internal implementation of select with the selector lock held */
-static VALUE NIO_Selector_select_each_synchronized(VALUE *args)
-{
-    struct NIO_Selector *selector;
-    int i, ready = NIO_Selector_fill_ready_buffer(args);
+    if (!rb_block_given_p()) {
+        RB_OBJ_WRITE(args[0], &selector->ready_array, rb_ary_new());
+    }
 
-    Data_Get_Struct(args[0], struct NIO_Selector, selector);
+    ready = NIO_Selector_run(selector, args[1]);
 
-    if(ready > 0) {
-        for(i = 0; i < ready; i++) {
-            rb_yield(selector->ready_buffer[i]);
+    /* Timeout */
+    if (ready < 0) {
+        if (!rb_block_given_p()) {
+            RB_OBJ_WRITE(args[0], &selector->ready_array, Qnil);
         }
 
+        return Qnil;
+    }
+
+    if (rb_block_given_p()) {
         return INT2NUM(ready);
     } else {
-        return Qnil;
+        ready_array = selector->ready_array;
+        RB_OBJ_WRITE(args[0], &selector->ready_array, Qnil);
+        return ready_array;
     }
 }
 
-static int NIO_Selector_fill_ready_buffer(VALUE *args)
+static int NIO_Selector_run(struct NIO_Selector *selector, VALUE timeout)
 {
-    VALUE self, timeout;
-    struct NIO_Selector *selector;
+    int ev_run_flags = EVRUN_ONCE;
     int result;
+    double timeout_val;
 
-    self = args[0];
-    timeout = args[1];
-
-    Data_Get_Struct(self, struct NIO_Selector, selector);
     selector->selecting = 1;
+    selector->wakeup_fired = 0;
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION) || defined(HAVE_RB_THREAD_ALONE)
-    /* Implement the optional timeout (if any) as a ev_timer */
-    if(timeout != Qnil) {
-        selector->timer.repeat = NUM2DBL(timeout);
-        ev_timer_again(selector->ev_loop, &selector->timer);
-    } else {
+    if (timeout == Qnil) {
+        /* Don't fire a wakeup timeout if we weren't passed one */
         ev_timer_stop(selector->ev_loop, &selector->timer);
-    }
-#else
-    /* Store when we started the loop so we can calculate the timeout */
-    ev_tstamp started_at = ev_now(selector->ev_loop);
-#endif
-
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
-    /* Ruby 1.9 lets us release the GIL and make a blocking I/O call */
-    rb_thread_blocking_region(NIO_Selector_run_evloop, selector, RUBY_UBF_IO, 0);
-#elif defined(HAVE_RB_THREAD_ALONE)
-    /* If we're the only thread we can make a blocking system call */
-    if(rb_thread_alone()) {
-#else
-    /* If we don't have rb_thread_alone() we can't block */
-    if(0) {
-#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
-
-#if !defined(HAVE_RB_THREAD_BLOCKING_REGION)
-        TRAP_BEG;
-        NIO_Selector_run_evloop(selector);
-        TRAP_END;
     } else {
-        /* We need to busy wait as not to stall the green thread scheduler
-           Ruby 1.8: just say no! :( */
-        ev_timer_init(&selector->timer, NIO_Selector_timeout_callback, BUSYWAIT_INTERVAL, BUSYWAIT_INTERVAL);
-        ev_timer_start(selector->ev_loop, &selector->timer);
-
-        /* Loop until we receive events */
-        while(selector->selecting && !selector->ready_count) {
-            TRAP_BEG;
-            NIO_Selector_run_evloop(selector);
-            TRAP_END;
-
-            /* Run the next green thread */
-            rb_thread_schedule();
-
-            /* Break if the timeout has elapsed */
-            if(timeout != Qnil && ev_now(selector->ev_loop) - started_at >= NUM2DBL(timeout))
-                break;
+        timeout_val = NUM2DBL(timeout);
+        if (timeout_val == 0) {
+            /* If we've been given an explicit timeout of 0, perform a non-blocking
+               select operation */
+            ev_run_flags = EVRUN_NOWAIT;
+        } else {
+            selector->timer.repeat = timeout_val;
+            ev_timer_again(selector->ev_loop, &selector->timer);
         }
-
-        ev_timer_stop(selector->ev_loop, &selector->timer);
     }
-#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
+
+    /* libev is patched to release the GIL when it makes its system call */
+    ev_run(selector->ev_loop, ev_run_flags);
 
     result = selector->ready_count;
     selector->selecting = selector->ready_count = 0;
 
-    return result;
-}
-
-/* Run the libev event loop */
-static VALUE NIO_Selector_run_evloop(void *ptr)
-{
-    struct NIO_Selector *selector = (struct NIO_Selector *)ptr;
-
-    ev_loop(selector->ev_loop, EVLOOP_ONESHOT);
-
-    return Qnil;
+    if (result > 0 || selector->wakeup_fired) {
+        selector->wakeup_fired = 0;
+        return result;
+    } else {
+        return -1;
+    }
 }
 
 /* Wake the selector up from another thread */
 static VALUE NIO_Selector_wakeup(VALUE self)
 {
     struct NIO_Selector *selector;
-    Data_Get_Struct(self, struct NIO_Selector, selector);
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
+
+    if (selector->closed) {
+        rb_raise(rb_eIOError, "selector is closed");
+    }
 
-    ev_async_send(selector->ev_loop, &selector->wakeup);
+    selector->wakeup_fired = 1;
+    write(selector->wakeup_writer, "\0", 1);
 
     return Qnil;
 }
 
 /* Close the selector and free system resources */
 static VALUE NIO_Selector_close(VALUE self)
+{
+    return NIO_Selector_synchronize(self, NIO_Selector_close_synchronized, self);
+}
+
+static VALUE NIO_Selector_close_synchronized(VALUE self)
 {
     struct NIO_Selector *selector;
-    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
 
     NIO_Selector_shutdown(selector);
 
@@ -401,38 +546,61 @@ static VALUE NIO_Selector_close(VALUE self)
 
 /* Is the selector closed? */
 static VALUE NIO_Selector_closed(VALUE self)
+{
+    return NIO_Selector_synchronize(self, NIO_Selector_closed_synchronized, self);
+}
+
+static VALUE NIO_Selector_closed_synchronized(VALUE self)
 {
     struct NIO_Selector *selector;
-    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    TypedData_Get_Struct(self, struct NIO_Selector, &NIO_Selector_type, selector);
 
     return selector->closed ? Qtrue : Qfalse;
 }
 
+/* True if there are monitors on the loop */
+static VALUE NIO_Selector_is_empty(VALUE self)
+{
+    VALUE selectables = rb_ivar_get(self, rb_intern("selectables"));
+
+    return rb_funcall(selectables, rb_intern("empty?"), 0) == Qtrue ? Qtrue : Qfalse;
+}
+
 /* Called whenever a timeout fires on the event loop */
 static void NIO_Selector_timeout_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
 {
-    /* We don't actually need to do anything here, the mere firing of the
-       timer is sufficient to interrupt the selector. However, libev still wants a callback */
 }
 
 /* Called whenever a wakeup request is sent to a selector */
-static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_async *async, int revents)
+static void NIO_Selector_wakeup_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
 {
-    struct NIO_Selector *selector = (struct NIO_Selector *)async->data;
+    char buffer[128];
+    struct NIO_Selector *selector = (struct NIO_Selector *)io->data;
     selector->selecting = 0;
+
+    /* Drain the wakeup pipe, giving us level-triggered behavior */
+    while (read(selector->wakeup_reader, buffer, 128) > 0)
+        ;
 }
 
-/* This gets called from individual monitors. We must be careful here because
-   the GIL isn't held, so we must rely only on standard C and can't touch
-   anything Ruby-related */
-void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents)
+/* libev callback fired whenever a monitor gets an event */
+void NIO_Selector_monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
 {
-    /* Grow the ready buffer if it's too small */
-    if(selector->ready_count >= selector->ready_buffer_size) {
-      selector->ready_buffer_size *= 2;
-      selector->ready_buffer = (VALUE *)xrealloc(selector->ready_buffer, sizeof(VALUE) * selector->ready_buffer_size);
-    }
+    struct NIO_Monitor *monitor_data = (struct NIO_Monitor *)io->data;
+    struct NIO_Selector *selector = monitor_data->selector;
+    VALUE monitor = monitor_data->self;
 
-    selector->ready_buffer[selector->ready_count] = monitor;
+    assert(monitor_data->interests != 0);
+
+    assert(selector != 0);
     selector->ready_count++;
+    monitor_data->revents = revents;
+
+    if (rb_block_given_p()) {
+        rb_yield(monitor);
+    } else {
+        assert(selector->ready_array != Qnil);
+        rb_ary_push(selector->ready_array, monitor);
+    }
 }