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

Comparing libev/ev.c (file contents):
Revision 1.222 by root, Sun Apr 6 12:45:58 2008 UTC vs.
Revision 1.229 by root, Fri May 2 08:08:45 2008 UTC

 # 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 EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
 #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 ();
       }
 }
 /*****************************************************************************/
+/* towards the root */
 void inline_speed
 upheap (WT *heap, int k)
 {
   WT w = heap [k];
-  while (k)
+  for (;;)
     {
-      int p = (k - 1) >> 1;
+      int p = k >> 1;
+      /* maybe we could use a dummy element at heap [0]? */
-      if (heap [p]->at <= w->at)
+      if (!p || heap [p]->at <= w->at)
         break;
       heap [k] = heap [p];
-      ((W)heap [k])->active = k + 1;
+      ((W)heap [k])->active = k;
       k = p;
     }
   heap [k] = w;
-  ((W)heap [k])->active = k + 1;
+  ((W)heap [k])->active = k;
 }
+/* away from the root */
 void inline_speed
 downheap (WT *heap, int N, int k)
 {
   WT w = heap [k];
   for (;;)
     {
-      int c = (k << 1) + 1;
+      int c = k << 1;
-      if (c >= N)
+      if (c > N)
         break;
-      c += c + 1 < N && heap [c]->at > heap [c + 1]->at
+      c += c < 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;
+      ((W)heap [k])->active = k;
       k = c;
     }
   heap [k] = w;
-  ((W)heap [k])->active = k + 1;
+  ((W)heap [k])->active = k;
 }
 void inline_size
 adjustheap (WT *heap, int N, int k)
 {
       if (!(flags & EVFLAG_NOENV)
           && !enable_secure ()
           && getenv ("LIBEV_FLAGS"))
         flags = atoi (getenv ("LIBEV_FLAGS"));
-      if (!(flags & 0x0000ffffUL))
+      if (!(flags & 0x0000ffffU))
         flags |= ev_recommended_backends ();
 #if EV_USE_PORT
       if (!backend && (flags & EVBACKEND_PORT  )) backend = port_init   (EV_A_ flags);
 #endif
 #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
 }
 void inline_size
 timers_reify (EV_P)
 {
-  while (timercnt && ((WT)timers [0])->at <= mn_now)
+  while (timercnt && ev_at (timers [1]) <= mn_now)
     {
-      ev_timer *w = (ev_timer *)timers [0];
+      ev_timer *w = (ev_timer *)timers [1];
       /*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;
+          ev_at (w) += w->repeat;
-          if (((WT)w)->at < mn_now)
+          if (ev_at (w) < mn_now)
-            ((WT)w)->at = mn_now;
+            ev_at (w) = mn_now;
-          downheap (timers, timercnt, 0);
+          downheap (timers, timercnt, 1);
         }
       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)
+  while (periodiccnt && ev_at (periodics [1]) <= ev_rt_now)
     {
-      ev_periodic *w = (ev_periodic *)periodics [0];
+      ev_periodic *w = (ev_periodic *)periodics [1];
       /*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);
+          ev_at (w) = 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));
+          assert (("ev_periodic reschedule callback returned time in the past", ev_at (w) > ev_rt_now));
-          downheap (periodics, periodiccnt, 0);
+          downheap (periodics, periodiccnt, 1);
         }
       else if (w->interval)
         {
-          ((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;
-          if (((WT)w)->at - ev_rt_now <= TIME_EPSILON) ((WT)w)->at += w->interval;
+          if (ev_at (w) - ev_rt_now <= TIME_EPSILON) ev_at (w) += w->interval;
-          assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ((WT)w)->at > ev_rt_now));
+          assert (("ev_periodic timeout in the past detected while processing timers, negative interval?", ev_at (w) > ev_rt_now));
-          downheap (periodics, periodiccnt, 0);
+          downheap (periodics, periodiccnt, 1);
         }
       else
         ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
       ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
   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);
+        ev_at (w) = 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;
+        ev_at (w) = 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);
         {
 #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)
+          for (i = 1; i <= timercnt; ++i)
-            ((WT)timers [i])->at += ev_rt_now - mn_now;
+            ev_at (timers [i]) += ev_rt_now - mn_now;
         }
       mn_now = ev_rt_now;
     }
 }
             waittime = MAX_BLOCKTIME;
             if (timercnt)
               {
-                ev_tstamp to = ((WT)timers [0])->at - mn_now + backend_fudge;
+                ev_tstamp to = ev_at (timers [1]) - 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 = ev_at (periodics [1]) - ev_rt_now + backend_fudge;
                 if (waittime > to) waittime = to;
               }
 #endif
             if (expect_false (waittime < timeout_blocktime))
 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_start (EV_A_ (W)w, ++timercnt);
-  array_needsize (WT, timers, timermax, timercnt, EMPTY2);
+  array_needsize (WT, timers, timermax, timercnt + 1, EMPTY2);
-  timers [timercnt - 1] = (WT)w;
+  timers [timercnt] = (WT)w;
-  upheap (timers, timercnt - 1);
+  upheap (timers, timercnt);
-  /*assert (("internal timer heap corruption", timers [((W)w)->active - 1] == w));*/
+  /*assert (("internal timer heap corruption", timers [((W)w)->active] == 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));
+  assert (("internal timer heap corruption", timers [((W)w)->active] == (WT)w));
   {
     int active = ((W)w)->active;
-    if (expect_true (--active < --timercnt))
+    if (expect_true (active < timercnt))
       {
         timers [active] = timers [timercnt];
         adjustheap (timers, timercnt, active);
       }
+    --timercnt;
   }
-  ((WT)w)->at -= mn_now;
+  ev_at (w) -= mn_now;
   ev_stop (EV_A_ (W)w);
 }
 void noinline
 {
   if (ev_is_active (w))
     {
       if (w->repeat)
         {
-          ((WT)w)->at = mn_now + w->repeat;
+          ev_at (w) = mn_now + w->repeat;
-          adjustheap (timers, timercnt, ((W)w)->active - 1);
+          adjustheap (timers, timercnt, ((W)w)->active);
         }
       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);
     }
 }
 #if EV_PERIODIC_ENABLE
 {
   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_start (EV_A_ (W)w, ++periodiccnt);
-  array_needsize (WT, periodics, periodicmax, periodiccnt, EMPTY2);
+  array_needsize (WT, periodics, periodicmax, periodiccnt + 1, EMPTY2);
-  periodics [periodiccnt - 1] = (WT)w;
+  periodics [periodiccnt] = (WT)w;
-  upheap (periodics, periodiccnt - 1);
+  upheap (periodics, periodiccnt);
   /*assert (("internal periodic heap corruption", periodics [((W)w)->active - 1] == w));*/
 }
 void noinline
 {
   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));
+  assert (("internal periodic heap corruption", periodics [((W)w)->active] == (WT)w));
   {
     int active = ((W)w)->active;
-    if (expect_true (--active < --periodiccnt))
+    if (expect_true (active < periodiccnt))
       {
         periodics [active] = periodics [periodiccnt];
         adjustheap (periodics, periodiccnt, active);
       }
+    --periodiccnt;
   }
   ev_stop (EV_A_ (W)w);
 }

Diff Legend

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

Comparing libev/ev.c (file contents): Revision 1.222 by root, Sun Apr 6 12:45:58 2008 UTC vs. Revision 1.229 by root, Fri May 2 08:08:45 2008 UTC

Diff Legend

Comparing libev/ev.c (file contents):
Revision 1.222 by root, Sun Apr 6 12:45:58 2008 UTC vs.
Revision 1.229 by root, Fri May 2 08:08:45 2008 UTC