*** empty log message ***

ev.c

@@ -290,6 +290,17 @@ int eventfd (unsigned int initval, int flags);
 
 /**/
 
+/* undefined or zero: no verification done or available */
+/* 1 or higher: ev_loop_verify function available */
+/* 2 or higher: ev_loop_verify is called frequently */
+#define EV_VERIFY 1
+
+#if EV_VERIFY > 1
+# 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
@@ -446,15 +457,15 @@ typedef struct
     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_set(he) (he).at = (he).w->at /* update at from watcher */
+  #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_set(he)
+  #define ANHE_w(he)        (he)
+  #define ANHE_at(he)       (he)->at
+  #define ANHE_at_cache(he)
 #endif
 
 #if EV_MULTIPLICITY
@@ -805,28 +816,7 @@ fd_rearm_all (EV_P)
 #define DHEAP 4
 #define HEAP0 (DHEAP - 1) /* index of first element in heap */
 #define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
-
-/* towards the root */
-void inline_speed
-upheap (ANHE *heap, int k)
-{
-  ANHE he = heap [k];
-
-  for (;;)
-    {
-      int p = HPARENT (k);
-
-      if (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;
-}
+#define UPHEAP_DONE(p,k) ((p) == (k))
 
 /* away from the root */
 void inline_speed
@@ -839,9 +829,9 @@ downheap (ANHE *heap, int N, int k)
     {
       ev_tstamp minat;
       ANHE *minpos;
-      ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0;
+      ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
 
-      // find minimum child
+      /* find minimum child */
       if (expect_true (pos + DHEAP - 1 < E))
         {
           /* fast path */                               (minpos = pos + 0), (minat = ANHE_at (*minpos));
@@ -872,63 +862,63 @@ downheap (ANHE *heap, int N, int k)
   ev_active (ANHE_w (he)) = k;
 }
 
-#else // 4HEAP
+#else /* 4HEAP */
 
 #define HEAP0 1
 #define HPARENT(k) ((k) >> 1)
+#define UPHEAP_DONE(p,k) (!(p))
 
-/* towards the root */
+/* away from the root */
 void inline_speed
-upheap (ANHE *heap, int k)
+downheap (ANHE *heap, int N, int k)
 {
   ANHE he = heap [k];
 
   for (;;)
     {
-      int p = HPARENT (k);
+      int c = k << 1;
 
-      /* maybe we could use a dummy element at heap [0]? */
-      if (!p || ANHE_at (heap [p]) <= ANHE_at (he))
+      if (c > N + HEAP0 - 1)
         break;
 
-      heap [k] = heap [p];
+      c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
+           ? 1 : 0;
+
+      if (ANHE_at (he) <= ANHE_at (heap [c]))
+        break;
+
+      heap [k] = heap [c];
       ev_active (ANHE_w (heap [k])) = k;
-      k = p;
+      
+      k = c;
     }
 
   heap [k] = he;
-  ev_active (ANHE_w (heap [k])) = k;
+  ev_active (ANHE_w (he)) = k;
 }
+#endif
 
-/* away from the root */
+/* towards the root */
 void inline_speed
-downheap (ANHE *heap, int N, int k)
+upheap (ANHE *heap, int k)
 {
   ANHE he = heap [k];
 
   for (;;)
     {
-      int c = k << 1;
-
-      if (c > N)
-        break;
-
-      c += c + 1 < N && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
-           ? 1 : 0;
+      int p = HPARENT (k);
 
-      if (ANHE_at (he) <= ANHE_at (heap [c]))
+      if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
         break;
 
-      heap [k] = heap [c];
+      heap [k] = heap [p];
       ev_active (ANHE_w (heap [k])) = k;
-      
-      k = c;
+      k = p;
     }
 
   heap [k] = he;
   ev_active (ANHE_w (he)) = k;
 }
-#endif
 
 void inline_size
 adjustheap (ANHE *heap, int N, int k)
@@ -939,6 +929,32 @@ adjustheap (ANHE *heap, int N, int k)
     downheap (heap, N, k);
 }
 
+/* rebuild the heap: this function is used only once and executed rarely */
+void inline_size
+reheap (ANHE *heap, int N)
+{
+  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);
+}
+
+#if EV_VERIFY
+static void
+checkheap (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]))));
+    }
+}
+#endif
+
 /*****************************************************************************/
 
 typedef struct
@@ -1491,6 +1507,40 @@ ev_loop_fork (EV_P)
 {
   postfork = 1; /* must be in line with ev_default_fork */
 }
+
+#if EV_VERIFY
+static void
+array_check (W **ws, int cnt)
+{
+  while (cnt--)
+    assert (("active index mismatch", ev_active (ws [cnt]) == cnt + 1));
+}
+
+static void
+ev_loop_verify (EV_P)
+{
+  int i;
+
+  checkheap (timers, timercnt);
+#if EV_PERIODIC_ENABLE
+  checkheap (periodics, periodiccnt);
+#endif
+
+#if EV_IDLE_ENABLE
+  for (i = NUMPRI; i--; )
+    array_check ((W **)idles [i], idlecnt [i]);
+#endif
+#if EV_FORK_ENABLE
+  array_check ((W **)forks, forkcnt);
+#endif
+  array_check ((W **)prepares, preparecnt);
+  array_check ((W **)checks, checkcnt);
+#if EV_ASYNC_ENABLE
+  array_check ((W **)asyncs, asynccnt);
+#endif
+}
+#endif
+
 #endif
 
 #if EV_MULTIPLICITY
@@ -1566,6 +1616,8 @@ call_pending (EV_P)
 {
   int pri;
 
+  EV_FREQUENT_CHECK;
+
   for (pri = NUMPRI; pri--; )
     while (pendingcnt [pri])
       {
@@ -1579,6 +1631,8 @@ call_pending (EV_P)
             EV_CB_INVOKE (p->w, p->events);
           }
       }
+
+  EV_FREQUENT_CHECK;
 }
 
 #if EV_IDLE_ENABLE
@@ -1607,6 +1661,8 @@ idle_reify (EV_P)
 void inline_size
 timers_reify (EV_P)
 {
+  EV_FREQUENT_CHECK;
+
   while (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
     {
       ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
@@ -1622,12 +1678,13 @@ timers_reify (EV_P)
 
           assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
 
-          ANHE_at_set (timers [HEAP0]);
+          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);
     }
 }
@@ -1636,6 +1693,7 @@ timers_reify (EV_P)
 void inline_size
 periodics_reify (EV_P)
 {
+  EV_FREQUENT_CHECK;
   while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
     {
       ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
@@ -1649,8 +1707,9 @@ periodics_reify (EV_P)
 
           assert (("ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now));
 
-          ANHE_at_set (periodics [HEAP0]);
+          ANHE_at_cache (periodics [HEAP0]);
           downheap (periodics, periodiccnt, HEAP0);
+          EV_FREQUENT_CHECK;
         }
       else if (w->interval)
         {
@@ -1668,12 +1727,13 @@ periodics_reify (EV_P)
                 ev_at (w) = ev_rt_now;
             }
 
-          ANHE_at_set (periodics [HEAP0]);
+          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);
     }
 }
@@ -1693,13 +1753,10 @@ periodics_reschedule (EV_P)
       else if (w->interval)
         ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
 
-      ANHE_at_set (periodics [i]);
+      ANHE_at_cache (periodics [i]);
     }
 
-  /* we don't use floyds algorithm, uphead is simpler and is more cache-efficient */
-  /* also, this is easy and corretc for both 2-heaps and 4-heaps */
-  for (i = 0; i < periodiccnt; ++i)
-    upheap (periodics, i + HEAP0);
+  reheap (periodics, periodiccnt);
 }
 #endif
 
@@ -1767,7 +1824,7 @@ time_update (EV_P_ ev_tstamp max_block)
             {
               ANHE *he = timers + i + HEAP0;
               ANHE_w (*he)->at += ev_rt_now - mn_now;
-              ANHE_at_set (*he);
+              ANHE_at_cache (*he);
             }
         }
 
@@ -2002,12 +2059,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
@@ -2019,10 +2080,14 @@ ev_io_stop (EV_P_ ev_io *w)
 
   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
@@ -2035,12 +2100,17 @@ ev_timer_start (EV_P_ ev_timer *w)
 
   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
 
-  ev_start (EV_A_ (W)w, ++timercnt + HEAP0 - 1);
+  EV_FREQUENT_CHECK;
+
+  ++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_set (timers [ev_active (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));*/
 }
 
@@ -2051,20 +2121,24 @@ ev_timer_stop (EV_P_ ev_timer *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ev_active (w);
 
     assert (("internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
 
-    if (expect_true (active < timercnt + HEAP0 - 1))
+    --timercnt;
+
+    if (expect_true (active < timercnt + HEAP0))
       {
-        timers [active] = timers [timercnt + HEAP0 - 1];
+        timers [active] = timers [timercnt + HEAP0];
         adjustheap (timers, timercnt, active);
       }
-
-    --timercnt;
   }
 
+  EV_FREQUENT_CHECK;
+
   ev_at (w) -= mn_now;
 
   ev_stop (EV_A_ (W)w);
@@ -2073,12 +2147,14 @@ 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)
         {
           ev_at (w) = mn_now + w->repeat;
-          ANHE_at_set (timers [ev_active (w)]);
+          ANHE_at_cache (timers [ev_active (w)]);
           adjustheap (timers, timercnt, ev_active (w));
         }
       else
@@ -2089,6 +2165,8 @@ ev_timer_again (EV_P_ ev_timer *w)
       ev_at (w) = w->repeat;
       ev_timer_start (EV_A_ w);
     }
+
+  EV_FREQUENT_CHECK;
 }
 
 #if EV_PERIODIC_ENABLE
@@ -2109,12 +2187,17 @@ ev_periodic_start (EV_P_ ev_periodic *w)
   else
     ev_at (w) = w->offset;
 
-  ev_start (EV_A_ (W)w, ++periodiccnt + HEAP0 - 1);
+  EV_FREQUENT_CHECK;
+
+  ++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_set (periodics [ev_active (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));*/
 }
 
@@ -2125,20 +2208,24 @@ ev_periodic_stop (EV_P_ ev_periodic *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ev_active (w);
 
     assert (("internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
 
-    if (expect_true (active < periodiccnt + HEAP0 - 1))
+    --periodiccnt;
+
+    if (expect_true (active < periodiccnt + HEAP0))
       {
-        periodics [active] = periodics [periodiccnt + HEAP0 - 1];
+        periodics [active] = periodics [periodiccnt + HEAP0];
         adjustheap (periodics, periodiccnt, active);
       }
-
-    --periodiccnt;
   }
 
+  EV_FREQUENT_CHECK;
+
   ev_stop (EV_A_ (W)w);
 }
 
@@ -2168,6 +2255,8 @@ ev_signal_start (EV_P_ ev_signal *w)
 
   evpipe_init (EV_A);
 
+  EV_FREQUENT_CHECK;
+
   {
 #ifndef _WIN32
     sigset_t full, prev;
@@ -2197,6 +2286,8 @@ ev_signal_start (EV_P_ ev_signal *w)
       sigaction (w->signum, &sa, 0);
 #endif
     }
+
+  EV_FREQUENT_CHECK;
 }
 
 void noinline
@@ -2206,11 +2297,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
@@ -2222,8 +2317,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
@@ -2233,8 +2332,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
@@ -2472,6 +2575,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
@@ -2481,12 +2586,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
 
@@ -2499,6 +2608,8 @@ ev_idle_start (EV_P_ ev_idle *w)
 
   pri_adjust (EV_A_ (W)w);
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ++idlecnt [ABSPRI (w)];
 
@@ -2508,6 +2619,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
@@ -2517,6 +2630,8 @@ ev_idle_stop (EV_P_ ev_idle *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ev_active (w);
 
@@ -2526,6 +2641,8 @@ ev_idle_stop (EV_P_ ev_idle *w)
     ev_stop (EV_A_ (W)w);
     --idleall;
   }
+
+  EV_FREQUENT_CHECK;
 }
 #endif
 
@@ -2535,9 +2652,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
@@ -2547,6 +2668,8 @@ ev_prepare_stop (EV_P_ ev_prepare *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ev_active (w);
 
@@ -2555,6 +2678,8 @@ ev_prepare_stop (EV_P_ ev_prepare *w)
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 void
@@ -2563,9 +2688,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
@@ -2575,6 +2704,8 @@ ev_check_stop (EV_P_ ev_check *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ev_active (w);
 
@@ -2583,6 +2714,8 @@ ev_check_stop (EV_P_ ev_check *w)
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 #if EV_EMBED_ENABLE
@@ -2639,6 +2772,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);
 
@@ -2649,6 +2784,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
@@ -2658,10 +2795,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
 
@@ -2672,9 +2813,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
@@ -2684,6 +2829,8 @@ ev_fork_stop (EV_P_ ev_fork *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ev_active (w);
 
@@ -2692,6 +2839,8 @@ ev_fork_stop (EV_P_ ev_fork *w)
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 #endif
 
@@ -2704,9 +2853,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
@@ -2716,6 +2869,8 @@ ev_async_stop (EV_P_ ev_async *w)
   if (expect_false (!ev_is_active (w)))
     return;
 
+  EV_FREQUENT_CHECK;
+
   {
     int active = ev_active (w);
 
@@ -2724,6 +2879,8 @@ ev_async_stop (EV_P_ ev_async *w)
   }
 
   ev_stop (EV_A_ (W)w);
+
+  EV_FREQUENT_CHECK;
 }
 
 void

ev.h

@@ -166,6 +166,15 @@ struct ev_loop;
  * private: you can look at them, but not change them, and they might not mean anything to you.
  * ro: can be read anytime, but only changed when the watcher isn't active
  * rw: can be read and modified anytime, even when the watcher is active
+ *
+ * some internal details that might be helpful for debugging:
+ *
+ * active is either 0, which means the watcher is not active,
+ *           or the array index of the watcher (periodics, timers)
+ *           or the array index + 1 (most other watchers)
+ *           or simply 1 for watchers that aren't in some array.
+ * pending is either 0, in which case the watcher isn't,
+ *            or the array index + 1 in the pendings array.
  */
 
 /* shared by all watchers */