ev_io - is this file descriptor readable or writableev_timer - relative and optionally recurring timeoutsev_periodic - to cron or not to cronev_signal - signal me when a signal gets signalledev_child - wait for pid status changesev_idle - when you've got nothing better to doev_prepare and ev_check - customise your event loopev_embed - when one backend isn't enoughev_io - is this file descriptor readable or writable?ev_timer - relative and optionally repeating timeoutsev_periodic - to cron or not to cron?ev_signal - signal me when a signal gets signalled!ev_child - watch out for process status changesev_idle - when you've got nothing better to do...ev_prepare and ev_check - customise your event loop!ev_embed - when one backend isn't enough...In the following description, TYPE stands for the watcher type,
e.g. timer for ev_timer watchers and io for ev_io watchers.
ev_TYPE_init mac
which rolls both calls into one.
You can reinitialise a watcher at any time as long as it has been stopped (or never started) and there are no pending events outstanding.
-The callbakc is always of type The callback is always of type void (*)(ev_loop *loop, ev_TYPE *watcher,
+ void (*)(ev_loop *loop, ev_TYPE *watcher,
int revents).ev_TYPE_set (ev_TYPE *, [args])
ev_io - is this file descriptor readable or writableev_io - is this file descriptor readable or writable?I/O watchers check whether a file descriptor is readable or writable -in each iteration of the event loop (This behaviour is called -level-triggering because you keep receiving events as long as the -condition persists. Remember you can stop the watcher if you don't want to -act on the event and neither want to receive future events).
+in each iteration of the event loop, or, more precisely, when reading +would not block the process and writing would at least be able to write +some data. This behaviour is called level-triggering because you keep +receiving events as long as the condition persists. Remember you can stop +the watcher if you don't want to act on the event and neither want to +receive future events.In general you can register as many read and/or write event watchers per fd as you want (as long as you don't confuse yourself). Setting all file descriptors to non-blocking mode is also usually a good idea (but not @@ -750,28 +757,31 @@ required if you know what you are doing).
You have to be careful with dup'ed file descriptors, though. Some backends (the linux epoll backend is a notable example) cannot handle dup'ed file descriptors correctly if you register interest in two or more fds pointing -to the same underlying file/socket etc. description (that is, they share +to the same underlying file/socket/etc. description (that is, they share the same underlying "file open").
If you must do this, then force the use of a known-to-be-good backend
(at the time of this writing, this includes only EVBACKEND_SELECT and
EVBACKEND_POLL).
Another thing you have to watch out for is that it is quite easy to
+receive "spurious" readyness notifications, that is your callback might
+be called with EV_READ but a subsequent read(2) will actually block
+because there is no data. Not only are some backends known to create a
+lot of those (for example solaris ports), it is very easy to get into
+this situation even with a relatively standard program structure. Thus
+it is best to always use non-blocking I/O: An extra read(2) returning
+EAGAIN is far preferable to a program hanging until some data arrives.
If you cannot run the fd in non-blocking mode (for example you should not +play around with an Xlib connection), then you have to seperately re-test +wether a file descriptor is really ready with a known-to-be good interface +such as poll (fortunately in our Xlib example, Xlib already does this on +its own, so its quite safe to use).
Configures an ev_io watcher. The fd is the file descriptor to rceeive
-events for and events is either EV_READ, EV_WRITE or EV_READ |
-EV_WRITE to receive the given events.
Please note that most of the more scalable backend mechanisms (for example
-epoll and solaris ports) can result in spurious readyness notifications
-for file descriptors, so you practically need to use non-blocking I/O (and
-treat callback invocation as hint only), or retest separately with a safe
-interface before doing I/O (XLib can do this), or force the use of either
-EVBACKEND_SELECT or EVBACKEND_POLL, which don't suffer from this
-problem. Also note that it is quite easy to have your callback invoked
-when the readyness condition is no longer valid even when employing
-typical ways of handling events, so its a good idea to use non-blocking
-I/O unconditionally.
Configures an ev_io watcher. The fd is the file descriptor to
+rceeive events for and events is either EV_READ, EV_WRITE or
+EV_READ | EV_WRITE to receive the given events.
Example: call stdin_readable_cb when STDIN_FILENO has become, well
@@ -797,7 +807,7 @@ attempt to read a whole line in the callback:
ev_timer - relative and optionally recurring timeoutsev_timer - relative and optionally repeating timeoutsTimer watchers are simple relative timers that generate an event after a given time, and optionally repeating in regular intervals after that.
@@ -883,7 +893,7 @@ inactivity.ev_periodic - to cron or not to cronev_periodic - to cron or not to cron?Periodic watchers are also timers of a kind, but they are very versatile (and unfortunately a bit complex).
@@ -1012,7 +1022,7 @@ potentially a lot of jittering, but good long-term stability.ev_signal - signal me when a signal gets signalledev_signal - signal me when a signal gets signalled!Signal watchers will trigger an event when the process receives a specific
signal one or more times. Even though signals are very asynchronous, libev
@@ -1038,8 +1048,8 @@ of the SIGxxx constants).
ev_child - wait for pid status changesev_child - watch out for process status changesChild watchers trigger when your process receives a SIGCHLD in response to some child status changes (most typically when a child of yours dies).
ev_idle - when you've got nothing better to doev_idle - when you've got nothing better to do...Idle watchers trigger events when there are no other events are pending (prepare, check and other idle watchers do not count). That is, as long @@ -1114,15 +1124,25 @@ callback, free it. Alos, use no error checking, as usual.
ev_prepare and ev_check - customise your event loopev_prepare and ev_check - customise your event loop!Prepare and check watchers are usually (but not always) used in tandem: prepare watchers get invoked before the process blocks and check watchers afterwards.
+You must not call ev_loop or similar functions that enter
+the current event loop from either ev_prepare or ev_check
+watchers. Other loops than the current one are fine, however. The
+rationale behind this is that you do not need to check for recursion in
+those watchers, i.e. the sequence will always be ev_prepare, blocking,
+ev_check so if you have one watcher of each kind they will always be
+called in pairs bracketing the blocking call.
Their main purpose is to integrate other event mechanisms into libev and their use is somewhat advanced. This could be used, for example, to track variable changes, implement your own watchers, integrate net-snmp or a -coroutine library and lots more.
+coroutine library and lots more. They are also occasionally useful if +you cache some data and want to flush it before blocking (for example, +in X programs you might want to do anXFlush () in an ev_prepare
+watcher).
This is done by examining in each prepare call which file descriptors need
to be watched by the other library, registering ev_io watchers for
them and starting an ev_timer watcher for any timeouts (many libraries
@@ -1148,14 +1168,67 @@ parameters of any kind. There are ev_prepare_set and ev_check
macros, but using them is utterly, utterly and completely pointless.
Example: *TODO*.
+Example: To include a library such as adns, you would add IO watchers +and a timeout watcher in a prepare handler, as required by libadns, and +in a check watcher, destroy them and call into libadns. What follows is +pseudo-code only of course:
+ static ev_io iow [nfd];
+ static ev_timer tw;
+
+ static void
+ io_cb (ev_loop *loop, ev_io *w, int revents)
+ {
+ // set the relevant poll flags
+ // could also call adns_processreadable etc. here
+ struct pollfd *fd = (struct pollfd *)w->data;
+ if (revents & EV_READ ) fd->revents |= fd->events & POLLIN;
+ if (revents & EV_WRITE) fd->revents |= fd->events & POLLOUT;
+ }
+
+ // create io watchers for each fd and a timer before blocking
+ static void
+ adns_prepare_cb (ev_loop *loop, ev_prepare *w, int revents)
+ {
+ int timeout = 3600000;truct pollfd fds [nfd];
+ // actual code will need to loop here and realloc etc.
+ adns_beforepoll (ads, fds, &nfd, &timeout, timeval_from (ev_time ()));
+
+ /* the callback is illegal, but won't be called as we stop during check */
+ ev_timer_init (&tw, 0, timeout * 1e-3);
+ ev_timer_start (loop, &tw);
+
+ // create on ev_io per pollfd
+ for (int i = 0; i < nfd; ++i)
+ {
+ ev_io_init (iow + i, io_cb, fds [i].fd,
+ ((fds [i].events & POLLIN ? EV_READ : 0)
+ | (fds [i].events & POLLOUT ? EV_WRITE : 0)));
+
+ fds [i].revents = 0;
+ iow [i].data = fds + i;
+ ev_io_start (loop, iow + i);
+ }
+ }
+
+ // stop all watchers after blocking
+ static void
+ adns_check_cb (ev_loop *loop, ev_check *w, int revents)
+ {
+ ev_timer_stop (loop, &tw);
+
+ for (int i = 0; i < nfd; ++i)
+ ev_io_stop (loop, iow + i);
+
+ adns_afterpoll (adns, fds, nfd, timeval_from (ev_now (loop));
+ }
+
ev_embed - when one backend isn't enoughev_embed - when one backend isn't enough...This is a rather advanced watcher type that lets you embed one event loop
into another (currently only ev_io events are supported in the embedded
@@ -1462,7 +1535,7 @@ in your include path (e.g. in libev/ when using -Ilibev):
ev.c includes the backend files directly when enabled, so you only need -to compile a single file.
+to compile this single file.Instead of using EV_STANDALONE=1 and providing your config in
whatever way you want, you can also m4_include([libev.m4]) in your
-configure.ac and leave EV_STANDALONE off. ev.c will then include
-config.h and configure itself accordingly.
EV_STANDALONE undefined. ev.c will then
+include config.h and configure itself accordingly.
For this of course you need the m4 file:
libev.m4 @@ -1585,7 +1658,7 @@ backend for BSD and BSD-like systems, although on most BSDs kqueue only supports some types of fds correctly (the only platform we found that supports ptys for example was NetBSD), so kqueue might be compiled in, but not be used unless explicitly requested. The best way to use it is to find -out wether kqueue supports your type of fd properly and use an embedded +out whether kqueue supports your type of fd properly and use an embedded kqueue loop.
Can be used to change the callback member declaration in each watcher, and the way callbacks are invoked and set. Must expand to a struct member definition and a statement, respectively. See the ev.v header file for their default definitions. One possible use for overriding these is to -avoid the ev_loop pointer as first argument in all cases, or to use method -calls instead of plain function calls in C++.
+avoid thestruct ev_loop * as first argument in all cases, or to use
+method calls instead of plain function calls in C++.
#include "ev_cpp.h" #include "ev.c" + + ++
In this section the complexities of (many of) the algorithms used inside
+libev will be explained. For complexity discussions about backends see the
+documentation for ev_default_init.
+