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 15 years ago
parent ac781805ae
commit 4c7e1773f0
2 changed files with 241 additions and 75 deletions
Show Stats Download Patch File Download Diff File

307
ev.c
Unescape Escape View File

@ -290,6 +290,17 @@ int eventfd (unsigned int initval, int flags);
/**/
/* undefined or zero: no verification done or available */
/* 1 or higher: ev_loop_verify function available */
/* 2 or higher: ev_loop_verify is called frequently */
#define EV_VERIFY 1
#if EV_VERIFY > 1
# define EV_FREQUENT_CHECK ev_loop_verify (EV_A)
#else
# define EV_FREQUENT_CHECK do { } while (0)
#endif
/*
* This is used to avoid floating point rounding problems.
* It is added to ev_rt_now when scheduling periodics
@ -446,15 +457,15 @@ typedef struct
WT w;
} ANHE;
#define ANHE_w(he) (he).w /* access watcher, read-write */
#define ANHE_at(he) (he).at /* access cached at, read-only */
#define ANHE_at_set(he) (he).at = (he).w->at /* update at from watcher */
#define ANHE_w(he) (he).w /* access watcher, read-write */
#define ANHE_at(he) (he).at /* access cached at, read-only */
#define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */
#else
typedef WT ANHE;
#define ANHE_w(he) (he)
#define ANHE_at(he) (he)->at
#define ANHE_at_set(he)
#define ANHE_w(he) (he)
#define ANHE_at(he) (he)->at
#define ANHE_at_cache(he)
#endif
#if EV_MULTIPLICITY
@ -805,28 +816,7 @@ fd_rearm_all (EV_P)
#define DHEAP 4
#define HEAP0 (DHEAP - 1) /* index of first element in heap */
#define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
/* towards the root */
void inline_speed
upheap (ANHE *heap, int k)
{
ANHE he = heap [k];
for (;;)
{
int p = HPARENT (k);
if (p == k || ANHE_at (heap [p]) <= ANHE_at (he))
break;
heap [k] = heap [p];
ev_active (ANHE_w (heap [k])) = k;
k = p;
}
heap [k] = he;
ev_active (ANHE_w (he)) = k;
}
#define UPHEAP_DONE(p,k) ((p) == (k))
/* away from the root */
void inline_speed
@ -839,9 +829,9 @@ downheap (ANHE *heap, int N, int k)
{
ev_tstamp minat;
ANHE *minpos;
ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0;
ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
// find minimum child
/* find minimum child */
if (expect_true (pos + DHEAP - 1 < E))
{
/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
@ -872,63 +862,63 @@ downheap (ANHE *heap, int N, int k)
ev_active (ANHE_w (he)) = k;
}
#else // 4HEAP
#else /* 4HEAP */
#define HEAP0 1
#define HPARENT(k) ((k) >> 1)
#define UPHEAP_DONE(p,k) (!(p))
/* towards the root */
/* away from the root */
void inline_speed
upheap (ANHE *heap, int k)
downheap (ANHE *heap, int N, int k)
{
ANHE he = heap [k];
for (;;)
{
int p = HPARENT (k);
int c = k << 1;
/* maybe we could use a dummy element at heap [0]? */
if (!p || ANHE_at (heap [p]) <= ANHE_at (he))
if (c > N + HEAP0 - 1)
break;
heap [k] = heap [p];
c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
? 1 : 0;
if (ANHE_at (he) <= ANHE_at (heap [c]))
break;
heap [k] = heap [c];
ev_active (ANHE_w (heap [k])) = k;
k = p;
k = c;
}
heap [k] = he;
ev_active (ANHE_w (heap [k])) = k;
ev_active (ANHE_w (he)) = k;
}
#endif
/* away from the root */
/* towards the root */
void inline_speed
downheap (ANHE *heap, int N, int k)
upheap (ANHE *heap, int k)
{
ANHE he = heap [k];
for (;;)
{
int c = k << 1;
if (c > N)
break;
c += c + 1 < N && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
? 1 : 0;
int p = HPARENT (k);
if (ANHE_at (he) <= ANHE_at (heap [c]))
if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
break;
heap [k] = heap [c];
heap [k] = heap [p];
ev_active (ANHE_w (heap [k])) = k;
k = c;
k = p;
}
heap [k] = he;
ev_active (ANHE_w (he)) = k;
}
#endif
void inline_size
adjustheap (ANHE *heap, int N, int k)
@ -939,6 +929,32 @@ adjustheap (ANHE *heap, int N, int k)
downheap (heap, N, k);
}
/* rebuild the heap: this function is used only once and executed rarely */
void inline_size
reheap (ANHE *heap, int N)
{
int i;
/* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
/* also, this is easy to implement and correct for both 2-heaps and 4-heaps */
for (i = 0; i < N; ++i)
upheap (heap, i + HEAP0);
}
#if EV_VERIFY
static void
checkheap (ANHE *heap, int N)
{
int i;
for (i = HEAP0; i < N + HEAP0; ++i)
{
assert (("active index mismatch in heap", ev_active (ANHE_w (heap [i])) == i));
assert (("heap condition violated", i == HEAP0 || ANHE_at (heap [HPARENT (i)]) <= ANHE_at (heap [i])));
assert (("heap at cache mismatch", ANHE_at (heap [i]) == ev_at (ANHE_w (heap [i]))));
}
}
#endif
/*****************************************************************************/
typedef struct
@ -1491,6 +1507,40 @@ ev_loop_fork (EV_P)
{
postfork = 1; /* must be in line with ev_default_fork */
}
#if EV_VERIFY
static void
array_check (W **ws, int cnt)
{
while (cnt--)
assert (("active index mismatch", ev_active (ws [cnt]) == cnt + 1));
}
static void
ev_loop_verify (EV_P)
{
int i;
checkheap (timers, timercnt);
#if EV_PERIODIC_ENABLE
checkheap (periodics, periodiccnt);
#endif
#if EV_IDLE_ENABLE
for (i = NUMPRI; i--; )
array_check ((W **)idles [i], idlecnt [i]);
#endif
#if EV_FORK_ENABLE
array_check ((W **)forks, forkcnt);
#endif
array_check ((W **)prepares, preparecnt);
array_check ((W **)checks, checkcnt);
#if EV_ASYNC_ENABLE
array_check ((W **)asyncs, asynccnt);
#endif
}
#endif
#endif
#if EV_MULTIPLICITY
@ -1566,6 +1616,8 @@ call_pending (EV_P)
{
int pri;
EV_FREQUENT_CHECK;
for (pri = NUMPRI; pri--; )
while (pendingcnt [pri])
{
@ -1579,6 +1631,8 @@ call_pending (EV_P)
EV_CB_INVOKE (p->w, p->events);
}
}
EV_FREQUENT_CHECK;
}
#if EV_IDLE_ENABLE
@ -1607,6 +1661,8 @@ idle_reify (EV_P)
void inline_size
timers_reify (EV_P)
{
EV_FREQUENT_CHECK;
while (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
{
ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
@ -1622,12 +1678,13 @@ timers_reify (EV_P)
assert (("negative ev_timer repeat value found while processing timers", w->repeat > 0.));
ANHE_at_set (timers [HEAP0]);
ANHE_at_cache (timers [HEAP0]);
downheap (timers, timercnt, HEAP0);
}
else
ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
EV_FREQUENT_CHECK;
ev_feed_event (EV_A_ (W)w, EV_TIMEOUT);
}
}
@ -1636,6 +1693,7 @@ timers_reify (EV_P)
void inline_size
periodics_reify (EV_P)
{
EV_FREQUENT_CHECK;
while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
{
ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
@ -1649,8 +1707,9 @@ periodics_reify (EV_P)
assert (("ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now));
ANHE_at_set (periodics [HEAP0]);
ANHE_at_cache (periodics [HEAP0]);
downheap (periodics, periodiccnt, HEAP0);
EV_FREQUENT_CHECK;
}
else if (w->interval)
{
@ -1668,12 +1727,13 @@ periodics_reify (EV_P)
ev_at (w) = ev_rt_now;
}
ANHE_at_set (periodics [HEAP0]);
ANHE_at_cache (periodics [HEAP0]);
downheap (periodics, periodiccnt, HEAP0);
}
else
ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
EV_FREQUENT_CHECK;
ev_feed_event (EV_A_ (W)w, EV_PERIODIC);
}
}
@ -1693,13 +1753,10 @@ periodics_reschedule (EV_P)
else if (w->interval)
ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
ANHE_at_set (periodics [i]);
ANHE_at_cache (periodics [i]);
}
/* we don't use floyds algorithm, uphead is simpler and is more cache-efficient */
/* also, this is easy and corretc for both 2-heaps and 4-heaps */
for (i = 0; i < periodiccnt; ++i)
upheap (periodics, i + HEAP0);
reheap (periodics, periodiccnt);
}
#endif
@ -1767,7 +1824,7 @@ time_update (EV_P_ ev_tstamp max_block)
{
ANHE *he = timers + i + HEAP0;
ANHE_w (*he)->at += ev_rt_now - mn_now;
ANHE_at_set (*he);
ANHE_at_cache (*he);
}
}
@ -2002,12 +2059,16 @@ ev_io_start (EV_P_ ev_io *w)
assert (("ev_io_start called with negative fd", fd >= 0));
EV_FREQUENT_CHECK;
ev_start (EV_A_ (W)w, 1);
array_needsize (ANFD, anfds, anfdmax, fd + 1, anfds_init);
wlist_add (&anfds[fd].head, (WL)w);
fd_change (EV_A_ fd, w->events & EV_IOFDSET | 1);
w->events &= ~EV_IOFDSET;
EV_FREQUENT_CHECK;
}
void noinline
@ -2019,10 +2080,14 @@ ev_io_stop (EV_P_ ev_io *w)
assert (("ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
EV_FREQUENT_CHECK;
wlist_del (&anfds[w->fd].head, (WL)w);
ev_stop (EV_A_ (W)w);
fd_change (EV_A_ w->fd, 1);
EV_FREQUENT_CHECK;
}
void noinline
@ -2035,12 +2100,17 @@ ev_timer_start (EV_P_ ev_timer *w)
assert (("ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
ev_start (EV_A_ (W)w, ++timercnt + HEAP0 - 1);
EV_FREQUENT_CHECK;
++timercnt;
ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);
ANHE_w (timers [ev_active (w)]) = (WT)w;
ANHE_at_set (timers [ev_active (w)]);
ANHE_at_cache (timers [ev_active (w)]);
upheap (timers, ev_active (w));
EV_FREQUENT_CHECK;
/*assert (("internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
}
@ -2051,20 +2121,24 @@ ev_timer_stop (EV_P_ ev_timer *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
{
int active = ev_active (w);
assert (("internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
if (expect_true (active < timercnt + HEAP0 - 1))
--timercnt;
if (expect_true (active < timercnt + HEAP0))
{
timers [active] = timers [timercnt + HEAP0 - 1];
timers [active] = timers [timercnt + HEAP0];
adjustheap (timers, timercnt, active);
}
--timercnt;
}
EV_FREQUENT_CHECK;
ev_at (w) -= mn_now;
ev_stop (EV_A_ (W)w);
@ -2073,12 +2147,14 @@ ev_timer_stop (EV_P_ ev_timer *w)
void noinline
ev_timer_again (EV_P_ ev_timer *w)
{
EV_FREQUENT_CHECK;
if (ev_is_active (w))
{
if (w->repeat)
{
ev_at (w) = mn_now + w->repeat;
ANHE_at_set (timers [ev_active (w)]);
ANHE_at_cache (timers [ev_active (w)]);
adjustheap (timers, timercnt, ev_active (w));
}
else
@ -2089,6 +2165,8 @@ ev_timer_again (EV_P_ ev_timer *w)
ev_at (w) = w->repeat;
ev_timer_start (EV_A_ w);
}
EV_FREQUENT_CHECK;
}
#if EV_PERIODIC_ENABLE
@ -2109,12 +2187,17 @@ ev_periodic_start (EV_P_ ev_periodic *w)
else
ev_at (w) = w->offset;
ev_start (EV_A_ (W)w, ++periodiccnt + HEAP0 - 1);
EV_FREQUENT_CHECK;
++periodiccnt;
ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);
ANHE_w (periodics [ev_active (w)]) = (WT)w;
ANHE_at_set (periodics [ev_active (w)]);
ANHE_at_cache (periodics [ev_active (w)]);
upheap (periodics, ev_active (w));
EV_FREQUENT_CHECK;
/*assert (("internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
}
@ -2125,20 +2208,24 @@ ev_periodic_stop (EV_P_ ev_periodic *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
{
int active = ev_active (w);
assert (("internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
if (expect_true (active < periodiccnt + HEAP0 - 1))
--periodiccnt;
if (expect_true (active < periodiccnt + HEAP0))
{
periodics [active] = periodics [periodiccnt + HEAP0 - 1];
periodics [active] = periodics [periodiccnt + HEAP0];
adjustheap (periodics, periodiccnt, active);
}
--periodiccnt;
}
EV_FREQUENT_CHECK;
ev_stop (EV_A_ (W)w);
}
@ -2168,6 +2255,8 @@ ev_signal_start (EV_P_ ev_signal *w)
evpipe_init (EV_A);
EV_FREQUENT_CHECK;
{
#ifndef _WIN32
sigset_t full, prev;
@ -2197,6 +2286,8 @@ ev_signal_start (EV_P_ ev_signal *w)
sigaction (w->signum, &sa, 0);
#endif
}
EV_FREQUENT_CHECK;
}
void noinline
@ -2206,11 +2297,15 @@ ev_signal_stop (EV_P_ ev_signal *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
wlist_del (&signals [w->signum - 1].head, (WL)w);
ev_stop (EV_A_ (W)w);
if (!signals [w->signum - 1].head)
signal (w->signum, SIG_DFL);
EV_FREQUENT_CHECK;
}
void
@ -2222,8 +2317,12 @@ ev_child_start (EV_P_ ev_child *w)
if (expect_false (ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
ev_start (EV_A_ (W)w, 1);
wlist_add (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
EV_FREQUENT_CHECK;
}
void
@ -2233,8 +2332,12 @@ ev_child_stop (EV_P_ ev_child *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
wlist_del (&childs [w->pid & (EV_PID_HASHSIZE - 1)], (WL)w);
ev_stop (EV_A_ (W)w);
EV_FREQUENT_CHECK;
}
#if EV_STAT_ENABLE
@ -2472,6 +2575,8 @@ ev_stat_start (EV_P_ ev_stat *w)
ev_timer_start (EV_A_ &w->timer);
ev_start (EV_A_ (W)w, 1);
EV_FREQUENT_CHECK;
}
void
@ -2481,12 +2586,16 @@ ev_stat_stop (EV_P_ ev_stat *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
#if EV_USE_INOTIFY
infy_del (EV_A_ w);
#endif
ev_timer_stop (EV_A_ &w->timer);
ev_stop (EV_A_ (W)w);
EV_FREQUENT_CHECK;
}
#endif
@ -2499,6 +2608,8 @@ ev_idle_start (EV_P_ ev_idle *w)
pri_adjust (EV_A_ (W)w);
EV_FREQUENT_CHECK;
{
int active = ++idlecnt [ABSPRI (w)];
@ -2508,6 +2619,8 @@ ev_idle_start (EV_P_ ev_idle *w)
array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);
idles [ABSPRI (w)][active - 1] = w;
}
EV_FREQUENT_CHECK;
}
void
@ -2517,6 +2630,8 @@ ev_idle_stop (EV_P_ ev_idle *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
{
int active = ev_active (w);
@ -2526,6 +2641,8 @@ ev_idle_stop (EV_P_ ev_idle *w)
ev_stop (EV_A_ (W)w);
--idleall;
}
EV_FREQUENT_CHECK;
}
#endif
@ -2535,9 +2652,13 @@ ev_prepare_start (EV_P_ ev_prepare *w)
if (expect_false (ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
ev_start (EV_A_ (W)w, ++preparecnt);
array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
prepares [preparecnt - 1] = w;
EV_FREQUENT_CHECK;
}
void
@ -2547,6 +2668,8 @@ ev_prepare_stop (EV_P_ ev_prepare *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
{
int active = ev_active (w);
@ -2555,6 +2678,8 @@ ev_prepare_stop (EV_P_ ev_prepare *w)
}
ev_stop (EV_A_ (W)w);
EV_FREQUENT_CHECK;
}
void
@ -2563,9 +2688,13 @@ ev_check_start (EV_P_ ev_check *w)
if (expect_false (ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
ev_start (EV_A_ (W)w, ++checkcnt);
array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
checks [checkcnt - 1] = w;
EV_FREQUENT_CHECK;
}
void
@ -2575,6 +2704,8 @@ ev_check_stop (EV_P_ ev_check *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
{
int active = ev_active (w);
@ -2583,6 +2714,8 @@ ev_check_stop (EV_P_ ev_check *w)
}
ev_stop (EV_A_ (W)w);
EV_FREQUENT_CHECK;
}
#if EV_EMBED_ENABLE
@ -2639,6 +2772,8 @@ ev_embed_start (EV_P_ ev_embed *w)
ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ);
}
EV_FREQUENT_CHECK;
ev_set_priority (&w->io, ev_priority (w));
ev_io_start (EV_A_ &w->io);
@ -2649,6 +2784,8 @@ ev_embed_start (EV_P_ ev_embed *w)
/*ev_idle_init (&w->idle, e,bed_idle_cb);*/
ev_start (EV_A_ (W)w, 1);
EV_FREQUENT_CHECK;
}
void
@ -2658,10 +2795,14 @@ ev_embed_stop (EV_P_ ev_embed *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
ev_io_stop (EV_A_ &w->io);
ev_prepare_stop (EV_A_ &w->prepare);
ev_stop (EV_A_ (W)w);
EV_FREQUENT_CHECK;
}
#endif
@ -2672,9 +2813,13 @@ ev_fork_start (EV_P_ ev_fork *w)
if (expect_false (ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
ev_start (EV_A_ (W)w, ++forkcnt);
array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);
forks [forkcnt - 1] = w;
EV_FREQUENT_CHECK;
}
void
@ -2684,6 +2829,8 @@ ev_fork_stop (EV_P_ ev_fork *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
{
int active = ev_active (w);
@ -2692,6 +2839,8 @@ ev_fork_stop (EV_P_ ev_fork *w)
}
ev_stop (EV_A_ (W)w);
EV_FREQUENT_CHECK;
}
#endif
@ -2704,9 +2853,13 @@ ev_async_start (EV_P_ ev_async *w)
evpipe_init (EV_A);
EV_FREQUENT_CHECK;
ev_start (EV_A_ (W)w, ++asynccnt);
array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);
asyncs [asynccnt - 1] = w;
EV_FREQUENT_CHECK;
}
void
@ -2716,6 +2869,8 @@ ev_async_stop (EV_P_ ev_async *w)
if (expect_false (!ev_is_active (w)))
return;
EV_FREQUENT_CHECK;
{
int active = ev_active (w);
@ -2724,6 +2879,8 @@ ev_async_stop (EV_P_ ev_async *w)
}
ev_stop (EV_A_ (W)w);
EV_FREQUENT_CHECK;
}
void

9
ev.h
Unescape Escape View File

@ -166,6 +166,15 @@ struct ev_loop;
* 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
*
* some internal details that might be helpful for debugging:
*
* active is either 0, which means the watcher is not active,
* or the array index of the watcher (periodics, timers)
* or the array index + 1 (most other watchers)
* or simply 1 for watchers that aren't in some array.
* pending is either 0, in which case the watcher isn't,
* or the array index + 1 in the pendings array.
*/
/* shared by all watchers */

Write Preview
Loading…
Cancel
Save