*** empty log message ***

[software/libev.git] / ev.c

diff --git a/ev.c b/ev.c
index 8c05776921bb6093430192e94719fd38f6e857d5..790baee1ed219276382f7d9c2abc6b5aef162001 100644 (file)
--- a/ev.c
+++ b/ev.c
@@ -115,6 +115,8 @@ typedef struct ev_watcher *W;
 typedef struct ev_watcher_list *WL;
 typedef struct ev_watcher_time *WT;
 
 typedef struct ev_watcher_list *WL;
 typedef struct ev_watcher_time *WT;
 

+static int have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
+

 /*****************************************************************************/
 
 typedef struct
 /*****************************************************************************/
 
 typedef struct


@@ -130,17 +132,23 @@ typedef struct
   int events;
 } ANPENDING;
 
   int events;
 } ANPENDING;
 

-#ifdef EV_MULTIPLICITY
+#if EV_MULTIPLICITY
+

 struct ev_loop
 {
 struct ev_loop
 {

-# define VAR(name,decl) decl
+# define VAR(name,decl) decl;

 # include "ev_vars.h"
 };
 # include "ev_vars.h"
 };

+# undef VAR
+# include "ev_wrap.h"
+

 #else
 #else

-# define VAR(name,decl) static decl
+
+# define VAR(name,decl) static decl;

 # include "ev_vars.h"
 # include "ev_vars.h"

+# undef VAR
+

 #endif
 #endif

-#undef VAR

 
 /*****************************************************************************/
 
 
 /*****************************************************************************/
 


@@ -332,47 +340,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;
+
+  /* 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 (fd);
+      }
+}
+

 /*****************************************************************************/
 
 static void
 /*****************************************************************************/
 
 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];
+      heap [k]->active = k + 1;

       k >>= 1;
     }
 
       k >>= 1;
     }
 

-  timers [k] = w;
-  timers [k]->active = k + 1;
+  heap [k] = w;
+  heap [k]->active = k + 1;

 
 }
 
 static void
 
 }
 
 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;
 
 
   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;
 
         ++j;
 

-      if (w->at <= timers [j]->at)
+      if (w->at <= heap [j]->at)

         break;
 
         break;
 

-      timers [k] = timers [j];
-      timers [k]->active = k + 1;
+      heap [k] = heap [j];
+      heap [k]->active = k + 1;

       k = j;
     }
 
       k = j;
     }
 

-  timers [k] = w;
-  timers [k]->active = k + 1;
+  heap [k] = w;
+  heap [k]->active = k + 1;

 }
 
 /*****************************************************************************/
 }
 
 /*****************************************************************************/


@@ -447,7 +470,7 @@ siginit (EV_P)
 #endif
 
   ev_io_set (&sigev, sigpipe [0], EV_READ);
 #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 */
 }
 
   ev_unref (EV_A); /* child watcher should not keep loop alive */
 }
 


@@ -536,13 +559,9 @@ ev_method (EV_P)
   return method;
 }
 
   return method;
 }
 

-int
-ev_init (EV_P_ int methods)
+static void
+loop_init (EV_P_ int methods)

 {
 {

-#ifdef EV_MULTIPLICITY
-  memset (loop, 0, sizeof (struct ev_loop));
-#endif
-

   if (!method)
     {
 #if EV_USE_MONOTONIC
   if (!method)
     {
 #if EV_USE_MONOTONIC


@@ -556,14 +575,11 @@ ev_init (EV_P_ int methods)
       rt_now    = ev_time ();
       mn_now    = get_clock ();
       now_floor = mn_now;
       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 (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;
 
         else
           methods = EVMETHOD_ANY;
 


@@ -579,9 +595,98 @@ ev_init (EV_P_ int methods)
 #endif
 #if EV_USE_SELECT
       if (!method && (methods & EVMETHOD_SELECT)) method = select_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)
+{
+#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_USEV_POLL
+  if (method == EVMETHOD_POLL  ) poll_destroy   (EV_A);
+#endif
+#if EV_USE_SELECT
+  if (method == EVMETHOD_SELECT) select_destroy (EV_A);
+#endif
+
+  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_methods (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
 
 #endif
 

-      if (method)
+#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 (!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);
         {
           ev_watcher_init (&sigev, sigcb);
           ev_set_priority (&sigev, EV_MAXPRI);


@@ -594,38 +699,44 @@ ev_init (EV_P_ int methods)
           ev_unref (EV_A); /* child watcher should not keep loop alive */
 #endif
         }
           ev_unref (EV_A); /* child watcher should not keep loop alive */
 #endif
         }

+      else
+        default_loop = 0;

     }
 
     }
 

-  return method;
+  return default_loop;

 }
 
 }
 

-/*****************************************************************************/
-

 void
 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
 }
 
 void

-ev_fork_child (void)
+ev_default_fork (EV_P)

 {
 {

-#if EV_USE_EPOLL
-  if (method == EVMETHOD_EPOLL)
-    epoll_postfork_child ();
-#endif
+  loop_fork (EV_A);

 
 

-  ev_io_stop (&sigev);
+  ev_io_stop (EV_A_ &sigev);

   close (sigpipe [0]);
   close (sigpipe [1]);
   pipe (sigpipe);
   close (sigpipe [0]);
   close (sigpipe [1]);
   pipe (sigpipe);

-  siginit ();
+
+  ev_ref (EV_A); /* signal watcher */
+  siginit (EV_A);

 }
 
 /*****************************************************************************/
 }
 
 /*****************************************************************************/


@@ -665,7 +776,7 @@ timers_reify (EV_P)
       else
         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 
       else
         ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
 

-      event ((W)w, EV_TIMEOUT);
+      event (EV_A_ (W)w, EV_TIMEOUT);

     }
 }
 
     }
 }
 


@@ -691,7 +802,7 @@ periodics_reify (EV_P)
 }
 
 static void
 }
 
 static void

-periodics_reschedule (EV_P_ ev_tstamp diff)
+periodics_reschedule (EV_P)

 {
   int i;
 
 {
   int i;
 


@@ -722,7 +833,7 @@ time_update_monotonic (EV_P)
 
   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
     {
 
   if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
     {

-      rt_now = mn_now + diff;
+      rt_now = rtmn_diff + mn_now;

       return 0;
     }
   else
       return 0;
     }
   else


@@ -743,13 +854,13 @@ time_update (EV_P)
     {
       if (time_update_monotonic (EV_A))
         {
     {
       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 */
             {
 
           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 ();
                 return; /* all is well */
 
               rt_now    = ev_time ();


@@ -757,8 +868,9 @@ time_update (EV_P)
               now_floor = mn_now;
             }
 
               now_floor = mn_now;
             }
 

-          periodics_reschedule (EV_A_ diff - odiff);
+          periodics_reschedule (EV_A);

           /* no timer adjustment, as the monotonic clock doesn't jump */
           /* no timer adjustment, as the monotonic clock doesn't jump */

+          /* timers_reschedule (EV_A_ rtmn_diff - odiff) */

         }
     }
   else
         }
     }
   else


@@ -768,11 +880,11 @@ time_update (EV_P)
 
       if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP))
         {
 
       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)
 
           /* adjust timers. this is easy, as the offset is the same for all */
           for (i = 0; i < timercnt; ++i)

-            timers [i]->at += diff;
+            timers [i]->at += rt_now - mn_now;

         }
 
       mn_now = rt_now;
         }
 
       mn_now = rt_now;


@@ -1045,46 +1157,6 @@ ev_periodic_stop (EV_P_ struct ev_periodic *w)
   ev_stop (EV_A_ (W)w);
 }
 
   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_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)
-    {
-      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);
-    }
-}
-
-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_idle_start (EV_P_ struct ev_idle *w)
 {
 void
 ev_idle_start (EV_P_ struct ev_idle *w)
 {


@@ -1151,9 +1223,55 @@ ev_check_stop (EV_P_ struct ev_check *w)
   ev_stop (EV_A_ (W)w);
 }
 
   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 (!w->next)
+    {
+      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);
+    }
+}
+
+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)
 {
 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;
 
   if (ev_is_active (w))
     return;
 


@@ -1235,86 +1353,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
-
-
-
-