Browse Source

*** empty log message ***

master
Marc Alexander Lehmann 12 years ago
parent
commit
76986c3ef9
  1. 3
      Changes
  2. 47
      ev.c
  3. 12
      ev.h
  4. 5
      ev.pod
  5. 4
      ev_epoll.c
  6. 4
      ev_kqueue.c
  7. 4
      ev_poll.c
  8. 4
      ev_port.c
  9. 4
      ev_select.c
  10. 11
      ev_vars.h
  11. 16
      ev_wrap.h

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

47
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;

12
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 */

5
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<EV_MAXPRI> == C<EV_MINPRI>.
You can save even more by disabling watcher types you do not need
and setting C<EV_MAXPRI> == C<EV_MINPRI>. Also, disabling C<assert>
(C<-DNDEBUG>) will usually reduce code size a lot.
Defining C<EV_MINIMAL> to C<2> will additionally reduce the core API to
provide a bare-bones event library. See C<ev.h> for details on what parts

4
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))
{

4
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))
{

4
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))
{

4
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)
{

4
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))
{

11
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

16
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
Loading…
Cancel
Save