X-Git-Url: https://git.llucax.com/software/libev.git/blobdiff_plain/228b0b302ab0857b23efad5a8b2429de2c0ccc00..d5b686568688adf526735190000d81a260db6c36:/ev.c

diff --git a/ev.c b/ev.c
index f813e58..53491e1 100644
--- a/ev.c
+++ b/ev.c
@@ -30,6 +30,28 @@
  */
 #ifndef EV_STANDALONE
 # include "config.h"
+
+# if HAVE_CLOCK_GETTIME
+#  define EV_USE_MONOTONIC 1
+#  define EV_USE_REALTIME  1
+# endif
+
+# if HAVE_SELECT && HAVE_SYS_SELECT_H
+#  define EV_USE_SELECT 1
+# endif
+
+# if HAVE_POLL && HAVE_POLL_H
+#  define EV_USE_POLL 1
+# endif
+
+# if HAVE_EPOLL && HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
+#  define EV_USE_EPOLL 1
+# endif
+
+# if HAVE_KQUEUE && HAVE_WORKING_KQUEUE && HAVE_SYS_EVENT_H && HAVE_SYS_QUEUE_H
+#  define EV_USE_KQUEUE 1
+# endif
+
 #endif
 
 #include <math.h>
@@ -60,8 +82,8 @@
 # define EV_USE_SELECT 1
 #endif
 
-#ifndef EV_USEV_POLL
-# define EV_USEV_POLL 0 /* poll is usually slower than select, and not as well tested */
+#ifndef EV_USE_POLL
+# define EV_USE_POLL 0 /* poll is usually slower than select, and not as well tested */
 #endif
 
 #ifndef EV_USE_EPOLL
@@ -72,6 +94,14 @@
 # define EV_USE_KQUEUE 0
 #endif
 
+#ifndef EV_USE_WIN32
+# ifdef WIN32
+#  define EV_USE_WIN32 1
+# else
+#  define EV_USE_WIN32 0
+# endif
+#endif
+
 #ifndef EV_USE_REALTIME
 # define EV_USE_REALTIME 1
 #endif
@@ -115,43 +145,45 @@ typedef struct ev_watcher *W;
 typedef struct ev_watcher_list *WL;
 typedef struct ev_watcher_time *WT;
 
-static ev_tstamp now_floor, mn_now, diff; /* monotonic clock */
-static ev_tstamp rt_now;
-static int method;
+static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 
-static int have_monotonic; /* runtime */
+#if WIN32
+/* note: the comment below could not be substantiated, but what would I care */
+/* MSDN says this is required to handle SIGFPE */
+volatile double SIGFPE_REQ = 0.0f; 
+#endif
 
-static ev_tstamp method_fudge; /* stupid epoll-returns-early bug */
-static void (*method_modify)(EV_P_ int fd, int oev, int nev);
-static void (*method_poll)(EV_P_ ev_tstamp timeout);
+/*****************************************************************************/
 
-static int activecnt; /* number of active events */
+typedef struct
+{
+  struct ev_watcher_list *head;
+  unsigned char events;
+  unsigned char reify;
+} ANFD;
 
-#if EV_USE_SELECT
-static unsigned char *vec_ri, *vec_ro, *vec_wi, *vec_wo;
-static int vec_max;
-#endif
+typedef struct
+{
+  W w;
+  int events;
+} ANPENDING;
 
-#if EV_USEV_POLL
-static struct pollfd *polls;
-static int pollmax, pollcnt;
-static int *pollidxs; /* maps fds into structure indices */
-static int pollidxmax;
-#endif
+#if EV_MULTIPLICITY
 
-#if EV_USE_EPOLL
-static int epoll_fd = -1;
+struct ev_loop
+{
+# define VAR(name,decl) decl;
+# include "ev_vars.h"
+};
+# undef VAR
+# include "ev_wrap.h"
 
-static struct epoll_event *events;
-static int eventmax;
-#endif
+#else
+
+# define VAR(name,decl) static decl;
+# include "ev_vars.h"
+# undef VAR
 
-#if EV_USE_KQUEUE
-static int kqueue_fd;
-static struct kevent *kqueue_changes;
-static int kqueue_changemax, kqueue_changecnt;
-static struct kevent *kqueue_events;
-static int kqueue_eventmax;
 #endif
 
 /*****************************************************************************/
@@ -208,17 +240,18 @@ ev_now (EV_P)
       cur = newcnt;					\
     }
 
-/*****************************************************************************/
+#define array_slim(stem)					\
+  if (stem ## max < array_roundsize (stem ## cnt >> 2))		\
+    {								\
+      stem ## max = array_roundsize (stem ## cnt >> 1);		\
+      base = realloc (base, sizeof (*base) * (stem ## max));	\
+      fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
+    }
 
-typedef struct
-{
-  struct ev_watcher_list *head;
-  unsigned char events;
-  unsigned char reify;
-} ANFD;
+#define array_free(stem, idx) \
+  free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0;
 
-static ANFD *anfds;
-static int anfdmax;
+/*****************************************************************************/
 
 static void
 anfds_init (ANFD *base, int count)
@@ -233,15 +266,6 @@ anfds_init (ANFD *base, int count)
     }
 }
 
-typedef struct
-{
-  W w;
-  int events;
-} ANPENDING;
-
-static ANPENDING *pendings [NUMPRI];
-static int pendingmax [NUMPRI], pendingcnt [NUMPRI];
-
 static void
 event (EV_P_ W w, int events)
 {
@@ -283,9 +307,6 @@ fd_event (EV_P_ int fd, int events)
 
 /*****************************************************************************/
 
-static int *fdchanges;
-static int fdchangemax, fdchangecnt;
-
 static void
 fd_reify (EV_P)
 {
@@ -304,11 +325,8 @@ fd_reify (EV_P)
 
       anfd->reify = 0;
 
-      if (anfd->events != events)
-        {
-          method_modify (EV_A_ fd, anfd->events, events);
-          anfd->events = events;
-        }
+      method_modify (EV_A_ fd, anfd->events, events);
+      anfd->events = events;
     }
 
   fdchangecnt = 0;
@@ -355,9 +373,9 @@ fd_ebadf (EV_P)
 static void
 fd_enomem (EV_P)
 {
-  int fd = anfdmax;
+  int fd;
 
-  while (fd--)
+  for (fd = anfdmax; fd--; )
     if (anfds [fd].events)
       {
         close (fd);
@@ -366,53 +384,62 @@ fd_enomem (EV_P)
       }
 }
 
-/*****************************************************************************/
+/* susually called after fork if method needs to re-arm all fds from scratch */
+static void
+fd_rearm_all (EV_P)
+{
+  int fd;
 
-static struct ev_timer **timers;
-static int timermax, timercnt;
+  /* this should be highly optimised to not do anything but set a flag */
+  for (fd = 0; fd < anfdmax; ++fd)
+    if (anfds [fd].events)
+      {
+        anfds [fd].events = 0;
+        fd_change (EV_A_ fd);
+      }
+}
 
-static struct ev_periodic **periodics;
-static int periodicmax, periodiccnt;
+/*****************************************************************************/
 
 static void
-upheap (WT *timers, int k)
+upheap (WT *heap, int k)
 {
-  WT w = timers [k];
+  WT w = heap [k];
 
-  while (k && timers [k >> 1]->at > w->at)
+  while (k && heap [k >> 1]->at > w->at)
     {
-      timers [k] = timers [k >> 1];
-      timers [k]->active = k + 1;
+      heap [k] = heap [k >> 1];
+      ((W)heap [k])->active = k + 1;
       k >>= 1;
     }
 
-  timers [k] = w;
-  timers [k]->active = k + 1;
+  heap [k] = w;
+  ((W)heap [k])->active = k + 1;
 
 }
 
 static void
-downheap (WT *timers, int N, int k)
+downheap (WT *heap, int N, int k)
 {
-  WT w = timers [k];
+  WT w = heap [k];
 
   while (k < (N >> 1))
     {
       int j = k << 1;
 
-      if (j + 1 < N && timers [j]->at > timers [j + 1]->at)
+      if (j + 1 < N && heap [j]->at > heap [j + 1]->at)
         ++j;
 
-      if (w->at <= timers [j]->at)
+      if (w->at <= heap [j]->at)
         break;
 
-      timers [k] = timers [j];
-      timers [k]->active = k + 1;
+      heap [k] = heap [j];
+      ((W)heap [k])->active = k + 1;
       k = j;
     }
 
-  timers [k] = w;
-  timers [k]->active = k + 1;
+  heap [k] = w;
+  ((W)heap [k])->active = k + 1;
 }
 
 /*****************************************************************************/
@@ -445,6 +472,10 @@ signals_init (ANSIG *base, int count)
 static void
 sighandler (int signum)
 {
+#if WIN32
+  signal (signum, sighandler);
+#endif
+
   signals [signum - 1].gotsig = 1;
 
   if (!gotsig)
@@ -488,27 +519,17 @@ siginit (EV_P)
 #endif
 
   ev_io_set (&sigev, sigpipe [0], EV_READ);
-  ev_io_start (&sigev);
+  ev_io_start (EV_A_ &sigev);
+  ev_unref (EV_A); /* child watcher should not keep loop alive */
 }
 
 /*****************************************************************************/
 
-static struct ev_idle **idles;
-static int idlemax, idlecnt;
-
-static struct ev_prepare **prepares;
-static int preparemax, preparecnt;
-
-static struct ev_check **checks;
-static int checkmax, checkcnt;
-
-/*****************************************************************************/
+#ifndef WIN32
 
 static struct ev_child *childs [PID_HASHSIZE];
 static struct ev_signal childev;
 
-#ifndef WIN32
-
 #ifndef WCONTINUED
 # define WCONTINUED 0
 #endif
@@ -521,9 +542,9 @@ child_reap (EV_P_ struct ev_signal *sw, int chain, int pid, int status)
   for (w = (struct ev_child *)childs [chain & (PID_HASHSIZE - 1)]; w; w = (struct ev_child *)((WL)w)->next)
     if (w->pid == pid || !w->pid)
       {
-        w->priority = sw->priority; /* need to do it *now* */
-        w->rpid     = pid;
-        w->rstatus  = status;
+        ev_priority (w) = ev_priority (sw); /* need to do it *now* */
+        w->rpid         = pid;
+        w->rstatus      = status;
         event (EV_A_ (W)w, EV_CHILD);
       }
 }
@@ -553,7 +574,7 @@ childcb (EV_P_ struct ev_signal *sw, int revents)
 #if EV_USE_EPOLL
 # include "ev_epoll.c"
 #endif
-#if EV_USEV_POLL
+#if EV_USE_POLL
 # include "ev_poll.c"
 #endif
 #if EV_USE_SELECT
@@ -590,8 +611,8 @@ ev_method (EV_P)
   return method;
 }
 
-int
-ev_init (EV_P_ int methods)
+static void
+loop_init (EV_P_ int methods)
 {
   if (!method)
     {
@@ -606,32 +627,136 @@ ev_init (EV_P_ int methods)
       rt_now    = ev_time ();
       mn_now    = get_clock ();
       now_floor = mn_now;
-      diff      = rt_now - mn_now;
-
-      if (pipe (sigpipe))
-        return 0;
+      rtmn_diff = rt_now - mn_now;
 
       if (methods == EVMETHOD_AUTO)
-        if (!enable_secure () && getenv ("LIBmethodS"))
-          methods = atoi (getenv ("LIBmethodS"));
+        if (!enable_secure () && getenv ("LIBEV_METHODS"))
+          methods = atoi (getenv ("LIBEV_METHODS"));
         else
           methods = EVMETHOD_ANY;
 
       method = 0;
+#if EV_USE_WIN32
+      if (!method && (methods & EVMETHOD_WIN32 )) method = win32_init  (EV_A_ methods);
+#endif
 #if EV_USE_KQUEUE
       if (!method && (methods & EVMETHOD_KQUEUE)) method = kqueue_init (EV_A_ methods);
 #endif
 #if EV_USE_EPOLL
       if (!method && (methods & EVMETHOD_EPOLL )) method = epoll_init  (EV_A_ methods);
 #endif
-#if EV_USEV_POLL
+#if EV_USE_POLL
       if (!method && (methods & EVMETHOD_POLL  )) method = poll_init   (EV_A_ methods);
 #endif
 #if EV_USE_SELECT
       if (!method && (methods & EVMETHOD_SELECT)) method = select_init (EV_A_ methods);
 #endif
+    }
+}
+
+void
+loop_destroy (EV_P)
+{
+  int i;
+
+#if EV_USE_WIN32
+  if (method == EVMETHOD_WIN32 ) win32_destroy  (EV_A);
+#endif
+#if EV_USE_KQUEUE
+  if (method == EVMETHOD_KQUEUE) kqueue_destroy (EV_A);
+#endif
+#if EV_USE_EPOLL
+  if (method == EVMETHOD_EPOLL ) epoll_destroy  (EV_A);
+#endif
+#if EV_USE_POLL
+  if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
+#endif
+#if EV_USE_SELECT
+  if (method == EVMETHOD_SELECT) select_destroy (EV_A);
+#endif
+
+  for (i = NUMPRI; i--; )
+    array_free (pending, [i]);
+
+  array_free (fdchange, );
+  array_free (timer, );
+  array_free (periodic, );
+  array_free (idle, );
+  array_free (prepare, );
+  array_free (check, );
+
+  method = 0;
+  /*TODO*/
+}
+
+void
+loop_fork (EV_P)
+{
+  /*TODO*/
+#if EV_USE_EPOLL
+  if (method == EVMETHOD_EPOLL ) epoll_fork  (EV_A);
+#endif
+#if EV_USE_KQUEUE
+  if (method == EVMETHOD_KQUEUE) kqueue_fork (EV_A);
+#endif
+}
+
+#if EV_MULTIPLICITY
+struct ev_loop *
+ev_loop_new (int methods)
+{
+  struct ev_loop *loop = (struct ev_loop *)calloc (1, sizeof (struct ev_loop));
+
+  loop_init (EV_A_ methods);
+
+  if (ev_method (EV_A))
+    return loop;
+
+  return 0;
+}
+
+void
+ev_loop_destroy (EV_P)
+{
+  loop_destroy (EV_A);
+  free (loop);
+}
+
+void
+ev_loop_fork (EV_P)
+{
+  loop_fork (EV_A);
+}
+
+#endif
+
+#if EV_MULTIPLICITY
+struct ev_loop default_loop_struct;
+static struct ev_loop *default_loop;
+
+struct ev_loop *
+#else
+static int default_loop;
+
+int
+#endif
+ev_default_loop (int methods)
+{
+  if (sigpipe [0] == sigpipe [1])
+    if (pipe (sigpipe))
+      return 0;
 
-      if (method)
+  if (!default_loop)
+    {
+#if EV_MULTIPLICITY
+      struct ev_loop *loop = default_loop = &default_loop_struct;
+#else
+      default_loop = 1;
+#endif
+
+      loop_init (EV_A_ methods);
+
+      if (ev_method (EV_A))
         {
           ev_watcher_init (&sigev, sigcb);
           ev_set_priority (&sigev, EV_MAXPRI);
@@ -641,40 +766,51 @@ ev_init (EV_P_ int methods)
           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 */
 #endif
         }
+      else
+        default_loop = 0;
     }
 
-  return method;
+  return default_loop;
 }
 
-/*****************************************************************************/
-
 void
-ev_fork_prepare (void)
+ev_default_destroy (void)
 {
-  /* nop */
-}
+#if EV_MULTIPLICITY
+  struct ev_loop *loop = default_loop;
+#endif
 
-void
-ev_fork_parent (void)
-{
-  /* nop */
+  ev_ref (EV_A); /* child watcher */
+  ev_signal_stop (EV_A_ &childev);
+
+  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_fork_child (void)
+ev_default_fork (void)
 {
-#if EV_USE_EPOLL
-  if (method == EVMETHOD_EPOLL)
-    epoll_postfork_child ();
+#if EV_MULTIPLICITY
+  struct ev_loop *loop = default_loop;
 #endif
 
-  ev_io_stop (&sigev);
+  loop_fork (EV_A);
+
+  ev_io_stop (EV_A_ &sigev);
   close (sigpipe [0]);
   close (sigpipe [1]);
   pipe (sigpipe);
-  siginit ();
+
+  ev_ref (EV_A); /* signal watcher */
+  siginit (EV_A);
 }
 
 /*****************************************************************************/
@@ -700,36 +836,40 @@ call_pending (EV_P)
 static void
 timers_reify (EV_P)
 {
-  while (timercnt && timers [0]->at <= mn_now)
+  while (timercnt && ((WT)timers [0])->at <= mn_now)
     {
       struct ev_timer *w = 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.));
-          w->at = mn_now + w->repeat;
+          ((WT)w)->at = mn_now + w->repeat;
           downheap ((WT *)timers, timercnt, 0);
         }
       else
         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 
-      event ((W)w, EV_TIMEOUT);
+      event (EV_A_ (W)w, EV_TIMEOUT);
     }
 }
 
 static void
 periodics_reify (EV_P)
 {
-  while (periodiccnt && periodics [0]->at <= rt_now)
+  while (periodiccnt && ((WT)periodics [0])->at <= rt_now)
     {
       struct ev_periodic *w = periodics [0];
 
+      assert (("inactive timer on periodic heap detected", ev_is_active (w)));
+
       /* first reschedule or stop timer */
       if (w->interval)
         {
-          w->at += floor ((rt_now - w->at) / w->interval + 1.) * w->interval;
-          assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", w->at > rt_now));
+          ((WT)w)->at += floor ((rt_now - ((WT)w)->at) / w->interval + 1.) * w->interval;
+          assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > rt_now));
           downheap ((WT *)periodics, periodiccnt, 0);
         }
       else
@@ -740,7 +880,7 @@ periodics_reify (EV_P)
 }
 
 static void
-periodics_reschedule (EV_P_ ev_tstamp diff)
+periodics_reschedule (EV_P)
 {
   int i;
 
@@ -751,7 +891,7 @@ periodics_reschedule (EV_P_ ev_tstamp diff)
 
       if (w->interval)
         {
-          ev_tstamp diff = ceil ((rt_now - w->at) / w->interval) * w->interval;
+          ev_tstamp diff = ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
 
           if (fabs (diff) >= 1e-4)
             {
@@ -771,7 +911,7 @@ time_update_monotonic (EV_P)
 
   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
     {
-      rt_now = mn_now + diff;
+      rt_now = rtmn_diff + mn_now;
       return 0;
     }
   else
@@ -792,13 +932,13 @@ time_update (EV_P)
     {
       if (time_update_monotonic (EV_A))
         {
-          ev_tstamp odiff = diff;
+          ev_tstamp odiff = rtmn_diff;
 
           for (i = 4; --i; ) /* loop a few times, before making important decisions */
             {
-              diff = rt_now - mn_now;
+              rtmn_diff = rt_now - mn_now;
 
-              if (fabs (odiff - diff) < MIN_TIMEJUMP)
+              if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP)
                 return; /* all is well */
 
               rt_now    = ev_time ();
@@ -806,8 +946,9 @@ time_update (EV_P)
               now_floor = mn_now;
             }
 
-          periodics_reschedule (EV_A_ diff - odiff);
+          periodics_reschedule (EV_A);
           /* no timer adjustment, as the monotonic clock doesn't jump */
+          /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
         }
     }
   else
@@ -817,11 +958,11 @@ time_update (EV_P)
 
       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
         {
-          periodics_reschedule (EV_A_ rt_now - mn_now);
+          periodics_reschedule (EV_A);
 
           /* adjust timers. this is easy, as the offset is the same for all */
           for (i = 0; i < timercnt; ++i)
-            timers [i]->at += diff;
+            ((WT)timers [i])->at += rt_now - mn_now;
         }
 
       mn_now = rt_now;
@@ -882,13 +1023,13 @@ ev_loop (EV_P_ int flags)
 
           if (timercnt)
             {
-              ev_tstamp to = timers [0]->at - mn_now + method_fudge;
+              ev_tstamp to = ((WT)timers [0])->at - mn_now + method_fudge;
               if (block > to) block = to;
             }
 
           if (periodiccnt)
             {
-              ev_tstamp to = periodics [0]->at - rt_now + method_fudge;
+              ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge;
               if (block > to) block = to;
             }
 
@@ -913,7 +1054,6 @@ ev_loop (EV_P_ int flags)
         queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
 
       call_pending (EV_A);
-      printf ("activecnt %d\n", activecnt);//D
     }
   while (activecnt && !loop_done);
 
@@ -1016,7 +1156,7 @@ ev_timer_start (EV_P_ struct ev_timer *w)
   if (ev_is_active (w))
     return;
 
-  w->at += mn_now;
+  ((WT)w)->at += mn_now;
 
   assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
 
@@ -1024,6 +1164,8 @@ ev_timer_start (EV_P_ struct ev_timer *w)
   array_needsize (timers, timermax, timercnt, );
   timers [timercnt - 1] = w;
   upheap ((WT *)timers, timercnt - 1);
+
+  assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
 }
 
 void
@@ -1033,13 +1175,15 @@ ev_timer_stop (EV_P_ struct ev_timer *w)
   if (!ev_is_active (w))
     return;
 
-  if (w->active < timercnt--)
+  assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));
+
+  if (((W)w)->active < timercnt--)
     {
-      timers [w->active - 1] = timers [timercnt];
-      downheap ((WT *)timers, timercnt, w->active - 1);
+      timers [((W)w)->active - 1] = timers [timercnt];
+      downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
     }
 
-  w->at = w->repeat;
+  ((WT)w)->at = w->repeat;
 
   ev_stop (EV_A_ (W)w);
 }
@@ -1051,8 +1195,8 @@ ev_timer_again (EV_P_ struct ev_timer *w)
     {
       if (w->repeat)
         {
-          w->at = mn_now + w->repeat;
-          downheap ((WT *)timers, timercnt, w->active - 1);
+          ((WT)w)->at = mn_now + w->repeat;
+          downheap ((WT *)timers, timercnt, ((W)w)->active - 1);
         }
       else
         ev_timer_stop (EV_A_ w);
@@ -1071,12 +1215,14 @@ ev_periodic_start (EV_P_ struct ev_periodic *w)
 
   /* this formula differs from the one in periodic_reify because we do not always round up */
   if (w->interval)
-    w->at += ceil ((rt_now - w->at) / w->interval) * w->interval;
+    ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval;
 
   ev_start (EV_A_ (W)w, ++periodiccnt);
   array_needsize (periodics, periodicmax, periodiccnt, );
   periodics [periodiccnt - 1] = w;
   upheap ((WT *)periodics, periodiccnt - 1);
+
+  assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
 }
 
 void
@@ -1086,53 +1232,15 @@ ev_periodic_stop (EV_P_ struct ev_periodic *w)
   if (!ev_is_active (w))
     return;
 
-  if (w->active < periodiccnt--)
-    {
-      periodics [w->active - 1] = periodics [periodiccnt];
-      downheap ((WT *)periodics, periodiccnt, w->active - 1);
-    }
-
-  ev_stop (EV_A_ (W)w);
-}
+  assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));
 
-#ifndef SA_RESTART
-# define SA_RESTART 0
-#endif
-
-void
-ev_signal_start (EV_P_ struct ev_signal *w)
-{
-  if (ev_is_active (w))
-    return;
-
-  assert (("ev_signal_start called with illegal signal number", w->signum > 0));
-
-  ev_start (EV_A_ (W)w, 1);
-  array_needsize (signals, signalmax, w->signum, signals_init);
-  wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
-
-  if (!w->next)
+  if (((W)w)->active < periodiccnt--)
     {
-      struct sigaction sa;
-      sa.sa_handler = sighandler;
-      sigfillset (&sa.sa_mask);
-      sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
-      sigaction (w->signum, &sa, 0);
+      periodics [((W)w)->active - 1] = periodics [periodiccnt];
+      downheap ((WT *)periodics, periodiccnt, ((W)w)->active - 1);
     }
-}
 
-void
-ev_signal_stop (EV_P_ struct ev_signal *w)
-{
-  ev_clear_pending (EV_A_ (W)w);
-  if (!ev_is_active (w))
-    return;
-
-  wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
   ev_stop (EV_A_ (W)w);
-
-  if (!signals [w->signum - 1].head)
-    signal (w->signum, SIG_DFL);
 }
 
 void
@@ -1153,7 +1261,7 @@ ev_idle_stop (EV_P_ struct ev_idle *w)
   if (ev_is_active (w))
     return;
 
-  idles [w->active - 1] = idles [--idlecnt];
+  idles [((W)w)->active - 1] = idles [--idlecnt];
   ev_stop (EV_A_ (W)w);
 }
 
@@ -1175,7 +1283,7 @@ ev_prepare_stop (EV_P_ struct ev_prepare *w)
   if (ev_is_active (w))
     return;
 
-  prepares [w->active - 1] = prepares [--preparecnt];
+  prepares [((W)w)->active - 1] = prepares [--preparecnt];
   ev_stop (EV_A_ (W)w);
 }
 
@@ -1197,13 +1305,63 @@ ev_check_stop (EV_P_ struct ev_check *w)
   if (ev_is_active (w))
     return;
 
-  checks [w->active - 1] = checks [--checkcnt];
+  checks [((W)w)->active - 1] = checks [--checkcnt];
   ev_stop (EV_A_ (W)w);
 }
 
+#ifndef SA_RESTART
+# define SA_RESTART 0
+#endif
+
+void
+ev_signal_start (EV_P_ struct ev_signal *w)
+{
+#if EV_MULTIPLICITY
+  assert (("signal watchers are only supported in the default loop", loop == default_loop));
+#endif
+  if (ev_is_active (w))
+    return;
+
+  assert (("ev_signal_start called with illegal signal number", w->signum > 0));
+
+  ev_start (EV_A_ (W)w, 1);
+  array_needsize (signals, signalmax, w->signum, signals_init);
+  wlist_add ((WL *)&signals [w->signum - 1].head, (WL)w);
+
+  if (!((WL)w)->next)
+    {
+#if WIN32
+      signal (w->signum, sighandler);
+#else
+      struct sigaction sa;
+      sa.sa_handler = sighandler;
+      sigfillset (&sa.sa_mask);
+      sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
+      sigaction (w->signum, &sa, 0);
+#endif
+    }
+}
+
+void
+ev_signal_stop (EV_P_ struct ev_signal *w)
+{
+  ev_clear_pending (EV_A_ (W)w);
+  if (!ev_is_active (w))
+    return;
+
+  wlist_del ((WL *)&signals [w->signum - 1].head, (WL)w);
+  ev_stop (EV_A_ (W)w);
+
+  if (!signals [w->signum - 1].head)
+    signal (w->signum, SIG_DFL);
+}
+
 void
 ev_child_start (EV_P_ struct ev_child *w)
 {
+#if EV_MULTIPLICITY
+  assert (("child watchers are only supported in the default loop", loop == default_loop));
+#endif
   if (ev_is_active (w))
     return;
 
@@ -1285,86 +1443,3 @@ ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, vo
     }
 }
 
-/*****************************************************************************/
-
-#if 0
-
-struct ev_io wio;
-
-static void
-sin_cb (struct ev_io *w, int revents)
-{
-  fprintf (stderr, "sin %d, revents %d\n", w->fd, revents);
-}
-
-static void
-ocb (struct ev_timer *w, int revents)
-{
-  //fprintf (stderr, "timer %f,%f (%x) (%f) d%p\n", w->at, w->repeat, revents, w->at - ev_time (), w->data);
-  ev_timer_stop (w);
-  ev_timer_start (w);
-}
-
-static void
-scb (struct ev_signal *w, int revents)
-{
-  fprintf (stderr, "signal %x,%d\n", revents, w->signum);
-  ev_io_stop (&wio);
-  ev_io_start (&wio);
-}
-
-static void
-gcb (struct ev_signal *w, int revents)
-{
-  fprintf (stderr, "generic %x\n", revents);
-
-}
-
-int main (void)
-{
-  ev_init (0);
-
-  ev_io_init (&wio, sin_cb, 0, EV_READ);
-  ev_io_start (&wio);
-
-  struct ev_timer t[10000];
-
-#if 0
-  int i;
-  for (i = 0; i < 10000; ++i)
-    {
-      struct ev_timer *w = t + i;
-      ev_watcher_init (w, ocb, i);
-      ev_timer_init_abs (w, ocb, drand48 (), 0.99775533);
-      ev_timer_start (w);
-      if (drand48 () < 0.5)
-        ev_timer_stop (w);
-    }
-#endif
-
-  struct ev_timer t1;
-  ev_timer_init (&t1, ocb, 5, 10);
-  ev_timer_start (&t1);
-
-  struct ev_signal sig;
-  ev_signal_init (&sig, scb, SIGQUIT);
-  ev_signal_start (&sig);
-
-  struct ev_check cw;
-  ev_check_init (&cw, gcb);
-  ev_check_start (&cw);
-
-  struct ev_idle iw;
-  ev_idle_init (&iw, gcb);
-  ev_idle_start (&iw);
-
-  ev_loop (0);
-
-  return 0;
-}
-
-#endif
-
-
-
-