nio4r 0.0.1

data/ext/libev/test_libev_win32.c

@@ -0,0 +1,123 @@
+  // a single header file is required
+  #include <ev.h>
+   #include <stdio.h>
+   #include <io.h>
+
+   // every watcher type has its own typedef'd struct
+   // with the name ev_TYPE
+   ev_io stdin_watcher;
+   ev_timer timeout_watcher;
+
+   // all watcher callbacks have a similar signature
+   // this callback is called when data is readable on stdin
+   static void
+   stdin_cb (EV_P_ ev_io *w, int revents)
+   {
+     puts ("stdin ready or done or something");
+     // for one-shot events, one must manually stop the watcher
+     // with its corresponding stop function.
+     //ev_io_stop (EV_A_ w);
+
+     // this causes all nested ev_loop's to stop iterating
+     //ev_unloop (EV_A_ EVUNLOOP_ALL);
+   }
+
+   // another callback, this time for a time-out
+   static void
+   timeout_cb (EV_P_ ev_timer *w, int revents)
+   {
+     puts ("timeout");
+     // this causes the innermost ev_loop to stop iterating
+     ev_unloop (EV_A_ EVUNLOOP_ONE);
+   }
+
+
+
+   #include <winsock.h>
+
+#include <stdlib.h>
+#include <iostream>
+   int get_server_fd()
+   {
+
+  //----------------------
+  // Initialize Winsock.
+  WSADATA wsaData;
+  int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
+  if (iResult != NO_ERROR) {
+    printf("Error at WSAStartup()\n");
+    return 1;
+  }
+
+  //----------------------
+  // Create a SOCKET for listening for
+  // incoming connection requests.
+  SOCKET ListenSocket;
+  ListenSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+  if (ListenSocket == INVALID_SOCKET) {
+    printf("Error at socket(): %ld\n", WSAGetLastError());
+    WSACleanup();
+    return 1;
+  }
+  printf("socket returned %d\n", ListenSocket);
+
+  //----------------------
+  // The sockaddr_in structure specifies the address family,
+  // IP address, and port for the socket that is being bound.
+  sockaddr_in service;
+  service.sin_family = AF_INET;
+  service.sin_addr.s_addr = inet_addr("127.0.0.1");
+  service.sin_port = htons(4444);
+
+  if (bind( ListenSocket,
+    (SOCKADDR*) &service,
+    sizeof(service)) == SOCKET_ERROR) {
+    printf("bind() failed.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+  //----------------------
+  // Listen for incoming connection requests.
+  // on the created socket
+  if (listen( ListenSocket, 1 ) == SOCKET_ERROR) {
+    printf("Error listening on socket.\n");
+    closesocket(ListenSocket);
+    WSACleanup();
+    return 1;
+  }
+
+
+  printf("sock and osf handle are %d %d, error is \n", ListenSocket, _get_osfhandle (ListenSocket)); // -1 is invalid file handle: http://msdn.microsoft.com/en-us/library/ks2530z6.aspx
+  printf("err was %d\n",  WSAGetLastError());
+  //----------------------
+  return ListenSocket;
+   }
+
+
+   int
+   main (void)
+   {
+     struct ev_loop *loopy = ev_default_loop(0);
+     int fd = get_server_fd();
+     int fd_real =  _open_osfhandle(fd, NULL);
+     int conv = _get_osfhandle(fd_real);
+     printf("got server fd %d, loop %d, fd_real %d, that converted %d\n", fd, loopy, fd_real, conv);
+    // accept(fd, NULL, NULL);
+     // initialise an io watcher, then start it
+     // this one will watch for stdin to become readable
+     ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ conv, EV_READ);
+     ev_io_start (loopy, &stdin_watcher);
+
+     // initialise a timer watcher, then start it
+     // simple non-repeating 5.5 second timeout
+     //ev_timer_init (&timeout_watcher, timeout_cb, 15.5, 0.);
+     //ev_timer_start (loopy, &timeout_watcher);
+    printf("starting loop\n");
+     // now wait for events to arrive
+     ev_loop (loopy, 0);
+
+     // unloop was called, so exit
+     return 0;
+   }

data/ext/nio4r/extconf.rb

@@ -0,0 +1,44 @@
+require 'mkmf'
+
+if have_func('rb_thread_blocking_region')
+  $defs << '-DHAVE_RB_THREAD_BLOCKING_REGION'
+end
+
+if have_header('sys/select.h')
+  $defs << '-DEV_USE_SELECT'
+end
+
+if have_header('poll.h')
+  $defs << '-DEV_USE_POLL'
+end
+
+if have_header('sys/epoll.h')
+  $defs << '-DEV_USE_EPOLL'
+end
+
+if have_header('sys/event.h') and have_header('sys/queue.h')
+  $defs << '-DEV_USE_KQUEUE'
+end
+
+if have_header('port.h')
+  $defs << '-DEV_USE_PORT'
+end
+
+if have_header('sys/resource.h')
+  $defs << '-DHAVE_SYS_RESOURCE_H'
+end
+
+dir_config 'nio4r_ext'
+create_makefile 'nio4r_ext'
+
+# win32 needs to link in "just the right order" for some reason or ioctlsocket will be mapped to an [inverted] ruby specific version.
+# See libev mailing list for (not so helpful discussion--true cause I'm not sure, but this overcomes the symptom)
+if RUBY_PLATFORM =~ /mingw|win32/
+  makefile_contents = File.read 'Makefile'
+
+  # "Init_cool could not be found" when loading cool.io.so.
+  makefile_contents.gsub! 'DLDFLAGS = ', 'DLDFLAGS = -export-all '
+
+  makefile_contents.gsub! 'LIBS = $(LIBRUBYARG_SHARED)', 'LIBS = -lws2_32 $(LIBRUBYARG_SHARED)'
+  File.open('Makefile', 'w') { |f| f.write makefile_contents }
+end

data/ext/nio4r/libev.h

@@ -0,0 +1,8 @@
+#define EV_STANDALONE /* keeps ev from requiring config.h */
+
+#ifdef _WIN32
+#define EV_SELECT_IS_WINSOCKET 1
+#define FD_SETSIZE 512
+#endif
+
+#include "../libev/ev.h"

data/ext/nio4r/monitor.c

@@ -0,0 +1,164 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#include "nio4r.h"
+#include <assert.h>
+
+static VALUE mNIO = Qnil;
+static VALUE cNIO_Monitor = Qnil;
+
+/* Allocator/deallocator */
+static VALUE NIO_Monitor_allocate(VALUE klass);
+static void NIO_Monitor_mark(struct NIO_Monitor *monitor);
+static void NIO_Monitor_free(struct NIO_Monitor *monitor);
+
+/* Methods */
+static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector, VALUE io, VALUE interests);
+static VALUE NIO_Monitor_close(VALUE self);
+static VALUE NIO_Monitor_is_closed(VALUE self);
+static VALUE NIO_Monitor_io(VALUE self);
+static VALUE NIO_Monitor_interests(VALUE self);
+static VALUE NIO_Monitor_value(VALUE self);
+static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj);
+
+/* Internal functions */
+static void NIO_Monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
+
+#if HAVE_RB_IO_T
+  rb_io_t *fptr;
+#else
+  OpenFile *fptr;
+#endif
+
+/* Monitor control how a channel is being waited for by a monitor */
+void Init_NIO_Monitor()
+{
+    mNIO = rb_define_module("NIO");
+    cNIO_Monitor = rb_define_class_under(mNIO, "Monitor", rb_cObject);
+    rb_define_alloc_func(cNIO_Monitor, NIO_Monitor_allocate);
+
+    rb_define_method(cNIO_Monitor, "initialize", NIO_Monitor_initialize, 3);
+    rb_define_method(cNIO_Monitor, "close", NIO_Monitor_close, 0);
+    rb_define_method(cNIO_Monitor, "closed?", NIO_Monitor_is_closed, 0);
+    rb_define_method(cNIO_Monitor, "io", NIO_Monitor_io, 0);
+    rb_define_method(cNIO_Monitor, "interests", NIO_Monitor_interests, 0);
+    rb_define_method(cNIO_Monitor, "value", NIO_Monitor_value, 0);
+    rb_define_method(cNIO_Monitor, "value=", NIO_Monitor_set_value, 1);
+}
+
+static VALUE NIO_Monitor_allocate(VALUE klass)
+{
+    struct NIO_Monitor *monitor = (struct NIO_Monitor *)xmalloc(sizeof(struct NIO_Monitor));
+
+    return Data_Wrap_Struct(klass, NIO_Monitor_mark, NIO_Monitor_free, monitor);
+}
+
+static void NIO_Monitor_mark(struct NIO_Monitor *monitor)
+{
+}
+
+static void NIO_Monitor_free(struct NIO_Monitor *monitor)
+{
+    xfree(monitor);
+}
+
+static VALUE NIO_Monitor_initialize(VALUE self, VALUE selector_obj, VALUE io, VALUE interests)
+{
+    struct NIO_Monitor *monitor;
+    struct NIO_Selector *selector;
+    int events;
+    ID interests_id;
+
+    #if HAVE_RB_IO_T
+        rb_io_t *fptr;
+    #else
+        OpenFile *fptr;
+    #endif
+
+    interests_id = SYM2ID(interests);
+
+    if(interests_id == rb_intern("r")) {
+        events = EV_READ;
+    } else if(interests_id == rb_intern("w")) {
+        events = EV_WRITE;
+    } else if(interests_id == rb_intern("rw")) {
+        events = EV_READ | EV_WRITE;
+    } else {
+        rb_raise(rb_eArgError, "invalid event type %s (must be :r, :w, or :rw)",
+            RSTRING_PTR(rb_funcall(interests, rb_intern("inspect"), 0, 0)));
+    }
+
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+    ev_io_init(&monitor->ev_io, NIO_Monitor_callback, FPTR_TO_FD(fptr), events);
+
+    rb_ivar_set(self, rb_intern("selector"), selector_obj);
+    rb_ivar_set(self, rb_intern("io"), io);
+    rb_ivar_set(self, rb_intern("interests"), interests);
+
+    Data_Get_Struct(selector_obj, struct NIO_Selector, selector);
+
+    monitor->self = self;
+    monitor->ev_io.data = (void *)monitor;
+
+    /* We can safely hang onto this as we also hang onto a reference to the
+       object where it originally came from */
+    monitor->selector = selector;
+
+    ev_io_start(selector->ev_loop, &monitor->ev_io);
+
+    return Qnil;
+}
+
+static VALUE NIO_Monitor_close(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    if(monitor->selector) {
+        ev_io_stop(monitor->selector->ev_loop, &monitor->ev_io);
+        monitor->selector = 0;
+    }
+
+    return Qnil;
+}
+
+static VALUE NIO_Monitor_is_closed(VALUE self)
+{
+    struct NIO_Monitor *monitor;
+    Data_Get_Struct(self, struct NIO_Monitor, monitor);
+
+    return !monitor->selector;
+}
+
+static VALUE NIO_Monitor_io(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("io"));
+}
+
+static VALUE NIO_Monitor_interests(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("interests"));
+}
+
+static VALUE NIO_Monitor_value(VALUE self)
+{
+    return rb_ivar_get(self, rb_intern("value"));
+}
+
+static VALUE NIO_Monitor_set_value(VALUE self, VALUE obj)
+{
+    return rb_ivar_set(self, rb_intern("value"), obj);
+}
+
+/* libev callback fired whenever this monitor gets events */
+static void NIO_Monitor_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
+{
+    struct NIO_Monitor *monitor = (struct NIO_Monitor *)io->data;
+
+    assert(monitor->selector != 0);
+    NIO_Selector_handle_event(monitor->selector, monitor->self, revents);
+}

data/ext/nio4r/nio4r.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#ifndef NIO4R_H
+#define NIO4R_H
+
+#include "ruby.h"
+#include "rubyio.h"
+#include "libev.h"
+
+struct NIO_Selector
+{
+    struct ev_loop *ev_loop;
+    struct ev_timer timer; /* for timeouts */
+    struct ev_async wakeup;
+
+    int closed, selecting;
+    int ready_count;
+    int ready_buffer_size;
+    VALUE *ready_buffer;
+};
+
+struct NIO_callback_data
+{
+    VALUE *monitor;
+    struct NIO_Selector *selector;
+};
+
+struct NIO_Monitor
+{
+    VALUE self;
+    struct ev_io ev_io;
+    struct NIO_Selector *selector;
+};
+
+#ifdef GetReadFile
+# define FPTR_TO_FD(fptr) (fileno(GetReadFile(fptr)))
+#else
+
+#if !HAVE_RB_IO_T || (RUBY_VERSION_MAJOR == 1 && RUBY_VERSION_MINOR == 8)
+# define FPTR_TO_FD(fptr) fileno(fptr->f)
+#else
+# define FPTR_TO_FD(fptr) fptr->fd
+#endif /* !HAVE_RB_IO_T */
+
+#endif /* GetReadFile */
+
+/* Thunk between libev callbacks in NIO::Monitors and NIO::Selectors */
+void NIO_Selector_handle_event(struct NIO_Selector *selector, VALUE monitor, int revents);
+
+#endif /* NIO4R_H */

data/ext/nio4r/selector.c

@@ -0,0 +1,370 @@
+/*
+ * Copyright (c) 2011 Tony Arcieri. Distributed under the MIT License. See
+ * LICENSE.txt for further details.
+ */
+
+#include "nio4r.h"
+#include "rubysig.h"
+
+static VALUE mNIO = Qnil;
+static VALUE cNIO_Channel  = 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_shutdown(struct NIO_Selector *selector);
+static void NIO_Selector_free(struct NIO_Selector *loop);
+
+/* Methods */
+static VALUE NIO_Selector_initialize(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_wakeup(VALUE self);
+static VALUE NIO_Selector_close(VALUE self);
+static VALUE NIO_Selector_closed(VALUE self);
+
+/* Internal functions */
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args);
+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_run_evloop(void *ptr);
+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);
+
+/* Default number of slots in the buffer for selected monitors */
+#define INITIAL_READY_BUFFER 32
+
+/* Ruby 1.8 needs us to busy wait and run the green threads scheduler every 10ms */
+#define BUSYWAIT_INTERVAL 0.01
+
+/* Selectors wait for events */
+void Init_NIO_Selector()
+{
+    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_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, "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);
+}
+
+/* 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));
+
+    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;
+
+    ev_async_start(selector->ev_loop, &selector->wakeup);
+
+    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);
+
+    return Data_Wrap_Struct(klass, NIO_Selector_mark, NIO_Selector_free, selector);
+}
+
+/* NIO selectors store all Ruby objects in instance variables so mark is a stub */
+static void NIO_Selector_mark(struct NIO_Selector *selector)
+{
+}
+
+/* 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;
+    }
+
+    selector->closed = 1;
+}
+
+/* Ruby finalizer for selector objects */
+static void NIO_Selector_free(struct NIO_Selector *selector)
+{
+    NIO_Selector_shutdown(selector);
+
+    xfree(selector->ready_buffer);
+    xfree(selector);
+}
+
+/* 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)
+{
+    VALUE lock;
+
+    rb_ivar_set(self, rb_intern("selectables"), rb_hash_new());
+
+    lock = rb_class_new_instance(0, 0, rb_const_get(rb_cObject, rb_intern("Mutex")));
+    rb_ivar_set(self, rb_intern("lock"), lock);
+
+    return Qnil;
+}
+
+/* Synchronize the given function with the selector mutex */
+static VALUE NIO_Selector_synchronize(VALUE self, VALUE (*func)(VALUE *args), VALUE *args)
+{
+    VALUE lock;
+
+    lock = rb_ivar_get(self, rb_intern("lock"));
+    rb_funcall(lock, rb_intern("lock"), 0, 0);
+    return rb_ensure(func, (VALUE)args, NIO_Selector_unlock, lock);
+}
+
+/* Unlock the selector mutex */
+static VALUE NIO_Selector_unlock(VALUE lock)
+{
+    rb_funcall(lock, rb_intern("unlock"), 0, 0);
+}
+
+/* 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);
+}
+
+/* Internal implementation of register after acquiring mutex */
+static VALUE NIO_Selector_register_synchronized(VALUE *args)
+{
+    VALUE self, io, interests, selectables, monitor;
+    VALUE monitor_args[3];
+
+    self = args[0];
+    io = args[1];
+    interests = args[2];
+
+    selectables = rb_ivar_get(self, rb_intern("selectables"));
+    monitor = rb_hash_lookup(selectables, io);
+
+    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 = rb_class_new_instance(3, monitor_args, cNIO_Monitor);
+    rb_hash_aset(selectables, io, monitor);
+
+    return monitor;
+}
+
+/* Deregister an IO object from the selector */
+static VALUE NIO_Selector_deregister(VALUE self, VALUE io)
+{
+    VALUE args[2] = {self, io};
+    return NIO_Selector_synchronize(self, NIO_Selector_deregister_synchronized, args);
+}
+
+/* Internal implementation of register after acquiring mutex */
+static VALUE NIO_Selector_deregister_synchronized(VALUE *args)
+{
+    VALUE self, io, interests, selectables, monitor;
+    VALUE monitor_args[3];
+
+    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);
+    }
+
+    return monitor;
+}
+
+/* Is the given IO object registered with the selector */
+static VALUE NIO_Selector_is_registered(VALUE self, VALUE io)
+{
+    VALUE selectables = rb_ivar_get(self, rb_intern("selectables"));
+
+    /* Perhaps this should be holding the mutex? */
+    return rb_funcall(selectables, rb_intern("has_key?"), 1, io);
+}
+
+/* Select from all registered IO objects */
+static VALUE NIO_Selector_select(int argc, VALUE *argv, VALUE self)
+{
+    VALUE timeout, array;
+    VALUE args[2];
+
+    rb_scan_args(argc, argv, "01", &timeout);
+
+    args[0] = self;
+    args[1] = timeout;
+
+    return NIO_Selector_synchronize(self, NIO_Selector_select_synchronized, args);
+}
+
+/* Internal implementation of select with the selector lock held */
+static VALUE NIO_Selector_select_synchronized(VALUE *args)
+{
+    VALUE self, timeout, result;
+    struct NIO_Selector *selector;
+
+    self = args[0];
+    timeout = args[1];
+
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+    selector->selecting = 1;
+
+#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 {
+        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;
+        }
+
+        ev_timer_stop(selector->ev_loop, &selector->timer);
+    }
+#endif /* defined(HAVE_RB_THREAD_BLOCKING_REGION) */
+
+    if(!selector->ready_count) {
+        return Qnil;
+    }
+
+    result = rb_ary_new4(selector->ready_count, selector->ready_buffer);
+    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;
+}
+
+/* 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);
+
+    ev_async_send(selector->ev_loop, &selector->wakeup);
+
+    return Qnil;
+}
+
+/* Close the selector and free system resources */
+static VALUE NIO_Selector_close(VALUE self)
+{
+    struct NIO_Selector *selector;
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    NIO_Selector_shutdown(selector);
+
+    return Qnil;
+}
+
+/* Is the selector closed? */
+static VALUE NIO_Selector_closed(VALUE self)
+{
+    struct NIO_Selector *selector;
+    Data_Get_Struct(self, struct NIO_Selector, selector);
+
+    return selector->closed ? 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)
+{
+    struct NIO_Selector *selector = (struct NIO_Selector *)async->data;
+    selector->selecting = 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)
+{
+    /* 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);
+    }
+
+    selector->ready_buffer[selector->ready_count] = monitor;
+    selector->ready_count++;
+}