From 6724cd5b6ffe05187a5520b0cd3771c7dbe83896 Mon Sep 17 00:00:00 2001 From: root Date: Sat, 10 Nov 2007 03:13:50 +0000 Subject: optimise ev_now when \!MULTIPLICITY --- ev.c | 50 ++++++++++++++++++++++++++------------------------ ev.h | 14 ++++++++++++-- ev_vars.h | 2 +- ev_wrap.h | 2 +- 4 files changed, 40 insertions(+), 28 deletions(-) diff --git a/ev.c b/ev.c index 14046a2..77e8011 100644 --- a/ev.c +++ b/ev.c @@ -273,11 +273,13 @@ get_clock (void) return ev_time (); } +#if EV_MULTIPLICITY ev_tstamp ev_now (EV_P) { - return rt_now; + return ev_rt_now; } +#endif #define array_roundsize(type,n) ((n) | 4 & ~3) @@ -737,10 +739,10 @@ loop_init (EV_P_ int methods) } #endif - rt_now = ev_time (); + ev_rt_now = ev_time (); mn_now = get_clock (); now_floor = mn_now; - rtmn_diff = rt_now - mn_now; + rtmn_diff = ev_rt_now - mn_now; if (methods == EVMETHOD_AUTO) if (!enable_secure () && getenv ("LIBEV_METHODS")) @@ -993,7 +995,7 @@ timers_reify (EV_P) static void periodics_reify (EV_P) { - while (periodiccnt && ((WT)periodics [0])->at <= rt_now) + while (periodiccnt && ((WT)periodics [0])->at <= ev_rt_now) { struct ev_periodic *w = periodics [0]; @@ -1002,15 +1004,15 @@ periodics_reify (EV_P) /* first reschedule or stop timer */ if (w->reschedule_cb) { - ev_tstamp at = ((WT)w)->at = w->reschedule_cb (w, rt_now + 0.0001); + ev_tstamp at = ((WT)w)->at = w->reschedule_cb (w, ev_rt_now + 0.0001); - assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > rt_now)); + assert (("ev_periodic reschedule callback returned time in the past", ((WT)w)->at > ev_rt_now)); downheap ((WT *)periodics, periodiccnt, 0); } else if (w->interval) { - ((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)); + ((WT)w)->at += floor ((ev_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 > ev_rt_now)); downheap ((WT *)periodics, periodiccnt, 0); } else @@ -1031,9 +1033,9 @@ periodics_reschedule (EV_P) struct ev_periodic *w = periodics [i]; if (w->reschedule_cb) - ((WT)w)->at = w->reschedule_cb (w, rt_now); + ((WT)w)->at = w->reschedule_cb (w, ev_rt_now); else if (w->interval) - ((WT)w)->at += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval; + ((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval; } /* now rebuild the heap */ @@ -1048,13 +1050,13 @@ time_update_monotonic (EV_P) if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5)) { - rt_now = rtmn_diff + mn_now; + ev_rt_now = rtmn_diff + mn_now; return 0; } else { now_floor = mn_now; - rt_now = ev_time (); + ev_rt_now = ev_time (); return 1; } } @@ -1073,12 +1075,12 @@ time_update (EV_P) for (i = 4; --i; ) /* loop a few times, before making important decisions */ { - rtmn_diff = rt_now - mn_now; + rtmn_diff = ev_rt_now - mn_now; if (fabs (odiff - rtmn_diff) < MIN_TIMEJUMP) return; /* all is well */ - rt_now = ev_time (); + ev_rt_now = ev_time (); mn_now = get_clock (); now_floor = mn_now; } @@ -1091,18 +1093,18 @@ time_update (EV_P) else #endif { - rt_now = ev_time (); + ev_rt_now = ev_time (); - if (expect_false (mn_now > rt_now || mn_now < rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP)) + if (expect_false (mn_now > ev_rt_now || mn_now < ev_rt_now - MAX_BLOCKTIME - MIN_TIMEJUMP)) { periodics_reschedule (EV_A); /* adjust timers. this is easy, as the offset is the same for all */ for (i = 0; i < timercnt; ++i) - ((WT)timers [i])->at += rt_now - mn_now; + ((WT)timers [i])->at += ev_rt_now - mn_now; } - mn_now = rt_now; + mn_now = ev_rt_now; } } @@ -1152,8 +1154,8 @@ ev_loop (EV_P_ int flags) else #endif { - rt_now = ev_time (); - mn_now = rt_now; + ev_rt_now = ev_time (); + mn_now = ev_rt_now; } if (flags & EVLOOP_NONBLOCK || idlecnt) @@ -1170,7 +1172,7 @@ ev_loop (EV_P_ int flags) if (periodiccnt) { - ev_tstamp to = ((WT)periodics [0])->at - rt_now + method_fudge; + ev_tstamp to = ((WT)periodics [0])->at - ev_rt_now + method_fudge; if (block > to) block = to; } @@ -1179,7 +1181,7 @@ ev_loop (EV_P_ int flags) method_poll (EV_A_ block); - /* update rt_now, do magic */ + /* update ev_rt_now, do magic */ time_update (EV_A); /* queue pending timers and reschedule them */ @@ -1350,12 +1352,12 @@ ev_periodic_start (EV_P_ struct ev_periodic *w) return; if (w->reschedule_cb) - ((WT)w)->at = w->reschedule_cb (w, rt_now); + ((WT)w)->at = 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 += ceil ((rt_now - ((WT)w)->at) / w->interval) * w->interval; + ((WT)w)->at += ceil ((ev_rt_now - ((WT)w)->at) / w->interval) * w->interval; } ev_start (EV_A_ (W)w, ++periodiccnt); diff --git a/ev.h b/ev.h index 126de49..589e8ea 100644 --- a/ev.h +++ b/ev.h @@ -262,8 +262,20 @@ struct ev_loop *ev_default_loop (int methods); /* returns default loop */ struct ev_loop *ev_loop_new (int methods); void ev_loop_destroy (EV_P); void ev_loop_fork (EV_P); + +ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */ + # else + int ev_default_loop (int methods); /* returns true when successful */ + +static ev_tstamp +ev_now () +{ + extern ev_rt_now; + + return ev_rt_now; +} # endif void ev_default_destroy (void); /* destroy the default loop */ @@ -285,8 +297,6 @@ int ev_method (EV_P); void ev_loop (EV_P_ int flags); void ev_unloop (EV_P_ int how); /* set to 1 to break out of event loop, set to 2 to break out of all event loops */ -ev_tstamp ev_now (EV_P); /* time w.r.t. timers and the eventloop, updated after each poll */ - /* * ref/unref can be used to add or remove a refcount on the mainloop. every watcher * keeps one reference. if you have a long-runing watcher you never unregister that diff --git a/ev_vars.h b/ev_vars.h index c506944..e4ece3c 100644 --- a/ev_vars.h +++ b/ev_vars.h @@ -2,7 +2,7 @@ VARx(ev_tstamp, now_floor) /* last time we refreshed rt_time */ VARx(ev_tstamp, mn_now) /* monotonic clock "now" */ -VARx(ev_tstamp, rt_now) +VARx(ev_tstamp, ev_rt_now) VARx(ev_tstamp, rtmn_diff) /* difference realtime - monotonic time */ VARx(int, method) diff --git a/ev_wrap.h b/ev_wrap.h index b0f55c1..d7d08ee 100644 --- a/ev_wrap.h +++ b/ev_wrap.h @@ -1,7 +1,7 @@ /* DO NOT EDIT, automaticlaly generated by update_ev_wrap */ #define now_floor ((loop)->now_floor) #define mn_now ((loop)->mn_now) -#define rt_now ((loop)->rt_now) +#define ev_rt_now ((loop)->ev_rt_now) #define rtmn_diff ((loop)->rtmn_diff) #define method ((loop)->method) #define method_fudge ((loop)->method_fudge) -- cgit v1.2.3