diff options
author | Stefan Metzmacher <metze@samba.org> | 2007-05-04 09:22:52 +0000 |
---|---|---|
committer | Gerald (Jerry) Carter <jerry@samba.org> | 2007-10-10 14:51:58 -0500 |
commit | 6c6c5927a1e16e347a0e353904241694b21b57f9 (patch) | |
tree | 58b8a0d18f21ecd8f1565738cb829a8bfa555a42 /source4/lib/events/events_timed.c | |
parent | e4161f9deee8198e9128e88458e3c5603e86cd3e (diff) | |
download | samba-6c6c5927a1e16e347a0e353904241694b21b57f9.tar.gz samba-6c6c5927a1e16e347a0e353904241694b21b57f9.tar.bz2 samba-6c6c5927a1e16e347a0e353904241694b21b57f9.zip |
r22661: optimize the handling of directly triggered timed events:
- if someone adds a timed_event with a zero timeval
we now avoid serval gettimeofday() calls and the
event handler doesn't get the current time when it's
called, instead we also pass a zero timeval
- this also makes sure multiple timed events with a zero timeval
are processed in the order there're added.
the little benchmark shows that processing 2000000 directly timed events
is now much faster, while avoiding syscalls at all!
> time ./evtest (with the old code)
real 0m6.388s
user 0m1.740s
sys 0m4.632s
> time ./evtest (with the new code)
real 0m1.498s
user 0m1.496s
sys 0m0.004s
metze@SERNOX:~/devel/samba/4.0/samba4-ci/source> cat evtest.c
#include <stdio.h>
#include <stdint.h>
#include <sys/time.h>
#include <talloc.h>
#include <events.h>
static void dummy_fde_handler(struct event_context *ev_ctx, struct fd_event *fde,
uint16_t flags, void *private_data)
{
}
static void timeout_handler(struct event_context *ev, struct timed_event *te,
struct timeval tval, void *private_data)
{
uint32_t *countp = (uint32_t *)private_data;
(*countp)++;
if (*countp > 2000000) exit(0);
event_add_timed(ev, ev, tval, timeout_handler, countp);
}
int main(void)
{
struct event_context *ev;
struct timeval tval = { 0, 0 };
uint32_t count = 0;
ev = event_context_init(NULL);
event_add_fd(ev, ev, 0, 0, dummy_fde_handler, NULL);
event_add_timed(ev, ev, tval, timeout_handler, &count);
return event_loop_wait(ev);
}
(This used to be commit 4db64b4ce2320b88d648078cbf86385f6fb44f1f)
Diffstat (limited to 'source4/lib/events/events_timed.c')
-rw-r--r-- | source4/lib/events/events_timed.c | 74 |
1 files changed, 45 insertions, 29 deletions
diff --git a/source4/lib/events/events_timed.c b/source4/lib/events/events_timed.c index c85f8371c1..31619dcb5f 100644 --- a/source4/lib/events/events_timed.c +++ b/source4/lib/events/events_timed.c @@ -68,9 +68,7 @@ struct timed_event *common_event_add_timed(struct event_context *ev, TALLOC_CTX last_te = NULL; for (cur_te = ev->timed_events; cur_te; cur_te = cur_te->next) { /* if the new event comes before the current one break */ - if (!timeval_is_zero(&cur_te->next_event) && - timeval_compare(&te->next_event, - &cur_te->next_event) < 0) { + if (timeval_compare(&te->next_event, &cur_te->next_event) < 0) { break; } @@ -85,17 +83,47 @@ struct timed_event *common_event_add_timed(struct event_context *ev, TALLOC_CTX } /* - a timer has gone off - call it + do a single event loop using the events defined in ev + + return the delay untill the next timed event, + or zero if a timed event was triggered */ -void common_event_loop_timer(struct event_context *ev) +struct timeval common_event_loop_timer_delay(struct event_context *ev) { - struct timeval t = timeval_current(); + struct timeval current_time = timeval_zero(); struct timed_event *te = ev->timed_events; - if (te == NULL) { - return; + if (!te) { + /* have a default tick time of 30 seconds. This guarantees + that code that uses its own timeout checking will be + able to proceeed eventually */ + return timeval_set(30, 0); } + /* + * work out the right timeout for the next timed event + * + * avoid the syscall to gettimeofday() if the timed event should + * be triggered directly + * + * if there's a delay till the next timed event, we're done + * with just returning the delay + */ + if (!timeval_is_zero(&te->next_event)) { + struct timeval delay; + + current_time = timeval_current(); + + delay = timeval_until(¤t_time, &te->next_event); + if (!timeval_is_zero(&delay)) { + return delay; + } + } + + /* + * ok, we have a timed event that we'll process ... + */ + /* deny the handler to free the event */ talloc_set_destructor(te, common_event_timed_deny_destructor); @@ -104,33 +132,21 @@ void common_event_loop_timer(struct event_context *ev) * handler we don't want to come across this event again -- vl */ DLIST_REMOVE(ev->timed_events, te); - te->handler(ev, te, t, te->private_data); + /* + * If the timed event was registered for a zero current_time, + * then we pass a zero timeval here too! To avoid the + * overhead of gettimeofday() calls. + * + * otherwise we pass the current time + */ + te->handler(ev, te, current_time, te->private_data); /* The destructor isn't necessary anymore, we've already removed the * event from the list. */ talloc_set_destructor(te, NULL); talloc_free(te); -} -/* - do a single event loop using the events defined in ev -*/ -struct timeval common_event_loop_delay(struct event_context *ev) -{ - struct timeval tval; - - /* work out the right timeout for all timed events */ - if (ev->timed_events) { - struct timeval t = timeval_current(); - tval = timeval_until(&t, &ev->timed_events->next_event); - } else { - /* have a default tick time of 30 seconds. This guarantees - that code that uses its own timeout checking will be - able to proceeed eventually */ - tval = timeval_set(30, 0); - } - - return tval; + return timeval_zero(); } |