rev 0.2.0 → 0.2.1

data/ext/libev/ev.h

@@ -1,7 +1,7 @@
 /*
  * libev native API header
  *
- * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -78,6 +78,15 @@ typedef double ev_tstamp;
 # define EV_EMBED_ENABLE 1
 #endif
 
+#ifndef EV_ASYNC_ENABLE
+# define EV_ASYNC_ENABLE 1
+#endif
+
+#ifndef EV_ATOMIC_T
+# include <signal.h>
+# define EV_ATOMIC_T sig_atomic_t volatile
+#endif
+
 /*****************************************************************************/
 
 #if EV_STAT_ENABLE
@@ -91,6 +100,8 @@ struct ev_loop;
 # define EV_P_ EV_P,
 # define EV_A loop
 # define EV_A_ EV_A,
+# define EV_DEFAULT_UC ev_default_loop_uc ()
+# define EV_DEFAULT_UC_ EV_DEFAULT_UC,
 # define EV_DEFAULT ev_default_loop (0)
 # define EV_DEFAULT_ EV_DEFAULT,
 #else
@@ -100,27 +111,37 @@ struct ev_loop;
 # define EV_A_
 # define EV_DEFAULT
 # define EV_DEFAULT_
-
+# define EV_DEFAULT_UC
+# define EV_DEFAULT_UC_
 # undef EV_EMBED_ENABLE
 #endif
 
+#if __STDC_VERSION__ >= 199901L || __GNUC__ >= 3
+# define EV_INLINE static inline
+#else
+# define EV_INLINE static
+#endif
+
+/*****************************************************************************/
+
 /* eventmask, revents, events... */
-#define EV_UNDEF            -1L /* guaranteed to be invalid */
-#define EV_NONE           0x00L /* no events */
-#define EV_READ           0x01L /* ev_io detected read will not block */
-#define EV_WRITE          0x02L /* ev_io detected write will not block */
-#define EV_IOFDSET        0x80L /* internal use only */
-#define EV_TIMEOUT  0x00000100L /* timer timed out */
-#define EV_PERIODIC 0x00000200L /* periodic timer timed out */
-#define EV_SIGNAL   0x00000400L /* signal was received */
-#define EV_CHILD    0x00000800L /* child/pid had status change */
-#define EV_STAT     0x00001000L /* stat data changed */
-#define EV_IDLE     0x00002000L /* event loop is idling */
-#define EV_PREPARE  0x00004000L /* event loop about to poll */
-#define EV_CHECK    0x00008000L /* event loop finished poll */
-#define EV_EMBED    0x00010000L /* embedded event loop needs sweep */
-#define EV_FORK     0x00020000L /* event loop resumed in child */
-#define EV_ERROR    0x80000000L /* sent when an error occurs */
+#define EV_UNDEF            -1 /* guaranteed to be invalid */
+#define EV_NONE           0x00 /* no events */
+#define EV_READ           0x01 /* ev_io detected read will not block */
+#define EV_WRITE          0x02 /* ev_io detected write will not block */
+#define EV_IOFDSET        0x80 /* internal use only */
+#define EV_TIMEOUT  0x00000100 /* timer timed out */
+#define EV_PERIODIC 0x00000200 /* periodic timer timed out */
+#define EV_SIGNAL   0x00000400 /* signal was received */
+#define EV_CHILD    0x00000800 /* child/pid had status change */
+#define EV_STAT     0x00001000 /* stat data changed */
+#define EV_IDLE     0x00002000 /* event loop is idling */
+#define EV_PREPARE  0x00004000 /* event loop about to poll */
+#define EV_CHECK    0x00008000 /* event loop finished poll */
+#define EV_EMBED    0x00010000 /* embedded event loop needs sweep */
+#define EV_FORK     0x00020000 /* event loop resumed in child */
+#define EV_ASYNC    0x00040000 /* async intra-loop signal */
+#define EV_ERROR    0x80000000 /* sent when an error occurs */
 
 /* can be used to add custom fields to all watchers, while losing binary compatibility */
 #ifndef EV_COMMON
@@ -307,6 +328,19 @@ typedef struct ev_embed
 } ev_embed;
 #endif
 
+#if EV_ASYNC_ENABLE
+/* invoked when somebody calls ev_async_send on the watcher */
+/* revent EV_ASYNC */
+typedef struct ev_async
+{
+  EV_WATCHER (ev_async)
+
+  EV_ATOMIC_T sent; /* private */
+} ev_async;
+
+# define ev_async_pending(w) ((w)->sent + 0)
+#endif
+
 /* the presence of this union forces similar struct layout */
 union ev_any_watcher
 {
@@ -332,21 +366,24 @@ union ev_any_watcher
 #if EV_EMBED_ENABLE
   struct ev_embed embed;
 #endif
+#if EV_ASYNC_ENABLE
+  struct ev_async async;
+#endif
 };
 
 /* bits for ev_default_loop and ev_loop_new */
 /* the default */
-#define EVFLAG_AUTO       0x00000000UL /* not quite a mask */
+#define EVFLAG_AUTO       0x00000000U /* not quite a mask */
 /* flag bits */
-#define EVFLAG_NOENV      0x01000000UL /* do NOT consult environment */
-#define EVFLAG_FORKCHECK  0x02000000UL /* check for a fork in each iteration */
+#define EVFLAG_NOENV      0x01000000U /* do NOT consult environment */
+#define EVFLAG_FORKCHECK  0x02000000U /* check for a fork in each iteration */
 /* method bits to be ored together */
-#define EVBACKEND_SELECT  0x00000001UL /* about anywhere */
-#define EVBACKEND_POLL    0x00000002UL /* !win */
-#define EVBACKEND_EPOLL   0x00000004UL /* linux */
-#define EVBACKEND_KQUEUE  0x00000008UL /* bsd */
-#define EVBACKEND_DEVPOLL 0x00000010UL /* solaris 8 */ /* NYI */
-#define EVBACKEND_PORT    0x00000020UL /* solaris 10 */
+#define EVBACKEND_SELECT  0x00000001U /* about anywhere */
+#define EVBACKEND_POLL    0x00000002U /* !win */
+#define EVBACKEND_EPOLL   0x00000004U /* linux */
+#define EVBACKEND_KQUEUE  0x00000008U /* bsd */
+#define EVBACKEND_DEVPOLL 0x00000010U /* solaris 8 */ /* NYI */
+#define EVBACKEND_PORT    0x00000020U /* solaris 10 */
 
 #if EV_PROTOTYPES
 int ev_version_major (void);
@@ -374,18 +411,29 @@ void ev_set_allocator (void *(*cb)(void *ptr, long size));
 void ev_set_syserr_cb (void (*cb)(const char *msg));
 
 # if EV_MULTIPLICITY
+EV_INLINE struct ev_loop *
+ev_default_loop_uc (void)
+{
+  extern struct ev_loop *ev_default_loop_ptr;
+
+  return ev_default_loop_ptr;
+}
+
 /* the default loop is the only one that handles signals and child watchers */
 /* you can call this as often as you like */
-static struct ev_loop *
+EV_INLINE struct ev_loop *
 ev_default_loop (unsigned int flags)
 {
-  extern struct ev_loop *ev_default_loop_ptr;
-  extern struct ev_loop *ev_default_loop_init (unsigned int flags);
+  struct ev_loop *loop = ev_default_loop_uc ();
 
-  if (!ev_default_loop_ptr)
-    ev_default_loop_init (flags);
+  if (!loop)
+    {
+      extern struct ev_loop *ev_default_loop_init (unsigned int flags);
 
-  return ev_default_loop_ptr;
+      loop = ev_default_loop_init (flags);
+    }
+
+  return loop;
 }
 
 /* create and destroy alternative loops that don't handle signals */
@@ -399,7 +447,7 @@ ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after
 
 int ev_default_loop (unsigned int flags); /* returns true when successful */
 
-static ev_tstamp
+EV_INLINE ev_tstamp
 ev_now (void)
 {
   extern ev_tstamp ev_rt_now;
@@ -408,6 +456,18 @@ ev_now (void)
 }
 # endif
 
+EV_INLINE int
+ev_is_default_loop (EV_P)
+{
+#if EV_MULTIPLICITY
+  extern struct ev_loop *ev_default_loop_ptr;
+
+  return !!(EV_A == ev_default_loop_ptr);
+#else
+  return 1;
+#endif
+}
+
 void ev_default_destroy (void); /* destroy the default loop */
 /* this needs to be called after fork, to duplicate the default loop */
 /* if you create alternative loops you have to call ev_loop_fork on them */
@@ -465,6 +525,7 @@ void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revent
 #define ev_check_set(ev)                    /* nop, yes, this is a serious in-joke */
 #define ev_embed_set(ev,other_)             do { (ev)->other = (other_); } while (0)
 #define ev_fork_set(ev)                     /* nop, yes, this is a serious in-joke */
+#define ev_async_set(ev)                    do { (ev)->sent = 0; } while (0)
 
 #define ev_io_init(ev,cb,fd,events)         do { ev_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
 #define ev_timer_init(ev,cb,after,repeat)   do { ev_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0)
@@ -477,6 +538,7 @@ void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revent
 #define ev_check_init(ev,cb)                do { ev_init ((ev), (cb)); ev_check_set ((ev)); } while (0)
 #define ev_embed_init(ev,cb,other)          do { ev_init ((ev), (cb)); ev_embed_set ((ev),(other)); } while (0)
 #define ev_fork_init(ev,cb)                 do { ev_init ((ev), (cb)); ev_fork_set ((ev)); } while (0)
+#define ev_async_init(ev,cb)                do { ev_init ((ev), (cb)); ev_async_set ((ev)); } while (0)
 
 #define ev_is_pending(ev)                   (0 + ((ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
 #define ev_is_active(ev)                    (0 + ((ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */
@@ -552,6 +614,12 @@ void ev_embed_stop     (EV_P_ ev_embed *w);
 void ev_embed_sweep    (EV_P_ ev_embed *w);
 # endif
 
+# if EV_ASYNC_ENABLE
+void ev_async_start    (EV_P_ ev_async *w);
+void ev_async_stop     (EV_P_ ev_async *w);
+void ev_async_send     (EV_P_ ev_async *w);
+# endif
+
 #endif
 
 #ifdef __cplusplus

data/ext/libev/ev_poll.c

@@ -86,7 +86,7 @@ poll_modify (EV_P_ int fd, int oev, int nev)
 static void
 poll_poll (EV_P_ ev_tstamp timeout)
 {
-  int i;
+  struct pollfd *p;
   int res = poll (polls, pollcnt, (int)ceil (timeout * 1000.));
 
   if (expect_false (res < 0))
@@ -97,20 +97,23 @@ poll_poll (EV_P_ ev_tstamp timeout)
         fd_enomem (EV_A);
       else if (errno != EINTR)
         syserr ("(libev) poll");
-
-      return;
     }
-
-  for (i = 0; i < pollcnt; ++i)
-    if (expect_false (polls [i].revents & POLLNVAL))
-      fd_kill (EV_A_ polls [i].fd);
-    else
-      fd_event (
-        EV_A_
-        polls [i].fd,
-        (polls [i].revents & (POLLOUT | POLLERR | POLLHUP) ? EV_WRITE : 0)
-        | (polls [i].revents & (POLLIN | POLLERR | POLLHUP) ? EV_READ : 0)
-      );
+  else
+    for (p = polls; res; ++p)
+      if (expect_false (p->revents)) /* this expect is debatable */
+        {
+          --res;
+
+          if (expect_false (p->revents & POLLNVAL))
+            fd_kill (EV_A_ p->fd);
+          else
+            fd_event (
+              EV_A_
+              p->fd,
+              (p->revents & (POLLOUT | POLLERR | POLLHUP) ? EV_WRITE : 0)
+              | (p->revents & (POLLIN | POLLERR | POLLHUP) ? EV_READ : 0)
+            );
+        }
 }
 
 int inline_size

data/ext/libev/ev_select.c

@@ -95,8 +95,8 @@ select_modify (EV_P_ int fd, int oev, int nev)
 
 #else
 
-    int word = fd / NFDBITS;
-    int mask = 1UL << (fd % NFDBITS);
+    int     word = fd / NFDBITS;
+    fd_mask mask = 1UL << (fd % NFDBITS);
 
     if (expect_false (vec_max < word + 1))
       {
@@ -108,8 +108,8 @@ select_modify (EV_P_ int fd, int oev, int nev)
         vec_wo = ev_realloc (vec_wo, new_max * NFDBYTES); /* could free/malloc */
 
         for (; vec_max < new_max; ++vec_max)
-          ((fd_mask *)vec_ri)[vec_max] =
-          ((fd_mask *)vec_wi)[vec_max] = 0;
+          ((fd_mask *)vec_ri) [vec_max] =
+          ((fd_mask *)vec_wi) [vec_max] = 0;
       }
 
     ((fd_mask *)vec_ri) [word] |= mask;

data/ext/libev/ev_vars.h

@@ -1,7 +1,7 @@
 /*
  * loop member variable declarations
  *
- * Copyright (c) 2007 Marc Alexander Lehmann <libev@schmorp.de>
+ * Copyright (c) 2007,2008 Marc Alexander Lehmann <libev@schmorp.de>
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without modifica-
@@ -55,6 +55,12 @@ VARx(ev_tstamp, backend_fudge) /* assumed typical timer resolution */
 VAR (backend_modify, void (*backend_modify)(EV_P_ int fd, int oev, int nev))
 VAR (backend_poll  , void (*backend_poll)(EV_P_ ev_tstamp timeout))
 
+#if EV_USE_EVENTFD || EV_GENWRAP
+VARx(int, evfd)
+#endif
+VAR (evpipe, int evpipe [2])
+VARx(ev_io, pipeev)
+
 #if !defined(_WIN32) || EV_GENWRAP
 VARx(pid_t, curpid)
 #endif
@@ -137,6 +143,13 @@ VARx(int, forkmax)
 VARx(int, forkcnt)
 #endif
 
+VARx(EV_ATOMIC_T, gotasync)
+#if EV_ASYNC_ENABLE || EV_GENWRAP
+VARx(struct ev_async **, asyncs)
+VARx(int, asyncmax)
+VARx(int, asynccnt)
+#endif
+
 #if EV_USE_INOTIFY || EV_GENWRAP
 VARx(int, fs_fd)
 VARx(ev_io, fs_w)

data/ext/libev/ev_wrap.h

@@ -13,6 +13,9 @@
 #define backend_fudge ((loop)->backend_fudge)
 #define backend_modify ((loop)->backend_modify)
 #define backend_poll ((loop)->backend_poll)
+#define evfd ((loop)->evfd)
+#define evpipe ((loop)->evpipe)
+#define pipeev ((loop)->pipeev)
 #define curpid ((loop)->curpid)
 #define postfork ((loop)->postfork)
 #define vec_ri ((loop)->vec_ri)
@@ -61,6 +64,10 @@
 #define forks ((loop)->forks)
 #define forkmax ((loop)->forkmax)
 #define forkcnt ((loop)->forkcnt)
+#define gotasync ((loop)->gotasync)
+#define asyncs ((loop)->asyncs)
+#define asyncmax ((loop)->asyncmax)
+#define asynccnt ((loop)->asynccnt)
 #define fs_fd ((loop)->fs_fd)
 #define fs_w ((loop)->fs_w)
 #define fs_hash ((loop)->fs_hash)
@@ -78,6 +85,9 @@
 #undef backend_fudge
 #undef backend_modify
 #undef backend_poll
+#undef evfd
+#undef evpipe
+#undef pipeev
 #undef curpid
 #undef postfork
 #undef vec_ri
@@ -126,6 +136,10 @@
 #undef forks
 #undef forkmax
 #undef forkcnt
+#undef gotasync
+#undef asyncs
+#undef asyncmax
+#undef asynccnt
 #undef fs_fd
 #undef fs_w
 #undef fs_hash

data/ext/rev/extconf.rb

@@ -1,48 +1,52 @@
 require 'mkmf'
 
-cflags = []
 libs = []
 
+$defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
+
 if have_func('rb_thread_blocking_region')
-  cflags << '-DHAVE_RB_THREAD_BLOCKING_REGION'
+  $defs << '-DHAVE_RB_THREAD_BLOCKING_REGION'
+end
+
+if have_func('rb_str_set_len')
+  $defs << '-DHAVE_RB_STR_SET_LEN'
 end
 
 if have_header('sys/select.h')
-  cflags << '-DEV_USE_SELECT'
+  $defs << '-DEV_USE_SELECT'
 end
 
 if have_header('poll.h')
-  cflags << '-DEV_USE_POLL'
+  $defs << '-DEV_USE_POLL'
 end
 
 if have_header('sys/epoll.h')
-  cflags << '-DEV_USE_EPOLL'
+  $defs << '-DEV_USE_EPOLL'
 end
 
 if have_header('sys/event.h') and have_header('sys/queue.h')
-  cflags << '-DEV_USE_KQUEUE'
+  $defs << '-DEV_USE_KQUEUE'
 end
 
 if have_header('port.h')
-  cflags << '-DEV_USE_PORT'
+  $defs << '-DEV_USE_PORT'
 end
 
 if have_header('openssl/ssl.h')
-  cflags << '-DHAVE_OPENSSL_SSL_H'
+  $defs << '-DHAVE_OPENSSL_SSL_H'
   libs << '-lssl -lcrypto'
 end
 
 # ncpu detection specifics
 case RUBY_PLATFORM
 when /linux/
-  cflags << '-DHAVE_LINUX_PROCFS'
+  $defs << '-DHAVE_LINUX_PROCFS'
 else
   if have_func('sysctlbyname', ['sys/param.h', 'sys/sysctl.h'])
-    cflags << '-DHAVE_SYSCTLBYNAME'
+    $defs << '-DHAVE_SYSCTLBYNAME'
   end
 end
 
-$CFLAGS << ' ' << cflags.join(' ')
 $LIBS << ' ' << libs.join(' ')
 
 dir_config('rev_ext')

data/ext/rev/rev_loop.c

@@ -6,6 +6,7 @@
 
 #include <assert.h>
 #include "ruby.h"
+#include "rubysig.h"
 
 #define EV_STANDALONE 1
 #include "../libev/ev.h"
@@ -28,6 +29,10 @@ static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data);
 static void Rev_Loop_dispatch_events(struct Rev_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;
 
 /* 
  * Rev::Loop represents an event loop.  Event watchers can be attached and
@@ -52,7 +57,6 @@ static VALUE Rev_Loop_allocate(VALUE klass)
   struct Rev_Loop *loop = (struct Rev_Loop *)xmalloc(sizeof(struct Rev_Loop));
 
   loop->ev_loop = 0;
-
   loop->running = 0;
   loop->events_received = 0;
   loop->eventbuf_size = DEFAULT_EVENTBUF_SIZE;
@@ -173,22 +177,19 @@ void Rev_Loop_process_event(VALUE watcher, int revents)
 static VALUE Rev_Loop_run_once(VALUE self)
 {
   struct Rev_Loop *loop_data;
+  VALUE nevents;
+  
   Data_Get_Struct(self, struct Rev_Loop, loop_data);
 
-  if(loop_data->running)
-    rb_raise(rb_eRuntimeError, "cannot run loop from within a callback");
-
   assert(loop_data->ev_loop && !loop_data->events_received);
-
-  loop_data->running = 1;
-
-  Rev_Loop_ev_loop_oneshot(loop_data);
+  
+  Rev_Loop_ev_loop_oneshot(loop_data);  
   Rev_Loop_dispatch_events(loop_data);
+  
+  nevents = INT2NUM(loop_data->events_received);
   loop_data->events_received = 0;
-
-  loop_data->running = 0;
-
-  return Qnil;
+  
+  return nevents;
 }
 
 /* Ruby 1.9 supports blocking system calls through rb_thread_blocking_region() */
@@ -197,16 +198,17 @@ static VALUE Rev_Loop_run_once(VALUE self)
 static VALUE Rev_Loop_ev_loop_oneshot_blocking(void *ptr) 
 {
   /* The libev loop has now escaped through the Global VM Lock unscathed! */
-  struct ev_loop *loop = (struct ev_loop *)ptr;
+  struct Rev_Loop *loop_data = (struct Rev_Loop *)ptr;
 
-  ev_loop(loop, EVLOOP_ONESHOT);
+  RUN_LOOP(loop_data, EVLOOP_ONESHOT);
+  
   return Qnil;
 }
 
 static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
 {
   /* Use Ruby 1.9's rb_thread_blocking_region call to make a blocking system call */
-  rb_thread_blocking_region(Rev_Loop_ev_loop_oneshot_blocking, loop_data->ev_loop, RB_UBF_DFL, 0);
+  rb_thread_blocking_region(Rev_Loop_ev_loop_oneshot_blocking, loop_data, RB_UBF_DFL, 0);
 }
 #endif
 
@@ -215,11 +217,12 @@ static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
 #ifndef HAVE_EV_LOOP_ONESHOT
 #define BLOCKING_INTERVAL 0.01 /* Block for 10ms at a time */
 
-/* Stub callback */
+/* Stub for scheduler's ev_timer callback */
 static void timer_callback(struct ev_loop *ev_loop, struct ev_timer *timer, int revents)
 {
 }
 
+/* Run the event loop, calling rb_thread_schedule every 10ms */
 static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
 {
   struct ev_timer timer;
@@ -229,15 +232,14 @@ static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
   ev_timer_init(&timer, timer_callback, BLOCKING_INTERVAL, BLOCKING_INTERVAL);
   ev_timer_start(loop_data->ev_loop, &timer);
 
-  do {
-    /* Since blocking calls would hang the Ruby 1.8 thread scheduler, don't block */
-    ev_loop(loop_data->ev_loop, EVLOOP_ONESHOT);
+  /* Loop until we receive events */
+  while(!loop_data->events_received) {
+    TRAP_BEG;
+    RUN_LOOP(loop_data, EVLOOP_ONESHOT);
+    TRAP_END;
 
-    /* Call rb_thread_select to resume the Ruby scheduler */
-    tv.tv_sec = 0;
-    tv.tv_usec = 0;
-    rb_thread_select(0, NULL, NULL, NULL, &tv);
-  } while(!loop_data->events_received);
+    rb_thread_schedule();
+  }
 
   ev_timer_stop(loop_data->ev_loop, &timer);
 }
@@ -245,27 +247,26 @@ static void Rev_Loop_ev_loop_oneshot(struct Rev_Loop *loop_data)
 
 /**
  *  call-seq:
- *    Rev::Loop.run_once -> nil
+ *    Rev::Loop.run_nonblock -> nil
  * 
  * Run the Rev::Loop once, but return immediately if there are no pending events.
  */
 static VALUE Rev_Loop_run_nonblock(VALUE self)
 {
   struct Rev_Loop *loop_data;
+  VALUE nevents;
+  
   Data_Get_Struct(self, struct Rev_Loop, loop_data);
 
-  if(loop_data->running)
-    rb_raise(rb_eRuntimeError, "cannot run loop from within a callback");
-
   assert(loop_data->ev_loop && !loop_data->events_received);
 
-  loop_data->running = 1;
-  ev_loop(loop_data->ev_loop, EVLOOP_NONBLOCK);
+  RUN_LOOP(loop_data, EVLOOP_NONBLOCK);  
   Rev_Loop_dispatch_events(loop_data);
+  
+  nevents = INT2NUM(loop_data->events_received);
   loop_data->events_received = 0;
-  loop_data->running = 0;
-
-  return Qnil;
+  
+  return nevents;
 }
 
 static void Rev_Loop_dispatch_events(struct Rev_Loop *loop_data)
@@ -283,4 +284,4 @@ static void Rev_Loop_dispatch_events(struct Rev_Loop *loop_data)
     Data_Get_Struct(loop_data->eventbuf[i].watcher, struct Rev_Watcher, watcher_data);
     watcher_data->dispatch_callback(loop_data->eventbuf[i].watcher, loop_data->eventbuf[i].revents);
   }
-}
+}