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

*** empty log message ***

master
Marc Alexander Lehmann 13 years ago
parent
843cdaedc8
commit
658e938a74
2 changed files with 89 additions and 59 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 144
      ev.c
  2. 4
      ev_vars.h

144
ev.c
View File

@ -424,12 +424,31 @@ typedef struct
} ANPENDING;
#if EV_USE_INOTIFY
/* hash table entry per inotify-id */
typedef struct
{
WL head;
} ANFS;
#endif
/* Heap Entry */
#if EV_HEAP_CACHE_AT
typedef struct {
WT w;
ev_tstamp at;
} ANHE;
#define ANHE_w(he) (he) /* access watcher, read-write */
#define ANHE_at(he) (he)->at /* acces cahced at, read-only */
#define ANHE_at_set(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)
#endif
#if EV_MULTIPLICITY
struct ev_loop
@ -761,83 +780,88 @@ fd_rearm_all (EV_P)
/*****************************************************************************/
/*
* the heap functions want a real array index. array index 0 uis guaranteed to not
* be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
* the branching factor of the d-tree.
*/
/*
* at the moment we allow libev the luxury of two heaps,
* a small-code-size 2-heap one and a ~1.5kb larger 4-heap
* which is more cache-efficient.
* the difference is about 5% with 50000+ watchers.
*/
#define USE_4HEAP !EV_MINIMAL
#if USE_4HEAP
#define EV_USE_4HEAP !EV_MINIMAL
#if EV_USE_4HEAP
#define DHEAP 4
#define HEAP0 (DHEAP - 1) /* index of first element in heap */
/* towards the root */
void inline_speed
upheap (WT *heap, int k)
upheap (ANHE *heap, int k)
{
WT w = heap [k];
ev_tstamp w_at = w->at;
ANHE he = heap [k];
for (;;)
{
int p = ((k - HEAP0 - 1) / DHEAP) + HEAP0;
if (p == k || heap [p]->at <= w_at)
if (p == k || ANHE_at (heap [p]) <= ANHE_at (he))
break;
heap [k] = heap [p];
ev_active (heap [k]) = k;
ev_active (ANHE_w (heap [k])) = k;
k = p;
}
heap [k] = w;
ev_active (heap [k]) = k;
ev_active (ANHE_w (he)) = k;
heap [k] = he;
}
/* away from the root */
void inline_speed
downheap (WT *heap, int N, int k)
downheap (ANHE *heap, int N, int k)
{
WT w = heap [k];
WT *E = heap + N + HEAP0;
ANHE he = heap [k];
ANHE *E = heap + N + HEAP0;
for (;;)
{
ev_tstamp minat;
WT *minpos;
WT *pos = heap + DHEAP * (k - HEAP0) + HEAP0;
ANHE *minpos;
ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0;
// find minimum child
if (expect_true (pos + DHEAP - 1 < E))
{
/* fast path */ (minpos = pos + 0), (minat = (*minpos)->at);
if (pos [1]->at < minat) (minpos = pos + 1), (minat = (*minpos)->at);
if (pos [2]->at < minat) (minpos = pos + 2), (minat = (*minpos)->at);
if (pos [3]->at < minat) (minpos = pos + 3), (minat = (*minpos)->at);
/* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
if (ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
if (ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
if (ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
}
else if (pos < E)
{
/* slow path */ (minpos = pos + 0), (minat = (*minpos)->at);
if (pos + 1 < E && pos [1]->at < minat) (minpos = pos + 1), (minat = (*minpos)->at);
if (pos + 2 < E && pos [2]->at < minat) (minpos = pos + 2), (minat = (*minpos)->at);
if (pos + 3 < E && pos [3]->at < minat) (minpos = pos + 3), (minat = (*minpos)->at);
/* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
}
else
break;
if (w->at <= minat)
if (ANHE_at (he) <= minat)
break;
ev_active (*minpos) = k;
ev_active (ANHE_w (*minpos)) = k;
heap [k] = *minpos;
k = minpos - heap;
}
heap [k] = w;
ev_active (heap [k]) = k;
ev_active (ANHE_w (he)) = k;
heap [k] = he;
}
#else // 4HEAP
@ -846,32 +870,32 @@ downheap (WT *heap, int N, int k)
/* towards the root */
void inline_speed
upheap (WT *heap, int k)
upheap (ANHE *heap, int k)
{
WT w = heap [k];
ANHE he = heap [k];
for (;;)
{
int p = k >> 1;
/* maybe we could use a dummy element at heap [0]? */
if (!p || heap [p]->at <= w->at)
if (!p || ANHE_at (heap [p]) <= ANHE_at (he))
break;
heap [k] = heap [p];
ev_active (heap [k]) = k;
ev_active (ANHE_w (heap [k])) = k;
k = p;
}
heap [k] = w;
ev_active (heap [k]) = k;
ev_active (ANHE_w (heap [k])) = k;
}
/* away from the root */
void inline_speed
downheap (WT *heap, int N, int k)
downheap (ANHE *heap, int N, int k)
{
WT w = heap [k];
ANHE he = heap [k];
for (;;)
{
@ -880,25 +904,25 @@ downheap (WT *heap, int N, int k)
if (c > N)
break;
c += c + 1 < N && heap [c]->at > heap [c + 1]->at
c += c + 1 < N && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
? 1 : 0;
if (w->at <= heap [c]->at)
if (w->at <= ANHE_at (heap [c]))
break;
heap [k] = heap [c];
((W)heap [k])->active = k;
ev_active (ANHE_w (heap [k])) = k;
k = c;
}
heap [k] = w;
ev_active (heap [k]) = k;
heap [k] = he;
ev_active (ANHE_w (he)) = k;
}
#endif
void inline_size
adjustheap (WT *heap, int N, int k)
adjustheap (ANHE *heap, int N, int k)
{
upheap (heap, k);
downheap (heap, N, k);
@ -1572,9 +1596,9 @@ idle_reify (EV_P)
void inline_size
timers_reify (EV_P)
{
while (timercnt && ev_at (timers [HEAP0]) <= mn_now)
while (timercnt && ANHE_at (timers [HEAP0]) <= mn_now)
{
ev_timer *w = (ev_timer *)timers [HEAP0];
ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
/*assert (("inactive timer on timer heap detected", ev_is_active (w)));*/
@ -1600,9 +1624,9 @@ timers_reify (EV_P)
void inline_size
periodics_reify (EV_P)
{
while (periodiccnt && ev_at (periodics [HEAP0]) <= ev_rt_now)
while (periodiccnt && ANHE_at (periodics [HEAP0]) <= ev_rt_now)
{
ev_periodic *w = (ev_periodic *)periodics [HEAP0];
ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
/*assert (("inactive timer on periodic heap detected", ev_is_active (w)));*/
@ -1633,9 +1657,9 @@ periodics_reschedule (EV_P)
int i;
/* adjust periodics after time jump */
for (i = 1; i <= periodiccnt; ++i)
for (i = HEAP0; i < periodiccnt + HEAP0; ++i)
{
ev_periodic *w = (ev_periodic *)periodics [i];
ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]);
if (w->reschedule_cb)
ev_at (w) = w->reschedule_cb (w, ev_rt_now);
@ -1643,7 +1667,7 @@ periodics_reschedule (EV_P)
ev_at (w) = w->offset + ceil ((ev_rt_now - w->offset) / w->interval) * w->interval;
}
/* now rebuild the heap */
/* now rebuild the heap, this for the 2-heap, inefficient for the 4-heap, but correct */
for (i = periodiccnt >> 1; --i; )
downheap (periodics, periodiccnt, i + HEAP0);
}
@ -1709,8 +1733,12 @@ time_update (EV_P_ ev_tstamp max_block)
periodics_reschedule (EV_A);
#endif
/* adjust timers. this is easy, as the offset is the same for all of them */
for (i = 1; i <= timercnt; ++i)
ev_at (timers [i]) += ev_rt_now - mn_now;
for (i = 0; i < timercnt; ++i)
{
ANHE *he = timers + i + HEAP0;
ANHE_w (*he)->at += ev_rt_now - mn_now;
ANHE_at_set (*he);
}
}
mn_now = ev_rt_now;
@ -1790,14 +1818,14 @@ ev_loop (EV_P_ int flags)
if (timercnt)
{
ev_tstamp to = ev_at (timers [HEAP0]) - mn_now + backend_fudge;
ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now + backend_fudge;
if (waittime > to) waittime = to;
}
#if EV_PERIODIC_ENABLE
if (periodiccnt)
{
ev_tstamp to = ev_at (periodics [HEAP0]) - ev_rt_now + backend_fudge;
ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now + backend_fudge;
if (waittime > to) waittime = to;
}
#endif
@ -1978,8 +2006,9 @@ 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);
array_needsize (WT, timers, timermax, timercnt + HEAP0, EMPTY2);
timers [ev_active (w)] = (WT)w;
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)]);
upheap (timers, ev_active (w));
/*assert (("internal timer heap corruption", timers [ev_active (w)] == w));*/
@ -1995,7 +2024,7 @@ ev_timer_stop (EV_P_ ev_timer *w)
{
int active = ev_active (w);
assert (("internal timer heap corruption", timers [active] == (WT)w));
assert (("internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
if (expect_true (active < timercnt + HEAP0 - 1))
{
@ -2019,6 +2048,7 @@ ev_timer_again (EV_P_ ev_timer *w)
if (w->repeat)
{
ev_at (w) = mn_now + w->repeat;
ANHE_at_set (timers [ev_active (w)]);
adjustheap (timers, timercnt, ev_active (w));
}
else
@ -2050,11 +2080,11 @@ ev_periodic_start (EV_P_ ev_periodic *w)
ev_at (w) = w->offset;
ev_start (EV_A_ (W)w, ++periodiccnt + HEAP0 - 1);
array_needsize (WT, periodics, periodicmax, periodiccnt + HEAP0, EMPTY2);
periodics [ev_active (w)] = (WT)w;
array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);
ANHE_w (periodics [ev_active (w)]) = (WT)w;
upheap (periodics, ev_active (w));
/*assert (("internal periodic heap corruption", periodics [ev_active (w)] == w));*/
/*assert (("internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
}
void noinline
@ -2067,7 +2097,7 @@ ev_periodic_stop (EV_P_ ev_periodic *w)
{
int active = ev_active (w);
assert (("internal periodic heap corruption", periodics [active] == (WT)w));
assert (("internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
if (expect_true (active < periodiccnt + HEAP0 - 1))
{

4
ev_vars.h
View File

@ -112,12 +112,12 @@ VARx(int *, fdchanges)
VARx(int, fdchangemax)
VARx(int, fdchangecnt)
VARx(WT *, timers)
VARx(ANHE *, timers)
VARx(int, timermax)
VARx(int, timercnt)
#if EV_PERIODIC_ENABLE || EV_GENWRAP
VARx(WT *, periodics)
VARx(ANHE *, periodics)
VARx(int, periodicmax)
VARx(int, periodiccnt)
#endif

Write Preview
Loading…
Cancel
Save