diff options
| -rw-r--r-- | ev.c | 218 | ||||
| -rw-r--r-- | ev.h | 73 |
2 files changed, 188 insertions, 103 deletions
@@ -11,6 +11,8 @@ #include <sys/time.h> #include <time.h> +#define HAVE_EPOLL 1 + #ifndef HAVE_MONOTONIC # ifdef CLOCK_MONOTONIC # define HAVE_MONOTONIC 1 @@ -42,8 +44,13 @@ struct ev_watcher_list { EV_WATCHER_LIST (ev_watcher_list); }; +struct ev_watcher_time { + EV_WATCHER_TIME (ev_watcher_time); +}; + typedef struct ev_watcher *W; typedef struct ev_watcher_list *WL; +typedef struct ev_watcher_time *WT; static ev_tstamp now, diff; /* monotonic clock */ ev_tstamp ev_now; @@ -165,16 +172,16 @@ queue_events (W *events, int eventcnt, int type) /*****************************************************************************/ -static struct ev_timer **atimers; -static int atimermax, atimercnt; +static struct ev_timer **timers; +static int timermax, timercnt; -static struct ev_timer **rtimers; -static int rtimermax, rtimercnt; +static struct ev_periodic **periodics; +static int periodicmax, periodiccnt; static void -upheap (struct ev_timer **timers, int k) +upheap (WT *timers, int k) { - struct ev_timer *w = timers [k]; + WT w = timers [k]; while (k && timers [k >> 1]->at > w->at) { @@ -189,9 +196,9 @@ upheap (struct ev_timer **timers, int k) } static void -downheap (struct ev_timer **timers, int N, int k) +downheap (WT *timers, int N, int k) { - struct ev_timer *w = timers [k]; + WT w = timers [k]; while (k < (N >> 1)) { @@ -327,7 +334,7 @@ int ev_init (int flags) if (ev_method) { - evw_init (&sigev, sigcb, 0); + evw_init (&sigev, sigcb); siginit (); } @@ -408,7 +415,7 @@ call_pending () } static void -timers_reify (struct ev_timer **timers, int timercnt, ev_tstamp now) +timers_reify () { while (timercnt && timers [0]->at <= now) { @@ -417,37 +424,79 @@ timers_reify (struct ev_timer **timers, int timercnt, ev_tstamp now) /* first reschedule or stop timer */ if (w->repeat) { - if (w->is_abs) - w->at += floor ((now - w->at) / w->repeat + 1.) * w->repeat; - else - w->at = now + w->repeat; - - assert (w->at > now); - - downheap (timers, timercnt, 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 */ + + event ((W)w, EV_TIMEOUT); + } +} + +static void +periodics_reify () +{ + while (periodiccnt && periodics [0]->at <= ev_now) + { + struct ev_periodic *w = periodics [0]; + + /* first reschedule or stop timer */ + if (w->interval) { - evtimer_stop (w); /* nonrepeating: stop timer */ - --timercnt; /* maybe pass by reference instead? */ + 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 */ event ((W)w, EV_TIMEOUT); } } static void +time_jump (ev_tstamp diff) +{ + int i; + + /* adjust periodics */ + for (i = 0; i < periodiccnt; ++i) + { + struct ev_periodic *w = periodics [i]; + + if (w->interval) + { + ev_tstamp diff = ceil ((ev_now - w->at) / w->interval) * w->interval; + + if (fabs (diff) >= 1e-4) + { + evperiodic_stop (w); + evperiodic_start (w); + + i = 0; /* restart loop, inefficient, but time jumps should be rare */ + } + } + } + + /* adjust timers. this is easy, as the offset is the same for all */ + for (i = 0; i < timercnt; ++i) + timers [i]->at += diff; +} + +static void time_update () { int i; + ev_now = ev_time (); if (have_monotonic) { ev_tstamp odiff = diff; - /* detecting time jumps is much more difficult */ - for (i = 2; --i; ) /* loop a few times, before making important decisions */ + for (i = 4; --i; ) /* loop a few times, before making important decisions */ { now = get_clock (); diff = ev_now - now; @@ -458,19 +507,12 @@ time_update () ev_now = ev_time (); } - /* time jump detected, reschedule atimers */ - for (i = 0; i < atimercnt; ++i) - { - struct ev_timer *w = atimers [i]; - w->at += ceil ((ev_now - w->at) / w->repeat + 1.) * w->repeat; - } + time_jump (diff - odiff); } else { if (now > ev_now || now < ev_now - MAX_BLOCKTIME - MIN_TIMEJUMP) - /* time jump detected, adjust rtimers */ - for (i = 0; i < rtimercnt; ++i) - rtimers [i]->at += ev_now - now; + time_jump (ev_now - now); now = ev_now; } @@ -495,21 +537,25 @@ void ev_loop (int flags) fd_reify (); /* calculate blocking time */ + + /* we only need this for !monotonic clock, but as we always have timers, we just calculate it every time */ + ev_now = ev_time (); + if (flags & EVLOOP_NONBLOCK || idlecnt) block = 0.; else { block = MAX_BLOCKTIME; - if (rtimercnt) + if (timercnt) { - ev_tstamp to = rtimers [0]->at - get_clock () + method_fudge; + ev_tstamp to = timers [0]->at - get_clock () + method_fudge; if (block > to) block = to; } - if (atimercnt) + if (periodiccnt) { - ev_tstamp to = atimers [0]->at - ev_time () + method_fudge; + ev_tstamp to = periodics [0]->at - ev_now + method_fudge; if (block > to) block = to; } @@ -522,10 +568,8 @@ void ev_loop (int flags) time_update (); /* queue pending timers and reschedule them */ - /* absolute timers first */ - timers_reify (atimers, atimercnt, ev_now); - /* relative timers second */ - timers_reify (rtimers, rtimercnt, now); + periodics_reify (); /* absolute timers first */ + timers_reify (); /* relative timers second */ /* queue idle watchers unless io or timers are pending */ if (!pendingcnt) @@ -612,33 +656,19 @@ evio_stop (struct ev_io *w) fdchanges [fdchangecnt - 1] = w->fd; } + void evtimer_start (struct ev_timer *w) { if (ev_is_active (w)) return; - if (w->is_abs) - { - /* this formula differs from the one in timer_reify becuse we do not round up */ - if (w->repeat) - w->at += ceil ((ev_now - w->at) / w->repeat) * w->repeat; - - ev_start ((W)w, ++atimercnt); - array_needsize (atimers, atimermax, atimercnt, ); - atimers [atimercnt - 1] = w; - upheap (atimers, atimercnt - 1); - } - else - { - w->at += now; - - ev_start ((W)w, ++rtimercnt); - array_needsize (rtimers, rtimermax, rtimercnt, ); - rtimers [rtimercnt - 1] = w; - upheap (rtimers, rtimercnt - 1); - } + w->at += now; + ev_start ((W)w, ++timercnt); + array_needsize (timers, timermax, timercnt, ); + timers [timercnt - 1] = w; + upheap ((WT *)timers, timercnt - 1); } void @@ -647,21 +677,41 @@ evtimer_stop (struct ev_timer *w) if (!ev_is_active (w)) return; - if (w->is_abs) + if (w->active < timercnt--) { - if (w->active < atimercnt--) - { - atimers [w->active - 1] = atimers [atimercnt]; - downheap (atimers, atimercnt, w->active - 1); - } + timers [w->active - 1] = timers [timercnt]; + downheap ((WT *)timers, timercnt, w->active - 1); } - else + + ev_stop ((W)w); +} + +void +evperiodic_start (struct ev_periodic *w) +{ + if (ev_is_active (w)) + return; + + /* this formula differs from the one in periodic_reify because we do not always round up */ + if (w->interval) + w->at += ceil ((ev_now - w->at) / w->interval) * w->interval; + + ev_start ((W)w, ++periodiccnt); + array_needsize (periodics, periodicmax, periodiccnt, ); + periodics [periodiccnt - 1] = w; + upheap ((WT *)periodics, periodiccnt - 1); +} + +void +evperiodic_stop (struct ev_periodic *w) +{ + if (!ev_is_active (w)) + return; + + if (w->active < periodiccnt--) { - if (w->active < rtimercnt--) - { - rtimers [w->active - 1] = rtimers [rtimercnt]; - downheap (rtimers, rtimercnt, w->active - 1); - } + periodics [w->active - 1] = periodics [periodiccnt]; + downheap ((WT *)periodics, periodiccnt, w->active - 1); } ev_stop ((W)w); @@ -734,7 +784,9 @@ void evcheck_stop (struct ev_check *w) /*****************************************************************************/ -#if 0 +#if 1 + +struct ev_io wio; static void sin_cb (struct ev_io *w, int revents) @@ -754,23 +806,23 @@ static void scb (struct ev_signal *w, int revents) { fprintf (stderr, "signal %x,%d\n", revents, w->signum); + evio_stop (&wio); + evio_start (&wio); } static void gcb (struct ev_signal *w, int revents) { fprintf (stderr, "generic %x\n", revents); + } int main (void) { - struct ev_io sin; - ev_init (0); - evw_init (&sin, sin_cb, 55); - evio_set (&sin, 0, EV_READ); - evio_start (&sin); + evio_init (&wio, sin_cb, 0, EV_READ); + evio_start (&wio); struct ev_timer t[10000]; @@ -780,7 +832,7 @@ int main (void) { struct ev_timer *w = t + i; evw_init (w, ocb, i); - evtimer_set_abs (w, drand48 (), 0.99775533); + evtimer_init_abs (w, ocb, drand48 (), 0.99775533); evtimer_start (w); if (drand48 () < 0.5) evtimer_stop (w); @@ -788,21 +840,19 @@ int main (void) #endif struct ev_timer t1; - evw_init (&t1, ocb, 0); - evtimer_set_abs (&t1, 5, 10); + evtimer_init (&t1, ocb, 5, 10); evtimer_start (&t1); struct ev_signal sig; - evw_init (&sig, scb, 65535); - evsignal_set (&sig, SIGQUIT); + evsignal_init (&sig, scb, SIGQUIT); evsignal_start (&sig); struct ev_check cw; - evw_init (&cw, gcb, 0); + evcheck_init (&cw, gcb); evcheck_start (&cw); struct ev_idle iw; - evw_init (&iw, gcb, 0); + evidle_init (&iw, gcb); evidle_start (&iw); ev_loop (0); @@ -13,25 +13,47 @@ typedef double ev_tstamp; #define EV_IDLE 0x10 #define EV_CHECK 0x20 +/* can be used to add custom fields to all watchers */ +#ifndef EV_COMMON +# define EV_COMMON void *data +#endif + +/* + * struct member types: + * private: you can look at them, but not change them, and they might not mean anything to you. + * ro: can be read anytime, but only changed when the watcher isn't active + * rw: can be read and modified anytime, even when the watcher is active + */ + /* shared by all watchers */ #define EV_WATCHER(type) \ int active; /* private */ \ int pending; /* private */ \ - void *data; /* rw */ \ - void (*cb)(struct type *, int revents) /* rw */ /* gets invoked with an eventmask */ + EV_COMMON; /* rw */ \ + void (*cb)(struct type *, int revents); /* rw */ /* gets invoked with an eventmask */ #define EV_WATCHER_LIST(type) \ EV_WATCHER (type); \ struct type *next /* private */ -/* invoked at a specific time or after a specific time, repeatable */ +#define EV_WATCHER_TIME(type) \ + EV_WATCHER (type); \ + ev_tstamp at /* private */ + +/* invoked after a specific time, repeatable (based on monotonic clock) */ struct ev_timer { - EV_WATCHER_LIST (ev_timer); + EV_WATCHER_TIME (ev_timer); - ev_tstamp at; /* private */ ev_tstamp repeat; /* rw */ - unsigned char is_abs; /* ro */ +}; + +/* invoked at some specific time, possibly repeating at regular intervals (based on UTC) */ +struct ev_periodic +{ + EV_WATCHER_TIME (ev_periodic); + + ev_tstamp interval; /* rw */ }; /* invoked when fd is either EV_READable or EV_WRITEable */ @@ -83,31 +105,44 @@ void ev_loop (int flags); extern int ev_loop_done; /* set to 1 to break out of event loop */ /* these may evaluate ev multiple times, and the other arguments at most once */ -#define evw_init(ev,cb_,data_) do { (ev)->active = 0; (ev)->cb = (cb_); (ev)->data = (void *)data_; } while (0) +/* either use evw_init + evXXX_set, or the evXXX_init macro, below, to first initialise a watcher */ +#define evw_init(ev,cb_) do { (ev)->active = 0; (ev)->cb = (cb_); } while (0) #define evio_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_); } while (0) -#define evtimer_set_rel(ev,after_,repeat_) do { (ev)->at = (after_); (ev)->repeat = (repeat_); (ev)->is_abs = 0; } while (0) -#define evtimer_set_abs(ev,at_,repeat_) do { (ev)->at = (at_); (ev)->repeat = (repeat_); (ev)->is_abs = 1; } while (0) +#define evtimer_set(ev,after_,repeat_) do { (ev)->at = (after_); (ev)->repeat = (repeat_); } while (0) +#define evperiodic_set(ev,at_,interval_) do { (ev)->at = (at_); (ev)->interval = (interval_); } while (0) #define evsignal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0) +#define evcheck_set(ev) /* nop, yes this is a serious in-joke */ +#define evidle_set(ev) /* nop, yes this is a serious in-joke */ + +#define evio_init(ev,cb,fd,events) do { evw_init ((ev), (cb)); evio_set ((ev),(fd),(events)); } while (0) +#define evtimer_init(ev,cb,after,repeat) do { evw_init ((ev), (cb)); evtimer_set ((ev),(after),(repeat)); } while (0) +#define evperiodic_init(ev,cb,at,interval) do { evw_init ((ev), (cb)); evperiodic_set ((ev),(at),(interval)); } while (0) +#define evsignal_init(ev,cb,signum) do { evw_init ((ev), (cb)); evsignal_set ((ev), (signum)); } while (0) +#define evcheck_init(ev,cb) do { evw_init ((ev), (cb)); evcheck_set ((ev)); } while (0) +#define evidle_init(ev,cb) do { evw_init ((ev), (cb)); evidle_set ((ev)); } while (0) #define ev_is_active(ev) (0 + (ev)->active) /* true when the watcher has been started */ /* stopping (enabling, adding) a watcher does nothing if it is already running */ /* stopping (disabling, deleting) a watcher does nothing unless its already running */ -void evio_start (struct ev_io *w); -void evio_stop (struct ev_io *w); +void evio_start (struct ev_io *w); +void evio_stop (struct ev_io *w); + +void evtimer_start (struct ev_timer *w); +void evtimer_stop (struct ev_timer *w); -void evtimer_start (struct ev_timer *w); -void evtimer_stop (struct ev_timer *w); +void evperiodic_start (struct ev_periodic *w); +void evperiodic_stop (struct ev_periodic *w); -void evsignal_start (struct ev_signal *w); -void evsignal_stop (struct ev_signal *w); +void evsignal_start (struct ev_signal *w); +void evsignal_stop (struct ev_signal *w); -void evidle_start (struct ev_idle *w); -void evidle_stop (struct ev_idle *w); +void evidle_start (struct ev_idle *w); +void evidle_stop (struct ev_idle *w); -void evcheck_start (struct ev_check *w); -void evcheck_stop (struct ev_check *w); +void evcheck_start (struct ev_check *w); +void evcheck_stop (struct ev_check *w); #endif |