[ViewVC] Diff of: cvs/libev/ev.c

Comparing libev/ev.c (file contents):
Revision 1.205 by root, Sun Jan 20 15:37:03 2008 UTC vs.
Revision 1.264 by root, Mon Oct 13 23:20:12 2008 UTC

 /*
  * libev event processing core, watcher management
  *
- * 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-
  * tion, are permitted provided that the following conditions are met:
  *
 #ifdef __cplusplus
 extern "C" {
 #endif
+/* this big block deduces configuration from config.h */
 #ifndef EV_STANDALONE
 # ifdef EV_CONFIG_H
 #  include EV_CONFIG_H
 # else
 #  include "config.h"
 #  else
 #   define EV_USE_INOTIFY 0
 #  endif
 # endif
+# ifndef EV_USE_EVENTFD
+#  if HAVE_EVENTFD
+#   define EV_USE_EVENTFD 1
+#  else
+#   define EV_USE_EVENTFD 0
+#  endif
+# endif
 #endif
 #include <math.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #ifndef _WIN32
 # include <sys/time.h>
 # include <sys/wait.h>
 # include <unistd.h>
 #else
+# include <io.h>
 # define WIN32_LEAN_AND_MEAN
 # include <windows.h>
 # ifndef EV_SELECT_IS_WINSOCKET
 #  define EV_SELECT_IS_WINSOCKET 1
 # endif
 #endif
-/**/
+/* this block tries to deduce configuration from header-defined symbols and defaults */
 #ifndef EV_USE_MONOTONIC
+# if defined (_POSIX_MONOTONIC_CLOCK) && _POSIX_MONOTONIC_CLOCK >= 0
+#  define EV_USE_MONOTONIC 1
+# else
-# define EV_USE_MONOTONIC 0
+#  define EV_USE_MONOTONIC 0
+# endif
 #endif
 #ifndef EV_USE_REALTIME
 # define EV_USE_REALTIME 0
 #endif
 #ifndef EV_USE_NANOSLEEP
+# if _POSIX_C_SOURCE >= 199309L
+#  define EV_USE_NANOSLEEP 1
+# else
-# define EV_USE_NANOSLEEP 0
+#  define EV_USE_NANOSLEEP 0
+# endif
 #endif
 #ifndef EV_USE_SELECT
 # define EV_USE_SELECT 1
 #endif
 #  define EV_USE_POLL 1
 # endif
 #endif
 #ifndef EV_USE_EPOLL
+# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
+#  define EV_USE_EPOLL 1
+# else
-# define EV_USE_EPOLL 0
+#  define EV_USE_EPOLL 0
+# endif
 #endif
 #ifndef EV_USE_KQUEUE
 # define EV_USE_KQUEUE 0
 #endif
 #ifndef EV_USE_PORT
 # define EV_USE_PORT 0
 #endif
 #ifndef EV_USE_INOTIFY
+# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
+#  define EV_USE_INOTIFY 1
+# else
-# define EV_USE_INOTIFY 0
+#  define EV_USE_INOTIFY 0
+# endif
 #endif
 #ifndef EV_PID_HASHSIZE
 # if EV_MINIMAL
 #  define EV_PID_HASHSIZE 1
 # else
 #  define EV_INOTIFY_HASHSIZE 16
 # endif
 #endif
-/**/
+#ifndef EV_USE_EVENTFD
+# if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
+#  define EV_USE_EVENTFD 1
+# else
+#  define EV_USE_EVENTFD 0
+# 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
 # undef EV_USE_MONOTONIC
 # define EV_USE_MONOTONIC 0
 #endif
 #  include <sys/select.h>
 # endif
 #endif
 #if EV_USE_INOTIFY
+# include <sys/utsname.h>
 # include <sys/inotify.h>
+/* some very old inotify.h headers don't have IN_DONT_FOLLOW */
+# ifndef IN_DONT_FOLLOW
+#  undef EV_USE_INOTIFY
+#  define EV_USE_INOTIFY 0
+# endif
 #endif
 #if EV_SELECT_IS_WINSOCKET
 # include <winsock.h>
 #endif
+#if EV_USE_EVENTFD
+/* our minimum requirement is glibc 2.7 which has the stub, but not the header */
+# include <stdint.h>
+# ifdef __cplusplus
+extern "C" {
+# endif
+int eventfd (unsigned int initval, int flags);
+# ifdef __cplusplus
+}
+# endif
+#endif
 /**/
+#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
  * to ensure progress, time-wise, even when rounding
 # define expect(expr,value)         __builtin_expect ((expr),(value))
 # define noinline                   __attribute__ ((noinline))
 #else
 # define expect(expr,value)         (expr)
 # define noinline
-# if __STDC_VERSION__ < 199901L
+# if __STDC_VERSION__ < 199901L && __GNUC__ < 2
 #  define inline
 # endif
 #endif
 #define expect_false(expr) expect ((expr) != 0, 0)
 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 */
-static sig_atomic_t have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
+static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 #endif
 #ifdef _WIN32
 # include "ev_win32.c"
 #endif
       perror (msg);
       abort ();
     }
 }
+static void *
+ev_realloc_emul (void *ptr, long size)
+{
+  /* some systems, notably openbsd and darwin, fail to properly
+   * implement realloc (x, 0) (as required by both ansi c-98 and
+   * the single unix specification, so work around them here.
+   */
+  if (size)
+    return realloc (ptr, size);
+  free (ptr);
+  return 0;
+}
-static void *(*alloc)(void *ptr, long size);
+static void *(*alloc)(void *ptr, long size) = ev_realloc_emul;
 void
 ev_set_allocator (void *(*cb)(void *ptr, long size))
 {
   alloc = cb;
 }
 inline_speed void *
 ev_realloc (void *ptr, long size)
 {
-  ptr = alloc ? alloc (ptr, size) : realloc (ptr, size);
+  ptr = alloc (ptr, size);
   if (!ptr && size)
     {
       fprintf (stderr, "libev: cannot allocate %ld bytes, aborting.", size);
       abort ();
   W w;
   int events;
 } 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
       ts.tv_sec  = (time_t)delay;
       ts.tv_nsec = (long)((delay - (ev_tstamp)(ts.tv_sec)) * 1e9);
       nanosleep (&ts, 0);
 #elif defined(_WIN32)
-      Sleep (delay * 1e3);
+      Sleep ((unsigned long)(delay * 1e3));
 #else
       struct timeval tv;
       tv.tv_sec  = (time_t)delay;
       tv.tv_usec = (long)((delay - (ev_tstamp)(tv.tv_sec)) * 1e6);
+      /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
+      /* somehting nto guaranteed by newer posix versions, but guaranteed */
+      /* by older ones */
       select (0, 0, 0, 0, &tv);
 #endif
     }
 }
 /*****************************************************************************/
+#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)
 {
   int ncur = cur + 1;
   do
     ncur <<= 1;
   while (cnt > ncur);
-  /* if size > 4096, round to 4096 - 4 * longs to accomodate malloc overhead */
+  /* if size is large, round to MALLOC_ROUND - 4 * longs to accomodate malloc overhead */
-  if (elem * ncur > 4096)
+  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;
     }
   return ncur;
         events |= (unsigned char)w->events;
 #if EV_SELECT_IS_WINSOCKET
       if (events)
         {
-          unsigned long argp;
+          unsigned long arg;
           #ifdef EV_FD_TO_WIN32_HANDLE
             anfd->handle = EV_FD_TO_WIN32_HANDLE (fd);
           #else
             anfd->handle = _get_osfhandle (fd);
           #endif
-          assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &argp) == 0));
+          assert (("libev only supports socket fds in this configuration", ioctlsocket (anfd->handle, FIONREAD, &arg) == 0));
         }
 #endif
       {
         unsigned char o_events = anfd->events;
 {
   int fd;
   for (fd = 0; fd < anfdmax; ++fd)
     if (anfds [fd].events)
-      if (!fd_valid (fd) == -1 && errno == EBADF)
+      if (!fd_valid (fd) && errno == EBADF)
         fd_kill (EV_A_ fd);
 }
 /* called on ENOMEM in select/poll to kill some fds and retry */
 static void noinline
       }
 }
 /*****************************************************************************/
+/*
+ * 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;
+      if (ANHE_at (he) <= minat)
+        break;
+      heap [k] = *minpos;
+      ev_active (ANHE_w (*minpos)) = k;
+      k = minpos - heap;
+    }
+  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 (ANHE *heap, int N, int k)
+{
+  ANHE he = heap [k];
+  for (;;)
+    {
+      int c = k << 1;
+      if (c > N + HEAP0 - 1)
+        break;
+      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 = c;
+    }
+  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];
-      ((W)heap [k])->active = k + 1;
+      ev_active (ANHE_w (heap [k])) = k;
       k = p;
     }
-  heap [k] = w;
+  heap [k] = he;
-  ((W)heap [k])->active = k + 1;
+  ev_active (ANHE_w (he)) = k;
-}
-void inline_speed
-downheap (WT *heap, int N, int k)
-{
-  WT w = heap [k];
-  for (;;)
-    {
-      int c = (k << 1) + 1;
-      if (c >= N)
-        break;
-      c += c + 1 < N && heap [c]->at > heap [c + 1]->at
-           ? 1 : 0;
-      if (w->at <= heap [c]->at)
-        break;
-      heap [k] = heap [c];
-      ((W)heap [k])->active = k + 1;
-      k = c;
-    }
-  heap [k] = w;
-  ((W)heap [k])->active = k + 1;
 }
 void inline_size
-adjustheap (WT *heap, int N, int k)
+adjustheap (ANHE *heap, int N, int k)
 {
+  if (k > HEAP0 && ANHE_at (heap [HPARENT (k)]) >= ANHE_at (heap [k]))
-  upheap (heap, k);
+    upheap (heap, k);
+  else
-  downheap (heap, N, 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);
 }
 /*****************************************************************************/
 typedef struct
 {
   WL head;
-  sig_atomic_t volatile gotsig;
+  EV_ATOMIC_T gotsig;
 } ANSIG;
 static ANSIG *signals;
 static int signalmax;
-static int sigpipe [2];
+static EV_ATOMIC_T gotsig;
-static sig_atomic_t volatile gotsig;
-static ev_io sigev;
 void inline_size
 signals_init (ANSIG *base, int count)
 {
   while (count--)
       ++base;
     }
 }
-static void
+/*****************************************************************************/
-sighandler (int signum)
-{
-#if _WIN32
-  signal (signum, sighandler);
-#endif
-  signals [signum - 1].gotsig = 1;
-  if (!gotsig)
-    {
-      int old_errno = errno;
-      gotsig = 1;
-      write (sigpipe [1], &signum, 1);
-      errno = old_errno;
-    }
-}
-void noinline
-ev_feed_signal_event (EV_P_ int signum)
-{
-  WL w;
-#if EV_MULTIPLICITY
-  assert (("feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
-#endif
-  --signum;
-  if (signum < 0 || signum >= signalmax)
-    return;
-  signals [signum].gotsig = 0;
-  for (w = signals [signum].head; w; w = w->next)
-    ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
-}
-static void
-sigcb (EV_P_ ev_io *iow, int revents)
-{
-  int signum;
-  read (sigpipe [0], &revents, 1);
-  gotsig = 0;
-  for (signum = signalmax; signum--; )
-    if (signals [signum].gotsig)
-      ev_feed_signal_event (EV_A_ signum + 1);
-}
 void inline_speed
 fd_intern (int fd)
 {
 #ifdef _WIN32
-  int arg = 1;
+  unsigned long arg = 1;
   ioctlsocket (_get_osfhandle (fd), FIONBIO, &arg);
 #else
   fcntl (fd, F_SETFD, FD_CLOEXEC);
   fcntl (fd, F_SETFL, O_NONBLOCK);
 #endif
 }
 static void noinline
-siginit (EV_P)
+evpipe_init (EV_P)
 {
+  if (!ev_is_active (&pipeev))
+    {
+#if EV_USE_EVENTFD
+      if ((evfd = eventfd (0, 0)) >= 0)
+        {
+          evpipe [0] = -1;
+          fd_intern (evfd);
+          ev_io_set (&pipeev, evfd, EV_READ);
+        }
+      else
+#endif
+        {
+          while (pipe (evpipe))
+            syserr ("(libev) error creating signal/async pipe");
-  fd_intern (sigpipe [0]);
+          fd_intern (evpipe [0]);
-  fd_intern (sigpipe [1]);
+          fd_intern (evpipe [1]);
+          ev_io_set (&pipeev, evpipe [0], EV_READ);
+        }
-  ev_io_set (&sigev, sigpipe [0], EV_READ);
-  ev_io_start (EV_A_ &sigev);
+      ev_io_start (EV_A_ &pipeev);
-  ev_unref (EV_A); /* child watcher should not keep loop alive */
+      ev_unref (EV_A); /* watcher should not keep loop alive */
+    }
+}
+void inline_size
+evpipe_write (EV_P_ EV_ATOMIC_T *flag)
+{
+  if (!*flag)
+    {
+      int old_errno = errno; /* save errno because write might clobber it */
+      *flag = 1;
+#if EV_USE_EVENTFD
+      if (evfd >= 0)
+        {
+          uint64_t counter = 1;
+          write (evfd, &counter, sizeof (uint64_t));
+        }
+      else
+#endif
+        write (evpipe [1], &old_errno, 1);
+      errno = old_errno;
+    }
+}
+static void
+pipecb (EV_P_ ev_io *iow, int revents)
+{
+#if EV_USE_EVENTFD
+  if (evfd >= 0)
+    {
+      uint64_t counter;
+      read (evfd, &counter, sizeof (uint64_t));
+    }
+  else
+#endif
+    {
+      char dummy;
+      read (evpipe [0], &dummy, 1);
+    }
+  if (gotsig && ev_is_default_loop (EV_A))
+    {
+      int signum;
+      gotsig = 0;
+      for (signum = signalmax; signum--; )
+        if (signals [signum].gotsig)
+          ev_feed_signal_event (EV_A_ signum + 1);
+    }
+#if EV_ASYNC_ENABLE
+  if (gotasync)
+    {
+      int i;
+      gotasync = 0;
+      for (i = asynccnt; i--; )
+        if (asyncs [i]->sent)
+          {
+            asyncs [i]->sent = 0;
+            ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
+          }
+    }
+#endif
 }
 /*****************************************************************************/
+static void
+ev_sighandler (int signum)
+{
+#if EV_MULTIPLICITY
+  struct ev_loop *loop = &default_loop_struct;
+#endif
+#if _WIN32
+  signal (signum, ev_sighandler);
+#endif
+  signals [signum - 1].gotsig = 1;
+  evpipe_write (EV_A_ &gotsig);
+}
+void noinline
+ev_feed_signal_event (EV_P_ int signum)
+{
+  WL w;
+#if EV_MULTIPLICITY
+  assert (("feeding signal events is only supported in the default loop", loop == ev_default_loop_ptr));
+#endif
+  --signum;
+  if (signum < 0 || signum >= signalmax)
+    return;
+  signals [signum].gotsig = 0;
+  for (w = signals [signum].head; w; w = w->next)
+    ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
+}
+/*****************************************************************************/
 static WL childs [EV_PID_HASHSIZE];
 #ifndef _WIN32
 static ev_signal childev;
+#ifndef WIFCONTINUED
+# define WIFCONTINUED(status) 0
+#endif
 void inline_speed
-child_reap (EV_P_ ev_signal *sw, int chain, int pid, int status)
+child_reap (EV_P_ int chain, int pid, int status)
 {
   ev_child *w;
+  int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
   for (w = (ev_child *)childs [chain & (EV_PID_HASHSIZE - 1)]; w; w = (ev_child *)((WL)w)->next)
+    {
-    if (w->pid == pid || !w->pid)
+      if ((w->pid == pid || !w->pid)
+          && (!traced || (w->flags & 1)))
-      {
+        {
-        ev_set_priority (w, ev_priority (sw)); /* need to do it *now* */
+          ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
-        w->rpid    = pid;
+          w->rpid    = pid;
-        w->rstatus = status;
+          w->rstatus = status;
-        ev_feed_event (EV_A_ (W)w, EV_CHILD);
+          ev_feed_event (EV_A_ (W)w, EV_CHILD);
-      }
+        }
+    }
 }
 #ifndef WCONTINUED
 # define WCONTINUED 0
 #endif
     if (!WCONTINUED
         || errno != EINVAL
         || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
       return;
-  /* make sure we are called again until all childs have been reaped */
+  /* make sure we are called again until all children have been reaped */
   /* we need to do it this way so that the callback gets called before we continue */
   ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
-  child_reap (EV_A_ sw, pid, pid, status);
+  child_reap (EV_A_ pid, pid, status);
   if (EV_PID_HASHSIZE > 1)
-    child_reap (EV_A_ sw, 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
+    child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
 }
 #endif
 /*****************************************************************************/
         if (!clock_gettime (CLOCK_MONOTONIC, &ts))
           have_monotonic = 1;
       }
 #endif
-      ev_rt_now = ev_time ();
+      ev_rt_now         = ev_time ();
-      mn_now    = get_clock ();
+      mn_now            = get_clock ();
-      now_floor = mn_now;
+      now_floor         = mn_now;
-      rtmn_diff = ev_rt_now - mn_now;
+      rtmn_diff         = ev_rt_now - mn_now;
       io_blocktime      = 0.;
       timeout_blocktime = 0.;
+      backend           = 0;
+      backend_fd        = -1;
+      gotasync          = 0;
+#if EV_USE_INOTIFY
+      fs_fd             = -2;
+#endif
       /* pid check not overridable via env */
 #ifndef _WIN32
       if (flags & EVFLAG_FORKCHECK)
         curpid = getpid ();
       if (!(flags & EVFLAG_NOENV)
           && !enable_secure ()
           && getenv ("LIBEV_FLAGS"))
         flags = atoi (getenv ("LIBEV_FLAGS"));
-      if (!(flags & 0x0000ffffUL))
+      if (!(flags & 0x0000ffffU))
         flags |= ev_recommended_backends ();
-      backend = 0;
-      backend_fd = -1;
-#if EV_USE_INOTIFY
-      fs_fd = -2;
-#endif
 #if EV_USE_PORT
       if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);
 #endif
 #if EV_USE_KQUEUE
 #endif
 #if EV_USE_SELECT
       if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
 #endif
-      ev_init (&sigev, sigcb);
+      ev_init (&pipeev, pipecb);
-      ev_set_priority (&sigev, EV_MAXPRI);
+      ev_set_priority (&pipeev, EV_MAXPRI);
     }
 }
 static void noinline
 loop_destroy (EV_P)
 {
   int i;
+  if (ev_is_active (&pipeev))
+    {
+      ev_ref (EV_A); /* signal watcher */
+      ev_io_stop (EV_A_ &pipeev);
+#if EV_USE_EVENTFD
+      if (evfd >= 0)
+        close (evfd);
+#endif
+      if (evpipe [0] >= 0)
+        {
+          close (evpipe [0]);
+          close (evpipe [1]);
+        }
+    }
 #if EV_USE_INOTIFY
   if (fs_fd >= 0)
     close (fs_fd);
 #endif
 #if EV_FORK_ENABLE
   array_free (fork, EMPTY);
 #endif
   array_free (prepare, EMPTY);
   array_free (check, EMPTY);
+#if EV_ASYNC_ENABLE
+  array_free (async, EMPTY);
+#endif
   backend = 0;
 }
+#if EV_USE_INOTIFY
 void inline_size infy_fork (EV_P);
+#endif
 void inline_size
 loop_fork (EV_P)
 {
 #if EV_USE_PORT
 #endif
 #if EV_USE_INOTIFY
   infy_fork (EV_A);
 #endif
-  if (ev_is_active (&sigev))
+  if (ev_is_active (&pipeev))
     {
-      /* default loop */
+      /* this "locks" the handlers against writing to the pipe */
+      /* while we modify the fd vars */
+      gotsig = 1;
+#if EV_ASYNC_ENABLE
+      gotasync = 1;
+#endif
       ev_ref (EV_A);
-      ev_io_stop (EV_A_ &sigev);
+      ev_io_stop (EV_A_ &pipeev);
+#if EV_USE_EVENTFD
+      if (evfd >= 0)
+        close (evfd);
+#endif
+      if (evpipe [0] >= 0)
+        {
-      close (sigpipe [0]);
+          close (evpipe [0]);
-      close (sigpipe [1]);
+          close (evpipe [1]);
+        }
-      while (pipe (sigpipe))
-        syserr ("(libev) error creating pipe");
-      siginit (EV_A);
+      evpipe_init (EV_A);
+      /* now iterate over everything, in case we missed something */
-      sigcb (EV_A_ &sigev, EV_READ);
+      pipecb (EV_A_ &pipeev, EV_READ);
     }
   postfork = 0;
 }
 #if EV_MULTIPLICITY
 struct ev_loop *
 ev_loop_new (unsigned int flags)
 {
   struct ev_loop *loop = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
 ev_loop_fork (EV_P)
 {
   postfork = 1; /* must be in line with ev_default_fork */
 }
+#if EV_VERIFY
+static 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
+}
+#endif /* multiplicity */
 #if EV_MULTIPLICITY
 struct ev_loop *
 ev_default_loop_init (unsigned int flags)
 #else
 int
 ev_default_loop (unsigned int flags)
 #endif
 {
-  if (sigpipe [0] == sigpipe [1])
-    if (pipe (sigpipe))
-      return 0;
   if (!ev_default_loop_ptr)
     {
 #if EV_MULTIPLICITY
       struct ev_loop *loop = ev_default_loop_ptr = &default_loop_struct;
 #else
       loop_init (EV_A_ flags);
       if (ev_backend (EV_A))
         {
-          siginit (EV_A);
 #ifndef _WIN32
           ev_signal_init (&childev, childcb, SIGCHLD);
           ev_set_priority (&childev, EV_MAXPRI);
           ev_signal_start (EV_A_ &childev);
           ev_unref (EV_A); /* child watcher should not keep loop alive */
 #ifndef _WIN32
   ev_ref (EV_A); /* child watcher */
   ev_signal_stop (EV_A_ &childev);
 #endif
-  ev_ref (EV_A); /* signal watcher */
-  ev_io_stop (EV_A_ &sigev);
-  close (sigpipe [0]); sigpipe [0] = 0;
-  close (sigpipe [1]); sigpipe [1] = 0;
   loop_destroy (EV_A);
 }
 void
 ev_default_fork (void)
           {
             /*assert (("non-pending watcher on pending list", p->w->pending));*/
             p->w->pending = 0;
             EV_CB_INVOKE (p->w, p->events);
+            EV_FREQUENT_CHECK;
           }
       }
 }
-void inline_size
-timers_reify (EV_P)
-{
-  while (timercnt && ((WT)timers [0])->at <= mn_now)
-    {
-      ev_timer *w = (ev_timer *)timers [0];
-      /*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.));
-          ((WT)w)->at += w->repeat;
-          if (((WT)w)->at < mn_now)
-            ((WT)w)->at = mn_now;
-          downheap (timers, timercnt, 0);
-        }
-      else
-        ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
-      ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
-    }
-}
-#if EV_PERIODIC_ENABLE
-void inline_size
-periodics_reify (EV_P)
-{
-  while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now)
-    {
-      ev_periodic *w = (ev_periodic *)periodics [0];
-      /*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);
-        }
-      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);
-        }
-      else
-        ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
-      ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
-    }
-}
-static void noinline
-periodics_reschedule (EV_P)
-{
-  int i;
-  /* adjust periodics after time jump */
-  for (i = 0; i < periodiccnt; ++i)
-    {
-      ev_periodic *w = (ev_periodic *)periodics [i];
-      if (w->reschedule_cb)
-        ((WT)w)->at = 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;
-    }
-  /* 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)
 {
               queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
               break;
             }
         }
     }
+}
+#endif
+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]);
+      /*assert (("inactive timer on timer heap detected", ev_is_active (w)));*/
+      /* first reschedule or stop timer */
+      if (w->repeat)
+        {
+          ev_at (w) += w->repeat;
+          if (ev_at (w) < mn_now)
+            ev_at (w) = mn_now;
+          assert (("negative ev_timer repeat value found while processing timers", w->repeat > 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);
+    }
+}
+#if EV_PERIODIC_ENABLE
+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]);
+      /*assert (("inactive timer on periodic heap detected", ev_is_active (w)));*/
+      /* first reschedule or stop timer */
+      if (w->reschedule_cb)
+        {
+          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)
+        {
+          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);
+    }
+}
+static void noinline
+periodics_reschedule (EV_P)
+{
+  int i;
+  /* adjust periodics after time jump */
+  for (i = HEAP0; i < periodiccnt + HEAP0; ++i)
+    {
+      ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]);
+      if (w->reschedule_cb)
+        ev_at (w) = w->reschedule_cb (w, ev_rt_now);
+      else if (w->interval)
+        ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
+      ANHE_at_cache (periodics [i]);
+    }
+  reheap (periodics, periodiccnt);
 }
 #endif
 void inline_speed
 time_update (EV_P_ ev_tstamp max_block)
        */
       for (i = 4; --i; )
         {
           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 ();
           mn_now    = get_clock ();
           now_floor = mn_now;
 #if EV_PERIODIC_ENABLE
           periodics_reschedule (EV_A);
 #endif
           /* adjust timers. this is easy, as the offset is the same for all of them */
           for (i = 0; i < timercnt; ++i)
+            {
+              ANHE *he = timers + i + HEAP0;
-            ((WT)timers [i])->at += ev_rt_now - mn_now;
+              ANHE_w (*he)->at += ev_rt_now - mn_now;
+              ANHE_at_cache (*he);
+            }
         }
       mn_now = ev_rt_now;
     }
 }
 ev_unref (EV_P)
 {
   --activecnt;
 }
+void
+ev_now_update (EV_P)
+{
+  time_update (EV_A_ 1e100);
+}
 static int loop_done;
 void
 ev_loop (EV_P_ int flags)
 {
-  loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK)
+  loop_done = EVUNLOOP_CANCEL;
-            ? EVUNLOOP_ONE
-            : EVUNLOOP_CANCEL;
   call_pending (EV_A); /* in case we recurse, ensure ordering stays nice and clean */
   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))
           {
             curpid = getpid ();
             waittime = MAX_BLOCKTIME;
             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
             if (expect_false (waittime < timeout_blocktime))
       /* queue check watchers, to be executed first */
       if (expect_false (checkcnt))
         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
       call_pending (EV_A);
     }
-  while (expect_true (activecnt && !loop_done));
+  while (expect_true (
+    activecnt
+    && !loop_done
+    && !(flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK))
+  ));
   if (loop_done == EVUNLOOP_ONE)
     loop_done = EVUNLOOP_CANCEL;
 }
   if (expect_false (ev_is_active (w)))
     return;
   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
 ev_io_stop (EV_P_ ev_io *w)
 {
   clear_pending (EV_A_ (W)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
 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_FREQUENT_CHECK;
+  ++timercnt;
-  ev_start (EV_A_ (W)w, ++timercnt);
+  ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
-  array_needsize (WT, timers, timermax, timercnt, EMPTY2);
+  array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);
-  timers [timercnt - 1] = (WT)w;
+  ANHE_w (timers [ev_active (w)]) = (WT)w;
-  upheap (timers, timercnt - 1);
+  ANHE_at_cache (timers [ev_active (w)]);
+  upheap (timers, ev_active (w));
+  EV_FREQUENT_CHECK;
-  /*assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));*/
+  /*assert (("internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
 }
 void noinline
 ev_timer_stop (EV_P_ ev_timer *w)
 {
   clear_pending (EV_A_ (W)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);
 }
 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;
+          ev_at (w) = mn_now + w->repeat;
+          ANHE_at_cache (timers [ev_active (w)]);
-          adjustheap (timers, timercnt, ((W)w)->active - 1);
+          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
 void noinline
 ev_periodic_start (EV_P_ ev_periodic *w)
 {
   if (expect_false (ev_is_active (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_FREQUENT_CHECK;
+  ++periodiccnt;
-  ev_start (EV_A_ (W)w, ++periodiccnt);
+  ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
-  array_needsize (WT, periodics, periodicmax, periodiccnt, EMPTY2);
+  array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);
-  periodics [periodiccnt - 1] = (WT)w;
+  ANHE_w (periodics [ev_active (w)]) = (WT)w;
-  upheap (periodics, periodiccnt - 1);
+  ANHE_at_cache (periodics [ev_active (w)]);
+  upheap (periodics, ev_active (w));
+  EV_FREQUENT_CHECK;
-  /*assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));*/
+  /*assert (("internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
 }
 void noinline
 ev_periodic_stop (EV_P_ ev_periodic *w)
 {
   clear_pending (EV_A_ (W)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);
 }
 void noinline
 ev_periodic_again (EV_P_ ev_periodic *w)
 #endif
   if (expect_false (ev_is_active (w)))
     return;
   assert (("ev_signal_start called with illegal signal number", w->signum > 0));
+  evpipe_init (EV_A);
+  EV_FREQUENT_CHECK;
   {
 #ifndef _WIN32
     sigset_t full, prev;
     sigfillset (&full);
   wlist_add (&signals [w->signum - 1].head, (WL)w);
   if (!((WL)w)->next)
     {
 #if _WIN32
-      signal (w->signum, sighandler);
+      signal (w->signum, ev_sighandler);
 #else
       struct sigaction sa;
-      sa.sa_handler = sighandler;
+      sa.sa_handler = ev_sighandler;
       sigfillset (&sa.sa_mask);
       sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
       sigaction (w->signum, &sa, 0);
 #endif
     }
+  EV_FREQUENT_CHECK;
 }
 void noinline
 ev_signal_stop (EV_P_ ev_signal *w)
 {
   clear_pending (EV_A_ (W)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
 ev_child_start (EV_P_ ev_child *w)
 {
   assert (("child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
 #endif
   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
 ev_child_stop (EV_P_ ev_child *w)
 {
   clear_pending (EV_A_ (W)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
 # ifdef _WIN32
   if (w->wd < 0)
     {
       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];
           strcpy (path, w->path);
 static void noinline
 infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
 {
   if (slot < 0)
-    /* overflow, need to check for all hahs slots */
+    /* overflow, need to check for all hash slots */
     for (slot = 0; slot < EV_INOTIFY_HASHSIZE; ++slot)
       infy_wd (EV_A_ slot, wd, ev);
   else
     {
       WL w_;
 infy_init (EV_P)
 {
   if (fs_fd != -2)
     return;
+  /* kernels < 2.6.25 are borked
+   * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
+   */
+  {
+    struct utsname buf;
+    int major, minor, micro;
+    fs_fd = -1;
+    if (uname (&buf))
+      return;
+    if (sscanf (buf.release, "%d.%d.%d", &major, &minor, &micro) != 3)
+      return;
+    if (major < 2
+        || (major == 2 && minor < 6)
+        || (major == 2 && minor == 6 && micro < 25))
+      return;
+  }
   fs_fd = inotify_init ();
   if (fs_fd >= 0)
     {
       ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
           if (fs_fd >= 0)
             infy_add (EV_A_ w); /* re-add, no matter what */
           else
             ev_timer_start (EV_A_ &w->timer);
         }
     }
 }
+#endif
+#ifdef _WIN32
+# define EV_LSTAT(p,b) _stati64 (p, b)
+#else
+# define EV_LSTAT(p,b) lstat (p, b)
 #endif
 void
 ev_stat_stat (EV_P_ ev_stat *w)
 {
     || w->prev.st_atime != w->attr.st_atime
     || w->prev.st_mtime != w->attr.st_mtime
     || w->prev.st_ctime != w->attr.st_ctime
   ) {
       #if EV_USE_INOTIFY
+        if (fs_fd >= 0)
+          {
-        infy_del (EV_A_ w);
+            infy_del (EV_A_ w);
-        infy_add (EV_A_ w);
+            infy_add (EV_A_ w);
-        ev_stat_stat (EV_A_ w); /* avoid race... */
+            ev_stat_stat (EV_A_ w); /* avoid race... */
+          }
       #endif
       ev_feed_event (EV_A_ w, EV_STAT);
     }
 }
   else
 #endif
     ev_timer_start (EV_A_ &w->timer);
   ev_start (EV_A_ (W)w, 1);
+  EV_FREQUENT_CHECK;
 }
 void
 ev_stat_stop (EV_P_ ev_stat *w)
 {
   clear_pending (EV_A_ (W)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
 #if EV_IDLE_ENABLE
 void
 {
   if (expect_false (ev_is_active (w)))
     return;
   pri_adjust (EV_A_ (W)w);
+  EV_FREQUENT_CHECK;
   {
     int active = ++idlecnt [ABSPRI (w)];
     ++idleall;
     ev_start (EV_A_ (W)w, active);
     array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);
     idles [ABSPRI (w)][active - 1] = w;
   }
+  EV_FREQUENT_CHECK;
 }
 void
 ev_idle_stop (EV_P_ ev_idle *w)
 {
   clear_pending (EV_A_ (W)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
 void
 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
 ev_prepare_stop (EV_P_ ev_prepare *w)
 {
   clear_pending (EV_A_ (W)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
 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
 ev_check_stop (EV_P_ ev_check *w)
 {
   clear_pending (EV_A_ (W)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
 void noinline
 ev_embed_sweep (EV_P_ ev_embed *w)
         ev_loop (EV_A_ EVLOOP_NONBLOCK);
       }
   }
 }
+static void
+embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
+{
+  ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
+  {
+    struct ev_loop *loop = w->other;
+    ev_loop_fork (EV_A);
+  }
+}
 #if 0
 static void
 embed_idle_cb (EV_P_ ev_idle *idle, int revents)
 {
   ev_idle_stop (EV_A_ idle);
     struct ev_loop *loop = w->other;
     assert (("loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
     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);
   ev_prepare_init (&w->prepare, embed_prepare_cb);
   ev_set_priority (&w->prepare, EV_MINPRI);
   ev_prepare_start (EV_A_ &w->prepare);
+  ev_fork_init (&w->fork, embed_fork_cb);
+  ev_fork_start (EV_A_ &w->fork);
   /*ev_idle_init (&w->idle, e,bed_idle_cb);*/
   ev_start (EV_A_ (W)w, 1);
+  EV_FREQUENT_CHECK;
 }
 void
 ev_embed_stop (EV_P_ ev_embed *w)
 {
   clear_pending (EV_A_ (W)w);
   if (expect_false (!ev_is_active (w)))
     return;
+  EV_FREQUENT_CHECK;
-  ev_io_stop (EV_A_ &w->io);
+  ev_io_stop      (EV_A_ &w->io);
   ev_prepare_stop (EV_A_ &w->prepare);
+  ev_fork_stop    (EV_A_ &w->fork);
-  ev_stop (EV_A_ (W)w);
+  EV_FREQUENT_CHECK;
 }
 #endif
 #if EV_FORK_ENABLE
 void
 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
 ev_fork_stop (EV_P_ ev_fork *w)
 {
   clear_pending (EV_A_ (W)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
+#if EV_ASYNC_ENABLE
+void
+ev_async_start (EV_P_ ev_async *w)
+{
+  if (expect_false (ev_is_active (w)))
+    return;
+  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
+ev_async_stop (EV_P_ ev_async *w)
+{
+  clear_pending (EV_A_ (W)w);
+  if (expect_false (!ev_is_active (w)))
+    return;
+  EV_FREQUENT_CHECK;
+  {
+    int active = ev_active (w);
+    asyncs [active - 1] = asyncs [--asynccnt];
+    ev_active (asyncs [active - 1]) = active;
+  }
+  ev_stop (EV_A_ (W)w);
+  EV_FREQUENT_CHECK;
+}
+void
+ev_async_send (EV_P_ ev_async *w)
+{
+  w->sent = 1;
+  evpipe_write (EV_A_ &gotasync);
 }
 #endif
 /*****************************************************************************/
 once_cb (EV_P_ struct ev_once *once, int revents)
 {
   void (*cb)(int revents, void *arg) = once->cb;
   void *arg = once->arg;
-  ev_io_stop (EV_A_ &once->io);
+  ev_io_stop    (EV_A_ &once->io);
   ev_timer_stop (EV_A_ &once->to);
   ev_free (once);
   cb (revents, arg);
 }
 static void
 once_cb_io (EV_P_ ev_io *w, int revents)
 {
-  once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io)), revents);
+  struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io));
+  once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->to));
 }
 static void
 once_cb_to (EV_P_ ev_timer *w, int revents)
 {
-  once_cb (EV_A_ (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to)), revents);
+  struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to));
+  once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
 }
 void
 ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg)
 {

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev.c (file contents): Revision 1.205 by root, Sun Jan 20 15:37:03 2008 UTC vs. Revision 1.264 by root, Mon Oct 13 23:20:12 2008 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.205 by root, Sun Jan 20 15:37:03 2008 UTC vs.
Revision 1.264 by root, Mon Oct 13 23:20:12 2008 UTC