cool.io 0.9.0

data/ext/cool.io/.gitignore

@@ -0,0 +1,5 @@
+Makefile
+mkmf.log
+*.o
+*.so
+*.bundle

data/ext/cool.io/cool.io.h

@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#ifndef COOLIO_H
+#define COOLIO_H
+
+#include "ruby.h"
+#include "rubyio.h"
+
+#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
+
+#endif
+
+struct Coolio_Event
+{
+  /* These values are used to extract events from libev callbacks */
+  VALUE watcher;
+  int revents;
+};
+
+struct Coolio_Loop 
+{
+  struct ev_loop *ev_loop;
+
+  int running;
+  int events_received;
+  int eventbuf_size;
+  struct Coolio_Event *eventbuf;
+};
+
+struct Coolio_Watcher
+{
+  union {
+    struct ev_io ev_io;
+    struct ev_timer ev_timer;
+    struct ev_stat ev_stat;
+  } event_types;
+
+  int enabled;
+  VALUE loop;
+
+  void (*dispatch_callback)(VALUE self, int revents);
+};
+
+void Coolio_Loop_process_event(VALUE watcher, int revents);
+
+#endif

data/ext/cool.io/cool.io_ext.c

@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+
+#include "ruby.h"
+
+#include "ev_wrap.h"
+#include "cool.io.h"
+
+static VALUE mCoolio = Qnil;
+
+/* Initialize the coolness */
+void Init_cool() 
+{
+  /* Initializers for other modules */
+  Init_coolio_loop();
+  Init_coolio_watcher();
+  Init_coolio_iowatcher();
+  Init_coolio_timer_watcher();
+  Init_coolio_stat_watcher();
+  Init_coolio_utils();
+}

data/ext/cool.io/ev_wrap.h

@@ -0,0 +1,8 @@
+#define EV_STANDALONE              /* keeps ev from requiring config.h */
+#ifdef _WIN32
+# define EV_SELECT_IS_WINSOCKET 1   /* configure libev for windows select */
+# define FD_SETSIZE 2048 /* wishful thinking, as msvcrt6 [?] seems to only allow 512 fd's and 256 sockets max */
+#endif
+
+#include "../libev/ev.h"
+

data/ext/cool.io/extconf.rb

@@ -0,0 +1,69 @@
+require 'mkmf'
+
+libs = []
+
+$defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
+
+if have_func('rb_thread_blocking_region')
+  $defs << '-DHAVE_RB_THREAD_BLOCKING_REGION'
+end
+
+if have_func('rb_thread_alone')
+  $defs << '-DHAVE_RB_THREAD_ALONE'
+end
+
+if have_func('rb_str_set_len')
+  $defs << '-DHAVE_RB_STR_SET_LEN'
+end
+
+if have_library('rt', 'clock_gettime')
+  libs << "-lrt"
+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
+
+# ncpu detection specifics
+case RUBY_PLATFORM
+when /linux/
+  $defs << '-DHAVE_LINUX_PROCFS'
+else
+  if have_func('sysctlbyname', ['sys/param.h', 'sys/sysctl.h'])
+    $defs << '-DHAVE_SYSCTLBYNAME'
+  end
+end
+
+$LIBS << ' ' << libs.join(' ')
+
+dir_config('cool.io_ext')
+create_makefile('cool.io_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'
+
+  makefile_contents.gsub! 'LIBS = $(LIBRUBYARG_SHARED)', 'LIBS = -lws2_32 $(LIBRUBYARG_SHARED)'
+  File.open('Makefile', 'w') { |f| f.write makefile_contents }
+end
+

data/ext/cool.io/iowatcher.c

@@ -0,0 +1,189 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ruby.h"
+#include "rubyio.h"
+
+#include "ev_wrap.h"
+
+#include "cool.io.h"
+#include "watcher.h"
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Watcher = Qnil;
+static VALUE cCoolio_Loop = Qnil;
+static VALUE cCoolio_IOWatcher = Qnil;
+
+static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self);
+static VALUE Coolio_IOWatcher_attach(VALUE self, VALUE loop);
+static VALUE Coolio_IOWatcher_detach(VALUE self);
+static VALUE Coolio_IOWatcher_enable(VALUE self);
+static VALUE Coolio_IOWatcher_disable(VALUE self);
+static VALUE Coolio_IOWatcher_on_readable(VALUE self);
+static VALUE Coolio_IOWatcher_on_writable(VALUE self);
+
+static void Coolio_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents);
+static void Coolio_IOWatcher_dispatch_callback(VALUE self, int revents);
+
+/*
+ * Coolio::IOWatcher monitors Ruby IO objects for readability or writability.
+ * This allows your application to block while the kernel is writing out
+ * data and fill the read or write buffer whenever there is space available.
+ */
+void Init_coolio_iowatcher()
+{
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Watcher = rb_define_class_under(mCoolio, "Watcher", rb_cObject);
+  cCoolio_IOWatcher = rb_define_class_under(mCoolio, "IOWatcher", cCoolio_Watcher);
+  cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
+
+  rb_define_method(cCoolio_IOWatcher, "initialize", Coolio_IOWatcher_initialize, -1);
+  rb_define_method(cCoolio_IOWatcher, "attach", Coolio_IOWatcher_attach, 1);
+  rb_define_method(cCoolio_IOWatcher, "detach", Coolio_IOWatcher_detach, 0);
+  rb_define_method(cCoolio_IOWatcher, "enable", Coolio_IOWatcher_enable, 0);
+  rb_define_method(cCoolio_IOWatcher, "disable", Coolio_IOWatcher_disable, 0);
+  rb_define_method(cCoolio_IOWatcher, "on_readable", Coolio_IOWatcher_on_readable, 0);
+  rb_define_method(cCoolio_IOWatcher, "on_writable", Coolio_IOWatcher_on_writable, 0);
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.initialize(IO, events = 'r') -> Coolio::IOWatcher
+ * 
+ * Create a new Coolio::IOWatcher for the given IO object and add it to the given Coolio::Loop
+ */
+static VALUE Coolio_IOWatcher_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE io, flags;
+  char *flags_str;
+  int events;
+  struct Coolio_Watcher *watcher_data;
+#if HAVE_RB_IO_T
+  rb_io_t *fptr;
+#else
+  OpenFile *fptr;
+#endif
+
+  rb_scan_args(argc, argv, "11", &io, &flags);
+
+  if(flags != Qnil)
+    flags_str = RSTRING_PTR(rb_String(flags));
+  else
+    flags_str = "r";
+
+  if(!strcmp(flags_str, "r"))
+    events = EV_READ;
+  else if(!strcmp(flags_str, "w"))
+    events = EV_WRITE;
+  else if(!strcmp(flags_str, "rw"))
+    events = EV_READ | EV_WRITE;
+  else
+    rb_raise(rb_eArgError, "invalid event type: '%s' (must be 'r', 'w', or 'rw')", flags_str);
+
+  Data_Get_Struct(self, struct Coolio_Watcher, watcher_data);
+  GetOpenFile(rb_convert_type(io, T_FILE, "IO", "to_io"), fptr);
+
+  watcher_data->dispatch_callback = Coolio_IOWatcher_dispatch_callback;
+  ev_io_init(&watcher_data->event_types.ev_io, Coolio_IOWatcher_libev_callback, FPTR_TO_FD(fptr), events);
+  watcher_data->event_types.ev_io.data = (void *)self;
+
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.attach(loop) -> Coolio::IOWatcher
+ * 
+ * Attach the IO watcher to the given Coolio::Loop.  If the watcher is already attached
+ * to a loop, detach it from the old one and attach it to the new one.
+ */
+static VALUE Coolio_IOWatcher_attach(VALUE self, VALUE loop)
+{
+  Watcher_Attach(io, Coolio_IOWatcher_detach, self, loop);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.detach -> Coolio::IOWatcher
+ * 
+ * Detach the IO watcher from its current Coolio::Loop.
+ */
+static VALUE Coolio_IOWatcher_detach(VALUE self)
+{
+  Watcher_Detach(io, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.enable -> Coolio::IOWatcher
+ * 
+ * Re-enable an IO watcher which has been temporarily disabled.  See the
+ * disable method for a more thorough explanation.
+ */
+static VALUE Coolio_IOWatcher_enable(VALUE self)
+{
+  Watcher_Enable(io, self);
+
+  return self;  
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher.disable -> Coolio::IOWatcher
+ * 
+ * Temporarily disable an IO watcher which is attached to a loop.  
+ * This is useful if you wish to toggle event monitoring on and off.  
+ */
+static VALUE Coolio_IOWatcher_disable(VALUE self)
+{
+  Watcher_Disable(io, self);
+
+  return self;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher#on_readable -> nil
+ * 
+ * Called whenever the IO object associated with the IOWatcher is readable
+ */
+static VALUE Coolio_IOWatcher_on_readable(VALUE self)
+{
+  return Qnil;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::IOWatcher#on_writable -> nil
+ * 
+ * Called whenever the IO object associated with the IOWatcher is writable
+ */
+
+static VALUE Coolio_IOWatcher_on_writable(VALUE self)
+{
+  return Qnil;
+}
+
+/* libev callback */
+static void Coolio_IOWatcher_libev_callback(struct ev_loop *ev_loop, struct ev_io *io, int revents)
+{
+  Coolio_Loop_process_event((VALUE)io->data, revents);
+}
+
+/* Coolio::Loop dispatch callback */
+static void Coolio_IOWatcher_dispatch_callback(VALUE self, int revents)
+{   
+  if(revents & EV_READ)
+    rb_funcall(self, rb_intern("on_readable"), 0, 0);
+  else if(revents & EV_WRITE)
+    rb_funcall(self, rb_intern("on_writable"), 0, 0);
+  else
+    rb_raise(rb_eRuntimeError, "unknown revents value for ev_io: %d", revents);
+}

data/ext/cool.io/libev.c

@@ -0,0 +1,8 @@
+/*
+ * Copyright (C) 2007 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include "ev_wrap.h"
+#include "../libev/ev.c"

data/ext/cool.io/loop.c

@@ -0,0 +1,303 @@
+/*
+ * Copyright (C) 2007-10 Tony Arcieri
+ * You may redistribute this under the terms of the Ruby license.
+ * See LICENSE for details
+ */
+
+#include <assert.h>
+#include "ruby.h"
+#include "rubysig.h"
+#include "ev_wrap.h"
+
+#include "cool.io.h"
+
+#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
+#  define Coolio_Loop_may_block_safely() (1)
+#elif defined(HAVE_RB_THREAD_ALONE)
+#  define Coolio_Loop_may_block_safely() (rb_thread_alone())
+#else /* just in case Ruby changes: */
+#  define Coolio_Loop_may_block_safely() (0)
+#endif
+
+static VALUE mCoolio = Qnil;
+static VALUE cCoolio_Loop = Qnil;
+
+static VALUE Coolio_Loop_allocate(VALUE klass);
+static void Coolio_Loop_mark(struct Coolio_Loop *loop);
+static void Coolio_Loop_free(struct Coolio_Loop *loop);
+
+static VALUE Coolio_Loop_initialize(VALUE self);
+static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags);
+static VALUE Coolio_Loop_run_once(VALUE self);
+static VALUE Coolio_Loop_run_nonblock(VALUE self);
+
+static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data);
+static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data);
+
+#define DEFAULT_EVENTBUF_SIZE 32
+#define RUN_LOOP(loop_data, options) \
+  loop_data->running = 1; \
+  ev_loop(loop_data->ev_loop, options); \
+  loop_data->running = 0;
+
+/* 
+ * Coolio::Loop represents an event loop.  Event watchers can be attached and
+ * unattached.  When an event loop is run, all currently attached watchers
+ * are monitored for events, and their respective callbacks are signaled
+ * whenever events occur.
+ */
+void Init_coolio_loop()
+{
+  mCoolio = rb_define_module("Coolio");
+  cCoolio_Loop = rb_define_class_under(mCoolio, "Loop", rb_cObject);
+  rb_define_alloc_func(cCoolio_Loop, Coolio_Loop_allocate);
+ 
+  rb_define_method(cCoolio_Loop, "initialize", Coolio_Loop_initialize, 0);
+  rb_define_private_method(cCoolio_Loop, "ev_loop_new", Coolio_Loop_ev_loop_new, 1);
+  rb_define_method(cCoolio_Loop, "run_once", Coolio_Loop_run_once, 0);
+  rb_define_method(cCoolio_Loop, "run_nonblock", Coolio_Loop_run_nonblock, 0);
+}
+
+static VALUE Coolio_Loop_allocate(VALUE klass)
+{
+  struct Coolio_Loop *loop = (struct Coolio_Loop *)xmalloc(sizeof(struct Coolio_Loop));
+
+  loop->ev_loop = 0;
+  loop->running = 0;
+  loop->events_received = 0;
+  loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE;
+  loop->eventbuf = (struct Coolio_Event *)xmalloc(sizeof(struct Coolio_Event) * DEFAULT_EVENTBUF_SIZE);
+
+  return Data_Wrap_Struct(klass, Coolio_Loop_mark, Coolio_Loop_free, loop);
+}
+
+static void Coolio_Loop_mark(struct Coolio_Loop *loop)
+{
+}
+
+static void Coolio_Loop_free(struct Coolio_Loop *loop)
+{
+  if(!loop->ev_loop)
+    return;
+
+  ev_loop_destroy(loop->ev_loop);
+
+  xfree(loop->eventbuf);
+  xfree(loop);
+}
+
+static VALUE Coolio_Loop_initialize(VALUE self)
+{
+  Coolio_Loop_ev_loop_new(self, INT2NUM(0));
+}
+
+/* Wrapper for populating a Coolio_Loop struct with a new event loop */
+static VALUE Coolio_Loop_ev_loop_new(VALUE self, VALUE flags)
+{
+  struct Coolio_Loop *loop_data;
+  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+
+  if(loop_data->ev_loop)
+    rb_raise(rb_eRuntimeError, "loop already initialized");
+
+  loop_data->ev_loop = ev_loop_new(NUM2INT(flags));
+
+  return Qnil;
+}
+
+/* libev callback for receiving events */
+void Coolio_Loop_process_event(VALUE watcher, int revents)
+{
+  struct Coolio_Loop *loop_data;
+  struct Coolio_Watcher *watcher_data;
+
+  /* The Global VM lock isn't held right now, but hopefully
+   * we can still do this safely */
+  Data_Get_Struct(watcher, struct Coolio_Watcher, watcher_data);
+  Data_Get_Struct(watcher_data->loop, struct Coolio_Loop, loop_data);
+
+  /*  Well, what better place to explain how this all works than
+   *  where the most wonky and convoluted stuff is going on!
+   *
+   *  Our call path up to here looks a little something like:
+   *
+   *  -> release GVL -> event syscall -> libev callback
+   *  (GVL = Global VM Lock)             ^^^ You are here
+   *
+   *  We released the GVL in the Coolio_Loop_run_once() function
+   *  so other Ruby threads can run while we make a blocking 
+   *  system call (one of epoll, kqueue, port, poll, or select,
+   *  depending on the platform).
+   *
+   *  More specifically, this is a libev callback abstraction
+   *  called from a real libev callback in every watcher,
+   *  hence this function not being static.  The real libev
+   *  callbacks are event-specific and handled in a watcher.
+   *
+   *  For syscalls like epoll and kqueue, the kernel tells libev
+   *  a pointer (to a structure with a pointer) to the watcher 
+   *  object.  No data structure lookups are required at all
+   *  (beyond structs), it's smooth O(1) sailing the entire way.  
+   *  Then libev calls out to the watcher's callback, which
+   *  calls this function.
+   *
+   *  Now, you may be curious: if the watcher already knew what
+   *  event fired, why the hell is it telling the loop?  Why
+   *  doesn't it just rb_funcall() the appropriate callback?
+   *
+   *  Well, the problem is the Global VM Lock isn't held right
+   *  now, so we can't rb_funcall() anything.  In order to get
+   *  it back we have to:
+   *
+   *  stash event and return -> acquire GVL -> dispatch to Ruby
+   *
+   *  Which is kinda ugly and confusing, but still gives us 
+   *  an O(1) event loop whose heart is in the kernel itself. w00t!
+   *
+   *  So, stash the event in the loop's data struct.  When we return
+   *  the ev_loop() call being made in the Coolio_Loop_run_once_blocking()
+   *  function below will also return, at which point the GVL is
+   *  reacquired and we can call out to Ruby */
+
+  /* Grow the event buffer if it's too small */
+  if(loop_data->events_received >= loop_data->eventbuf_size) {
+    loop_data->eventbuf_size *= 2;
+    loop_data->eventbuf = (struct Coolio_Event *)xrealloc(
+        loop_data->eventbuf, 
+        sizeof(struct Coolio_Event) * loop_data->eventbuf_size
+        );
+  }
+
+  loop_data->eventbuf[loop_data->events_received].watcher = watcher;
+  loop_data->eventbuf[loop_data->events_received].revents = revents;
+
+  loop_data->events_received++;
+}
+
+/**
+ *  call-seq:
+ *    Coolio::Loop.run_once -> nil
+ * 
+ * Run the Coolio::Loop once, blocking until events are received.
+ */
+static VALUE Coolio_Loop_run_once(VALUE self)
+{
+  VALUE nevents;
+
+  if (Coolio_Loop_may_block_safely()) {
+    struct Coolio_Loop *loop_data;
+
+    Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+
+    assert(loop_data->ev_loop && !loop_data->events_received);
+
+    Coolio_Loop_ev_loop_oneshot(loop_data);
+    Coolio_Loop_dispatch_events(loop_data);
+
+    nevents = INT2NUM(loop_data->events_received);
+    loop_data->events_received = 0;
+
+  } else {
+    nevents = Coolio_Loop_run_nonblock(self);
+    rb_thread_schedule();
+  }
+
+  return nevents;
+}
+
+/* Ruby 1.9 supports blocking system calls through rb_thread_blocking_region() */
+#ifdef HAVE_RB_THREAD_BLOCKING_REGION
+#define HAVE_EV_LOOP_ONESHOT
+static VALUE Coolio_Loop_ev_loop_oneshot_blocking(void *ptr) 
+{
+  /* The libev loop has now escaped through the Global VM Lock unscathed! */
+  struct Coolio_Loop *loop_data = (struct Coolio_Loop *)ptr;
+
+  RUN_LOOP(loop_data, EVLOOP_ONESHOT);
+  
+  return Qnil;
+}
+
+static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
+{
+  /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
+  rb_thread_blocking_region(Coolio_Loop_ev_loop_oneshot_blocking, loop_data, RUBY_UBF_IO, 0);
+}
+#endif
+
+/* Ruby 1.8 requires us to periodically run the event loop then defer back to
+ * the green threads scheduler */
+#ifndef HAVE_EV_LOOP_ONESHOT
+#define BLOCKING_INTERVAL 0.01 /* Block for 10ms at a time */
+
+/* Stub for scheduler's ev_timer callback */
+static void timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
+{
+   ev_timer_again (ev_loop, timer);
+}
+
+/* Run the event loop, calling rb_thread_schedule every 10ms */
+static void Coolio_Loop_ev_loop_oneshot(struct Coolio_Loop *loop_data)
+{
+  struct ev_timer timer;
+  struct timeval tv;
+
+  /* Set up an ev_timer to unblock the loop every 10ms */
+  ev_timer_init(&timer, timer_callback, BLOCKING_INTERVAL, BLOCKING_INTERVAL);
+  ev_timer_start(loop_data->ev_loop, &timer);
+
+  /* Loop until we receive events */
+  while(!loop_data->events_received) {
+    TRAP_BEG;
+    RUN_LOOP(loop_data, EVLOOP_ONESHOT);
+    TRAP_END;
+
+    rb_thread_schedule();
+  }
+
+  ev_timer_stop(loop_data->ev_loop, &timer);
+}
+#endif
+
+/**
+ *  call-seq:
+ *    Coolio::Loop.run_nonblock -> nil
+ * 
+ * Run the Coolio::Loop once, but return immediately if there are no pending events.
+ */
+static VALUE Coolio_Loop_run_nonblock(VALUE self)
+{
+  struct Coolio_Loop *loop_data;
+  VALUE nevents;
+  
+  Data_Get_Struct(self, struct Coolio_Loop, loop_data);
+
+  assert(loop_data->ev_loop && !loop_data->events_received);
+
+  TRAP_BEG;
+  RUN_LOOP(loop_data, EVLOOP_NONBLOCK);  
+  TRAP_END;
+  Coolio_Loop_dispatch_events(loop_data);
+  
+  nevents = INT2NUM(loop_data->events_received);
+  loop_data->events_received = 0;
+  
+  return nevents;
+}
+
+static void Coolio_Loop_dispatch_events(struct Coolio_Loop *loop_data)
+{
+  int i;
+  struct Coolio_Watcher *watcher_data;
+
+  for(i = 0; i < loop_data->events_received; i++) {
+    /* A watcher with pending events may have been detached from the loop
+     * during the dispatch process.  If so, the watcher clears the pending
+     * events, so skip over them */
+    if(loop_data->eventbuf[i].watcher == Qnil)
+      continue;
+
+    Data_Get_Struct(loop_data->eventbuf[i].watcher, struct Coolio_Watcher, watcher_data);
+    watcher_data->dispatch_callback(loop_data->eventbuf[i].watcher, loop_data->eventbuf[i].revents);
+  }
+}