mirrors
/
libev
mirror of /home/gitosis/repositories/libev.git
1
0
Fork 0
Code Releases Activity

*** empty log message ***

Browse Source
master
Marc Alexander Lehmann 16 years ago
parent 0b9bd69e70
commit 4d05586119
2 changed files with 188 additions and 103 deletions
Show Stats Download Patch File Download Diff File

218
ev.c
Unescape View File

@ -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);

73
ev.h
Unescape View File

@ -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

Write Preview
Loading…
Cancel
Save