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

Comparing libev/ev.c (file contents):
Revision 1.23 by root, Wed Oct 31 20:10:17 2007 UTC vs.
Revision 1.28 by root, Thu Nov 1 06:48:49 2007 UTC

 /*****************************************************************************/
 typedef struct
 {
   struct ev_io *head;
-  unsigned char wev, rev; /* want, received event set */
+  int events;
 } ANFD;
 static ANFD *anfds;
 static int anfdmax;
-static int *fdchanges;
-static int fdchangemax, fdchangecnt;
 static void
 anfds_init (ANFD *base, int count)
 {
   while (count--)
     {
-      base->head = 0;
+      base->head   = 0;
-      base->wev = base->rev = EV_NONE;
+      base->events = EV_NONE;
       ++base;
     }
 }
 typedef struct
       pendings [pendingcnt - 1].events = events;
     }
 }
 static void
+queue_events (W *events, int eventcnt, int type)
+{
+  int i;
+  for (i = 0; i < eventcnt; ++i)
+    event (events [i], type);
+}
+static void
 fd_event (int fd, int events)
 {
   ANFD *anfd = anfds + fd;
   struct ev_io *w;
       if (ev)
         event ((W)w, ev);
     }
 }
+/*****************************************************************************/
+static int *fdchanges;
+static int fdchangemax, fdchangecnt;
 static void
-queue_events (W *events, int eventcnt, int type)
+fd_reify (void)
 {
   int i;
-  for (i = 0; i < eventcnt; ++i)
+  for (i = 0; i < fdchangecnt; ++i)
-    event (events [i], type);
+    {
+      int fd = fdchanges [i];
+      ANFD *anfd = anfds + fd;
+      struct ev_io *w;
+      int events = 0;
+      for (w = anfd->head; w; w = w->next)
+        events |= w->events;
+      anfd->events &= ~EV_REIFY;
+      if (anfd->events != events)
+        {
+          method_modify (fd, anfd->events, events);
+          anfd->events = events;
+        }
+    }
+  fdchangecnt = 0;
+}
+static void
+fd_change (int fd)
+{
+  if (anfds [fd].events & EV_REIFY)
+    return;
+  anfds [fd].events |= EV_REIFY;
+  ++fdchangecnt;
+  array_needsize (fdchanges, fdchangemax, fdchangecnt, );
+  fdchanges [fdchangecnt - 1] = fd;
 }
 /* called on EBADF to verify fds */
 static void
-fd_recheck ()
+fd_recheck (void)
 {
   int fd;
   for (fd = 0; fd < anfdmax; ++fd)
-    if (anfds [fd].wev)
+    if (anfds [fd].events)
       if (fcntl (fd, F_GETFD) == -1 && errno == EBADF)
         while (anfds [fd].head)
+          {
+            event ((W)anfds [fd].head, EV_ERROR);
-          evio_stop (anfds [fd].head);
+            ev_io_stop (anfds [fd].head);
+          }
 }
 /*****************************************************************************/
 static struct ev_timer **timers;
   /* rather than sort out wether we really need nb, set it */
   fcntl (sigpipe [0], F_SETFL, O_NONBLOCK);
   fcntl (sigpipe [1], F_SETFL, O_NONBLOCK);
-  evio_set (&sigev, sigpipe [0], EV_READ);
+  ev_io_set (&sigev, sigpipe [0], EV_READ);
-  evio_start (&sigev);
+  ev_io_start (&sigev);
 }
 /*****************************************************************************/
 static struct ev_idle **idles;
 # include "ev_epoll.c"
 #endif
 #if HAVE_SELECT
 # include "ev_select.c"
 #endif
+int
+ev_version_major (void)
+{
+  return EV_VERSION_MAJOR;
+}
+int
+ev_version_minor (void)
+{
+  return EV_VERSION_MINOR;
+}
 int ev_init (int flags)
 {
   if (!ev_method)
     {
       if (ev_method == EVMETHOD_NONE) select_init (flags);
 #endif
       if (ev_method)
         {
-          evw_init (&sigev, sigcb);
+          ev_watcher_init (&sigev, sigcb);
           siginit ();
-          evsignal_init (&childev, childcb, SIGCHLD);
+          ev_signal_init (&childev, childcb, SIGCHLD);
-          evsignal_start (&childev);
+          ev_signal_start (&childev);
         }
     }
   return ev_method;
 }
 /*****************************************************************************/
+void
-void ev_prefork (void)
+ev_prefork (void)
 {
   /* nop */
 }
+void
-void ev_postfork_parent (void)
+ev_postfork_parent (void)
 {
   /* nop */
 }
+void
-void ev_postfork_child (void)
+ev_postfork_child (void)
 {
 #if HAVE_EPOLL
   if (ev_method == EVMETHOD_EPOLL)
     epoll_postfork_child ();
 #endif
-  evio_stop (&sigev);
+  ev_io_stop (&sigev);
   close (sigpipe [0]);
   close (sigpipe [1]);
   pipe (sigpipe);
   siginit ();
 }
 /*****************************************************************************/
 static void
-fd_reify (void)
-{
-  int i;
-  for (i = 0; i < fdchangecnt; ++i)
-    {
-      int fd = fdchanges [i];
-      ANFD *anfd = anfds + fd;
-      struct ev_io *w;
-      int wev = 0;
-      for (w = anfd->head; w; w = w->next)
-        wev |= w->events;
-      if (anfd->wev != wev)
-        {
-          method_modify (fd, anfd->wev, wev);
-          anfd->wev = wev;
-        }
-    }
-  fdchangecnt = 0;
-}
-static void
-call_pending ()
+call_pending (void)
 {
   while (pendingcnt)
     {
       ANPENDING *p = pendings + --pendingcnt;
         }
     }
 }
 static void
-timers_reify ()
+timers_reify (void)
 {
   while (timercnt && timers [0]->at <= now)
     {
       struct ev_timer *w = timers [0];
           w->at = now + w->repeat;
           assert (("timer timeout in the past, negative repeat?", w->at > now));
           downheap ((WT *)timers, timercnt, 0);
         }
       else
-        evtimer_stop (w); /* nonrepeating: stop timer */
+        ev_timer_stop (w); /* nonrepeating: stop timer */
     }
 }
 static void
-periodics_reify ()
+periodics_reify (void)
 {
   while (periodiccnt && periodics [0]->at <= ev_now)
     {
       struct ev_periodic *w = periodics [0];
           w->at += floor ((ev_now - w->at) / w->interval + 1.) * w->interval;
           assert (("periodic timeout in the past, negative interval?", w->at > ev_now));
           downheap ((WT *)periodics, periodiccnt, 0);
         }
       else
-        evperiodic_stop (w); /* nonrepeating: stop timer */
+        ev_periodic_stop (w); /* nonrepeating: stop timer */
       event ((W)w, EV_TIMEOUT);
     }
 }
         {
           ev_tstamp diff = ceil ((ev_now - w->at) / w->interval) * w->interval;
           if (fabs (diff) >= 1e-4)
             {
-              evperiodic_stop (w);
+              ev_periodic_stop (w);
-              evperiodic_start (w);
+              ev_periodic_start (w);
               i = 0; /* restart loop, inefficient, but time jumps should be rare */
             }
         }
     }
 }
 static void
-time_update ()
+time_update (void)
 {
   int i;
   ev_now = ev_time ();
 int ev_loop_done;
 void ev_loop (int flags)
 {
   double block;
-  ev_loop_done = flags & EVLOOP_ONESHOT ? 1 : 0;
+  ev_loop_done = flags & (EVLOOP_ONESHOT | EVLOOP_NONBLOCK) ? 1 : 0;
   do
     {
       /* queue check watchers (and execute them) */
       if (preparecnt)
 }
 /*****************************************************************************/
 void
-evio_start (struct ev_io *w)
+ev_io_start (struct ev_io *w)
 {
   if (ev_is_active (w))
     return;
   int fd = w->fd;
   ev_start ((W)w, 1);
   array_needsize (anfds, anfdmax, fd + 1, anfds_init);
   wlist_add ((WL *)&anfds[fd].head, (WL)w);
-  ++fdchangecnt;
+  fd_change (fd);
-  array_needsize (fdchanges, fdchangemax, fdchangecnt, );
-  fdchanges [fdchangecnt - 1] = fd;
 }
 void
-evio_stop (struct ev_io *w)
+ev_io_stop (struct ev_io *w)
 {
   ev_clear ((W)w);
   if (!ev_is_active (w))
     return;
   wlist_del ((WL *)&anfds[w->fd].head, (WL)w);
   ev_stop ((W)w);
-  ++fdchangecnt;
+  fd_change (w->fd);
-  array_needsize (fdchanges, fdchangemax, fdchangecnt, );
-  fdchanges [fdchangecnt - 1] = w->fd;
 }
 void
-evtimer_start (struct ev_timer *w)
+ev_timer_start (struct ev_timer *w)
 {
   if (ev_is_active (w))
     return;
   w->at += now;
   timers [timercnt - 1] = w;
   upheap ((WT *)timers, timercnt - 1);
 }
 void
-evtimer_stop (struct ev_timer *w)
+ev_timer_stop (struct ev_timer *w)
 {
   ev_clear ((W)w);
   if (!ev_is_active (w))
     return;
   ev_stop ((W)w);
 }
 void
-evtimer_again (struct ev_timer *w)
+ev_timer_again (struct ev_timer *w)
 {
   if (ev_is_active (w))
     {
       if (w->repeat)
         {
           w->at = now + w->repeat;
           downheap ((WT *)timers, timercnt, w->active - 1);
         }
       else
-        evtimer_stop (w);
+        ev_timer_stop (w);
     }
   else if (w->repeat)
-    evtimer_start (w);
+    ev_timer_start (w);
 }
 void
-evperiodic_start (struct ev_periodic *w)
+ev_periodic_start (struct ev_periodic *w)
 {
   if (ev_is_active (w))
     return;
   assert (("periodic interval value less than zero not allowed", w->interval >= 0.));
   periodics [periodiccnt - 1] = w;
   upheap ((WT *)periodics, periodiccnt - 1);
 }
 void
-evperiodic_stop (struct ev_periodic *w)
+ev_periodic_stop (struct ev_periodic *w)
 {
   ev_clear ((W)w);
   if (!ev_is_active (w))
     return;
   ev_stop ((W)w);
 }
 void
-evsignal_start (struct ev_signal *w)
+ev_signal_start (struct ev_signal *w)
 {
   if (ev_is_active (w))
     return;
   ev_start ((W)w, 1);
       sigaction (w->signum, &sa, 0);
     }
 }
 void
-evsignal_stop (struct ev_signal *w)
+ev_signal_stop (struct ev_signal *w)
 {
   ev_clear ((W)w);
   if (!ev_is_active (w))
     return;
   if (!signals [w->signum - 1].head)
     signal (w->signum, SIG_DFL);
 }
+void
-void evidle_start (struct ev_idle *w)
+ev_idle_start (struct ev_idle *w)
 {
   if (ev_is_active (w))
     return;
   ev_start ((W)w, ++idlecnt);
   array_needsize (idles, idlemax, idlecnt, );
   idles [idlecnt - 1] = w;
 }
+void
-void evidle_stop (struct ev_idle *w)
+ev_idle_stop (struct ev_idle *w)
 {
   ev_clear ((W)w);
   if (ev_is_active (w))
     return;
   idles [w->active - 1] = idles [--idlecnt];
   ev_stop ((W)w);
 }
+void
-void evprepare_start (struct ev_prepare *w)
+ev_prepare_start (struct ev_prepare *w)
 {
   if (ev_is_active (w))
     return;
   ev_start ((W)w, ++preparecnt);
   array_needsize (prepares, preparemax, preparecnt, );
   prepares [preparecnt - 1] = w;
 }
+void
-void evprepare_stop (struct ev_prepare *w)
+ev_prepare_stop (struct ev_prepare *w)
 {
   ev_clear ((W)w);
   if (ev_is_active (w))
     return;
   prepares [w->active - 1] = prepares [--preparecnt];
   ev_stop ((W)w);
 }
+void
-void evcheck_start (struct ev_check *w)
+ev_check_start (struct ev_check *w)
 {
   if (ev_is_active (w))
     return;
   ev_start ((W)w, ++checkcnt);
   array_needsize (checks, checkmax, checkcnt, );
   checks [checkcnt - 1] = w;
 }
+void
-void evcheck_stop (struct ev_check *w)
+ev_check_stop (struct ev_check *w)
 {
   ev_clear ((W)w);
   if (ev_is_active (w))
     return;
   checks [w->active - 1] = checks [--checkcnt];
   ev_stop ((W)w);
 }
+void
-void evchild_start (struct ev_child *w)
+ev_child_start (struct ev_child *w)
 {
   if (ev_is_active (w))
     return;
   ev_start ((W)w, 1);
   wlist_add ((WL *)&childs [w->pid & (PID_HASHSIZE - 1)], (WL)w);
 }
+void
-void evchild_stop (struct ev_child *w)
+ev_child_stop (struct ev_child *w)
 {
   ev_clear ((W)w);
   if (ev_is_active (w))
     return;
 once_cb (struct ev_once *once, int revents)
 {
   void (*cb)(int revents, void *arg) = once->cb;
   void *arg = once->arg;
-  evio_stop (&once->io);
+  ev_io_stop (&once->io);
-  evtimer_stop (&once->to);
+  ev_timer_stop (&once->to);
   free (once);
   cb (revents, arg);
 }
   else
     {
       once->cb  = cb;
       once->arg = arg;
-      evw_init (&once->io, once_cb_io);
+      ev_watcher_init (&once->io, once_cb_io);
       if (fd >= 0)
         {
-          evio_set (&once->io, fd, events);
+          ev_io_set (&once->io, fd, events);
-          evio_start (&once->io);
+          ev_io_start (&once->io);
         }
-      evw_init (&once->to, once_cb_to);
+      ev_watcher_init (&once->to, once_cb_to);
       if (timeout >= 0.)
         {
-          evtimer_set (&once->to, timeout, 0.);
+          ev_timer_set (&once->to, timeout, 0.);
-          evtimer_start (&once->to);
+          ev_timer_start (&once->to);
         }
     }
 }
 /*****************************************************************************/
 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);
-  evtimer_stop (w);
+  ev_timer_stop (w);
-  evtimer_start (w);
+  ev_timer_start (w);
 }
 static void
 scb (struct ev_signal *w, int revents)
 {
   fprintf (stderr, "signal %x,%d\n", revents, w->signum);
-  evio_stop (&wio);
+  ev_io_stop (&wio);
-  evio_start (&wio);
+  ev_io_start (&wio);
 }
 static void
 gcb (struct ev_signal *w, int revents)
 {
 int main (void)
 {
   ev_init (0);
-  evio_init (&wio, sin_cb, 0, EV_READ);
+  ev_io_init (&wio, sin_cb, 0, EV_READ);
-  evio_start (&wio);
+  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;
-      evw_init (w, ocb, i);
+      ev_watcher_init (w, ocb, i);
-      evtimer_init_abs (w, ocb, drand48 (), 0.99775533);
+      ev_timer_init_abs (w, ocb, drand48 (), 0.99775533);
-      evtimer_start (w);
+      ev_timer_start (w);
       if (drand48 () < 0.5)
-        evtimer_stop (w);
+        ev_timer_stop (w);
     }
 #endif
   struct ev_timer t1;
-  evtimer_init (&t1, ocb, 5, 10);
+  ev_timer_init (&t1, ocb, 5, 10);
-  evtimer_start (&t1);
+  ev_timer_start (&t1);
   struct ev_signal sig;
-  evsignal_init (&sig, scb, SIGQUIT);
+  ev_signal_init (&sig, scb, SIGQUIT);
-  evsignal_start (&sig);
+  ev_signal_start (&sig);
   struct ev_check cw;
-  evcheck_init (&cw, gcb);
+  ev_check_init (&cw, gcb);
-  evcheck_start (&cw);
+  ev_check_start (&cw);
   struct ev_idle iw;
-  evidle_init (&iw, gcb);
+  ev_idle_init (&iw, gcb);
-  evidle_start (&iw);
+  ev_idle_start (&iw);
   ev_loop (0);
   return 0;
 }

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.23 by root, Wed Oct 31 20:10:17 2007 UTC vs. Revision 1.28 by root, Thu Nov 1 06:48:49 2007 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.23 by root, Wed Oct 31 20:10:17 2007 UTC vs.
Revision 1.28 by root, Thu Nov 1 06:48:49 2007 UTC