From 9a4bdcd75ef07d4a9fee91d2dd3f9d4ac1c57580 Mon Sep 17 00:00:00 2001 From: root Date: Fri, 10 Jul 2009 19:10:19 +0000 Subject: *** empty log message *** --- Changes | 3 +++ ev.c | 47 +++++++++++++++++++++++++++++++++++------------ ev.h | 12 ++---------- ev.pod | 5 +++-- ev_epoll.c | 4 ++-- ev_kqueue.c | 4 ++-- ev_poll.c | 4 ++-- ev_port.c | 4 ++-- ev_select.c | 4 ++-- ev_vars.h | 11 ++++------- ev_wrap.h | 16 ++++++++-------- 11 files changed, 65 insertions(+), 49 deletions(-) diff --git a/Changes b/Changes index 354a2d4..4e14ed5 100644 --- a/Changes +++ b/Changes @@ -3,8 +3,11 @@ Revision history for libev, a high-performance and full-featured event loop. TODO: ev_walk TODO: remain TODO: on_call_pending, on_suspend_resume ev_invoke_pending (EV_P) +TODO: EV_MINIMAL - ev_unloop and ev_loop wrongly used a global variable to exit loops, instead of using a per-loop variable (bug caught by accident...). + - calling ev_unloop in fork/prepare watchers will no longer poll + for new events. - Denis F. Latypoff corrected many typos in example code snippets. - the ev_set_io_collect_interval interpretation has changed. - honor autoconf detection of EV_USE_CLOCK_SYSCALL, also double- diff --git a/ev.c b/ev.c index bfa8781..72084ad 100644 --- a/ev.c +++ b/ev.c @@ -492,12 +492,15 @@ ev_realloc (void *ptr, long size) /*****************************************************************************/ +/* set in reify when reification needed */ +#define EV_ANFD_REIFY 1 + /* file descriptor info structure */ typedef struct { WL head; unsigned char events; /* the events watched for */ - unsigned char reify; /* flag set when this ANFD needs reification */ + unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */ unsigned char emask; /* the epoll backend stores the actual kernel mask in here */ unsigned char unused; #if EV_USE_EPOLL @@ -570,15 +573,17 @@ typedef struct #endif #if EV_MINIMAL < 2 -# define EV_SUSPEND_CB if (expect_false (suspend_cb)) suspend_cb (EV_A) -# define EV_RESUME_CB if (expect_false (resume_cb )) resume_cb (EV_A) +# define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A) +# define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A) # define EV_INVOKE_PENDING invoke_cb (EV_A) #else -# define EV_SUSPEND_CB (void)0 -# define EV_RESUME_CB (void)0 +# define EV_RELEASE_CB (void)0 +# define EV_ACQUIRE_CB (void)0 # define EV_INVOKE_PENDING ev_invoke_pending (EV_A) #endif +#define EVUNLOOP_RECURSE 0x80 + /*****************************************************************************/ #ifndef EV_HAVE_EV_TIME @@ -762,7 +767,7 @@ queue_events (EV_P_ W *events, int eventcnt, int type) /*****************************************************************************/ inline_speed void -fd_event (EV_P_ int fd, int revents) +fd_event_nc (EV_P_ int fd, int revents) { ANFD *anfd = anfds + fd; ev_io *w; @@ -776,11 +781,22 @@ fd_event (EV_P_ int fd, int revents) } } +/* do not submit kernel events for fds that have reify set */ +/* because that means they changed while we were polling for new events */ +inline_speed void +fd_event (EV_P_ int fd, int revents) +{ + ANFD *anfd = anfds + fd; + + if (expect_true (!anfd->reify)) + fd_event_nc (EV_A_ fd, revents); +} + void ev_feed_fd_event (EV_P_ int fd, int revents) { if (fd >= 0 && fd < anfdmax) - fd_event (EV_A_ fd, revents); + fd_event_nc (EV_A_ fd, revents); } /* make sure the external fd watch events are in-sync */ @@ -905,7 +921,7 @@ fd_rearm_all (EV_P) { anfds [fd].events = 0; anfds [fd].emask = 0; - fd_change (EV_A_ fd, EV__IOFDSET | 1); + fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY); } } @@ -1411,10 +1427,10 @@ void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) invoke_cb = invoke_pending_cb; } -void ev_set_blocking_cb (EV_P_ void (*suspend_cb_)(EV_P), void (*resume_cb_)(EV_P)) +void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)) { - suspend_cb = suspend_cb_; - resume_cb = resume_cb_; + release_cb = release; + acquire_cb = acquire; } #endif @@ -2079,6 +2095,8 @@ ev_loop (EV_P_ int flags) ++loop_depth; #endif + assert (("libev: ev_loop recursion during release detected", loop_done != EVUNLOOP_RECURSE)); + loop_done = EVUNLOOP_CANCEL; EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */ @@ -2115,6 +2133,9 @@ ev_loop (EV_P_ int flags) EV_INVOKE_PENDING; } + if (expect_false (loop_done)) + break; + /* we might have forked, so reify kernel state if necessary */ if (expect_false (postfork)) loop_fork (EV_A); @@ -2174,7 +2195,9 @@ ev_loop (EV_P_ int flags) #if EV_MINIMAL < 2 ++loop_count; #endif + assert ((loop_done = EVUNLOOP_RECURSE, 1)); /* assert for side effect */ backend_poll (EV_A_ waittime); + assert ((loop_done = EVUNLOOP_CANCEL, 1)); /* assert for side effect */ /* update ev_rt_now, do magic */ time_update (EV_A_ waittime + sleeptime); @@ -2350,7 +2373,7 @@ ev_io_start (EV_P_ ev_io *w) array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero); wlist_add (&anfds[fd].head, (WL)w); - fd_change (EV_A_ fd, w->events & EV__IOFDSET | 1); + fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY); w->events &= ~EV__IOFDSET; EV_FREQUENT_CHECK; diff --git a/ev.h b/ev.h index 104a3c9..3d49eca 100644 --- a/ev.h +++ b/ev.h @@ -547,19 +547,11 @@ void ev_loop_verify (EV_P); /* abort if loop data corrupted */ void ev_set_io_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */ void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval); /* sleep at least this time, default 0 */ -/* - * a single void * can be attached to each loop. this is intended - * to aid the invoke_pending/blocking callbacks. - */ +/* advanced stuff for threading etc. support, see docs */ void ev_set_userdata (EV_P_ void *data); void *ev_userdata (EV_P); - -/* - * hooks to overide how and when libev invokes callbacks, - * and hooks that wrap the actual eventloop blocking call. - */ void ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)); -void ev_set_blocking_cb (EV_P_ void (*suspend_cb_)(EV_P), void (*resume_cb_)(EV_P)); +void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P), void (*acquire)(EV_P)); void ev_invoke_pending (EV_P); /* invoke all pending watchers */ diff --git a/ev.pod b/ev.pod index 29ee970..3cad615 100644 --- a/ev.pod +++ b/ev.pod @@ -3678,8 +3678,9 @@ is used to override some inlining decisions, saves roughly 30% code size on amd64. It also selects a much smaller 2-heap for timer management over the default 4-heap. -You can save even more by disabling watcher types you do not need and -setting C == C. +You can save even more by disabling watcher types you do not need +and setting C == C. Also, disabling C +(C<-DNDEBUG>) will usually reduce code size a lot. Defining C to C<2> will additionally reduce the core API to provide a bare-bones event library. See C for details on what parts diff --git a/ev_epoll.c b/ev_epoll.c index 4b7d255..40c320a 100644 --- a/ev_epoll.c +++ b/ev_epoll.c @@ -121,9 +121,9 @@ epoll_poll (EV_P_ ev_tstamp timeout) int i; int eventcnt; - EV_SUSPEND_CB; + EV_RELEASE_CB; eventcnt = epoll_wait (backend_fd, epoll_events, epoll_eventmax, (int)ceil (timeout * 1000.)); - EV_RESUME_CB; + EV_ACQUIRE_CB; if (expect_false (eventcnt < 0)) { diff --git a/ev_kqueue.c b/ev_kqueue.c index 2a9832f..ac73f7c 100644 --- a/ev_kqueue.c +++ b/ev_kqueue.c @@ -85,7 +85,7 @@ kqueue_poll (EV_P_ ev_tstamp timeout) int res, i; struct timespec ts; - EV_SUSPEND_CB; + EV_RELEASE_CB; /* need to resize so there is enough space for errors */ if (kqueue_changecnt > kqueue_eventmax) @@ -100,7 +100,7 @@ kqueue_poll (EV_P_ ev_tstamp timeout) res = kevent (backend_fd, kqueue_changes, kqueue_changecnt, kqueue_events, kqueue_eventmax, &ts); kqueue_changecnt = 0; - EV_RESUME_CB; + EV_ACQUIRE_CB; if (expect_false (res < 0)) { diff --git a/ev_poll.c b/ev_poll.c index 8702aca..c33ea02 100644 --- a/ev_poll.c +++ b/ev_poll.c @@ -91,9 +91,9 @@ poll_poll (EV_P_ ev_tstamp timeout) struct pollfd *p; int res; - EV_SUSPEND_CB; + EV_RELEASE_CB; res = poll (polls, pollcnt, (int)ceil (timeout * 1000.)); - EV_RESUME_CB; + EV_ACQUIRE_CB; if (expect_false (res < 0)) { diff --git a/ev_port.c b/ev_port.c index ff745da..16fe86e 100644 --- a/ev_port.c +++ b/ev_port.c @@ -85,11 +85,11 @@ port_poll (EV_P_ ev_tstamp timeout) struct timespec ts; uint_t nget = 1; - EV_SUSPEND_CB; + EV_RELEASE_CB; ts.tv_sec = (time_t)timeout; ts.tv_nsec = (long)(timeout - (ev_tstamp)ts.tv_sec) * 1e9; res = port_getn (backend_fd, port_events, port_eventmax, &nget, &ts); - EV_RESUME_CB; + EV_ACQUIRE_CB; if (res == -1) { diff --git a/ev_select.c b/ev_select.c index b7bb69d..e57c1e2 100644 --- a/ev_select.c +++ b/ev_select.c @@ -140,7 +140,7 @@ select_poll (EV_P_ ev_tstamp timeout) int res; int fd_setsize; - EV_SUSPEND_CB; + EV_RELEASE_CB; tv.tv_sec = (long)timeout; tv.tv_usec = (long)((timeout - (ev_tstamp)tv.tv_sec) * 1e6); @@ -167,7 +167,7 @@ select_poll (EV_P_ ev_tstamp timeout) #else res = select (vec_max * NFDBITS, (fd_set *)vec_ro, (fd_set *)vec_wo, 0, &tv); #endif - EV_RESUME_CB; + EV_ACQUIRE_CB; if (expect_false (res < 0)) { diff --git a/ev_vars.h b/ev_vars.h index 8c6bbab..da73ca2 100644 --- a/ev_vars.h +++ b/ev_vars.h @@ -48,7 +48,7 @@ VARx(ev_tstamp, timeout_blocktime) VARx(int, backend) VARx(int, activecnt) /* total number of active events ("refcount") */ -VARx(char, loop_done) /* signal by ev_unloop */ +VARx(unsigned char, loop_done) /* signal by ev_unloop */ VARx(int, backend_fd) VARx(ev_tstamp, backend_fudge) /* assumed typical timer resolution */ @@ -166,16 +166,13 @@ VARx(char, fs_2625) /* whether we are running in linux 2.6.25 or newer */ VAR (fs_hash, ANFS fs_hash [EV_INOTIFY_HASHSIZE]) #endif -#if EV_MINIMAL < 2 +#if EV_MINIMAL < 2 || EV_GENWRAP VARx(unsigned int, loop_count) /* total number of loop iterations/blocks */ VARx(unsigned int, loop_depth) /* #ev_loop enters - #ev_loop leaves */ VARx(void *, userdata) -#endif - -#if EV_MINIMAL < 2 -VAR (suspend_cb, void (*suspend_cb)(EV_P)) -VAR (resume_cb , void (*resume_cb) (EV_P)) +VAR (release_cb, void (*release_cb)(EV_P)) +VAR (acquire_cb, void (*acquire_cb)(EV_P)) VAR (invoke_cb , void (*invoke_cb) (EV_P)) #endif diff --git a/ev_wrap.h b/ev_wrap.h index 336b5bc..ba99da6 100644 --- a/ev_wrap.h +++ b/ev_wrap.h @@ -8,8 +8,6 @@ #define timeout_blocktime ((loop)->timeout_blocktime) #define backend ((loop)->backend) #define activecnt ((loop)->activecnt) -#define loop_count ((loop)->loop_count) -#define loop_depth ((loop)->loop_depth) #define loop_done ((loop)->loop_done) #define backend_fd ((loop)->backend_fd) #define backend_fudge ((loop)->backend_fudge) @@ -79,9 +77,11 @@ #define fs_w ((loop)->fs_w) #define fs_2625 ((loop)->fs_2625) #define fs_hash ((loop)->fs_hash) +#define loop_count ((loop)->loop_count) +#define loop_depth ((loop)->loop_depth) #define userdata ((loop)->userdata) -#define suspend_cb ((loop)->suspend_cb) -#define resume_cb ((loop)->resume_cb) +#define release_cb ((loop)->release_cb) +#define acquire_cb ((loop)->acquire_cb) #define invoke_cb ((loop)->invoke_cb) #else #undef EV_WRAP_H @@ -92,8 +92,6 @@ #undef timeout_blocktime #undef backend #undef activecnt -#undef loop_count -#undef loop_depth #undef loop_done #undef backend_fd #undef backend_fudge @@ -163,8 +161,10 @@ #undef fs_w #undef fs_2625 #undef fs_hash +#undef loop_count +#undef loop_depth #undef userdata -#undef suspend_cb -#undef resume_cb +#undef release_cb +#undef acquire_cb #undef invoke_cb #endif -- cgit v1.2.3