rev 0.2.1 → 0.2.2

data/ext/http11_client/http11_parser.rl

@@ -71,11 +71,11 @@
 # elements
   token = (ascii -- (CTL | tspecials));
 
-  Reason_Phrase = (any -- CRLF)+ >mark %reason_phrase;
-  Status_Code = digit+ >mark %status_code;
+  Reason_Phrase = (any -- CRLF)* >mark %reason_phrase;
+  Status_Code = digit{3} >mark %status_code;
   http_number = (digit+ "." digit+) ;
   HTTP_Version = ("HTTP/" http_number) >mark %http_version ;
-  Status_Line = HTTP_Version " " Status_Code " " Reason_Phrase :> CRLF;
+  Status_Line = HTTP_Version " " Status_Code " "? Reason_Phrase :> CRLF;
 
   field_name = token+ >start_field %write_field;
   field_value = any* >start_value %write_value;

data/ext/libev/Changes

@@ -1,5 +1,26 @@
 Revision history for libev, a high-performance and full-featured event loop.
 
+3.41 Fri May 23 18:42:54 CEST 2008
+	- work around an (undocumented) bug in winsocket select: if you
+          provide only empty fd sets then select returns WSAEINVAL. how sucky.
+        - improve timer scheduling stability and reduce use of time_epsilon.
+        - use 1-based 2-heap for EV_MINIMAL, simplifies code, reduces
+          codesize and makes for better cache-efficiency.
+        - use 3-based 4-heap for !EV_MINIMAL. this makes better use
+          of cpu cache lines and gives better growth behaviour than
+          2-based heaps.
+        - cache timestamp within heap for !EV_MINIMAL, to avoid random
+          memory accesses.
+        - document/add EV_USE_4HEAP and EV_HEAP_CACHE_AT.
+        - fix a potential aliasing issue in ev_timer_again.
+        - add/document ev_periodic_at, retract direct access to ->at.
+        - improve ev_stat docs.
+        - add portability requirements section.
+	- fix manpage headers etc.
+        - normalise WSA error codes to lower range on windows.
+        - add consistency check code that can be called automatically
+          or on demand to check for internal structures (ev_loop_verify).
+
 3.31 Wed Apr 16 20:45:04 CEST 2008
 	- added last minute fix for ev_poll.c by Brandon Black.
 

data/ext/libev/LICENSE

@@ -1,4 +1,4 @@
-All files in libev are Copyright (C)2007 Marc Alexander Lehmann.
+All files in libev are Copyright (C)2007,2008 Marc Alexander Lehmann.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -23,3 +23,14 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+Alternatively, the contents of this package may be used under the terms
+of the GNU General Public License ("GPL") version 2 or any later version,
+in which case the provisions of the GPL are applicable instead of the
+above. If you wish to allow the use of your version of this package only
+under the terms of the GPL and not to allow others to use your version of
+this file under the BSD license, indicate your decision by deleting the
+provisions above and replace them with the notice and other provisions
+required by the GPL in this and the other files of this package. If you do
+not delete the provisions above, a recipient may use your version of this
+file under either the BSD or the GPL.

data/ext/libev/README

@@ -1,128 +1,56 @@
 libev is a high-performance event loop/event model with lots of features.
 (see benchmark at http://libev.schmorp.de/bench.html)
 
-   Homepage: http://software.schmorp.de/pkg/libev
-   E-Mail: libev@lists.schmorp.de
-   Library Documentation: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod
-
-   It is modelled (very losely) after libevent and the Event perl module,
-   but aims to be faster and more correct, and also more featureful. And
-   also smaller. Yay.
 
-ABOUT THIS DISTRIBUTION
+ABOUT
 
-   If you downloaded the libevent+libev distribution of libev, you will
-   find it looks very much like libevent. In fact, the distributed libev
-   tarballs are indeed libevent tarballs patched up with the libev
-   event core, taking the evbuffer, evtag, evdns and evhttpd parts from
-   libevent (they use the libevent emulation inside libev). Configure and
-   Makefile stuff is also a more or less direct copy of libevent, and are
-   maintained by the libevent authors.
-
-   If you downloaded the libev distribution (without libevent), then
-   you only get the core parts of the library, meaning http and dns
-   client/server code and similar things are missing. Only the core event
-   loop is included.
+   Homepage: http://software.schmorp.de/pkg/libev
+   Mailinglist: libev@lists.schmorp.de
+                http://lists.schmorp.de/cgi-bin/mailman/listinfo/libev
+   Library Documentation: http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod
 
-   If you are looking for an easily embeddable version, I recommend using
-   the libev standalone distribution or the CVS repository.
+   Libev is modelled (very losely) after libevent and the Event perl
+   module, but is faster, scales better and is more correct, and also more
+   featureful. And also smaller. Yay.
+
+   Some of the specialties of libev not commonly found elsewhere are:
+   
+   - extensive and detailed, readable documentation (not doxygen garbage).
+   - fully supports fork, can detect fork in various ways and automatically
+     re-arms kernel mechanisms that do not support fork.
+   - highly optimised select, poll, epoll, kqueue and event ports backends.
+   - filesystem object (path) watching (with optional linux inotify support).
+   - wallclock-based times (using absolute time, cron-like).
+   - relative timers/timeouts (handle time jumps).
+   - fast intra-thread communication between multiple
+     event loops (with optional fast linux eventfd backend).
+   - extremely easy to embed.
+   - very small codebase, no bloated library.
+   - fully extensible by being able to plug into the event loop,
+     integrate other event loops, integrate other event loop users.
+   - very little memory use (small watchers, small event loop data).
+   - optional C++ interface allowing method and function callbacks
+     at no extra memory or runtime overhead.
+   - optional Perl interface with similar characteristics (capable
+     of running Glib/Gtk2 on libev, interfaces with Net::SNMP and
+     libadns).
+   - support for other languages (multiple C++ interfaces, D, Ruby,
+     Python) available from third-parties.
 
    Examples of programs that embed libev: the EV perl module,
-   rxvt-unicode, gvpe (GNU Virtual Private Ethernet) and deliantra
-   (http://www.deliantra.net).
-
-DIFFERENCES AND COMPARISON TO LIBEVENT
-
-   The comparisons below are relative to libevent-1.3e.
-
-   - multiple watchers can wait for the same event without deregistering others,
-     both for file descriptors as well as signals.
-     (registering two read events on fd 10 and unregistering one will not
-     break the other).
-
-   - fork() is supported and can be handled
-     (there is no way to recover from a fork with libevent).
-
-   - timers are handled as a priority queue (important operations are O(1))
-     (libevent uses a much less efficient but more complex red-black tree).
-
-   - supports absolute (wallclock-based) timers in addition to relative ones,
-     i.e. can schedule timers to occur after n seconds, or at a specific time.
-
-   - timers can be repeating (both absolute and relative ones).
-
-   - absolute timers can have customised rescheduling hooks (suitable for cron-like
-     applications).
-
-   - detects time jumps and adjusts timers
-     (works for both forward and backward time jumps and also for absolute timers).
-
-   - race-free signal processing
-     (libevent may delay processing signals till after the next event).
-
-   - more efficient epoll backend
-     (stopping and starting an io watcher between two loop iterations will not
-     result in spurious epoll_ctl calls).
-
-   - usually less calls to gettimeofday and clock_gettime
-     (libevent calls it on every timer event change, libev twice per iteration).
-
-   - watchers use less memory
-     (libevent watcher on amd64: 152 bytes, libev native: <= 56 bytes, libevent emulation: 144 bytes).
-
-   - library uses less memory
-     (libevent allocates large data structures wether used or not, libev
-     scales all its data structures dynamically).
-
-   - no hardcoded arbitrary limits
-     (libevent contains an off-by-one bug and sometimes hardcodes limits).
-
-   - libev separates timer, signal and io watchers from each other
-     (libevent combines them, but with libev you can combine them yourself
-     by reusing the same callback and still save memory).
-
-   - simpler design, backends are potentially much simpler
-     (in libevent, backends have to deal with watchers, thus the problems with
-     wildly different semantics between diferent backends)
-     (epoll backend in libevent: 366 lines no caching, libev: 90 lines full caching).
-
-   - libev handles EBADF gracefully by removing the offending fds.
-
-   - libev communicates errors to the callback, libevent to the
-     event adder or not at all.
-
-   - doesn't rely on nonportable BSD header files.
-
-   - an event.h compatibility header exists, and can be used to run a wide
-     range of libevent programs unchanged (such as evdns.c).
-
-   - win32 compatibility for the core parts.
-     (the backend is fd-based as documented and on other platforms,
-     not handle-based like libevent, and can be used for both winscoket environments
-     and unix-like ones).
-
-   - libev can be embedded easily with or without autoconf support into
-     other programs, with no changes to the source code necessary.
-
-   - the event core library (ev and event layer) compiles and works both as
-     C and C++.
-
-   - a simple C++ wrapper that supports methods as callbacks exists.
-
-   - a full featured and widely used perl module is available.
-
-   whats missing?
+   rxvt-unicode, gvpe (GNU Virtual Private Ethernet), the Deliantra MMORPG
+   server (http://www.deliantra.net/), Rubinius (a next-generation Ruby
+   VM), the Ebb web server, the Rev event toolkit.
 
-   - no event-like priority support at the moment (the ev priorities work
-     differently, but you can use idle watchers to get a similar effect).
 
-AUTHOR
+CONTRIBUTORS
 
    libev was written and designed by Marc Lehmann and Emanuele Giaquinta.
 
    The following people sent in patches or made other noteworthy
-   contributions to the design (if I forgot to include you, please shout
-   at me, it was an accident):
+   contributions to the design (for minor patches, see the Changes
+   file. If I forgot to include you, please shout at me, it was an
+   accident):
 
    W.C.A. Wijngaards
    Christopher Layne

data/ext/libev/ev.c

@@ -128,7 +128,7 @@ extern "C" {
 #   define EV_USE_EVENTFD 0
 #  endif
 # endif
-   
+ 
 #endif
 
 #include <math.h>
@@ -237,6 +237,24 @@ extern "C" {
 # endif
 #endif
 
+#if 0 /* debugging */
+# define EV_VERIFY 3
+# define EV_USE_4HEAP 1
+# define EV_HEAP_CACHE_AT 1
+#endif
+
+#ifndef EV_VERIFY
+# define EV_VERIFY !EV_MINIMAL
+#endif
+
+#ifndef EV_USE_4HEAP
+# define EV_USE_4HEAP !EV_MINIMAL
+#endif
+
+#ifndef EV_HEAP_CACHE_AT
+# define EV_HEAP_CACHE_AT !EV_MINIMAL
+#endif
+
 /* this block fixes any misconfiguration where we know we run into trouble otherwise */
 
 #ifndef CLOCK_MONOTONIC
@@ -282,6 +300,12 @@ int eventfd (unsigned int initval, int flags);
 
 /**/
 
+#if EV_VERIFY >= 3
+# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)
+#else
+# define EV_FREQUENT_CHECK do { } while (0)
+#endif
+
 /*
  * This is used to avoid floating point rounding problems.
  * It is added to ev_rt_now when scheduling periodics
@@ -327,6 +351,9 @@ typedef ev_watcher *W;
 typedef ev_watcher_list *WL;
 typedef ev_watcher_time *WT;
 
+#define ev_active(w) ((W)(w))->active
+#define ev_at(w) ((WT)(w))->at
+
 #if EV_USE_MONOTONIC
 /* sig_atomic_t is used to avoid per-thread variables or locking but still */
 /* giving it a reasonably high chance of working on typical architetcures */
@@ -421,12 +448,31 @@ typedef struct
 } ANPENDING;
 
 #if EV_USE_INOTIFY
+/* hash table entry per inotify-id */
 typedef struct
 {
   WL head;
 } ANFS;
 #endif
 
+/* Heap Entry */
+#if EV_HEAP_CACHE_AT
+  typedef struct {
+    ev_tstamp at;
+    WT w;
+  } ANHE;
+
+  #define ANHE_w(he)        (he).w     /* access watcher, read-write */
+  #define ANHE_at(he)       (he).at    /* access cached at, read-only */
+  #define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */
+#else
+  typedef WT ANHE;
+
+  #define ANHE_w(he)        (he)
+  #define ANHE_at(he)       (he)->at
+  #define ANHE_at_cache(he)
+#endif
+
 #if EV_MULTIPLICITY
 
   struct ev_loop
@@ -519,6 +565,8 @@ ev_sleep (ev_tstamp delay)
 
 /*****************************************************************************/
 
+#define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
+
 int inline_size
 array_nextsize (int elem, int cur, int cnt)
 {
@@ -528,11 +576,11 @@ array_nextsize (int elem, int cur, int cnt)
     ncur <<= 1;
   while (cnt > ncur);
 
-  /* if size > 4096, round to 4096 - 4 * longs to accomodate malloc overhead */
-  if (elem * ncur > 4096)
+  /* if size is large, round to MALLOC_ROUND - 4 * longs to accomodate malloc overhead */
+  if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
     {
       ncur *= elem;
-      ncur = (ncur + elem + 4095 + sizeof (void *) * 4) & ~4095;
+      ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
       ncur = ncur - sizeof (void *) * 4;
       ncur /= elem;
     }
@@ -756,60 +804,146 @@ fd_rearm_all (EV_P)
 
 /*****************************************************************************/
 
+/*
+ * the heap functions want a real array index. array index 0 uis guaranteed to not
+ * be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
+ * the branching factor of the d-tree.
+ */
+
+/*
+ * at the moment we allow libev the luxury of two heaps,
+ * a small-code-size 2-heap one and a ~1.5kb larger 4-heap
+ * which is more cache-efficient.
+ * the difference is about 5% with 50000+ watchers.
+ */
+#if EV_USE_4HEAP
+
+#define DHEAP 4
+#define HEAP0 (DHEAP - 1) /* index of first element in heap */
+#define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
+#define UPHEAP_DONE(p,k) ((p) == (k))
+
+/* away from the root */
 void inline_speed
-upheap (WT *heap, int k)
+downheap (ANHE *heap, int N, int k)
 {
-  WT w = heap [k];
+  ANHE he = heap [k];
+  ANHE *E = heap + N + HEAP0;
 
-  while (k)
+  for (;;)
     {
-      int p = (k - 1) >> 1;
+      ev_tstamp minat;
+      ANHE *minpos;
+      ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
 
-      if (heap [p]->at <= w->at)
+      /* find minimum child */
+      if (expect_true (pos + DHEAP - 1 < E))
+        {
+          /* fast path */                               (minpos = pos + 0), (minat = ANHE_at (*minpos));
+          if (               ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
+          if (               ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
+          if (               ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
+        }
+      else if (pos < E)
+        {
+          /* slow path */                               (minpos = pos + 0), (minat = ANHE_at (*minpos));
+          if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
+          if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
+          if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
+        }
+      else
         break;
 
-      heap [k] = heap [p];
-      ((W)heap [k])->active = k + 1;
-      k = p;
+      if (ANHE_at (he) <= minat)
+        break;
+
+      heap [k] = *minpos;
+      ev_active (ANHE_w (*minpos)) = k;
+
+      k = minpos - heap;
     }
 
-  heap [k] = w;
-  ((W)heap [k])->active = k + 1;
+  heap [k] = he;
+  ev_active (ANHE_w (he)) = k;
 }
 
+#else /* 4HEAP */
+
+#define HEAP0 1
+#define HPARENT(k) ((k) >> 1)
+#define UPHEAP_DONE(p,k) (!(p))
+
+/* away from the root */
 void inline_speed
-downheap (WT *heap, int N, int k)
+downheap (ANHE *heap, int N, int k)
 {
-  WT w = heap [k];
+  ANHE he = heap [k];
 
   for (;;)
     {
-      int c = (k << 1) + 1;
+      int c = k << 1;
 
-      if (c >= N)
+      if (c > N + HEAP0 - 1)
         break;
 
-      c += c + 1 < N && heap [c]->at > heap [c + 1]->at
+      c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
            ? 1 : 0;
 
-      if (w->at <= heap [c]->at)
+      if (ANHE_at (he) <= ANHE_at (heap [c]))
         break;
 
       heap [k] = heap [c];
-      ((W)heap [k])->active = k + 1;
-
+      ev_active (ANHE_w (heap [k])) = k;
+      
       k = c;
     }
 
-  heap [k] = w;
-  ((W)heap [k])->active = k + 1;
+  heap [k] = he;
+  ev_active (ANHE_w (he)) = k;
+}
+#endif
+
+/* towards the root */
+void inline_speed
+upheap (ANHE *heap, int k)
+{
+  ANHE he = heap [k];
+
+  for (;;)
+    {
+      int p = HPARENT (k);
+
+      if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
+        break;
+
+      heap [k] = heap [p];
+      ev_active (ANHE_w (heap [k])) = k;
+      k = p;
+    }
+
+  heap [k] = he;
+  ev_active (ANHE_w (he)) = k;
+}
+
+void inline_size
+adjustheap (ANHE *heap, int N, int k)
+{
+  if (k > HEAP0 && ANHE_at (heap [HPARENT (k)]) >= ANHE_at (heap [k]))
+    upheap (heap, k);
+  else
+    downheap (heap, N, k);
 }
 
+/* rebuild the heap: this function is used only once and executed rarely */
 void inline_size
-adjustheap (WT *heap, int N, int k)
+reheap (ANHE *heap, int N)
 {
-  upheap (heap, k);
-  downheap (heap, N, k);
+  int i;
+
+  /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
+  /* also, this is easy to implement and correct for both 2-heaps and 4-heaps */
+  for (i = 0; i < N; ++i)
+    upheap (heap, i + HEAP0);
 }
 
 /*****************************************************************************/
@@ -908,7 +1042,7 @@ pipecb (EV_P_ ev_io *iow, int revents)
 #if EV_USE_EVENTFD
   if (evfd >= 0)
     {
-      uint64_t counter = 1;
+      uint64_t counter;
       read (evfd, &counter, sizeof (uint64_t));
     }
   else
@@ -1285,7 +1419,9 @@ loop_destroy (EV_P)
   backend = 0;
 }
 
+#if EV_USE_INOTIFY
 void inline_size infy_fork (EV_P);
+#endif
 
 void inline_size
 loop_fork (EV_P)
@@ -1335,6 +1471,7 @@ loop_fork (EV_P)
 }
 
 #if EV_MULTIPLICITY
+
 struct ev_loop *
 ev_loop_new (unsigned int flags)
 {
@@ -1363,7 +1500,106 @@ ev_loop_fork (EV_P)
   postfork = 1; /* must be in line with ev_default_fork */
 }
 
+#if EV_VERIFY
+void noinline
+verify_watcher (EV_P_ W w)
+{
+  assert (("watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
+
+  if (w->pending)
+    assert (("pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
+}
+
+static void noinline
+verify_heap (EV_P_ ANHE *heap, int N)
+{
+  int i;
+
+  for (i = HEAP0; i < N + HEAP0; ++i)
+    {
+      assert (("active index mismatch in heap", ev_active (ANHE_w (heap [i])) == i));
+      assert (("heap condition violated", i == HEAP0 || ANHE_at (heap [HPARENT (i)]) <= ANHE_at (heap [i])));
+      assert (("heap at cache mismatch", ANHE_at (heap [i]) == ev_at (ANHE_w (heap [i]))));
+
+      verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
+    }
+}
+
+static void noinline
+array_verify (EV_P_ W *ws, int cnt)
+{
+  while (cnt--)
+    {
+      assert (("active index mismatch", ev_active (ws [cnt]) == cnt + 1));
+      verify_watcher (EV_A_ ws [cnt]);
+    }
+}
+#endif
+
+void
+ev_loop_verify (EV_P)
+{
+#if EV_VERIFY
+  int i;
+  WL w;
+
+  assert (activecnt >= -1);
+
+  assert (fdchangemax >= fdchangecnt);
+  for (i = 0; i < fdchangecnt; ++i)
+    assert (("negative fd in fdchanges", fdchanges [i] >= 0));
+
+  assert (anfdmax >= 0);
+  for (i = 0; i < anfdmax; ++i)
+    for (w = anfds [i].head; w; w = w->next)
+      {
+        verify_watcher (EV_A_ (W)w);
+        assert (("inactive fd watcher on anfd list", ev_active (w) == 1));
+        assert (("fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i));
+      }
+
+  assert (timermax >= timercnt);
+  verify_heap (EV_A_ timers, timercnt);
+
+#if EV_PERIODIC_ENABLE
+  assert (periodicmax >= periodiccnt);
+  verify_heap (EV_A_ periodics, periodiccnt);
+#endif
+
+  for (i = NUMPRI; i--; )
+    {
+      assert (pendingmax [i] >= pendingcnt [i]);
+#if EV_IDLE_ENABLE
+      assert (idleall >= 0);
+      assert (idlemax [i] >= idlecnt [i]);
+      array_verify (EV_A_ (W *)idles [i], idlecnt [i]);
+#endif
+    }
+
+#if EV_FORK_ENABLE
+  assert (forkmax >= forkcnt);
+  array_verify (EV_A_ (W *)forks, forkcnt);
+#endif
+
+#if EV_ASYNC_ENABLE
+  assert (asyncmax >= asynccnt);
+  array_verify (EV_A_ (W *)asyncs, asynccnt);
+#endif
+
+  assert (preparemax >= preparecnt);
+  array_verify (EV_A_ (W *)prepares, preparecnt);
+
+  assert (checkmax >= checkcnt);
+  array_verify (EV_A_ (W *)checks, checkcnt);
+
+# if 0
+  for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
+  for (signum = signalmax; signum--; ) if (signals [signum].gotsig)
+# endif
 #endif
+}
+
+#endif /* multiplicity */
 
 #if EV_MULTIPLICITY
 struct ev_loop *
@@ -1449,33 +1685,61 @@ call_pending (EV_P)
 
             p->w->pending = 0;
             EV_CB_INVOKE (p->w, p->events);
+            EV_FREQUENT_CHECK;
           }
       }
 }
 
+#if EV_IDLE_ENABLE
+void inline_size
+idle_reify (EV_P)
+{
+  if (expect_false (idleall))
+    {
+      int pri;
+
+      for (pri = NUMPRI; pri--; )
+        {
+          if (pendingcnt [pri])
+            break;
+
+          if (idlecnt [pri])
+            {
+              queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
+              break;
+            }
+        }
+    }
+}
+#endif
+
 void inline_size
 timers_reify (EV_P)
 {
-  while (timercnt && ((WT)timers [0])->at <= mn_now)
+  EV_FREQUENT_CHECK;
+
+  while (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
     {
-      ev_timer *w = (ev_timer *)timers [0];
+      ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
 
       /*assert (("inactive timer on timer heap detected", ev_is_active (w)));*/
 
       /* first reschedule or stop timer */
       if (w->repeat)
         {
-          assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
+          ev_at (w) += w->repeat;
+          if (ev_at (w) < mn_now)
+            ev_at (w) = mn_now;
 
-          ((WT)w)->at += w->repeat;
-          if (((WT)w)->at < mn_now)
-            ((WT)w)->at = mn_now;
+          assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 
-          downheap (timers, timercnt, 0);
+          ANHE_at_cache (timers [HEAP0]);
+          downheap (timers, timercnt, HEAP0);
         }
       else
         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 
+      EV_FREQUENT_CHECK;
       ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
     }
 }
@@ -1484,29 +1748,47 @@ timers_reify (EV_P)
 void inline_size
 periodics_reify (EV_P)
 {
-  while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now)
+  EV_FREQUENT_CHECK;
+
+  while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
     {
-      ev_periodic *w = (ev_periodic *)periodics [0];
+      ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
 
       /*assert (("inactive timer on periodic heap detected", ev_is_active (w)));*/
 
       /* first reschedule or stop timer */
       if (w->reschedule_cb)
         {
-          ((WT)w)->at = w->reschedule_cb (w, ev_rt_now + TIME_EPSILON);
-          assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > ev_rt_now));
-          downheap (periodics, periodiccnt, 0);
+          ev_at (w) = w->reschedule_cb (w, ev_rt_now);
+
+          assert (("ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now));
+
+          ANHE_at_cache (periodics [HEAP0]);
+          downheap (periodics, periodiccnt, HEAP0);
         }
       else if (w->interval)
         {
-          ((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
-          if (((WT)w)->at - ev_rt_now <= TIME_EPSILON) ((WT)w)->at += w->interval;
-          assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > ev_rt_now));
-          downheap (periodics, periodiccnt, 0);
+          ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
+          /* if next trigger time is not sufficiently in the future, put it there */
+          /* this might happen because of floating point inexactness */
+          if (ev_at (w) - ev_rt_now < TIME_EPSILON)
+            {
+              ev_at (w) += w->interval;
+
+              /* if interval is unreasonably low we might still have a time in the past */
+              /* so correct this. this will make the periodic very inexact, but the user */
+              /* has effectively asked to get triggered more often than possible */
+              if (ev_at (w) < ev_rt_now)
+                ev_at (w) = ev_rt_now;
+            }
+
+          ANHE_at_cache (periodics [HEAP0]);
+          downheap (periodics, periodiccnt, HEAP0);
         }
       else
         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
 
+      EV_FREQUENT_CHECK;
       ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
     }
 }
@@ -1517,42 +1799,19 @@ periodics_reschedule (EV_P)
   int i;
 
   /* adjust periodics after time jump */
-  for (i = 0; i < periodiccnt; ++i)
+  for (i = HEAP0; i < periodiccnt + HEAP0; ++i)
     {
-      ev_periodic *w = (ev_periodic *)periodics [i];
+      ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]);
 
       if (w->reschedule_cb)
-        ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
+        ev_at (w) = w->reschedule_cb (w, ev_rt_now);
       else if (w->interval)
-        ((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
-    }
+        ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
 
-  /* now rebuild the heap */
-  for (i = periodiccnt >> 1; i--; )
-    downheap (periodics, periodiccnt, i);
-}
-#endif
-
-#if EV_IDLE_ENABLE
-void inline_size
-idle_reify (EV_P)
-{
-  if (expect_false (idleall))
-    {
-      int pri;
-
-      for (pri = NUMPRI; pri--; )
-        {
-          if (pendingcnt [pri])
-            break;
-
-          if (idlecnt [pri])
-            {
-              queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
-              break;
-            }
-        }
+      ANHE_at_cache (periodics [i]);
     }
+
+  reheap (periodics, periodiccnt);
 }
 #endif
 
@@ -1591,7 +1850,7 @@ time_update (EV_P_ ev_tstamp max_block)
         {
           rtmn_diff = ev_rt_now - mn_now;
 
-          if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
+          if (expect_true (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP))
             return; /* all is well */
 
           ev_rt_now = ev_time ();
@@ -1617,7 +1876,11 @@ time_update (EV_P_ ev_tstamp max_block)
 #endif
           /* adjust timers. this is easy, as the offset is the same for all of them */
           for (i = 0; i < timercnt; ++i)
-            ((WT)timers [i])->at += ev_rt_now - mn_now;
+            {
+              ANHE *he = timers + i + HEAP0;
+              ANHE_w (*he)->at += ev_rt_now - mn_now;
+              ANHE_at_cache (*he);
+            }
         }
 
       mn_now = ev_rt_now;
@@ -1647,6 +1910,10 @@ ev_loop (EV_P_ int flags)
 
   do
     {
+#if EV_VERIFY >= 2
+      ev_loop_verify (EV_A);
+#endif
+
 #ifndef _WIN32
       if (expect_false (curpid)) /* penalise the forking check even more */
         if (expect_false (getpid () != curpid))
@@ -1697,14 +1964,14 @@ ev_loop (EV_P_ int flags)
 
             if (timercnt)
               {
-                ev_tstamp to = ((WT)timers [0])->at - mn_now + backend_fudge;
+                ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now + backend_fudge;
                 if (waittime > to) waittime = to;
               }
 
 #if EV_PERIODIC_ENABLE
             if (periodiccnt)
               {
-                ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + backend_fudge;
+                ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now + backend_fudge;
                 if (waittime > to) waittime = to;
               }
 #endif
@@ -1851,12 +2118,16 @@ ev_io_start (EV_P_ ev_io *w)
 
   assert (("ev_io_start called with negative fd", fd >= 0));
 
+  EV_FREQUENT_CHECK;
+
   ev_start (EV_A_ (W)w, 1);
   array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
   wlist_add (&anfds[fd].head, (WL)w);
 
   fd_change (EV_A_ fd, w->events & EV_IOFDSET | 1);
   w->events &= ~EV_IOFDSET;
+
+  EV_FREQUENT_CHECK;
 }
 
 void noinline
@@ -1866,12 +2137,16 @@ ev_io_stop (EV_P_ ev_io *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
-  assert (("ev_io_start called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
+  assert (("ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
+
+  EV_FREQUENT_CHECK;
 
   wlist_del (&anfds[w->fd].head, (WL)w);
   ev_stop (EV_A_ (W)w);
 
   fd_change (EV_A_ w->fd, 1);
+
+  EV_FREQUENT_CHECK;
 }
 
 void noinline
@@ -1880,16 +2155,22 @@ ev_timer_start (EV_P_ ev_timer *w)
   if (expect_false (ev_is_active (w)))
     return;
 
-  ((WT)w)->at += mn_now;
+  ev_at (w) += mn_now;
 
   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
 
-  ev_start (EV_A_ (W)w, ++timercnt);
-  array_needsize (WT, timers, timermax, timercnt, EMPTY2);
-  timers [timercnt - 1] = (WT)w;
-  upheap (timers, timercnt - 1);
+  EV_FREQUENT_CHECK;
 
-  /*assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));*/
+  ++timercnt;
+  ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
+  array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);
+  ANHE_w (timers [ev_active (w)]) = (WT)w;
+  ANHE_at_cache (timers [ev_active (w)]);
+  upheap (timers, ev_active (w));
+
+  EV_FREQUENT_CHECK;
+
+  /*assert (("internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
 }
 
 void noinline
@@ -1899,19 +2180,25 @@ ev_timer_stop (EV_P_ ev_timer *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
-  assert (("internal timer heap corruption", timers [((W)w)->active - 1] == (WT)w));
+  EV_FREQUENT_CHECK;
 
   {
-    int active = ((W)w)->active;
+    int active = ev_active (w);
+
+    assert (("internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
+
+    --timercnt;
 
-    if (expect_true (--active < --timercnt))
+    if (expect_true (active < timercnt + HEAP0))
       {
-        timers [active] = timers [timercnt];
+        timers [active] = timers [timercnt + HEAP0];
         adjustheap (timers, timercnt, active);
       }
   }
 
-  ((WT)w)->at -= mn_now;
+  EV_FREQUENT_CHECK;
+
+  ev_at (w) -= mn_now;
 
   ev_stop (EV_A_ (W)w);
 }
@@ -1919,21 +2206,26 @@ ev_timer_stop (EV_P_ ev_timer *w)
 void noinline
 ev_timer_again (EV_P_ ev_timer *w)
 {
+  EV_FREQUENT_CHECK;
+
   if (ev_is_active (w))
     {
       if (w->repeat)
         {
-          ((WT)w)->at = mn_now + w->repeat;
-          adjustheap (timers, timercnt, ((W)w)->active - 1);
+          ev_at (w) = mn_now + w->repeat;
+          ANHE_at_cache (timers [ev_active (w)]);
+          adjustheap (timers, timercnt, ev_active (w));
         }
       else
         ev_timer_stop (EV_A_ w);
     }
   else if (w->repeat)
     {
-      w->at = w->repeat;
+      ev_at (w) = w->repeat;
       ev_timer_start (EV_A_ w);
     }
+
+  EV_FREQUENT_CHECK;
 }
 
 #if EV_PERIODIC_ENABLE
@@ -1944,22 +2236,28 @@ ev_periodic_start (EV_P_ ev_periodic *w)
     return;
 
   if (w->reschedule_cb)
-    ((WT)w)->at = w->reschedule_cb (w, ev_rt_now);
+    ev_at (w) = w->reschedule_cb (w, ev_rt_now);
   else if (w->interval)
     {
       assert (("ev_periodic_start called with negative interval value", w->interval >= 0.));
       /* this formula differs from the one in periodic_reify because we do not always round up */
-      ((WT)w)->at = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
+      ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
     }
   else
-    ((WT)w)->at = w->offset;
+    ev_at (w) = w->offset;
 
-  ev_start (EV_A_ (W)w, ++periodiccnt);
-  array_needsize (WT, periodics, periodicmax, periodiccnt, EMPTY2);
-  periodics [periodiccnt - 1] = (WT)w;
-  upheap (periodics, periodiccnt - 1);
+  EV_FREQUENT_CHECK;
 
-  /*assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));*/
+  ++periodiccnt;
+  ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
+  array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);
+  ANHE_w (periodics [ev_active (w)]) = (WT)w;
+  ANHE_at_cache (periodics [ev_active (w)]);
+  upheap (periodics, ev_active (w));
+
+  EV_FREQUENT_CHECK;
+
+  /*assert (("internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
 }
 
 void noinline
@@ -1969,18 +2267,24 @@ ev_periodic_stop (EV_P_ ev_periodic *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
-  assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == (WT)w));
+  EV_FREQUENT_CHECK;
 
   {
-    int active = ((W)w)->active;
+    int active = ev_active (w);
+
+    assert (("internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
+
+    --periodiccnt;
 
-    if (expect_true (--active < --periodiccnt))
+    if (expect_true (active < periodiccnt + HEAP0))
       {
-        periodics [active] = periodics [periodiccnt];
+        periodics [active] = periodics [periodiccnt + HEAP0];
         adjustheap (periodics, periodiccnt, active);
       }
   }
 
+  EV_FREQUENT_CHECK;
+
   ev_stop (EV_A_ (W)w);
 }
 
@@ -2010,6 +2314,8 @@ ev_signal_start (EV_P_ ev_signal *w)
 
   evpipe_init (EV_A);
 
+  EV_FREQUENT_CHECK;
+
   {
 #ifndef _WIN32
     sigset_t full, prev;
@@ -2039,6 +2345,8 @@ ev_signal_start (EV_P_ ev_signal *w)
       sigaction (w->signum, &sa, 0);
 #endif
     }
+
+  EV_FREQUENT_CHECK;
 }
 
 void noinline
@@ -2048,11 +2356,15 @@ ev_signal_stop (EV_P_ ev_signal *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   wlist_del (&signals [w->signum - 1].head, (WL)w);
   ev_stop (EV_A_ (W)w);
 
   if (!signals [w->signum - 1].head)
     signal (w->signum, SIG_DFL);
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2064,8 +2376,12 @@ ev_child_start (EV_P_ ev_child *w)
   if (expect_false (ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   ev_start (EV_A_ (W)w, 1);
   wlist_add (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2075,8 +2391,12 @@ ev_child_stop (EV_P_ ev_child *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   wlist_del (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 #if EV_STAT_ENABLE
@@ -2104,6 +2424,8 @@ infy_add (EV_P_ ev_stat *w)
       ev_timer_start (EV_A_ &w->timer); /* this is not race-free, so we still need to recheck periodically */
 
       /* monitor some parent directory for speedup hints */
+      /* note that exceeding the hardcoded limit is not a correctness issue, */
+      /* but an efficiency issue only */
       if ((errno == ENOENT || errno == EACCES) && strlen (w->path) < 4096)
         {
           char path [4096];
@@ -2312,6 +2634,8 @@ ev_stat_start (EV_P_ ev_stat *w)
     ev_timer_start (EV_A_ &w->timer);
 
   ev_start (EV_A_ (W)w, 1);
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2321,12 +2645,16 @@ ev_stat_stop (EV_P_ ev_stat *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
 #if EV_USE_INOTIFY
   infy_del (EV_A_ w);
 #endif
   ev_timer_stop (EV_A_ &w->timer);
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 #endif
 
@@ -2339,6 +2667,8 @@ ev_idle_start (EV_P_ ev_idle *w)
 
   pri_adjust (EV_A_ (W)w);
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ++idlecnt [ABSPRI (w)];
 
@@ -2348,6 +2678,8 @@ ev_idle_start (EV_P_ ev_idle *w)
     array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);
     idles [ABSPRI (w)][active - 1] = w;
   }
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2357,15 +2689,19 @@ ev_idle_stop (EV_P_ ev_idle *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
-    int active = ((W)w)->active;
+    int active = ev_active (w);
 
     idles [ABSPRI (w)][active - 1] = idles [ABSPRI (w)][--idlecnt [ABSPRI (w)]];
-    ((W)idles [ABSPRI (w)][active - 1])->active = active;
+    ev_active (idles [ABSPRI (w)][active - 1]) = active;
 
     ev_stop (EV_A_ (W)w);
     --idleall;
   }
+
+  EV_FREQUENT_CHECK;
 }
 #endif
 
@@ -2375,9 +2711,13 @@ ev_prepare_start (EV_P_ ev_prepare *w)
   if (expect_false (ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   ev_start (EV_A_ (W)w, ++preparecnt);
   array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
   prepares [preparecnt - 1] = w;
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2387,13 +2727,18 @@ ev_prepare_stop (EV_P_ ev_prepare *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
-    int active = ((W)w)->active;
+    int active = ev_active (w);
+
     prepares [active - 1] = prepares [--preparecnt];
-    ((W)prepares [active - 1])->active = active;
+    ev_active (prepares [active - 1]) = active;
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2402,9 +2747,13 @@ ev_check_start (EV_P_ ev_check *w)
   if (expect_false (ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   ev_start (EV_A_ (W)w, ++checkcnt);
   array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
   checks [checkcnt - 1] = w;
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2414,13 +2763,18 @@ ev_check_stop (EV_P_ ev_check *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
-    int active = ((W)w)->active;
+    int active = ev_active (w);
+
     checks [active - 1] = checks [--checkcnt];
-    ((W)checks [active - 1])->active = active;
+    ev_active (checks [active - 1]) = active;
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 #if EV_EMBED_ENABLE
@@ -2477,6 +2831,8 @@ ev_embed_start (EV_P_ ev_embed *w)
     ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ);
   }
 
+  EV_FREQUENT_CHECK;
+
   ev_set_priority (&w->io, ev_priority (w));
   ev_io_start (EV_A_ &w->io);
 
@@ -2487,6 +2843,8 @@ ev_embed_start (EV_P_ ev_embed *w)
   /*ev_idle_init (&w->idle, e,bed_idle_cb);*/
 
   ev_start (EV_A_ (W)w, 1);
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2496,10 +2854,14 @@ ev_embed_stop (EV_P_ ev_embed *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   ev_io_stop (EV_A_ &w->io);
   ev_prepare_stop (EV_A_ &w->prepare);
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 #endif
 
@@ -2510,9 +2872,13 @@ ev_fork_start (EV_P_ ev_fork *w)
   if (expect_false (ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   ev_start (EV_A_ (W)w, ++forkcnt);
   array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);
   forks [forkcnt - 1] = w;
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2522,13 +2888,18 @@ ev_fork_stop (EV_P_ ev_fork *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
-    int active = ((W)w)->active;
+    int active = ev_active (w);
+
     forks [active - 1] = forks [--forkcnt];
-    ((W)forks [active - 1])->active = active;
+    ev_active (forks [active - 1]) = active;
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 #endif
 
@@ -2541,9 +2912,13 @@ ev_async_start (EV_P_ ev_async *w)
 
   evpipe_init (EV_A);
 
+  EV_FREQUENT_CHECK;
+
   ev_start (EV_A_ (W)w, ++asynccnt);
   array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);
   asyncs [asynccnt - 1] = w;
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2553,13 +2928,18 @@ ev_async_stop (EV_P_ ev_async *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
-    int active = ((W)w)->active;
+    int active = ev_active (w);
+
     asyncs [active - 1] = asyncs [--asynccnt];
-    ((W)asyncs [active - 1])->active = active;
+    ev_active (asyncs [active - 1]) = active;
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 void