[ViewVC] Diff of: cvs/libev/ev.3

Comparing libev/ev.3 (file contents):
Revision 1.82 by root, Mon Oct 25 10:50:13 2010 UTC vs.
Revision 1.108 by root, Sat Jul 28 04:15:15 2018 UTC

-.\" Automatically generated by Pod::Man 2.22 (Pod::Simple 3.07)
+.\" Automatically generated by Pod::Man 2.28 (Pod::Simple 3.29)
 .\"
 .\" Standard preamble:
 .\" ========================================================================
 .de Sp \" Vertical space (when we can't use .PP)
 .if t .sp .5v
 .el\{\
 .    ds -- \|\(em\|
 .    ds PI \(*p
 .    ds L" ``
 .    ds R" ''
+.    ds C`
+.    ds C'
 'br\}
 .\"
 .\" Escape single quotes in literal strings from groff's Unicode transform.
 .ie \n(.g .ds Aq \(aq
 .el       .ds Aq '
 .\"
 .\" If the F register is turned on, we'll generate index entries on stderr for
 .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
 .\" entries marked with X<> in POD.  Of course, you'll have to process the
 .\" output yourself in some meaningful fashion.
-.ie \nF \{\
+.\"
+.\" Avoid warning from groff about undefined register 'F'.
-.    de IX
+.de IX
-.    tm Index:\\$1\t\\n%\t"\\$2"
 ..
-.    nr % 0
+.nr rF 0
-.    rr F
+.if \n(.g .if rF .nr rF 1
+.if (\n(rF:(\n(.g==0)) \{
+.    if \nF \{
+.        de IX
+.        tm Index:\\$1\t\\n%\t"\\$2"
+..
+.        if !\nF==2 \{
+.            nr % 0
+.            nr F 2
+.        \}
+.    \}
 .\}
-.el \{\
+.rr rF
-.    de IX
-..
-.\}
 .\"
 .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
 .\" Fear.  Run.  Save yourself.  No user-serviceable parts.
 .    \" fudge factors for nroff and troff
 .if n \{\
 .\}
 .rm #[ #] #H #V #F C
 .\" ========================================================================
 .\"
 .IX Title "LIBEV 3"
-.TH LIBEV 3 "2010-10-25" "libev-4.00" "libev - high performance full featured event loop"
+.TH LIBEV 3 "2017-11-14" "libev-4.24" "libev - high performance full featured event loop"
 .\" For nroff, turn off justification.  Always turn off hyphenation; it makes
 .\" way too many mistakes in technical documents.
 .if n .ad l
 .nh
 .SH "NAME"
 .SH "SYNOPSIS"
 .IX Header "SYNOPSIS"
 .Vb 1
 \&   #include <ev.h>
 .Ve
-.SS "\s-1EXAMPLE\s0 \s-1PROGRAM\s0"
+.SS "\s-1EXAMPLE PROGRAM\s0"
 .IX Subsection "EXAMPLE PROGRAM"
 .Vb 2
 \&   // a single header file is required
 \&   #include <ev.h>
 \&
 \&     ev_timer_start (loop, &timeout_watcher);
 \&
 \&     // now wait for events to arrive
 \&     ev_run (loop, 0);
 \&
-\&     // unloop was called, so exit
+\&     // break was called, so exit
 \&     return 0;
 \&   }
 .Ve
 .SH "ABOUT THIS DOCUMENT"
 .IX Header "ABOUT THIS DOCUMENT"
 throughout this document.
 .SH "WHAT TO READ WHEN IN A HURRY"
 .IX Header "WHAT TO READ WHEN IN A HURRY"
 This manual tries to be very detailed, but unfortunately, this also makes
 it very long. If you just want to know the basics of libev, I suggest
-reading \*(L"\s-1ANATOMY\s0 \s-1OF\s0 A \s-1WATCHER\s0\*(R", then the \*(L"\s-1EXAMPLE\s0 \s-1PROGRAM\s0\*(R" above and
+reading \*(L"\s-1ANATOMY OF A WATCHER\*(R"\s0, then the \*(L"\s-1EXAMPLE PROGRAM\*(R"\s0 above and
-look up the missing functions in \*(L"\s-1GLOBAL\s0 \s-1FUNCTIONS\s0\*(R" and the \f(CW\*(C`ev_io\*(C'\fR and
+look up the missing functions in \*(L"\s-1GLOBAL FUNCTIONS\*(R"\s0 and the \f(CW\*(C`ev_io\*(C'\fR and
-\&\f(CW\*(C`ev_timer\*(C'\fR sections in \*(L"\s-1WATCHER\s0 \s-1TYPES\s0\*(R".
+\&\f(CW\*(C`ev_timer\*(C'\fR sections in \*(L"\s-1WATCHER TYPES\*(R"\s0.
 .SH "ABOUT LIBEV"
 .IX Header "ABOUT LIBEV"
 Libev is an event loop: you register interest in certain events (such as a
 file descriptor being readable or a timeout occurring), and it will manage
 these event sources and provide your program with events.
 loop mechanism itself (\f(CW\*(C`ev_idle\*(C'\fR, \f(CW\*(C`ev_embed\*(C'\fR, \f(CW\*(C`ev_prepare\*(C'\fR and
 \&\f(CW\*(C`ev_check\*(C'\fR watchers) as well as file watchers (\f(CW\*(C`ev_stat\*(C'\fR) and even
 limited support for fork events (\f(CW\*(C`ev_fork\*(C'\fR).
 .PP
 It also is quite fast (see this
-<benchmark> comparing it to libevent
+benchmark <http://libev.schmorp.de/bench.html> comparing it to libevent
 for example).
 .SS "\s-1CONVENTIONS\s0"
 .IX Subsection "CONVENTIONS"
 Libev is very configurable. In this manual the default (and most common)
 configuration will be described, which supports multiple event loops. For
 more info about various configuration options please have a look at
 \&\fB\s-1EMBED\s0\fR section in this manual. If libev was configured without support
 for multiple event loops, then all functions taking an initial argument of
 name \f(CW\*(C`loop\*(C'\fR (which is always of type \f(CW\*(C`struct ev_loop *\*(C'\fR) will not have
 this argument.
-.SS "\s-1TIME\s0 \s-1REPRESENTATION\s0"
+.SS "\s-1TIME REPRESENTATION\s0"
 .IX Subsection "TIME REPRESENTATION"
 Libev represents time as a single floating point number, representing
 the (fractional) number of seconds since the (\s-1POSIX\s0) epoch (in practice
 somewhere near the beginning of 1970, details are complicated, don't
 ask). This type is called \f(CW\*(C`ev_tstamp\*(C'\fR, which is what you should use
 .IP "ev_tstamp ev_time ()" 4
 .IX Item "ev_tstamp ev_time ()"
 Returns the current time as libev would use it. Please note that the
 \&\f(CW\*(C`ev_now\*(C'\fR function is usually faster and also often returns the timestamp
 you actually want to know. Also interesting is the combination of
-\&\f(CW\*(C`ev_update_now\*(C'\fR and \f(CW\*(C`ev_now\*(C'\fR.
+\&\f(CW\*(C`ev_now_update\*(C'\fR and \f(CW\*(C`ev_now\*(C'\fR.
 .IP "ev_sleep (ev_tstamp interval)" 4
 .IX Item "ev_sleep (ev_tstamp interval)"
-Sleep for the given interval: The current thread will be blocked until
+Sleep for the given interval: The current thread will be blocked
-either it is interrupted or the given time interval has passed. Basically
+until either it is interrupted or the given time interval has
+passed (approximately \- it might return a bit earlier even if not
+interrupted). Returns immediately if \f(CW\*(C`interval <= 0\*(C'\fR.
+.Sp
-this is a sub-second-resolution \f(CW\*(C`sleep ()\*(C'\fR.
+Basically this is a sub-second-resolution \f(CW\*(C`sleep ()\*(C'\fR.
+.Sp
+The range of the \f(CW\*(C`interval\*(C'\fR is limited \- libev only guarantees to work
+with sleep times of up to one day (\f(CW\*(C`interval <= 86400\*(C'\fR).
 .IP "int ev_version_major ()" 4
 .IX Item "int ev_version_major ()"
 .PD 0
 .IP "int ev_version_minor ()" 4
 .IX Item "int ev_version_minor ()"
 current system. To find which embeddable backends might be supported on
 the current system, you would need to look at \f(CW\*(C`ev_embeddable_backends ()
 & ev_supported_backends ()\*(C'\fR, likewise for recommended ones.
 .Sp
 See the description of \f(CW\*(C`ev_embed\*(C'\fR watchers for more info.
-.IP "ev_set_allocator (void *(*cb)(void *ptr, long size)) [\s-1NOT\s0 \s-1REENTRANT\s0]" 4
+.IP "ev_set_allocator (void *(*cb)(void *ptr, long size) throw ())" 4
-.IX Item "ev_set_allocator (void *(*cb)(void *ptr, long size)) [NOT REENTRANT]"
+.IX Item "ev_set_allocator (void *(*cb)(void *ptr, long size) throw ())"
 Sets the allocation function to use (the prototype is similar \- the
 semantics are identical to the \f(CW\*(C`realloc\*(C'\fR C89/SuS/POSIX function). It is
 used to allocate and free memory (no surprises here). If it returns zero
 when memory needs to be allocated (\f(CW\*(C`size != 0\*(C'\fR), the library might abort
 or take some potentially destructive action.
 \&   }
 \&
 \&   ...
 \&   ev_set_allocator (persistent_realloc);
 .Ve
-.IP "ev_set_syserr_cb (void (*cb)(const char *msg)); [\s-1NOT\s0 \s-1REENTRANT\s0]" 4
+.IP "ev_set_syserr_cb (void (*cb)(const char *msg) throw ())" 4
-.IX Item "ev_set_syserr_cb (void (*cb)(const char *msg)); [NOT REENTRANT]"
+.IX Item "ev_set_syserr_cb (void (*cb)(const char *msg) throw ())"
 Set the callback function to call on a retryable system call error (such
 as failed select, poll, epoll_wait). The message is a printable string
 indicating the system call or subsystem causing the problem. If this
 callback is set, then libev will expect it to remedy the situation, no
 matter what, when it returns. That is, libev will generally retry the
 \&   }
 \&
 \&   ...
 \&   ev_set_syserr_cb (fatal_error);
 .Ve
+.IP "ev_feed_signal (int signum)" 4
+.IX Item "ev_feed_signal (int signum)"
+This function can be used to \*(L"simulate\*(R" a signal receive. It is completely
+safe to call this function at any time, from any context, including signal
+handlers or random threads.
+.Sp
+Its main use is to customise signal handling in your process, especially
+in the presence of threads. For example, you could block signals
+by default in all threads (and specifying \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR when
+creating any loops), and in one thread, use \f(CW\*(C`sigwait\*(C'\fR or any other
+mechanism to wait for signals, then \*(L"deliver\*(R" them to libev by calling
+\&\f(CW\*(C`ev_feed_signal\*(C'\fR.
 .SH "FUNCTIONS CONTROLLING EVENT LOOPS"
 .IX Header "FUNCTIONS CONTROLLING EVENT LOOPS"
 An event loop is described by a \f(CW\*(C`struct ev_loop *\*(C'\fR (the \f(CW\*(C`struct\*(C'\fR is
 \&\fInot\fR optional in this case unless libev 3 compatibility is disabled, as
 libev 3 had an \f(CW\*(C`ev_loop\*(C'\fR function colliding with the struct name).
 .IP "struct ev_loop *ev_loop_new (unsigned int flags)" 4
 .IX Item "struct ev_loop *ev_loop_new (unsigned int flags)"
 This will create and initialise a new event loop object. If the loop
 could not be initialised, returns false.
 .Sp
-Note that this function \fIis\fR thread-safe, and one common way to use
+This function is thread-safe, and one common way to use libev with
-libev with threads is indeed to create one loop per thread, and using the
+threads is indeed to create one loop per thread, and using the default
-default loop in the \*(L"main\*(R" or \*(L"initial\*(R" thread.
+loop in the \*(L"main\*(R" or \*(L"initial\*(R" thread.
 .Sp
 The flags argument can be used to specify special behaviour or specific
 backends to use, and is usually specified as \f(CW0\fR (or \f(CW\*(C`EVFLAG_AUTO\*(C'\fR).
 .Sp
 The following flags are supported:
 .IX Item "EVFLAG_NOENV"
 If this flag bit is or'ed into the flag value (or the program runs setuid
 or setgid) then libev will \fInot\fR look at the environment variable
 \&\f(CW\*(C`LIBEV_FLAGS\*(C'\fR. Otherwise (the default), this environment variable will
 override the flags completely if it is found in the environment. This is
-useful to try out specific backends to test their performance, or to work
+useful to try out specific backends to test their performance, to work
-around bugs.
+around bugs, or to make libev threadsafe (accessing environment variables
+cannot be done in a threadsafe way, but usually it works if no other
+thread modifies them).
 .ie n .IP """EVFLAG_FORKCHECK""" 4
 .el .IP "\f(CWEVFLAG_FORKCHECK\fR" 4
 .IX Item "EVFLAG_FORKCHECK"
 Instead of calling \f(CW\*(C`ev_loop_fork\*(C'\fR manually after a fork, you can also
 make libev check for a fork in each iteration by enabling this flag.
 .Sp
 This works by calling \f(CW\*(C`getpid ()\*(C'\fR on every iteration of the loop,
 and thus this might slow down your event loop if you do a lot of loop
 iterations and little real work, but is usually not noticeable (on my
-GNU/Linux system for example, \f(CW\*(C`getpid\*(C'\fR is actually a simple 5\-insn sequence
+GNU/Linux system for example, \f(CW\*(C`getpid\*(C'\fR is actually a simple 5\-insn
-without a system call and thus \fIvery\fR fast, but my GNU/Linux system also has
+sequence without a system call and thus \fIvery\fR fast, but my GNU/Linux
-\&\f(CW\*(C`pthread_atfork\*(C'\fR which is even faster).
+system also has \f(CW\*(C`pthread_atfork\*(C'\fR which is even faster). (Update: glibc
+versions 2.25 apparently removed the \f(CW\*(C`getpid\*(C'\fR optimisation again).
 .Sp
 The big advantage of this flag is that you can forget about fork (and
-forget about forgetting to tell libev about forking) when you use this
+forget about forgetting to tell libev about forking, although you still
-flag.
+have to ignore \f(CW\*(C`SIGPIPE\*(C'\fR) when you use this flag.
 .Sp
 This flag setting cannot be overridden or specified in the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR
 environment variable.
 .ie n .IP """EVFLAG_NOINOTIFY""" 4
 .el .IP "\f(CWEVFLAG_NOINOTIFY\fR" 4
 .IX Item "EVFLAG_NOINOTIFY"
 When this flag is specified, then libev will not attempt to use the
-\&\fIinotify\fR \s-1API\s0 for it's \f(CW\*(C`ev_stat\*(C'\fR watchers. Apart from debugging and
+\&\fIinotify\fR \s-1API\s0 for its \f(CW\*(C`ev_stat\*(C'\fR watchers. Apart from debugging and
 testing, this flag can be useful to conserve inotify file descriptors, as
 otherwise each loop using \f(CW\*(C`ev_stat\*(C'\fR watchers consumes one inotify handle.
 .ie n .IP """EVFLAG_SIGNALFD""" 4
 .el .IP "\f(CWEVFLAG_SIGNALFD\fR" 4
 .IX Item "EVFLAG_SIGNALFD"
 When this flag is specified, then libev will attempt to use the
-\&\fIsignalfd\fR \s-1API\s0 for it's \f(CW\*(C`ev_signal\*(C'\fR (and \f(CW\*(C`ev_child\*(C'\fR) watchers. This \s-1API\s0
+\&\fIsignalfd\fR \s-1API\s0 for its \f(CW\*(C`ev_signal\*(C'\fR (and \f(CW\*(C`ev_child\*(C'\fR) watchers. This \s-1API\s0
 delivers signals synchronously, which makes it both faster and might make
 it possible to get the queued signal data. It can also simplify signal
 handling with threads, as long as you properly block signals in your
 threads that are not interested in handling them.
 .Sp
 Signalfd will not be used by default as this changes your signal mask, and
 there are a lot of shoddy libraries and programs (glib's threadpool for
 example) that can't properly initialise their signal masks.
+.ie n .IP """EVFLAG_NOSIGMASK""" 4
+.el .IP "\f(CWEVFLAG_NOSIGMASK\fR" 4
+.IX Item "EVFLAG_NOSIGMASK"
+When this flag is specified, then libev will avoid to modify the signal
+mask. Specifically, this means you have to make sure signals are unblocked
+when you want to receive them.
+.Sp
+This behaviour is useful when you want to do your own signal handling, or
+want to handle signals only in specific threads and want to avoid libev
+unblocking the signals.
+.Sp
+It's also required by \s-1POSIX\s0 in a threaded program, as libev calls
+\&\f(CW\*(C`sigprocmask\*(C'\fR, whose behaviour is officially unspecified.
+.Sp
+This flag's behaviour will become the default in future versions of libev.
 .ie n .IP """EVBACKEND_SELECT""  (value 1, portable select backend)" 4
 .el .IP "\f(CWEVBACKEND_SELECT\fR  (value 1, portable select backend)" 4
-.IX Item "EVBACKEND_SELECT  (value 1, portable select backend)"
+.IX Item "EVBACKEND_SELECT (value 1, portable select backend)"
 This is your standard \fIselect\fR\|(2) backend. Not \fIcompletely\fR standard, as
 libev tries to roll its own fd_set with no limits on the number of fds,
 but if that fails, expect a fairly low limit on the number of fds when
 using this backend. It doesn't scale too well (O(highest_fd)), but its
 usually the fastest backend for a low number of (low-numbered :) fds.
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR to the \f(CW\*(C`readfds\*(C'\fR set and \f(CW\*(C`EV_WRITE\*(C'\fR to the
 \&\f(CW\*(C`writefds\*(C'\fR set (and to work around Microsoft Windows bugs, also onto the
 \&\f(CW\*(C`exceptfds\*(C'\fR set on that platform).
 .ie n .IP """EVBACKEND_POLL""    (value 2, poll backend, available everywhere except on windows)" 4
 .el .IP "\f(CWEVBACKEND_POLL\fR    (value 2, poll backend, available everywhere except on windows)" 4
-.IX Item "EVBACKEND_POLL    (value 2, poll backend, available everywhere except on windows)"
+.IX Item "EVBACKEND_POLL (value 2, poll backend, available everywhere except on windows)"
 And this is your standard \fIpoll\fR\|(2) backend. It's more complicated
 than select, but handles sparse fds better and has no artificial
 limit on the number of fds you can use (except it will slow down
 considerably with a lot of inactive fds). It scales similarly to select,
 i.e. O(total_fds). See the entry for \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR, above, for
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR to \f(CW\*(C`POLLIN | POLLERR | POLLHUP\*(C'\fR, and
 \&\f(CW\*(C`EV_WRITE\*(C'\fR to \f(CW\*(C`POLLOUT | POLLERR | POLLHUP\*(C'\fR.
 .ie n .IP """EVBACKEND_EPOLL""   (value 4, Linux)" 4
 .el .IP "\f(CWEVBACKEND_EPOLL\fR   (value 4, Linux)" 4
-.IX Item "EVBACKEND_EPOLL   (value 4, Linux)"
+.IX Item "EVBACKEND_EPOLL (value 4, Linux)"
 Use the linux-specific \fIepoll\fR\|(7) interface (for both pre\- and post\-2.6.9
 kernels).
 .Sp
-For few fds, this backend is a bit little slower than poll and select,
+For few fds, this backend is a bit little slower than poll and select, but
-but it scales phenomenally better. While poll and select usually scale
+it scales phenomenally better. While poll and select usually scale like
-like O(total_fds) where n is the total number of fds (or the highest fd),
+O(total_fds) where total_fds is the total number of fds (or the highest
-epoll scales either O(1) or O(active_fds).
+fd), epoll scales either O(1) or O(active_fds).
 .Sp
 The epoll mechanism deserves honorable mention as the most misdesigned
 of the more advanced event mechanisms: mere annoyances include silently
 dropping file descriptors, requiring a system call per change per file
-descriptor (and unnecessary guessing of parameters), problems with dup and
+descriptor (and unnecessary guessing of parameters), problems with dup,
+returning before the timeout value, resulting in additional iterations
+(and only giving 5ms accuracy while select on the same platform gives
-so on. The biggest issue is fork races, however \- if a program forks then
+0.1ms) and so on. The biggest issue is fork races, however \- if a program
-\&\fIboth\fR parent and child process have to recreate the epoll set, which can
+forks then \fIboth\fR parent and child process have to recreate the epoll
-take considerable time (one syscall per file descriptor) and is of course
+set, which can take considerable time (one syscall per file descriptor)
-hard to detect.
+and is of course hard to detect.
 .Sp
-Epoll is also notoriously buggy \- embedding epoll fds \fIshould\fR work, but
+Epoll is also notoriously buggy \- embedding epoll fds \fIshould\fR work,
-of course \fIdoesn't\fR, and epoll just loves to report events for totally
+but of course \fIdoesn't\fR, and epoll just loves to report events for
-\&\fIdifferent\fR file descriptors (even already closed ones, so one cannot
+totally \fIdifferent\fR file descriptors (even already closed ones, so
-even remove them from the set) than registered in the set (especially
+one cannot even remove them from the set) than registered in the set
-on \s-1SMP\s0 systems). Libev tries to counter these spurious notifications by
+(especially on \s-1SMP\s0 systems). Libev tries to counter these spurious
-employing an additional generation counter and comparing that against the
+notifications by employing an additional generation counter and comparing
-events to filter out spurious ones, recreating the set when required. Last
+that against the events to filter out spurious ones, recreating the set
+when required. Epoll also erroneously rounds down timeouts, but gives you
+no way to know when and by how much, so sometimes you have to busy-wait
+because epoll returns immediately despite a nonzero timeout. And last
 not least, it also refuses to work with some file descriptors which work
 perfectly fine with \f(CW\*(C`select\*(C'\fR (files, many character devices...).
+.Sp
+Epoll is truly the train wreck among event poll mechanisms, a frankenpoll,
+cobbled together in a hurry, no thought to design or interaction with
+others. Oh, the pain, will it ever stop...
 .Sp
 While stopping, setting and starting an I/O watcher in the same iteration
 will result in some caching, there is still a system call per such
 incident (because the same \fIfile descriptor\fR could point to a different
 \&\fIfile description\fR now), so its best to avoid that. Also, \f(CW\*(C`dup ()\*(C'\fR'ed
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as
 \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
 .ie n .IP """EVBACKEND_KQUEUE""  (value 8, most \s-1BSD\s0 clones)" 4
 .el .IP "\f(CWEVBACKEND_KQUEUE\fR  (value 8, most \s-1BSD\s0 clones)" 4
-.IX Item "EVBACKEND_KQUEUE  (value 8, most BSD clones)"
+.IX Item "EVBACKEND_KQUEUE (value 8, most BSD clones)"
 Kqueue deserves special mention, as at the time of this writing, it
 was broken on all BSDs except NetBSD (usually it doesn't work reliably
 with anything but sockets and pipes, except on Darwin, where of course
 it's completely useless). Unlike epoll, however, whose brokenness
 is by design, these kqueue bugs can (and eventually will) be fixed
 .Sp
 It scales in the same way as the epoll backend, but the interface to the
 kernel is more efficient (which says nothing about its actual speed, of
 course). While stopping, setting and starting an I/O watcher does never
 cause an extra system call as with \f(CW\*(C`EVBACKEND_EPOLL\*(C'\fR, it still adds up to
-two event changes per incident. Support for \f(CW\*(C`fork ()\*(C'\fR is very bad (but
+two event changes per incident. Support for \f(CW\*(C`fork ()\*(C'\fR is very bad (you
-sane, unlike epoll) and it drops fds silently in similarly hard-to-detect
+might have to leak fd's on fork, but it's more sane than epoll) and it
-cases
+drops fds silently in similarly hard-to-detect cases.
 .Sp
 This backend usually performs well under most conditions.
 .Sp
 While nominally embeddable in other event loops, this doesn't work
 everywhere, so you might need to test for this. And since it is broken
 almost everywhere, you should only use it when you have a lot of sockets
 (for which it usually works), by embedding it into another event loop
 (e.g. \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR (but \f(CW\*(C`poll\*(C'\fR is of course
-also broken on \s-1OS\s0 X)) and, did I mention it, using it only for sockets.
+also broken on \s-1OS X\s0)) and, did I mention it, using it only for sockets.
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR into an \f(CW\*(C`EVFILT_READ\*(C'\fR kevent with
 \&\f(CW\*(C`NOTE_EOF\*(C'\fR, and \f(CW\*(C`EV_WRITE\*(C'\fR into an \f(CW\*(C`EVFILT_WRITE\*(C'\fR kevent with
 \&\f(CW\*(C`NOTE_EOF\*(C'\fR.
 .ie n .IP """EVBACKEND_DEVPOLL"" (value 16, Solaris 8)" 4
 implementation). According to reports, \f(CW\*(C`/dev/poll\*(C'\fR only supports sockets
 and is not embeddable, which would limit the usefulness of this backend
 immensely.
 .ie n .IP """EVBACKEND_PORT""    (value 32, Solaris 10)" 4
 .el .IP "\f(CWEVBACKEND_PORT\fR    (value 32, Solaris 10)" 4
-.IX Item "EVBACKEND_PORT    (value 32, Solaris 10)"
+.IX Item "EVBACKEND_PORT (value 32, Solaris 10)"
 This uses the Solaris 10 event port mechanism. As with everything on Solaris,
 it's really slow, but it still scales very well (O(active_fds)).
-.Sp
-Please note that Solaris event ports can deliver a lot of spurious
-notifications, so you need to use non-blocking I/O or other means to avoid
-blocking when no data (or space) is available.
 .Sp
 While this backend scales well, it requires one system call per active
 file descriptor per loop iteration. For small and medium numbers of file
 descriptors a \*(L"slow\*(R" \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR backend
 might perform better.
 .Sp
-On the positive side, with the exception of the spurious readiness
+On the positive side, this backend actually performed fully to
-notifications, this backend actually performed fully to specification
-in all tests and is fully embeddable, which is a rare feat among the
+specification in all tests and is fully embeddable, which is a rare feat
-OS-specific backends (I vastly prefer correctness over speed hacks).
+among the OS-specific backends (I vastly prefer correctness over speed
+hacks).
+.Sp
+On the negative side, the interface is \fIbizarre\fR \- so bizarre that
+even sun itself gets it wrong in their code examples: The event polling
+function sometimes returns events to the caller even though an error
+occurred, but with no indication whether it has done so or not (yes, it's
+even documented that way) \- deadly for edge-triggered interfaces where you
+absolutely have to know whether an event occurred or not because you have
+to re-arm the watcher.
+.Sp
+Fortunately libev seems to be able to work around these idiocies.
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as
 \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
 .ie n .IP """EVBACKEND_ALL""" 4
 .el .IP "\f(CWEVBACKEND_ALL\fR" 4
 .IX Item "EVBACKEND_ALL"
 Try all backends (even potentially broken ones that wouldn't be tried
 with \f(CW\*(C`EVFLAG_AUTO\*(C'\fR). Since this is a mask, you can do stuff such as
 \&\f(CW\*(C`EVBACKEND_ALL & ~EVBACKEND_KQUEUE\*(C'\fR.
 .Sp
-It is definitely not recommended to use this flag.
+It is definitely not recommended to use this flag, use whatever
+\&\f(CW\*(C`ev_recommended_backends ()\*(C'\fR returns, or simply do not specify a backend
+at all.
+.ie n .IP """EVBACKEND_MASK""" 4
+.el .IP "\f(CWEVBACKEND_MASK\fR" 4
+.IX Item "EVBACKEND_MASK"
+Not a backend at all, but a mask to select all backend bits from a
+\&\f(CW\*(C`flags\*(C'\fR value, in case you want to mask out any backends from a flags
+value (e.g. when modifying the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR environment variable).
 .RE
 .RS 4
 .Sp
 If one or more of the backend flags are or'ed into the flags value,
 then only these backends will be tried (in the reverse order as listed
 This function is normally used on loop objects allocated by
 \&\f(CW\*(C`ev_loop_new\*(C'\fR, but it can also be used on the default loop returned by
 \&\f(CW\*(C`ev_default_loop\*(C'\fR, in which case it is not thread-safe.
 .Sp
 Note that it is not advisable to call this function on the default loop
-except in the rare occasion where you really need to free it's resources.
+except in the rare occasion where you really need to free its resources.
 If you need dynamically allocated loops it is better to use \f(CW\*(C`ev_loop_new\*(C'\fR
 and \f(CW\*(C`ev_loop_destroy\*(C'\fR.
 .IP "ev_loop_fork (loop)" 4
 .IX Item "ev_loop_fork (loop)"
-This function sets a flag that causes subsequent \f(CW\*(C`ev_run\*(C'\fR iterations to
+This function sets a flag that causes subsequent \f(CW\*(C`ev_run\*(C'\fR iterations
-reinitialise the kernel state for backends that have one. Despite the
+to reinitialise the kernel state for backends that have one. Despite
-name, you can call it anytime, but it makes most sense after forking, in
+the name, you can call it anytime you are allowed to start or stop
-the child process. You \fImust\fR call it (or use \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR) in the
+watchers (except inside an \f(CW\*(C`ev_prepare\*(C'\fR callback), but it makes most
-child before resuming or calling \f(CW\*(C`ev_run\*(C'\fR.
+sense after forking, in the child process. You \fImust\fR call it (or use
+\&\f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR) in the child before resuming or calling \f(CW\*(C`ev_run\*(C'\fR.
 .Sp
+In addition, if you want to reuse a loop (via this function or
+\&\f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR), you \fIalso\fR have to ignore \f(CW\*(C`SIGPIPE\*(C'\fR.
+.Sp
 Again, you \fIhave\fR to call it on \fIany\fR loop that you want to re-use after
 a fork, \fIeven if you do not plan to use the loop in the parent\fR. This is
 because some kernel interfaces *cough* \fIkqueue\fR *cough* do funny things
 during fork.
 .Sp
 On the other hand, you only need to call this function in the child
 \&\f(CW\*(C`ev_prepare\*(C'\fR and \f(CW\*(C`ev_check\*(C'\fR calls \- and is incremented between the
 prepare and check phases.
 .IP "unsigned int ev_depth (loop)" 4
 .IX Item "unsigned int ev_depth (loop)"
 Returns the number of times \f(CW\*(C`ev_run\*(C'\fR was entered minus the number of
-times \f(CW\*(C`ev_run\*(C'\fR was exited, in other words, the recursion depth.
+times \f(CW\*(C`ev_run\*(C'\fR was exited normally, in other words, the recursion depth.
 .Sp
 Outside \f(CW\*(C`ev_run\*(C'\fR, this number is zero. In a callback, this number is
 \&\f(CW1\fR, unless \f(CW\*(C`ev_run\*(C'\fR was invoked recursively (or from another thread),
 in which case it is higher.
 .Sp
-Leaving \f(CW\*(C`ev_run\*(C'\fR abnormally (setjmp/longjmp, cancelling the thread
+Leaving \f(CW\*(C`ev_run\*(C'\fR abnormally (setjmp/longjmp, cancelling the thread,
-etc.), doesn't count as \*(L"exit\*(R" \- consider this as a hint to avoid such
+throwing an exception etc.), doesn't count as \*(L"exit\*(R" \- consider this
-ungentleman-like behaviour unless it's really convenient.
+as a hint to avoid such ungentleman-like behaviour unless it's really
+convenient, in which case it is fully supported.
 .IP "unsigned int ev_backend (loop)" 4
 .IX Item "unsigned int ev_backend (loop)"
 Returns one of the \f(CW\*(C`EVBACKEND_*\*(C'\fR flags indicating the event backend in
 use.
 .IP "ev_tstamp ev_now (loop)" 4
 given loop other than \f(CW\*(C`ev_resume\*(C'\fR, and you \fBmust not\fR call \f(CW\*(C`ev_resume\*(C'\fR
 without a previous call to \f(CW\*(C`ev_suspend\*(C'\fR.
 .Sp
 Calling \f(CW\*(C`ev_suspend\*(C'\fR/\f(CW\*(C`ev_resume\*(C'\fR has the side effect of updating the
 event loop time (see \f(CW\*(C`ev_now_update\*(C'\fR).
-.IP "ev_run (loop, int flags)" 4
+.IP "bool ev_run (loop, int flags)" 4
-.IX Item "ev_run (loop, int flags)"
+.IX Item "bool ev_run (loop, int flags)"
 Finally, this is it, the event handler. This function usually is called
 after you have initialised all your watchers and you want to start
 handling events. It will ask the operating system for any new events, call
-the watcher callbacks, an then repeat the whole process indefinitely: This
+the watcher callbacks, and then repeat the whole process indefinitely: This
 is why event loops are called \fIloops\fR.
 .Sp
 If the flags argument is specified as \f(CW0\fR, it will keep handling events
 until either no event watchers are active anymore or \f(CW\*(C`ev_break\*(C'\fR was
 called.
+.Sp
+The return value is false if there are no more active watchers (which
+usually means \*(L"all jobs done\*(R" or \*(L"deadlock\*(R"), and true in all other cases
+(which usually means " you should call \f(CW\*(C`ev_run\*(C'\fR again").
 .Sp
 Please note that an explicit \f(CW\*(C`ev_break\*(C'\fR is usually better than
 relying on all watchers to be stopped when deciding when a program has
 finished (especially in interactive programs), but having a program
 that automatically loops as long as it has to and no longer by virtue
 of relying on its watchers stopping correctly, that is truly a thing of
 beauty.
 .Sp
+This function is \fImostly\fR exception-safe \- you can break out of a
+\&\f(CW\*(C`ev_run\*(C'\fR call by calling \f(CW\*(C`longjmp\*(C'\fR in a callback, throwing a \*(C+
+exception and so on. This does not decrement the \f(CW\*(C`ev_depth\*(C'\fR value, nor
+will it clear any outstanding \f(CW\*(C`EVBREAK_ONE\*(C'\fR breaks.
+.Sp
 A flags value of \f(CW\*(C`EVRUN_NOWAIT\*(C'\fR will look for new events, will handle
 those events and any already outstanding ones, but will not wait and
 block your process in case there are no events and will return after one
 iteration of the loop. This is sometimes useful to poll and handle new
 events while doing lengthy calculations, to keep the program responsive.
 This is useful if you are waiting for some external event in conjunction
 with something not expressible using other libev watchers (i.e. "roll your
 own \f(CW\*(C`ev_run\*(C'\fR"). However, a pair of \f(CW\*(C`ev_prepare\*(C'\fR/\f(CW\*(C`ev_check\*(C'\fR watchers is
 usually a better approach for this kind of thing.
 .Sp
-Here are the gory details of what \f(CW\*(C`ev_run\*(C'\fR does:
+Here are the gory details of what \f(CW\*(C`ev_run\*(C'\fR does (this is for your
+understanding, not a guarantee that things will work exactly like this in
+future versions):
 .Sp
 .Vb 10
 \&   \- Increment loop depth.
 \&   \- Reset the ev_break status.
 \&   \- Before the first iteration, call any pending watchers.
 .Sp
 .Vb 4
 \&   ... queue jobs here, make sure they register event watchers as long
 \&   ... as they still have work to do (even an idle watcher will do..)
 \&   ev_run (my_loop, 0);
-\&   ... jobs done or somebody called unloop. yeah!
+\&   ... jobs done or somebody called break. yeah!
 .Ve
 .IP "ev_break (loop, how)" 4
 .IX Item "ev_break (loop, how)"
 Can be used to make a call to \f(CW\*(C`ev_run\*(C'\fR return early (but only after it
 has processed all outstanding events). The \f(CW\*(C`how\*(C'\fR argument must be either
 \&\f(CW\*(C`EVBREAK_ONE\*(C'\fR, which will make the innermost \f(CW\*(C`ev_run\*(C'\fR call return, or
 \&\f(CW\*(C`EVBREAK_ALL\*(C'\fR, which will make all nested \f(CW\*(C`ev_run\*(C'\fR calls return.
 .Sp
-This \*(L"unloop state\*(R" will be cleared when entering \f(CW\*(C`ev_run\*(C'\fR again.
+This \*(L"break state\*(R" will be cleared on the next call to \f(CW\*(C`ev_run\*(C'\fR.
 .Sp
-It is safe to call \f(CW\*(C`ev_break\*(C'\fR from outside any \f(CW\*(C`ev_run\*(C'\fR calls. ##TODO##
+It is safe to call \f(CW\*(C`ev_break\*(C'\fR from outside any \f(CW\*(C`ev_run\*(C'\fR calls, too, in
+which case it will have no effect.
 .IP "ev_ref (loop)" 4
 .IX Item "ev_ref (loop)"
 .PD 0
 .IP "ev_unref (loop)" 4
 .IX Item "ev_unref (loop)"
 .Sp
 .Vb 4
 \&   ev_signal exitsig;
 \&   ev_signal_init (&exitsig, sig_cb, SIGINT);
 \&   ev_signal_start (loop, &exitsig);
-\&   evf_unref (loop);
+\&   ev_unref (loop);
 .Ve
 .Sp
 Example: For some weird reason, unregister the above signal handler again.
 .Sp
 .Vb 2
 overhead for the actual polling but can deliver many events at once.
 .Sp
 By setting a higher \fIio collect interval\fR you allow libev to spend more
 time collecting I/O events, so you can handle more events per iteration,
 at the cost of increasing latency. Timeouts (both \f(CW\*(C`ev_periodic\*(C'\fR and
-\&\f(CW\*(C`ev_timer\*(C'\fR) will be not affected. Setting this to a non-null value will
+\&\f(CW\*(C`ev_timer\*(C'\fR) will not be affected. Setting this to a non-null value will
 introduce an additional \f(CW\*(C`ev_sleep ()\*(C'\fR call into most loop iterations. The
 sleep time ensures that libev will not poll for I/O events more often then
-once per this interval, on average.
+once per this interval, on average (as long as the host time resolution is
+good enough).
 .Sp
 Likewise, by setting a higher \fItimeout collect interval\fR you allow libev
 to spend more time collecting timeouts, at the expense of increased
 latency/jitter/inexactness (the watcher callback will be called
 later). \f(CW\*(C`ev_io\*(C'\fR watchers will not be affected. Setting this to a non-null
 this callback instead. This is useful, for example, when you want to
 invoke the actual watchers inside another context (another thread etc.).
 .Sp
 If you want to reset the callback, use \f(CW\*(C`ev_invoke_pending\*(C'\fR as new
 callback.
-.IP "ev_set_loop_release_cb (loop, void (*release)(\s-1EV_P\s0), void (*acquire)(\s-1EV_P\s0))" 4
+.IP "ev_set_loop_release_cb (loop, void (*release)(\s-1EV_P\s0) throw (), void (*acquire)(\s-1EV_P\s0) throw ())" 4
-.IX Item "ev_set_loop_release_cb (loop, void (*release)(EV_P), void (*acquire)(EV_P))"
+.IX Item "ev_set_loop_release_cb (loop, void (*release)(EV_P) throw (), void (*acquire)(EV_P) throw ())"
 Sometimes you want to share the same loop between multiple threads. This
 can be done relatively simply by putting mutex_lock/unlock calls around
 each call to a libev function.
 .Sp
 However, \f(CW\*(C`ev_run\*(C'\fR can run an indefinite time, so it is not feasible
 to wait for it to return. One way around this is to wake up the event
-loop via \f(CW\*(C`ev_break\*(C'\fR and \f(CW\*(C`av_async_send\*(C'\fR, another way is to set these
+loop via \f(CW\*(C`ev_break\*(C'\fR and \f(CW\*(C`ev_async_send\*(C'\fR, another way is to set these
 \&\fIrelease\fR and \fIacquire\fR callbacks on the loop.
 .Sp
 When set, then \f(CW\*(C`release\*(C'\fR will be called just before the thread is
 suspended waiting for new events, and \f(CW\*(C`acquire\*(C'\fR is called just
 afterwards.
 See also the locking example in the \f(CW\*(C`THREADS\*(C'\fR section later in this
 document.
 .IP "ev_set_userdata (loop, void *data)" 4
 .IX Item "ev_set_userdata (loop, void *data)"
 .PD 0
-.IP "ev_userdata (loop)" 4
+.IP "void *ev_userdata (loop)" 4
-.IX Item "ev_userdata (loop)"
+.IX Item "void *ev_userdata (loop)"
 .PD
 Set and retrieve a single \f(CW\*(C`void *\*(C'\fR associated with a loop. When
 \&\f(CW\*(C`ev_set_userdata\*(C'\fR has never been called, then \f(CW\*(C`ev_userdata\*(C'\fR returns
-\&\f(CW0.\fR
+\&\f(CW0\fR.
 .Sp
 These two functions can be used to associate arbitrary data with a loop,
 and are intended solely for the \f(CW\*(C`invoke_pending_cb\*(C'\fR, \f(CW\*(C`release\*(C'\fR and
 \&\f(CW\*(C`acquire\*(C'\fR callbacks described above, but of course can be (ab\-)used for
 any other purpose as well.
 .PD 0
 .ie n .IP """EV_CHECK""" 4
 .el .IP "\f(CWEV_CHECK\fR" 4
 .IX Item "EV_CHECK"
 .PD
-All \f(CW\*(C`ev_prepare\*(C'\fR watchers are invoked just \fIbefore\fR \f(CW\*(C`ev_run\*(C'\fR starts
+All \f(CW\*(C`ev_prepare\*(C'\fR watchers are invoked just \fIbefore\fR \f(CW\*(C`ev_run\*(C'\fR starts to
-to gather new events, and all \f(CW\*(C`ev_check\*(C'\fR watchers are invoked just after
+gather new events, and all \f(CW\*(C`ev_check\*(C'\fR watchers are queued (not invoked)
-\&\f(CW\*(C`ev_run\*(C'\fR has gathered them, but before it invokes any callbacks for any
+just after \f(CW\*(C`ev_run\*(C'\fR has gathered them, but before it queues any callbacks
+for any received events. That means \f(CW\*(C`ev_prepare\*(C'\fR watchers are the last
+watchers invoked before the event loop sleeps or polls for new events, and
+\&\f(CW\*(C`ev_check\*(C'\fR watchers will be invoked before any other watchers of the same
+or lower priority within an event loop iteration.
+.Sp
-received events. Callbacks of both watcher types can start and stop as
+Callbacks of both watcher types can start and stop as many watchers as
-many watchers as they want, and all of them will be taken into account
+they want, and all of them will be taken into account (for example, a
-(for example, a \f(CW\*(C`ev_prepare\*(C'\fR watcher might start an idle watcher to keep
+\&\f(CW\*(C`ev_prepare\*(C'\fR watcher might start an idle watcher to keep \f(CW\*(C`ev_run\*(C'\fR from
-\&\f(CW\*(C`ev_run\*(C'\fR from blocking).
+blocking).
 .ie n .IP """EV_EMBED""" 4
 .el .IP "\f(CWEV_EMBED\fR" 4
 .IX Item "EV_EMBED"
 The embedded event loop specified in the \f(CW\*(C`ev_embed\*(C'\fR watcher needs attention.
 .ie n .IP """EV_FORK""" 4
 example it might indicate that a fd is readable or writable, and if your
 callbacks is well-written it can just attempt the operation and cope with
 the error from \fIread()\fR or \fIwrite()\fR. This will not work in multi-threaded
 programs, though, as the fd could already be closed and reused for another
 thing, so beware.
-.SS "\s-1GENERIC\s0 \s-1WATCHER\s0 \s-1FUNCTIONS\s0"
+.SS "\s-1GENERIC WATCHER FUNCTIONS\s0"
 .IX Subsection "GENERIC WATCHER FUNCTIONS"
 .ie n .IP """ev_init"" (ev_TYPE *watcher, callback)" 4
 .el .IP "\f(CWev_init\fR (ev_TYPE *watcher, callback)" 4
 .IX Item "ev_init (ev_TYPE *watcher, callback)"
 This macro initialises the generic portion of a watcher. The contents
 make sure the watcher is available to libev (e.g. you cannot \f(CW\*(C`free ()\*(C'\fR
 it).
 .IP "callback ev_cb (ev_TYPE *watcher)" 4
 .IX Item "callback ev_cb (ev_TYPE *watcher)"
 Returns the callback currently set on the watcher.
-.IP "ev_cb_set (ev_TYPE *watcher, callback)" 4
+.IP "ev_set_cb (ev_TYPE *watcher, callback)" 4
-.IX Item "ev_cb_set (ev_TYPE *watcher, callback)"
+.IX Item "ev_set_cb (ev_TYPE *watcher, callback)"
 Change the callback. You can change the callback at virtually any time
 (modulo threads).
 .IP "ev_set_priority (ev_TYPE *watcher, int priority)" 4
 .IX Item "ev_set_priority (ev_TYPE *watcher, int priority)"
 .PD 0
 or might not have been clamped to the valid range.
 .Sp
 The default priority used by watchers when no priority has been set is
 always \f(CW0\fR, which is supposed to not be too high and not be too low :).
 .Sp
-See \*(L"\s-1WATCHER\s0 \s-1PRIORITY\s0 \s-1MODELS\s0\*(R", below, for a more thorough treatment of
+See \*(L"\s-1WATCHER PRIORITY MODELS\*(R"\s0, below, for a more thorough treatment of
 priorities.
 .IP "ev_invoke (loop, ev_TYPE *watcher, int revents)" 4
 .IX Item "ev_invoke (loop, ev_TYPE *watcher, int revents)"
 Invoke the \f(CW\*(C`watcher\*(C'\fR with the given \f(CW\*(C`loop\*(C'\fR and \f(CW\*(C`revents\*(C'\fR. Neither
 \&\f(CW\*(C`loop\*(C'\fR nor \f(CW\*(C`revents\*(C'\fR need to be valid as long as the watcher callback
 \&\f(CW\*(C`ev_clear_pending\*(C'\fR will clear the pending event, even if the watcher was
 not started in the first place.
 .Sp
 See also \f(CW\*(C`ev_feed_fd_event\*(C'\fR and \f(CW\*(C`ev_feed_signal_event\*(C'\fR for related
 functions that do not need a watcher.
-.SS "\s-1ASSOCIATING\s0 \s-1CUSTOM\s0 \s-1DATA\s0 \s-1WITH\s0 A \s-1WATCHER\s0"
-.IX Subsection "ASSOCIATING CUSTOM DATA WITH A WATCHER"
-Each watcher has, by default, a member \f(CW\*(C`void *data\*(C'\fR that you can change
-and read at any time: libev will completely ignore it. This can be used
-to associate arbitrary data with your watcher. If you need more data and
-don't want to allocate memory and store a pointer to it in that data
-member, you can also \*(L"subclass\*(R" the watcher type and provide your own
-data:
 .PP
-.Vb 7
+See also the \*(L"\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\*(R"\s0 and \*(L"\s-1BUILDING YOUR
-\&   struct my_io
+OWN COMPOSITE WATCHERS\*(R"\s0 idioms.
-\&   {
-\&     ev_io io;
-\&     int otherfd;
-\&     void *somedata;
-\&     struct whatever *mostinteresting;
-\&   };
-\&
-\&   ...
-\&   struct my_io w;
-\&   ev_io_init (&w.io, my_cb, fd, EV_READ);
-.Ve
-.PP
-And since your callback will be called with a pointer to the watcher, you
-can cast it back to your own type:
-.PP
-.Vb 5
-\&   static void my_cb (struct ev_loop *loop, ev_io *w_, int revents)
-\&   {
-\&     struct my_io *w = (struct my_io *)w_;
-\&     ...
-\&   }
-.Ve
-.PP
-More interesting and less C\-conformant ways of casting your callback type
-instead have been omitted.
-.PP
-Another common scenario is to use some data structure with multiple
-embedded watchers:
-.PP
-.Vb 6
-\&   struct my_biggy
-\&   {
-\&     int some_data;
-\&     ev_timer t1;
-\&     ev_timer t2;
-\&   }
-.Ve
-.PP
-In this case getting the pointer to \f(CW\*(C`my_biggy\*(C'\fR is a bit more
-complicated: Either you store the address of your \f(CW\*(C`my_biggy\*(C'\fR struct
-in the \f(CW\*(C`data\*(C'\fR member of the watcher (for woozies), or you need to use
-some pointer arithmetic using \f(CW\*(C`offsetof\*(C'\fR inside your watchers (for real
-programmers):
-.PP
-.Vb 1
-\&   #include <stddef.h>
-\&
-\&   static void
-\&   t1_cb (EV_P_ ev_timer *w, int revents)
-\&   {
-\&     struct my_biggy big = (struct my_biggy *)
-\&       (((char *)w) \- offsetof (struct my_biggy, t1));
-\&   }
-\&
-\&   static void
-\&   t2_cb (EV_P_ ev_timer *w, int revents)
-\&   {
-\&     struct my_biggy big = (struct my_biggy *)
-\&       (((char *)w) \- offsetof (struct my_biggy, t2));
-\&   }
-.Ve
-.SS "\s-1WATCHER\s0 \s-1STATES\s0"
+.SS "\s-1WATCHER STATES\s0"
 .IX Subsection "WATCHER STATES"
 There are various watcher states mentioned throughout this manual \-
 active, pending and so on. In this section these states and the rules to
 transition between them will be described in more detail \- and while these
 rules might look complicated, they usually do \*(L"the right thing\*(R".
-.IP "initialiased" 4
+.IP "initialised" 4
-.IX Item "initialiased"
+.IX Item "initialised"
-Before a watcher can be registered with the event looop it has to be
+Before a watcher can be registered with the event loop it has to be
 initialised. This can be done with a call to \f(CW\*(C`ev_TYPE_init\*(C'\fR, or calls to
 \&\f(CW\*(C`ev_init\*(C'\fR followed by the watcher-specific \f(CW\*(C`ev_TYPE_set\*(C'\fR function.
 .Sp
-In this state it is simply some block of memory that is suitable for use
+In this state it is simply some block of memory that is suitable for
-in an event loop. It can be moved around, freed, reused etc. at will.
+use in an event loop. It can be moved around, freed, reused etc. at
+will \- as long as you either keep the memory contents intact, or call
+\&\f(CW\*(C`ev_TYPE_init\*(C'\fR again.
 .IP "started/running/active" 4
 .IX Item "started/running/active"
 Once a watcher has been started with a call to \f(CW\*(C`ev_TYPE_start\*(C'\fR it becomes
 property of the event loop, and is actively waiting for events. While in
 this state it cannot be accessed (except in a few documented ways), moved,
 latter will clear any pending state the watcher might be in, regardless
 of whether it was active or not, so stopping a watcher explicitly before
 freeing it is often a good idea.
 .Sp
 While stopped (and not pending) the watcher is essentially in the
-initialised state, that is it can be reused, moved, modified in any way
+initialised state, that is, it can be reused, moved, modified in any way
-you wish.
+you wish (but when you trash the memory block, you need to \f(CW\*(C`ev_TYPE_init\*(C'\fR
+it again).
-.SS "\s-1WATCHER\s0 \s-1PRIORITY\s0 \s-1MODELS\s0"
+.SS "\s-1WATCHER PRIORITY MODELS\s0"
 .IX Subsection "WATCHER PRIORITY MODELS"
 Many event loops support \fIwatcher priorities\fR, which are usually small
 integers that influence the ordering of event callback invocation
 between watchers in some way, all else being equal.
 .PP
 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
 required if you know what you are doing).
 .PP
-If you cannot use non-blocking mode, then force the use of a
-known-to-be-good backend (at the time of this writing, this includes only
-\&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR and \f(CW\*(C`EVBACKEND_POLL\*(C'\fR). The same applies to file
-descriptors for which non-blocking operation makes no sense (such as
-files) \- libev doesn't guarantee any specific behaviour in that case.
-.PP
 Another thing you have to watch out for is that it is quite easy to
-receive \*(L"spurious\*(R" readiness notifications, that is your callback might
+receive \*(L"spurious\*(R" readiness notifications, that is, your callback might
 be called with \f(CW\*(C`EV_READ\*(C'\fR but a subsequent \f(CW\*(C`read\*(C'\fR(2) will actually block
-because there is no data. Not only are some backends known to create a
+because there is no data. It is very easy to get into this situation even
-lot of those (for example Solaris ports), it is very easy to get into
+with a relatively standard program structure. Thus it is best to always
-this situation even with a relatively standard program structure. Thus
+use non-blocking I/O: An extra \f(CW\*(C`read\*(C'\fR(2) returning \f(CW\*(C`EAGAIN\*(C'\fR is far
-it is best to always use non-blocking I/O: An extra \f(CW\*(C`read\*(C'\fR(2) returning
-\&\f(CW\*(C`EAGAIN\*(C'\fR is far preferable to a program hanging until some data arrives.
+preferable to a program hanging until some data arrives.
 .PP
 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 separately
 re-test whether a file descriptor is really ready with a known-to-be good
-interface such as poll (fortunately in our Xlib example, Xlib already
+interface such as poll (fortunately in the case of Xlib, it already does
-does this on its own, so its quite safe to use). Some people additionally
+this on its own, so its quite safe to use). Some people additionally
 use \f(CW\*(C`SIGALRM\*(C'\fR and an interval timer, just to be sure you won't block
 indefinitely.
 .PP
 But really, best use non-blocking mode.
 .PP
 .PP
 There is no workaround possible except not registering events
 for potentially \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors, or to resort to
 \&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
 .PP
+\fIThe special problem of files\fR
+.IX Subsection "The special problem of files"
+.PP
+Many people try to use \f(CW\*(C`select\*(C'\fR (or libev) on file descriptors
+representing files, and expect it to become ready when their program
+doesn't block on disk accesses (which can take a long time on their own).
+.PP
+However, this cannot ever work in the \*(L"expected\*(R" way \- you get a readiness
+notification as soon as the kernel knows whether and how much data is
+there, and in the case of open files, that's always the case, so you
+always get a readiness notification instantly, and your read (or possibly
+write) will still block on the disk I/O.
+.PP
+Another way to view it is that in the case of sockets, pipes, character
+devices and so on, there is another party (the sender) that delivers data
+on its own, but in the case of files, there is no such thing: the disk
+will not send data on its own, simply because it doesn't know what you
+wish to read \- you would first have to request some data.
+.PP
+Since files are typically not-so-well supported by advanced notification
+mechanism, libev tries hard to emulate \s-1POSIX\s0 behaviour with respect
+to files, even though you should not use it. The reason for this is
+convenience: sometimes you want to watch \s-1STDIN\s0 or \s-1STDOUT,\s0 which is
+usually a tty, often a pipe, but also sometimes files or special devices
+(for example, \f(CW\*(C`epoll\*(C'\fR on Linux works with \fI/dev/random\fR but not with
+\&\fI/dev/urandom\fR), and even though the file might better be served with
+asynchronous I/O instead of with non-blocking I/O, it is still useful when
+it \*(L"just works\*(R" instead of freezing.
+.PP
+So avoid file descriptors pointing to files when you know it (e.g. use
+libeio), but use them when it is convenient, e.g. for \s-1STDIN/STDOUT,\s0 or
+when you rarely read from a file instead of from a socket, and want to
+reuse the same code path.
+.PP
 \fIThe special problem of fork\fR
 .IX Subsection "The special problem of fork"
 .PP
 Some backends (epoll, kqueue) do not support \f(CW\*(C`fork ()\*(C'\fR at all or exhibit
 useless behaviour. Libev fully supports fork, but needs to be told about
-it in the child.
+it in the child if you want to continue to use it in the child.
 .PP
-To support fork in your programs, you either have to call
+To support fork in your child processes, you have to call \f(CW\*(C`ev_loop_fork
-\&\f(CW\*(C`ev_default_fork ()\*(C'\fR or \f(CW\*(C`ev_loop_fork ()\*(C'\fR after a fork in the child,
+()\*(C'\fR after a fork in the child, enable \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR, or resort to
-enable \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR, or resort to \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or
+\&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
-\&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
 .PP
 \fIThe special problem of \s-1SIGPIPE\s0\fR
 .IX Subsection "The special problem of SIGPIPE"
 .PP
 While not really specific to libev, it is easy to forget about \f(CW\*(C`SIGPIPE\*(C'\fR:
 when writing to a pipe whose other end has been closed, your program gets
-sent a \s-1SIGPIPE\s0, which, by default, aborts your program. For most programs
+sent a \s-1SIGPIPE,\s0 which, by default, aborts your program. For most programs
 this is sensible behaviour, for daemons, this is usually undesirable.
 .PP
 So when you encounter spurious, unexplained daemon exits, make sure you
-ignore \s-1SIGPIPE\s0 (and maybe make sure you log the exit status of your daemon
+ignore \s-1SIGPIPE \s0(and maybe make sure you log the exit status of your daemon
 somewhere, as that would have given you a big clue).
 .PP
 \fIThe special problem of \fIaccept()\fIing when you can't\fR
 .IX Subsection "The special problem of accept()ing when you can't"
 .PP
-Many implementations of the \s-1POSIX\s0 \f(CW\*(C`accept\*(C'\fR function (for example,
+Many implementations of the \s-1POSIX \s0\f(CW\*(C`accept\*(C'\fR function (for example,
 found in post\-2004 Linux) have the peculiar behaviour of not removing a
 connection from the pending queue in all error cases.
 .PP
 For example, larger servers often run out of file descriptors (because
 of resource limits), causing \f(CW\*(C`accept\*(C'\fR to fail with \f(CW\*(C`ENFILE\*(C'\fR but not
 detecting time jumps is hard, and some inaccuracies are unavoidable (the
 monotonic clock option helps a lot here).
 .PP
 The callback is guaranteed to be invoked only \fIafter\fR its timeout has
 passed (not \fIat\fR, so on systems with very low-resolution clocks this
-might introduce a small delay). If multiple timers become ready during the
+might introduce a small delay, see \*(L"the special problem of being too
+early\*(R", below). If multiple timers become ready during the same loop
-same loop iteration then the ones with earlier time-out values are invoked
+iteration then the ones with earlier time-out values are invoked before
-before ones of the same priority with later time-out values (but this is
+ones of the same priority with later time-out values (but this is no
-no longer true when a callback calls \f(CW\*(C`ev_run\*(C'\fR recursively).
+longer true when a callback calls \f(CW\*(C`ev_run\*(C'\fR recursively).
 .PP
 \fIBe smart about timeouts\fR
 .IX Subsection "Be smart about timeouts"
 .PP
 Many real-world problems involve some kind of timeout, usually for error
 .Sp
 In this case, it would be more efficient to leave the \f(CW\*(C`ev_timer\*(C'\fR alone,
 but remember the time of last activity, and check for a real timeout only
 within the callback:
 .Sp
-.Vb 1
+.Vb 3
+\&   ev_tstamp timeout = 60.;
 \&   ev_tstamp last_activity; // time of last activity
+\&   ev_timer timer;
 \&
 \&   static void
 \&   callback (EV_P_ ev_timer *w, int revents)
 \&   {
-\&     ev_tstamp now     = ev_now (EV_A);
+\&     // calculate when the timeout would happen
-\&     ev_tstamp timeout = last_activity + 60.;
+\&     ev_tstamp after = last_activity \- ev_now (EV_A) + timeout;
 \&
-\&     // if last_activity + 60. is older than now, we did time out
+\&     // if negative, it means we the timeout already occurred
-\&     if (timeout < now)
+\&     if (after < 0.)
 \&       {
 \&         // timeout occurred, take action
 \&       }
 \&     else
 \&       {
-\&         // callback was invoked, but there was some activity, re\-arm
+\&         // callback was invoked, but there was some recent
-\&         // the watcher to fire in last_activity + 60, which is
+\&         // activity. simply restart the timer to time out
-\&         // guaranteed to be in the future, so "again" is positive:
+\&         // after "after" seconds, which is the earliest time
-\&         w\->repeat = timeout \- now;
+\&         // the timeout can occur.
+\&         ev_timer_set (w, after, 0.);
-\&         ev_timer_again (EV_A_ w);
+\&         ev_timer_start (EV_A_ w);
 \&       }
 \&   }
 .Ve
 .Sp
-To summarise the callback: first calculate the real timeout (defined
+To summarise the callback: first calculate in how many seconds the
-as \*(L"60 seconds after the last activity\*(R"), then check if that time has
+timeout will occur (by calculating the absolute time when it would occur,
-been reached, which means something \fIdid\fR, in fact, time out. Otherwise
+\&\f(CW\*(C`last_activity + timeout\*(C'\fR, and subtracting the current time, \f(CW\*(C`ev_now
-the callback was invoked too early (\f(CW\*(C`timeout\*(C'\fR is in the future), so
+(EV_A)\*(C'\fR from that).
-re-schedule the timer to fire at that future time, to see if maybe we have
-a timeout then.
 .Sp
-Note how \f(CW\*(C`ev_timer_again\*(C'\fR is used, taking advantage of the
+If this value is negative, then we are already past the timeout, i.e. we
-\&\f(CW\*(C`ev_timer_again\*(C'\fR optimisation when the timer is already running.
+timed out, and need to do whatever is needed in this case.
+.Sp
+Otherwise, we now the earliest time at which the timeout would trigger,
+and simply start the timer with this timeout value.
+.Sp
+In other words, each time the callback is invoked it will check whether
+the timeout occurred. If not, it will simply reschedule itself to check
+again at the earliest time it could time out. Rinse. Repeat.
 .Sp
 This scheme causes more callback invocations (about one every 60 seconds
 minus half the average time between activity), but virtually no calls to
 libev to change the timeout.
 .Sp
-To start the timer, simply initialise the watcher and set \f(CW\*(C`last_activity\*(C'\fR
+To start the machinery, simply initialise the watcher and set
-to the current time (meaning we just have some activity :), then call the
+\&\f(CW\*(C`last_activity\*(C'\fR to the current time (meaning there was some activity just
-callback, which will \*(L"do the right thing\*(R" and start the timer:
+now), then call the callback, which will \*(L"do the right thing\*(R" and start
+the timer:
 .Sp
 .Vb 3
+\&   last_activity = ev_now (EV_A);
-\&   ev_init (timer, callback);
+\&   ev_init (&timer, callback);
-\&   last_activity = ev_now (loop);
+\&   callback (EV_A_ &timer, 0);
-\&   callback (loop, timer, EV_TIMER);
 .Ve
 .Sp
-And when there is some activity, simply store the current time in
+When there is some activity, simply store the current time in
 \&\f(CW\*(C`last_activity\*(C'\fR, no libev calls at all:
 .Sp
-.Vb 1
+.Vb 2
+\&   if (activity detected)
-\&   last_activity = ev_now (loop);
+\&     last_activity = ev_now (EV_A);
+.Ve
+.Sp
+When your timeout value changes, then the timeout can be changed by simply
+providing a new value, stopping the timer and calling the callback, which
+will again do the right thing (for example, time out immediately :).
+.Sp
+.Vb 3
+\&   timeout = new_value;
+\&   ev_timer_stop (EV_A_ &timer);
+\&   callback (EV_A_ &timer, 0);
 .Ve
 .Sp
 This technique is slightly more complex, but in most cases where the
 time-out is unlikely to be triggered, much more efficient.
-.Sp
-Changing the timeout is trivial as well (if it isn't hard-coded in the
-callback :) \- just change the timeout and invoke the callback, which will
-fix things for you.
 .IP "4. Wee, just use a double-linked list for your timeouts." 4
 .IX Item "4. Wee, just use a double-linked list for your timeouts."
 If there is not one request, but many thousands (millions...), all
 employing some kind of timeout with the same timeout value, then one can
 do even better:
 Method #1 is almost always a bad idea, and buys you nothing. Method #4 is
 rather complicated, but extremely efficient, something that really pays
 off after the first million or so of active timers, i.e. it's usually
 overkill :)
 .PP
+\fIThe special problem of being too early\fR
+.IX Subsection "The special problem of being too early"
+.PP
+If you ask a timer to call your callback after three seconds, then
+you expect it to be invoked after three seconds \- but of course, this
+cannot be guaranteed to infinite precision. Less obviously, it cannot be
+guaranteed to any precision by libev \- imagine somebody suspending the
+process with a \s-1STOP\s0 signal for a few hours for example.
+.PP
+So, libev tries to invoke your callback as soon as possible \fIafter\fR the
+delay has occurred, but cannot guarantee this.
+.PP
+A less obvious failure mode is calling your callback too early: many event
+loops compare timestamps with a \*(L"elapsed delay >= requested delay\*(R", but
+this can cause your callback to be invoked much earlier than you would
+expect.
+.PP
+To see why, imagine a system with a clock that only offers full second
+resolution (think windows if you can't come up with a broken enough \s-1OS\s0
+yourself). If you schedule a one-second timer at the time 500.9, then the
+event loop will schedule your timeout to elapse at a system time of 500
+(500.9 truncated to the resolution) + 1, or 501.
+.PP
+If an event library looks at the timeout 0.1s later, it will see \*(L"501 >=
+501\*(R" and invoke the callback 0.1s after it was started, even though a
+one-second delay was requested \- this is being \*(L"too early\*(R", despite best
+intentions.
+.PP
+This is the reason why libev will never invoke the callback if the elapsed
+delay equals the requested delay, but only when the elapsed delay is
+larger than the requested delay. In the example above, libev would only invoke
+the callback at system time 502, or 1.1s after the timer was started.
+.PP
+So, while libev cannot guarantee that your callback will be invoked
+exactly when requested, it \fIcan\fR and \fIdoes\fR guarantee that the requested
+delay has actually elapsed, or in other words, it always errs on the \*(L"too
+late\*(R" side of things.
+.PP
 \fIThe special problem of time updates\fR
 .IX Subsection "The special problem of time updates"
 .PP
-Establishing the current time is a costly operation (it usually takes at
+Establishing the current time is a costly operation (it usually takes
-least two system calls): \s-1EV\s0 therefore updates its idea of the current
+at least one system call): \s-1EV\s0 therefore updates its idea of the current
 time only before and after \f(CW\*(C`ev_run\*(C'\fR collects new events, which causes a
 growing difference between \f(CW\*(C`ev_now ()\*(C'\fR and \f(CW\*(C`ev_time ()\*(C'\fR when handling
 lots of events in one iteration.
 .PP
 The relative timeouts are calculated relative to the \f(CW\*(C`ev_now ()\*(C'\fR
 time. This is usually the right thing as this timestamp refers to the time
 of the event triggering whatever timeout you are modifying/starting. If
 you suspect event processing to be delayed and you \fIneed\fR to base the
-timeout on the current time, use something like this to adjust for this:
+timeout on the current time, use something like the following to adjust
+for it:
 .PP
 .Vb 1
-\&   ev_timer_set (&timer, after + ev_now () \- ev_time (), 0.);
+\&   ev_timer_set (&timer, after + (ev_time () \- ev_now ()), 0.);
 .Ve
 .PP
 If the event loop is suspended for a long time, you can also force an
 update of the time returned by \f(CW\*(C`ev_now ()\*(C'\fR by calling \f(CW\*(C`ev_now_update
-()\*(C'\fR.
+()\*(C'\fR, although that will push the event time of all outstanding events
+further into the future.
+.PP
+\fIThe special problem of unsynchronised clocks\fR
+.IX Subsection "The special problem of unsynchronised clocks"
+.PP
+Modern systems have a variety of clocks \- libev itself uses the normal
+\&\*(L"wall clock\*(R" clock and, if available, the monotonic clock (to avoid time
+jumps).
+.PP
+Neither of these clocks is synchronised with each other or any other clock
+on the system, so \f(CW\*(C`ev_time ()\*(C'\fR might return a considerably different time
+than \f(CW\*(C`gettimeofday ()\*(C'\fR or \f(CW\*(C`time ()\*(C'\fR. On a GNU/Linux system, for example,
+a call to \f(CW\*(C`gettimeofday\*(C'\fR might return a second count that is one higher
+than a directly following call to \f(CW\*(C`time\*(C'\fR.
+.PP
+The moral of this is to only compare libev-related timestamps with
+\&\f(CW\*(C`ev_time ()\*(C'\fR and \f(CW\*(C`ev_now ()\*(C'\fR, at least if you want better precision than
+a second or so.
+.PP
+One more problem arises due to this lack of synchronisation: if libev uses
+the system monotonic clock and you compare timestamps from \f(CW\*(C`ev_time\*(C'\fR
+or \f(CW\*(C`ev_now\*(C'\fR from when you started your timer and when your callback is
+invoked, you will find that sometimes the callback is a bit \*(L"early\*(R".
+.PP
+This is because \f(CW\*(C`ev_timer\*(C'\fRs work in real time, not wall clock time, so
+libev makes sure your callback is not invoked before the delay happened,
+\&\fImeasured according to the real time\fR, not the system clock.
+.PP
+If your timeouts are based on a physical timescale (e.g. \*(L"time out this
+connection after 100 seconds\*(R") then this shouldn't bother you as it is
+exactly the right behaviour.
+.PP
+If you want to compare wall clock/system timestamps to your timers, then
+you need to use \f(CW\*(C`ev_periodic\*(C'\fRs, as these are based on the wall clock
+time, where your comparisons will always generate correct results.
 .PP
 \fIThe special problems of suspended animation\fR
 .IX Subsection "The special problems of suspended animation"
 .PP
 When you leave the server world it is quite customary to hit machines that
 trigger at exactly 10 second intervals. If, however, your program cannot
 keep up with the timer (because it takes longer than those 10 seconds to
 do stuff) the timer will not fire more than once per event loop iteration.
 .IP "ev_timer_again (loop, ev_timer *)" 4
 .IX Item "ev_timer_again (loop, ev_timer *)"
-This will act as if the timer timed out and restart it again if it is
+This will act as if the timer timed out, and restarts it again if it is
-repeating. The exact semantics are:
+repeating. It basically works like calling \f(CW\*(C`ev_timer_stop\*(C'\fR, updating the
+timeout to the \f(CW\*(C`repeat\*(C'\fR value and calling \f(CW\*(C`ev_timer_start\*(C'\fR.
 .Sp
+The exact semantics are as in the following rules, all of which will be
+applied to the watcher:
+.RS 4
-If the timer is pending, its pending status is cleared.
+.IP "If the timer is pending, the pending status is always cleared." 4
-.Sp
+.IX Item "If the timer is pending, the pending status is always cleared."
+.PD 0
-If the timer is started but non-repeating, stop it (as if it timed out).
+.IP "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)." 4
-.Sp
+.IX Item "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)."
-If the timer is repeating, either start it if necessary (with the
+.ie n .IP "If the timer is repeating, make the ""repeat"" value the new timeout and start the timer, if necessary." 4
-\&\f(CW\*(C`repeat\*(C'\fR value), or reset the running timer to the \f(CW\*(C`repeat\*(C'\fR value.
+.el .IP "If the timer is repeating, make the \f(CWrepeat\fR value the new timeout and start the timer, if necessary." 4
+.IX Item "If the timer is repeating, make the repeat value the new timeout and start the timer, if necessary."
+.RE
+.RS 4
+.PD
 .Sp
 This sounds a bit complicated, see \*(L"Be smart about timeouts\*(R", above, for a
 usage example.
+.RE
 .IP "ev_tstamp ev_timer_remaining (loop, ev_timer *)" 4
 .IX Item "ev_tstamp ev_timer_remaining (loop, ev_timer *)"
 Returns the remaining time until a timer fires. If the timer is active,
 then this time is relative to the current event loop time, otherwise it's
 the timeout value currently configured.
 Periodic watchers are also timers of a kind, but they are very versatile
 (and unfortunately a bit complex).
 .PP
 Unlike \f(CW\*(C`ev_timer\*(C'\fR, periodic watchers are not based on real time (or
 relative time, the physical time that passes) but on wall clock time
-(absolute time, the thing you can read on your calender or clock). The
+(absolute time, the thing you can read on your calendar or clock). The
 difference is that wall clock time can run faster or slower than real
 time, and time jumps are not uncommon (e.g. when you adjust your
 wrist-watch).
 .PP
 You can tell a periodic watcher to trigger after some specific point
 .Sp
 Another way to think about it (for the mathematically inclined) is that
 \&\f(CW\*(C`ev_periodic\*(C'\fR will try to run the callback in this mode at the next possible
 time where \f(CW\*(C`time = offset (mod interval)\*(C'\fR, regardless of any time jumps.
 .Sp
-For numerical stability it is preferable that the \f(CW\*(C`offset\*(C'\fR value is near
+The \f(CW\*(C`interval\*(C'\fR \fI\s-1MUST\s0\fR be positive, and for numerical stability, the
-\&\f(CW\*(C`ev_now ()\*(C'\fR (the current time), but there is no range requirement for
+interval value should be higher than \f(CW\*(C`1/8192\*(C'\fR (which is around 100
-this value, and in fact is often specified as zero.
+microseconds) and \f(CW\*(C`offset\*(C'\fR should be higher than \f(CW0\fR and should have
+at most a similar magnitude as the current time (say, within a factor of
+ten). Typical values for offset are, in fact, \f(CW0\fR or something between
+\&\f(CW0\fR and \f(CW\*(C`interval\*(C'\fR, which is also the recommended range.
 .Sp
 Note also that there is an upper limit to how often a timer can fire (\s-1CPU\s0
 speed for example), so if \f(CW\*(C`interval\*(C'\fR is very small then timing stability
 will of course deteriorate. Libev itself tries to be exact to be about one
 millisecond (if the \s-1OS\s0 supports it and the machine is fast enough).
 In this mode the values for \f(CW\*(C`interval\*(C'\fR and \f(CW\*(C`offset\*(C'\fR are both being
 ignored. Instead, each time the periodic watcher gets scheduled, the
 reschedule callback will be called with the watcher as first, and the
 current time as second argument.
 .Sp
-\&\s-1NOTE:\s0 \fIThis callback \s-1MUST\s0 \s-1NOT\s0 stop or destroy any periodic watcher, ever,
+\&\s-1NOTE: \s0\fIThis callback \s-1MUST NOT\s0 stop or destroy any periodic watcher, ever,
 or make \s-1ANY\s0 other event loop modifications whatsoever, unless explicitly
 allowed by documentation here\fR.
 .Sp
 If you need to stop it, return \f(CW\*(C`now + 1e30\*(C'\fR (or so, fudge fudge) and stop
 it afterwards (e.g. by starting an \f(CW\*(C`ev_prepare\*(C'\fR watcher, which is the
 It must return the next time to trigger, based on the passed time value
 (that is, the lowest time value larger than to the second argument). It
 will usually be called just before the callback will be triggered, but
 might be called at other times, too.
 .Sp
-\&\s-1NOTE:\s0 \fIThis callback must always return a time that is higher than or
+\&\s-1NOTE: \s0\fIThis callback must always return a time that is higher than or
 equal to the passed \f(CI\*(C`now\*(C'\fI value\fR.
 .Sp
 This can be used to create very complex timers, such as a timer that
 triggers on \*(L"next midnight, local time\*(R". To do this, you would calculate the
 next midnight after \f(CW\*(C`now\*(C'\fR and return the timestamp value for this. How
 .ie n .SS """ev_signal"" \- signal me when a signal gets signalled!"
 .el .SS "\f(CWev_signal\fP \- signal me when a signal gets signalled!"
 .IX Subsection "ev_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
-will try it's best to deliver signals synchronously, i.e. as part of the
+will try its best to deliver signals synchronously, i.e. as part of the
 normal event processing, like any other event.
 .PP
 If you want signals to be delivered truly asynchronously, just use
 \&\f(CW\*(C`sigaction\*(C'\fR as you would do without libev and forget about sharing
 the signal. You can even use \f(CW\*(C`ev_async\*(C'\fR from a signal handler to
 only within the same loop, i.e. you can watch for \f(CW\*(C`SIGINT\*(C'\fR in your
 default loop and for \f(CW\*(C`SIGIO\*(C'\fR in another loop, but you cannot watch for
 \&\f(CW\*(C`SIGINT\*(C'\fR in both the default loop and another loop at the same time. At
 the moment, \f(CW\*(C`SIGCHLD\*(C'\fR is permanently tied to the default loop.
 .PP
-When the first watcher gets started will libev actually register something
+Only after the first watcher for a signal is started will libev actually
-with the kernel (thus it coexists with your own signal handlers as long as
+register something with the kernel. It thus coexists with your own signal
-you don't register any with libev for the same signal).
+handlers as long as you don't register any with libev for the same signal.
 .PP
 If possible and supported, libev will install its handlers with
 \&\f(CW\*(C`SA_RESTART\*(C'\fR (or equivalent) behaviour enabled, so system calls should
 not be unduly interrupted. If you have a problem with system calls getting
 interrupted by signals you can block all signals in an \f(CW\*(C`ev_check\*(C'\fR watcher
 .IX Subsection "The special problem of inheritance over fork/execve/pthread_create"
 .PP
 Both the signal mask (\f(CW\*(C`sigprocmask\*(C'\fR) and the signal disposition
 (\f(CW\*(C`sigaction\*(C'\fR) are unspecified after starting a signal watcher (and after
 stopping it again), that is, libev might or might not block the signal,
-and might or might not set or restore the installed signal handler.
+and might or might not set or restore the installed signal handler (but
+see \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR).
 .PP
 While this does not matter for the signal disposition (libev never
 sets signals to \f(CW\*(C`SIG_IGN\*(C'\fR, so handlers will be reset to \f(CW\*(C`SIG_DFL\*(C'\fR on
 \&\f(CW\*(C`execve\*(C'\fR), this matters for the signal mask: many programs do not expect
 certain signals to be blocked.
 The simplest way to ensure that the signal mask is reset in the child is
 to install a fork handler with \f(CW\*(C`pthread_atfork\*(C'\fR that resets it. That will
 catch fork calls done by libraries (such as the libc) as well.
 .PP
 In current versions of libev, the signal will not be blocked indefinitely
-unless you use the \f(CW\*(C`signalfd\*(C'\fR \s-1API\s0 (\f(CW\*(C`EV_SIGNALFD\*(C'\fR). While this reduces
+unless you use the \f(CW\*(C`signalfd\*(C'\fR \s-1API \s0(\f(CW\*(C`EV_SIGNALFD\*(C'\fR). While this reduces
 the window of opportunity for problems, it will not go away, as libev
 \&\fIhas\fR to modify the signal mask, at least temporarily.
 .PP
 So I can't stress this enough: \fIIf you do not reset your signal mask when
 you expect it to be empty, you have a race condition in your code\fR. This
 is not a libev-specific thing, this is true for most event libraries.
+.PP
+\fIThe special problem of threads signal handling\fR
+.IX Subsection "The special problem of threads signal handling"
+.PP
+\&\s-1POSIX\s0 threads has problematic signal handling semantics, specifically,
+a lot of functionality (sigfd, sigwait etc.) only really works if all
+threads in a process block signals, which is hard to achieve.
+.PP
+When you want to use sigwait (or mix libev signal handling with your own
+for the same signals), you can tackle this problem by globally blocking
+all signals before creating any threads (or creating them with a fully set
+sigprocmask) and also specifying the \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR when creating
+loops. Then designate one thread as \*(L"signal receiver thread\*(R" which handles
+these signals. You can pass on any signals that libev might be interested
+in by calling \f(CW\*(C`ev_feed_signal\*(C'\fR.
 .PP
 \fIWatcher-Specific Functions and Data Members\fR
 .IX Subsection "Watcher-Specific Functions and Data Members"
 .IP "ev_signal_init (ev_signal *, callback, int signum)" 4
 .IX Item "ev_signal_init (ev_signal *, callback, int signum)"
 The signal the watcher watches out for.
 .PP
 \fIExamples\fR
 .IX Subsection "Examples"
 .PP
-Example: Try to exit cleanly on \s-1SIGINT\s0.
+Example: Try to exit cleanly on \s-1SIGINT.\s0
 .PP
 .Vb 5
 \&   static void
 \&   sigint_cb (struct ev_loop *loop, ev_signal *w, int revents)
 \&   {
 .ie n .SS """ev_stat"" \- did the file attributes just change?"
 .el .SS "\f(CWev_stat\fP \- did the file attributes just change?"
 .IX Subsection "ev_stat - did the file attributes just change?"
 This watches a file system path for attribute changes. That is, it calls
 \&\f(CW\*(C`stat\*(C'\fR on that path in regular intervals (or when the \s-1OS\s0 says it changed)
-and sees if it changed compared to the last time, invoking the callback if
+and sees if it changed compared to the last time, invoking the callback
-it did.
+if it did. Starting the watcher \f(CW\*(C`stat\*(C'\fR's the file, so only changes that
+happen after the watcher has been started will be reported.
 .PP
 The path does not need to exist: changing from \*(L"path exists\*(R" to \*(L"path does
 not exist\*(R" is a status change like any other. The condition \*(L"path does not
 exist\*(R" (or more correctly \*(L"path cannot be stat'ed\*(R") is signified by the
 \&\f(CW\*(C`st_nlink\*(C'\fR field being zero (which is otherwise always forced to be at
 compilation environment, which means that on systems with large file
 support disabled by default, you get the 32 bit version of the stat
 structure. When using the library from programs that change the \s-1ABI\s0 to
 use 64 bit file offsets the programs will fail. In that case you have to
 compile libev with the same flags to get binary compatibility. This is
-obviously the case with any flags that change the \s-1ABI\s0, but the problem is
+obviously the case with any flags that change the \s-1ABI,\s0 but the problem is
 most noticeably displayed with ev_stat and large file support.
 .PP
 The solution for this is to lobby your distribution maker to make large
 file interfaces available by default (as e.g. FreeBSD does) and not
 optional. Libev cannot simply switch on large file support because it has
 Apart from keeping your process non-blocking (which is a useful
 effect on its own sometimes), idle watchers are a good place to do
 \&\*(L"pseudo-background processing\*(R", or delay processing stuff to after the
 event loop has handled all outstanding events.
 .PP
+\fIAbusing an \f(CI\*(C`ev_idle\*(C'\fI watcher for its side-effect\fR
+.IX Subsection "Abusing an ev_idle watcher for its side-effect"
+.PP
+As long as there is at least one active idle watcher, libev will never
+sleep unnecessarily. Or in other words, it will loop as fast as possible.
+For this to work, the idle watcher doesn't need to be invoked at all \- the
+lowest priority will do.
+.PP
+This mode of operation can be useful together with an \f(CW\*(C`ev_check\*(C'\fR watcher,
+to do something on each event loop iteration \- for example to balance load
+between different connections.
+.PP
+See \*(L"Abusing an ev_check watcher for its side-effect\*(R" for a longer
+example.
+.PP
 \fIWatcher-Specific Functions and Data Members\fR
 .IX Subsection "Watcher-Specific Functions and Data Members"
 .IP "ev_idle_init (ev_idle *, callback)" 4
 .IX Item "ev_idle_init (ev_idle *, callback)"
 Initialises and configures the idle watcher \- it has no parameters of any
 .IX Subsection "Examples"
 .PP
 Example: Dynamically allocate an \f(CW\*(C`ev_idle\*(C'\fR watcher, start it, and in the
 callback, free it. Also, use no error checking, as usual.
 .PP
-.Vb 7
+.Vb 5
 \&   static void
 \&   idle_cb (struct ev_loop *loop, ev_idle *w, int revents)
 \&   {
+\&     // stop the watcher
+\&     ev_idle_stop (loop, w);
+\&
+\&     // now we can free it
 \&     free (w);
+\&
 \&     // now do something you wanted to do when the program has
 \&     // no longer anything immediate to do.
 \&   }
 \&
 \&   ev_idle *idle_watcher = malloc (sizeof (ev_idle));
 \&   ev_idle_start (loop, idle_watcher);
 .Ve
 .ie n .SS """ev_prepare"" and ""ev_check"" \- customise your event loop!"
 .el .SS "\f(CWev_prepare\fP and \f(CWev_check\fP \- customise your event loop!"
 .IX Subsection "ev_prepare and ev_check - customise your event loop!"
-Prepare and check watchers are usually (but not always) used in pairs:
+Prepare and check watchers are often (but not always) used in pairs:
 prepare watchers get invoked before the process blocks and check watchers
 afterwards.
 .PP
-You \fImust not\fR call \f(CW\*(C`ev_run\*(C'\fR or similar functions that enter
+You \fImust not\fR call \f(CW\*(C`ev_run\*(C'\fR (or similar functions that enter the
-the current event loop from either \f(CW\*(C`ev_prepare\*(C'\fR or \f(CW\*(C`ev_check\*(C'\fR
+current event loop) or \f(CW\*(C`ev_loop_fork\*(C'\fR from either \f(CW\*(C`ev_prepare\*(C'\fR or
-watchers. Other loops than the current one are fine, however. The
+\&\f(CW\*(C`ev_check\*(C'\fR watchers. Other loops than the current one are fine,
-rationale behind this is that you do not need to check for recursion in
+however. The rationale behind this is that you do not need to check
-those watchers, i.e. the sequence will always be \f(CW\*(C`ev_prepare\*(C'\fR, blocking,
+for recursion in those watchers, i.e. the sequence will always be
-\&\f(CW\*(C`ev_check\*(C'\fR so if you have one watcher of each kind they will always be
+\&\f(CW\*(C`ev_prepare\*(C'\fR, blocking, \f(CW\*(C`ev_check\*(C'\fR so if you have one watcher of each
-called in pairs bracketing the blocking call.
+kind they will always be called in pairs bracketing the blocking call.
 .PP
 Their main purpose is to integrate other event mechanisms into libev and
 their use is somewhat advanced. They could be used, for example, to track
 variable changes, implement your own watchers, integrate net-snmp or a
 coroutine library and lots more. They are also occasionally useful if
 with priority higher than or equal to the event loop and one coroutine
 of lower priority, but only once, using idle watchers to keep the event
 loop from blocking if lower-priority coroutines are active, thus mapping
 low-priority coroutines to idle/background tasks).
 .PP
-It is recommended to give \f(CW\*(C`ev_check\*(C'\fR watchers highest (\f(CW\*(C`EV_MAXPRI\*(C'\fR)
+When used for this purpose, it is recommended to give \f(CW\*(C`ev_check\*(C'\fR watchers
-priority, to ensure that they are being run before any other watchers
+highest (\f(CW\*(C`EV_MAXPRI\*(C'\fR) priority, to ensure that they are being run before
-after the poll (this doesn't matter for \f(CW\*(C`ev_prepare\*(C'\fR watchers).
+any other watchers after the poll (this doesn't matter for \f(CW\*(C`ev_prepare\*(C'\fR
+watchers).
 .PP
 Also, \f(CW\*(C`ev_check\*(C'\fR watchers (and \f(CW\*(C`ev_prepare\*(C'\fR watchers, too) should not
 activate (\*(L"feed\*(R") events into libev. While libev fully supports this, they
 might get executed before other \f(CW\*(C`ev_check\*(C'\fR watchers did their job. As
 \&\f(CW\*(C`ev_check\*(C'\fR watchers are often used to embed other (non-libev) event
 loops those other event loops might be in an unusable state until their
 \&\f(CW\*(C`ev_check\*(C'\fR watcher ran (always remind yourself to coexist peacefully with
 others).
+.PP
+\fIAbusing an \f(CI\*(C`ev_check\*(C'\fI watcher for its side-effect\fR
+.IX Subsection "Abusing an ev_check watcher for its side-effect"
+.PP
+\&\f(CW\*(C`ev_check\*(C'\fR (and less often also \f(CW\*(C`ev_prepare\*(C'\fR) watchers can also be
+useful because they are called once per event loop iteration. For
+example, if you want to handle a large number of connections fairly, you
+normally only do a bit of work for each active connection, and if there
+is more work to do, you wait for the next event loop iteration, so other
+connections have a chance of making progress.
+.PP
+Using an \f(CW\*(C`ev_check\*(C'\fR watcher is almost enough: it will be called on the
+next event loop iteration. However, that isn't as soon as possible \-
+without external events, your \f(CW\*(C`ev_check\*(C'\fR watcher will not be invoked.
+.PP
+This is where \f(CW\*(C`ev_idle\*(C'\fR watchers come in handy \- all you need is a
+single global idle watcher that is active as long as you have one active
+\&\f(CW\*(C`ev_check\*(C'\fR watcher. The \f(CW\*(C`ev_idle\*(C'\fR watcher makes sure the event loop
+will not sleep, and the \f(CW\*(C`ev_check\*(C'\fR watcher makes sure a callback gets
+invoked. Neither watcher alone can do that.
 .PP
 \fIWatcher-Specific Functions and Data Members\fR
 .IX Subsection "Watcher-Specific Functions and Data Members"
 .IP "ev_prepare_init (ev_prepare *, callback)" 4
 .IX Item "ev_prepare_init (ev_prepare *, callback)"
 .Ve
 .PP
 Method 4: Do not use a prepare or check watcher because the module you
 want to embed is not flexible enough to support it. Instead, you can
 override their poll function. The drawback with this solution is that the
-main loop is now no longer controllable by \s-1EV\s0. The \f(CW\*(C`Glib::EV\*(C'\fR module uses
+main loop is now no longer controllable by \s-1EV.\s0 The \f(CW\*(C`Glib::EV\*(C'\fR module uses
 this approach, effectively embedding \s-1EV\s0 as a client into the horrible
 libglib event loop.
 .PP
 .Vb 4
 \&   static gint
 \fIWatcher-Specific Functions and Data Members\fR
 .IX Subsection "Watcher-Specific Functions and Data Members"
 .IP "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)" 4
 .IX Item "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)"
 .PD 0
-.IP "ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)" 4
+.IP "ev_embed_set (ev_embed *, struct ev_loop *embedded_loop)" 4
-.IX Item "ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)"
+.IX Item "ev_embed_set (ev_embed *, struct ev_loop *embedded_loop)"
 .PD
 Configures the watcher to embed the given loop, which must be
 embeddable. If the callback is \f(CW0\fR, then \f(CW\*(C`ev_embed_sweep\*(C'\fR will be
 invoked automatically, otherwise it is the responsibility of the callback
 to invoke it (it will continue to be called until the sweep has been done,
 .PP
 .Vb 3
 \&   struct ev_loop *loop_hi = ev_default_init (0);
 \&   struct ev_loop *loop_lo = 0;
 \&   ev_embed embed;
 \&
 \&   // see if there is a chance of getting one that works
 \&   // (remember that a flags value of 0 means autodetection)
 \&   loop_lo = ev_embeddable_backends () & ev_recommended_backends ()
 \&     ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ())
 \&     : 0;
 .PP
 .Vb 3
 \&   struct ev_loop *loop = ev_default_init (0);
 \&   struct ev_loop *loop_socket = 0;
 \&   ev_embed embed;
 \&
 \&   if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE)
 \&     if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE))
 \&       {
 \&         ev_embed_init (&embed, 0, loop_socket);
 \&         ev_embed_start (loop, &embed);
 .ie n .SS """ev_fork"" \- the audacity to resume the event loop after a fork"
 .el .SS "\f(CWev_fork\fP \- the audacity to resume the event loop after a fork"
 .IX Subsection "ev_fork - the audacity to resume the event loop after a fork"
 Fork watchers are called when a \f(CW\*(C`fork ()\*(C'\fR was detected (usually because
 whoever is a good citizen cared to tell libev about it by calling
-\&\f(CW\*(C`ev_default_fork\*(C'\fR or \f(CW\*(C`ev_loop_fork\*(C'\fR). The invocation is done before the
+\&\f(CW\*(C`ev_loop_fork\*(C'\fR). The invocation is done before the event loop blocks next
-event loop blocks next and before \f(CW\*(C`ev_check\*(C'\fR watchers are being called,
+and before \f(CW\*(C`ev_check\*(C'\fR watchers are being called, and only in the child
-and only in the child after the fork. If whoever good citizen calling
+after the fork. If whoever good citizen calling \f(CW\*(C`ev_default_fork\*(C'\fR cheats
-\&\f(CW\*(C`ev_default_fork\*(C'\fR cheats and calls it in the wrong process, the fork
+and calls it in the wrong process, the fork handlers will be invoked, too,
-handlers will be invoked, too, of course.
+of course.
 .PP
 \fIThe special problem of life after fork \- how is it possible?\fR
 .IX Subsection "The special problem of life after fork - how is it possible?"
 .PP
-Most uses of \f(CW\*(C`fork()\*(C'\fR consist of forking, then some simple calls to set
+Most uses of \f(CW\*(C`fork ()\*(C'\fR consist of forking, then some simple calls to set
 up/change the process environment, followed by a call to \f(CW\*(C`exec()\*(C'\fR. This
 sequence should be handled by libev without any problems.
 .PP
 This changes when the application actually wants to do event handling
 in the child, or both parent in child, in effect \*(L"continuing\*(R" after the
 \&   atexit (program_exits);
 .Ve
 .ie n .SS """ev_async"" \- how to wake up an event loop"
 .el .SS "\f(CWev_async\fP \- how to wake up an event loop"
 .IX Subsection "ev_async - how to wake up an event loop"
-In general, you cannot use an \f(CW\*(C`ev_run\*(C'\fR from multiple threads or other
+In general, you cannot use an \f(CW\*(C`ev_loop\*(C'\fR from multiple threads or other
 asynchronous sources such as signal handlers (as opposed to multiple event
 loops \- those are of course safe to use in different threads).
 .PP
 Sometimes, however, you need to wake up an event loop you do not control,
 for example because it belongs to another thread. This is what \f(CW\*(C`ev_async\*(C'\fR
 it by calling \f(CW\*(C`ev_async_send\*(C'\fR, which is thread\- and signal safe.
 .PP
 This functionality is very similar to \f(CW\*(C`ev_signal\*(C'\fR watchers, as signals,
 too, are asynchronous in nature, and signals, too, will be compressed
 (i.e. the number of callback invocations may be less than the number of
-\&\f(CW\*(C`ev_async_sent\*(C'\fR calls).
+\&\f(CW\*(C`ev_async_send\*(C'\fR calls). In fact, you could use signal watchers as a kind
-.PP
+of \*(L"global async watchers\*(R" by using a watcher on an otherwise unused
-Unlike \f(CW\*(C`ev_signal\*(C'\fR watchers, \f(CW\*(C`ev_async\*(C'\fR works with any event loop, not
+signal, and \f(CW\*(C`ev_feed_signal\*(C'\fR to signal this watcher from another thread,
-just the default loop.
+even without knowing which loop owns the signal.
 .PP
 \fIQueueing\fR
 .IX Subsection "Queueing"
 .PP
 \&\f(CW\*(C`ev_async\*(C'\fR does not support queueing of data in any way. The reason
 kind. There is a \f(CW\*(C`ev_async_set\*(C'\fR macro, but using it is utterly pointless,
 trust me.
 .IP "ev_async_send (loop, ev_async *)" 4
 .IX Item "ev_async_send (loop, ev_async *)"
 Sends/signals/activates the given \f(CW\*(C`ev_async\*(C'\fR watcher, that is, feeds
-an \f(CW\*(C`EV_ASYNC\*(C'\fR event on the watcher into the event loop. Unlike
+an \f(CW\*(C`EV_ASYNC\*(C'\fR event on the watcher into the event loop, and instantly
+returns.
+.Sp
-\&\f(CW\*(C`ev_feed_event\*(C'\fR, this call is safe to do from other threads, signal or
+Unlike \f(CW\*(C`ev_feed_event\*(C'\fR, this call is safe to do from other threads,
-similar contexts (see the discussion of \f(CW\*(C`EV_ATOMIC_T\*(C'\fR in the embedding
+signal or similar contexts (see the discussion of \f(CW\*(C`EV_ATOMIC_T\*(C'\fR in the
-section below on what exactly this means).
+embedding section below on what exactly this means).
 .Sp
 Note that, as with other watchers in libev, multiple events might get
-compressed into a single callback invocation (another way to look at this
+compressed into a single callback invocation (another way to look at
-is that \f(CW\*(C`ev_async\*(C'\fR watchers are level-triggered, set on \f(CW\*(C`ev_async_send\*(C'\fR,
+this is that \f(CW\*(C`ev_async\*(C'\fR watchers are level-triggered: they are set on
-reset when the event loop detects that).
+\&\f(CW\*(C`ev_async_send\*(C'\fR, reset when the event loop detects that).
 .Sp
-This call incurs the overhead of a system call only once per event loop
+This call incurs the overhead of at most one extra system call per event
-iteration, so while the overhead might be noticeable, it doesn't apply to
+loop iteration, if the event loop is blocked, and no syscall at all if
-repeated calls to \f(CW\*(C`ev_async_send\*(C'\fR for the same event loop.
+the event loop (or your program) is processing events. That means that
+repeated calls are basically free (there is no need to avoid calls for
+performance reasons) and that the overhead becomes smaller (typically
+zero) under load.
 .IP "bool = ev_async_pending (ev_async *)" 4
 .IX Item "bool = ev_async_pending (ev_async *)"
 Returns a non-zero value when \f(CW\*(C`ev_async_send\*(C'\fR has been called on the
 watcher but the event has not yet been processed (or even noted) by the
 event loop.
 \&\f(CW\*(C`EV_ERROR\*(C'\fR, \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR or \f(CW\*(C`EV_TIMER\*(C'\fR) and the \f(CW\*(C`arg\*(C'\fR
 value passed to \f(CW\*(C`ev_once\*(C'\fR. Note that it is possible to receive \fIboth\fR
 a timeout and an io event at the same time \- you probably should give io
 events precedence.
 .Sp
-Example: wait up to ten seconds for data to appear on \s-1STDIN_FILENO\s0.
+Example: wait up to ten seconds for data to appear on \s-1STDIN_FILENO.\s0
 .Sp
 .Vb 7
 \&   static void stdin_ready (int revents, void *arg)
 \&   {
 \&     if (revents & EV_READ)
 \&   ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);
 .Ve
 .IP "ev_feed_fd_event (loop, int fd, int revents)" 4
 .IX Item "ev_feed_fd_event (loop, int fd, int revents)"
 Feed an event on the given fd, as if a file descriptor backend detected
-the given events it.
+the given events.
 .IP "ev_feed_signal_event (loop, int signum)" 4
 .IX Item "ev_feed_signal_event (loop, int signum)"
-Feed an event as if the given signal occurred (\f(CW\*(C`loop\*(C'\fR must be the default
+Feed an event as if the given signal occurred. See also \f(CW\*(C`ev_feed_signal\*(C'\fR,
-loop!).
+which is async-safe.
+.SH "COMMON OR USEFUL IDIOMS (OR BOTH)"
+.IX Header "COMMON OR USEFUL IDIOMS (OR BOTH)"
+This section explains some common idioms that are not immediately
+obvious. Note that examples are sprinkled over the whole manual, and this
+section only contains stuff that wouldn't fit anywhere else.
+.SS "\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\s0"
+.IX Subsection "ASSOCIATING CUSTOM DATA WITH A WATCHER"
+Each watcher has, by default, a \f(CW\*(C`void *data\*(C'\fR member that you can read
+or modify at any time: libev will completely ignore it. This can be used
+to associate arbitrary data with your watcher. If you need more data and
+don't want to allocate memory separately and store a pointer to it in that
+data member, you can also \*(L"subclass\*(R" the watcher type and provide your own
+data:
+.PP
+.Vb 7
+\&   struct my_io
+\&   {
+\&     ev_io io;
+\&     int otherfd;
+\&     void *somedata;
+\&     struct whatever *mostinteresting;
+\&   };
+\&
+\&   ...
+\&   struct my_io w;
+\&   ev_io_init (&w.io, my_cb, fd, EV_READ);
+.Ve
+.PP
+And since your callback will be called with a pointer to the watcher, you
+can cast it back to your own type:
+.PP
+.Vb 5
+\&   static void my_cb (struct ev_loop *loop, ev_io *w_, int revents)
+\&   {
+\&     struct my_io *w = (struct my_io *)w_;
+\&     ...
+\&   }
+.Ve
+.PP
+More interesting and less C\-conformant ways of casting your callback
+function type instead have been omitted.
+.SS "\s-1BUILDING YOUR OWN COMPOSITE WATCHERS\s0"
+.IX Subsection "BUILDING YOUR OWN COMPOSITE WATCHERS"
+Another common scenario is to use some data structure with multiple
+embedded watchers, in effect creating your own watcher that combines
+multiple libev event sources into one \*(L"super-watcher\*(R":
+.PP
+.Vb 6
+\&   struct my_biggy
+\&   {
+\&     int some_data;
+\&     ev_timer t1;
+\&     ev_timer t2;
+\&   }
+.Ve
+.PP
+In this case getting the pointer to \f(CW\*(C`my_biggy\*(C'\fR is a bit more
+complicated: Either you store the address of your \f(CW\*(C`my_biggy\*(C'\fR struct in
+the \f(CW\*(C`data\*(C'\fR member of the watcher (for woozies or \*(C+ coders), or you need
+to use some pointer arithmetic using \f(CW\*(C`offsetof\*(C'\fR inside your watchers (for
+real programmers):
+.PP
+.Vb 1
+\&   #include <stddef.h>
+\&
+\&   static void
+\&   t1_cb (EV_P_ ev_timer *w, int revents)
+\&   {
+\&     struct my_biggy big = (struct my_biggy *)
+\&       (((char *)w) \- offsetof (struct my_biggy, t1));
+\&   }
+\&
+\&   static void
+\&   t2_cb (EV_P_ ev_timer *w, int revents)
+\&   {
+\&     struct my_biggy big = (struct my_biggy *)
+\&       (((char *)w) \- offsetof (struct my_biggy, t2));
+\&   }
+.Ve
+.SS "\s-1AVOIDING FINISHING BEFORE RETURNING\s0"
+.IX Subsection "AVOIDING FINISHING BEFORE RETURNING"
+Often you have structures like this in event-based programs:
+.PP
+.Vb 4
+\&  callback ()
+\&  {
+\&    free (request);
+\&  }
+\&
+\&  request = start_new_request (..., callback);
+.Ve
+.PP
+The intent is to start some \*(L"lengthy\*(R" operation. The \f(CW\*(C`request\*(C'\fR could be
+used to cancel the operation, or do other things with it.
+.PP
+It's not uncommon to have code paths in \f(CW\*(C`start_new_request\*(C'\fR that
+immediately invoke the callback, for example, to report errors. Or you add
+some caching layer that finds that it can skip the lengthy aspects of the
+operation and simply invoke the callback with the result.
+.PP
+The problem here is that this will happen \fIbefore\fR \f(CW\*(C`start_new_request\*(C'\fR
+has returned, so \f(CW\*(C`request\*(C'\fR is not set.
+.PP
+Even if you pass the request by some safer means to the callback, you
+might want to do something to the request after starting it, such as
+canceling it, which probably isn't working so well when the callback has
+already been invoked.
+.PP
+A common way around all these issues is to make sure that
+\&\f(CW\*(C`start_new_request\*(C'\fR \fIalways\fR returns before the callback is invoked. If
+\&\f(CW\*(C`start_new_request\*(C'\fR immediately knows the result, it can artificially
+delay invoking the callback by using a \f(CW\*(C`prepare\*(C'\fR or \f(CW\*(C`idle\*(C'\fR watcher for
+example, or more sneakily, by reusing an existing (stopped) watcher and
+pushing it into the pending queue:
+.PP
+.Vb 2
+\&   ev_set_cb (watcher, callback);
+\&   ev_feed_event (EV_A_ watcher, 0);
+.Ve
+.PP
+This way, \f(CW\*(C`start_new_request\*(C'\fR can safely return before the callback is
+invoked, while not delaying callback invocation too much.
+.SS "\s-1MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS\s0"
+.IX Subsection "MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS"
+Often (especially in \s-1GUI\s0 toolkits) there are places where you have
+\&\fImodal\fR interaction, which is most easily implemented by recursively
+invoking \f(CW\*(C`ev_run\*(C'\fR.
+.PP
+This brings the problem of exiting \- a callback might want to finish the
+main \f(CW\*(C`ev_run\*(C'\fR call, but not the nested one (e.g. user clicked \*(L"Quit\*(R", but
+a modal \*(L"Are you sure?\*(R" dialog is still waiting), or just the nested one
+and not the main one (e.g. user clocked \*(L"Ok\*(R" in a modal dialog), or some
+other combination: In these cases, a simple \f(CW\*(C`ev_break\*(C'\fR will not work.
+.PP
+The solution is to maintain \*(L"break this loop\*(R" variable for each \f(CW\*(C`ev_run\*(C'\fR
+invocation, and use a loop around \f(CW\*(C`ev_run\*(C'\fR until the condition is
+triggered, using \f(CW\*(C`EVRUN_ONCE\*(C'\fR:
+.PP
+.Vb 2
+\&   // main loop
+\&   int exit_main_loop = 0;
+\&
+\&   while (!exit_main_loop)
+\&     ev_run (EV_DEFAULT_ EVRUN_ONCE);
+\&
+\&   // in a modal watcher
+\&   int exit_nested_loop = 0;
+\&
+\&   while (!exit_nested_loop)
+\&     ev_run (EV_A_ EVRUN_ONCE);
+.Ve
+.PP
+To exit from any of these loops, just set the corresponding exit variable:
+.PP
+.Vb 2
+\&   // exit modal loop
+\&   exit_nested_loop = 1;
+\&
+\&   // exit main program, after modal loop is finished
+\&   exit_main_loop = 1;
+\&
+\&   // exit both
+\&   exit_main_loop = exit_nested_loop = 1;
+.Ve
+.SS "\s-1THREAD LOCKING EXAMPLE\s0"
+.IX Subsection "THREAD LOCKING EXAMPLE"
+Here is a fictitious example of how to run an event loop in a different
+thread from where callbacks are being invoked and watchers are
+created/added/removed.
+.PP
+For a real-world example, see the \f(CW\*(C`EV::Loop::Async\*(C'\fR perl module,
+which uses exactly this technique (which is suited for many high-level
+languages).
+.PP
+The example uses a pthread mutex to protect the loop data, a condition
+variable to wait for callback invocations, an async watcher to notify the
+event loop thread and an unspecified mechanism to wake up the main thread.
+.PP
+First, you need to associate some data with the event loop:
+.PP
+.Vb 6
+\&   typedef struct {
+\&     mutex_t lock; /* global loop lock */
+\&     ev_async async_w;
+\&     thread_t tid;
+\&     cond_t invoke_cv;
+\&   } userdata;
+\&
+\&   void prepare_loop (EV_P)
+\&   {
+\&      // for simplicity, we use a static userdata struct.
+\&      static userdata u;
+\&
+\&      ev_async_init (&u\->async_w, async_cb);
+\&      ev_async_start (EV_A_ &u\->async_w);
+\&
+\&      pthread_mutex_init (&u\->lock, 0);
+\&      pthread_cond_init (&u\->invoke_cv, 0);
+\&
+\&      // now associate this with the loop
+\&      ev_set_userdata (EV_A_ u);
+\&      ev_set_invoke_pending_cb (EV_A_ l_invoke);
+\&      ev_set_loop_release_cb (EV_A_ l_release, l_acquire);
+\&
+\&      // then create the thread running ev_run
+\&      pthread_create (&u\->tid, 0, l_run, EV_A);
+\&   }
+.Ve
+.PP
+The callback for the \f(CW\*(C`ev_async\*(C'\fR watcher does nothing: the watcher is used
+solely to wake up the event loop so it takes notice of any new watchers
+that might have been added:
+.PP
+.Vb 5
+\&   static void
+\&   async_cb (EV_P_ ev_async *w, int revents)
+\&   {
+\&      // just used for the side effects
+\&   }
+.Ve
+.PP
+The \f(CW\*(C`l_release\*(C'\fR and \f(CW\*(C`l_acquire\*(C'\fR callbacks simply unlock/lock the mutex
+protecting the loop data, respectively.
+.PP
+.Vb 6
+\&   static void
+\&   l_release (EV_P)
+\&   {
+\&     userdata *u = ev_userdata (EV_A);
+\&     pthread_mutex_unlock (&u\->lock);
+\&   }
+\&
+\&   static void
+\&   l_acquire (EV_P)
+\&   {
+\&     userdata *u = ev_userdata (EV_A);
+\&     pthread_mutex_lock (&u\->lock);
+\&   }
+.Ve
+.PP
+The event loop thread first acquires the mutex, and then jumps straight
+into \f(CW\*(C`ev_run\*(C'\fR:
+.PP
+.Vb 4
+\&   void *
+\&   l_run (void *thr_arg)
+\&   {
+\&     struct ev_loop *loop = (struct ev_loop *)thr_arg;
+\&
+\&     l_acquire (EV_A);
+\&     pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0);
+\&     ev_run (EV_A_ 0);
+\&     l_release (EV_A);
+\&
+\&     return 0;
+\&   }
+.Ve
+.PP
+Instead of invoking all pending watchers, the \f(CW\*(C`l_invoke\*(C'\fR callback will
+signal the main thread via some unspecified mechanism (signals? pipe
+writes? \f(CW\*(C`Async::Interrupt\*(C'\fR?) and then waits until all pending watchers
+have been called (in a while loop because a) spurious wakeups are possible
+and b) skipping inter-thread-communication when there are no pending
+watchers is very beneficial):
+.PP
+.Vb 4
+\&   static void
+\&   l_invoke (EV_P)
+\&   {
+\&     userdata *u = ev_userdata (EV_A);
+\&
+\&     while (ev_pending_count (EV_A))
+\&       {
+\&         wake_up_other_thread_in_some_magic_or_not_so_magic_way ();
+\&         pthread_cond_wait (&u\->invoke_cv, &u\->lock);
+\&       }
+\&   }
+.Ve
+.PP
+Now, whenever the main thread gets told to invoke pending watchers, it
+will grab the lock, call \f(CW\*(C`ev_invoke_pending\*(C'\fR and then signal the loop
+thread to continue:
+.PP
+.Vb 4
+\&   static void
+\&   real_invoke_pending (EV_P)
+\&   {
+\&     userdata *u = ev_userdata (EV_A);
+\&
+\&     pthread_mutex_lock (&u\->lock);
+\&     ev_invoke_pending (EV_A);
+\&     pthread_cond_signal (&u\->invoke_cv);
+\&     pthread_mutex_unlock (&u\->lock);
+\&   }
+.Ve
+.PP
+Whenever you want to start/stop a watcher or do other modifications to an
+event loop, you will now have to lock:
+.PP
+.Vb 2
+\&   ev_timer timeout_watcher;
+\&   userdata *u = ev_userdata (EV_A);
+\&
+\&   ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.);
+\&
+\&   pthread_mutex_lock (&u\->lock);
+\&   ev_timer_start (EV_A_ &timeout_watcher);
+\&   ev_async_send (EV_A_ &u\->async_w);
+\&   pthread_mutex_unlock (&u\->lock);
+.Ve
+.PP
+Note that sending the \f(CW\*(C`ev_async\*(C'\fR watcher is required because otherwise
+an event loop currently blocking in the kernel will have no knowledge
+about the newly added timer. By waking up the loop it will pick up any new
+watchers in the next event loop iteration.
+.SS "\s-1THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS\s0"
+.IX Subsection "THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS"
+While the overhead of a callback that e.g. schedules a thread is small, it
+is still an overhead. If you embed libev, and your main usage is with some
+kind of threads or coroutines, you might want to customise libev so that
+doesn't need callbacks anymore.
+.PP
+Imagine you have coroutines that you can switch to using a function
+\&\f(CW\*(C`switch_to (coro)\*(C'\fR, that libev runs in a coroutine called \f(CW\*(C`libev_coro\*(C'\fR
+and that due to some magic, the currently active coroutine is stored in a
+global called \f(CW\*(C`current_coro\*(C'\fR. Then you can build your own \*(L"wait for libev
+event\*(R" primitive by changing \f(CW\*(C`EV_CB_DECLARE\*(C'\fR and \f(CW\*(C`EV_CB_INVOKE\*(C'\fR (note
+the differing \f(CW\*(C`;\*(C'\fR conventions):
+.PP
+.Vb 2
+\&   #define EV_CB_DECLARE(type)   struct my_coro *cb;
+\&   #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb)
+.Ve
+.PP
+That means instead of having a C callback function, you store the
+coroutine to switch to in each watcher, and instead of having libev call
+your callback, you instead have it switch to that coroutine.
+.PP
+A coroutine might now wait for an event with a function called
+\&\f(CW\*(C`wait_for_event\*(C'\fR. (the watcher needs to be started, as always, but it doesn't
+matter when, or whether the watcher is active or not when this function is
+called):
+.PP
+.Vb 6
+\&   void
+\&   wait_for_event (ev_watcher *w)
+\&   {
+\&     ev_set_cb (w, current_coro);
+\&     switch_to (libev_coro);
+\&   }
+.Ve
+.PP
+That basically suspends the coroutine inside \f(CW\*(C`wait_for_event\*(C'\fR and
+continues the libev coroutine, which, when appropriate, switches back to
+this or any other coroutine.
+.PP
+You can do similar tricks if you have, say, threads with an event queue \-
+instead of storing a coroutine, you store the queue object and instead of
+switching to a coroutine, you push the watcher onto the queue and notify
+any waiters.
+.PP
+To embed libev, see \*(L"\s-1EMBEDDING\*(R"\s0, but in short, it's easiest to create two
+files, \fImy_ev.h\fR and \fImy_ev.c\fR that include the respective libev files:
+.PP
+.Vb 4
+\&   // my_ev.h
+\&   #define EV_CB_DECLARE(type)   struct my_coro *cb;
+\&   #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb)
+\&   #include "../libev/ev.h"
+\&
+\&   // my_ev.c
+\&   #define EV_H "my_ev.h"
+\&   #include "../libev/ev.c"
+.Ve
+.PP
+And then use \fImy_ev.h\fR when you would normally use \fIev.h\fR, and compile
+\&\fImy_ev.c\fR into your project. When properly specifying include paths, you
+can even use \fIev.h\fR as header file name directly.
 .SH "LIBEVENT EMULATION"
 .IX Header "LIBEVENT EMULATION"
 Libev offers a compatibility emulation layer for libevent. It cannot
 emulate the internals of libevent, so here are some usage hints:
+.IP "\(bu" 4
+Only the libevent\-1.4.1\-beta \s-1API\s0 is being emulated.
+.Sp
+This was the newest libevent version available when libev was implemented,
+and is still mostly unchanged in 2010.
 .IP "\(bu" 4
 Use it by including <event.h>, as usual.
 .IP "\(bu" 4
 The following members are fully supported: ev_base, ev_callback,
 ev_arg, ev_fd, ev_res, ev_events.
 Priorities are not currently supported. Initialising priorities
 will fail and all watchers will have the same priority, even though there
 is an ev_pri field.
 .IP "\(bu" 4
 In libevent, the last base created gets the signals, in libev, the
-first base created (== the default loop) gets the signals.
+base that registered the signal gets the signals.
 .IP "\(bu" 4
 Other members are not supported.
 .IP "\(bu" 4
 The libev emulation is \fInot\fR \s-1ABI\s0 compatible to libevent, you need
 to use the libev header file and library.
 .SH "\*(C+ SUPPORT"
 .IX Header " SUPPORT"
+.SS "C \s-1API\s0"
+.IX Subsection "C API"
+The normal C \s-1API\s0 should work fine when used from \*(C+: both ev.h and the
+libev sources can be compiled as \*(C+. Therefore, code that uses the C \s-1API\s0
+will work fine.
+.PP
+Proper exception specifications might have to be added to callbacks passed
+to libev: exceptions may be thrown only from watcher callbacks, all
+other callbacks (allocator, syserr, loop acquire/release and periodic
+reschedule callbacks) must not throw exceptions, and might need a \f(CW\*(C`throw
+()\*(C'\fR specification. If you have code that needs to be compiled as both C
+and \*(C+ you can use the \f(CW\*(C`EV_THROW\*(C'\fR macro for this:
+.PP
+.Vb 6
+\&   static void
+\&   fatal_error (const char *msg) EV_THROW
+\&   {
+\&     perror (msg);
+\&     abort ();
+\&   }
+\&
+\&   ...
+\&   ev_set_syserr_cb (fatal_error);
+.Ve
+.PP
+The only \s-1API\s0 functions that can currently throw exceptions are \f(CW\*(C`ev_run\*(C'\fR,
+\&\f(CW\*(C`ev_invoke\*(C'\fR, \f(CW\*(C`ev_invoke_pending\*(C'\fR and \f(CW\*(C`ev_loop_destroy\*(C'\fR (the latter
+because it runs cleanup watchers).
+.PP
+Throwing exceptions in watcher callbacks is only supported if libev itself
+is compiled with a \*(C+ compiler or your C and \*(C+ environments allow
+throwing exceptions through C libraries (most do).
+.SS "\*(C+ \s-1API\s0"
+.IX Subsection " API"
 Libev comes with some simplistic wrapper classes for \*(C+ that mainly allow
 you to use some convenience methods to start/stop watchers and also change
 the callback model to a model using method callbacks on objects.
 .PP
 To use it,
 Care has been taken to keep the overhead low. The only data member the \*(C+
 classes add (compared to plain C\-style watchers) is the event loop pointer
 that the watcher is associated with (or no additional members at all if
 you disable \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR when embedding libev).
 .PP
-Currently, functions, and static and non-static member functions can be
+Currently, functions, static and non-static member functions and classes
-used as callbacks. Other types should be easy to add as long as they only
+with \f(CW\*(C`operator ()\*(C'\fR can be used as callbacks. Other types should be easy
-need one additional pointer for context. If you need support for other
+to add as long as they only need one additional pointer for context. If
-types of functors please contact the author (preferably after implementing
+you need support for other types of functors please contact the author
-it).
+(preferably after implementing it).
+.PP
+For all this to work, your \*(C+ compiler either has to use the same calling
+conventions as your C compiler (for static member functions), or you have
+to embed libev and compile libev itself as \*(C+.
 .PP
 Here is a list of things available in the \f(CW\*(C`ev\*(C'\fR namespace:
 .ie n .IP """ev::READ"", ""ev::WRITE"" etc." 4
 .el .IP "\f(CWev::READ\fR, \f(CWev::WRITE\fR etc." 4
 .IX Item "ev::READ, ev::WRITE etc."
 .el .IP "\f(CWev::io\fR, \f(CWev::timer\fR, \f(CWev::periodic\fR, \f(CWev::idle\fR, \f(CWev::sig\fR etc." 4
 .IX Item "ev::io, ev::timer, ev::periodic, ev::idle, ev::sig etc."
 For each \f(CW\*(C`ev_TYPE\*(C'\fR watcher in \fIev.h\fR there is a corresponding class of
 the same name in the \f(CW\*(C`ev\*(C'\fR namespace, with the exception of \f(CW\*(C`ev_signal\*(C'\fR
 which is called \f(CW\*(C`ev::sig\*(C'\fR to avoid clashes with the \f(CW\*(C`signal\*(C'\fR macro
-defines by many implementations.
+defined by many implementations.
 .Sp
 All of those classes have these methods:
 .RS 4
 .IP "ev::TYPE::TYPE ()" 4
 .IX Item "ev::TYPE::TYPE ()"
 \&     void operator() (ev::io &w, int revents)
 \&     {
 \&       ...
 \&     }
 \&   }
 \&
 \&   myfunctor f;
 \&
 \&   ev::io w;
 \&   w.set (&f);
 .Ve
 .IX Item "w->set (loop)"
 Associates a different \f(CW\*(C`struct ev_loop\*(C'\fR with this watcher. You can only
 do this when the watcher is inactive (and not pending either).
 .IP "w\->set ([arguments])" 4
 .IX Item "w->set ([arguments])"
-Basically the same as \f(CW\*(C`ev_TYPE_set\*(C'\fR, with the same arguments. Either this
+Basically the same as \f(CW\*(C`ev_TYPE_set\*(C'\fR (except for \f(CW\*(C`ev::embed\*(C'\fR watchers>),
-method or a suitable start method must be called at least once. Unlike the
+with the same arguments. Either this method or a suitable start method
-C counterpart, an active watcher gets automatically stopped and restarted
+must be called at least once. Unlike the C counterpart, an active watcher
-when reconfiguring it with this method.
+gets automatically stopped and restarted when reconfiguring it with this
+method.
+.Sp
+For \f(CW\*(C`ev::embed\*(C'\fR watchers this method is called \f(CW\*(C`set_embed\*(C'\fR, to avoid
+clashing with the \f(CW\*(C`set (loop)\*(C'\fR method.
 .IP "w\->start ()" 4
 .IX Item "w->start ()"
 Starts the watcher. Note that there is no \f(CW\*(C`loop\*(C'\fR argument, as the
 constructor already stores the event loop.
 .IP "w\->start ([arguments])" 4
 .PP
 .Vb 5
 \&   class myclass
 \&   {
 \&     ev::io   io  ; void io_cb   (ev::io   &w, int revents);
-\&     ev::io2  io2 ; void io2_cb  (ev::io   &w, int revents);
+\&     ev::io   io2 ; void io2_cb  (ev::io   &w, int revents);
 \&     ev::idle idle; void idle_cb (ev::idle &w, int revents);
 \&
 \&     myclass (int fd)
 \&     {
 \&       io  .set <myclass, &myclass::io_cb  > (this);
 there are additional modules that implement libev-compatible interfaces
 to \f(CW\*(C`libadns\*(C'\fR (\f(CW\*(C`EV::ADNS\*(C'\fR, but \f(CW\*(C`AnyEvent::DNS\*(C'\fR is preferred nowadays),
 \&\f(CW\*(C`Net::SNMP\*(C'\fR (\f(CW\*(C`Net::SNMP::EV\*(C'\fR) and the \f(CW\*(C`libglib\*(C'\fR event core (\f(CW\*(C`Glib::EV\*(C'\fR
 and \f(CW\*(C`EV::Glib\*(C'\fR).
 .Sp
-It can be found and installed via \s-1CPAN\s0, its homepage is at
+It can be found and installed via \s-1CPAN,\s0 its homepage is at
 <http://software.schmorp.de/pkg/EV>.
 .IP "Python" 4
 .IX Item "Python"
 Python bindings can be found at <http://code.google.com/p/pyev/>. It
 seems to be quite complete and well-documented.
 A haskell binding to libev is available at
 <http://hackage.haskell.org/cgi\-bin/hackage\-scripts/package/hlibev>.
 .IP "D" 4
 .IX Item "D"
 Leandro Lucarella has written a D language binding (\fIev.d\fR) for libev, to
-be found at <http://proj.llucax.com.ar/wiki/evd>.
+be found at <http://www.llucax.com.ar/proj/ev.d/index.html>.
 .IP "Ocaml" 4
 .IX Item "Ocaml"
 Erkki Seppala has written Ocaml bindings for libev, to be found at
 <http://modeemi.cs.tut.fi/~flux/software/ocaml\-ev/>.
 .IP "Lua" 4
 .IX Item "Lua"
 Brian Maher has written a partial interface to libev for lua (at the
 time of this writing, only \f(CW\*(C`ev_io\*(C'\fR and \f(CW\*(C`ev_timer\*(C'\fR), to be found at
 <http://github.com/brimworks/lua\-ev>.
+.IP "Javascript" 4
+.IX Item "Javascript"
+Node.js (<http://nodejs.org>) uses libev as the underlying event library.
+.IP "Others" 4
+.IX Item "Others"
+There are others, and I stopped counting.
 .SH "MACRO MAGIC"
 .IX Header "MACRO MAGIC"
 Libev can be compiled with a variety of options, the most fundamental
 of which is \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR. This option determines whether (most)
 functions and callbacks have an initial \f(CW\*(C`struct ev_loop *\*(C'\fR argument.
 suitable for use with \f(CW\*(C`EV_A\*(C'\fR.
 .ie n .IP """EV_DEFAULT"", ""EV_DEFAULT_""" 4
 .el .IP "\f(CWEV_DEFAULT\fR, \f(CWEV_DEFAULT_\fR" 4
 .IX Item "EV_DEFAULT, EV_DEFAULT_"
 Similar to the other two macros, this gives you the value of the default
-loop, if multiple loops are supported (\*(L"ev loop default\*(R").
+loop, if multiple loops are supported (\*(L"ev loop default\*(R"). The default loop
+will be initialised if it isn't already initialised.
+.Sp
+For non-multiplicity builds, these macros do nothing, so you always have
+to initialise the loop somewhere.
 .ie n .IP """EV_DEFAULT_UC"", ""EV_DEFAULT_UC_""" 4
 .el .IP "\f(CWEV_DEFAULT_UC\fR, \f(CWEV_DEFAULT_UC_\fR" 4
 .IX Item "EV_DEFAULT_UC, EV_DEFAULT_UC_"
 Usage identical to \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR, but requires that the
 default loop has been initialised (\f(CW\*(C`UC\*(C'\fR == unchecked). Their behaviour
 .SS "\s-1FILESETS\s0"
 .IX Subsection "FILESETS"
 Depending on what features you need you need to include one or more sets of files
 in your application.
 .PP
-\fI\s-1CORE\s0 \s-1EVENT\s0 \s-1LOOP\s0\fR
+\fI\s-1CORE EVENT LOOP\s0\fR
 .IX Subsection "CORE EVENT LOOP"
 .PP
 To include only the libev core (all the \f(CW\*(C`ev_*\*(C'\fR functions), with manual
 configuration (no autoconf):
 .PP
 \&   #include "ev.c"
 .Ve
 .PP
 This will automatically include \fIev.h\fR, too, and should be done in a
 single C source file only to provide the function implementations. To use
-it, do the same for \fIev.h\fR in all files wishing to use this \s-1API\s0 (best
+it, do the same for \fIev.h\fR in all files wishing to use this \s-1API \s0(best
 done by writing a wrapper around \fIev.h\fR that you can include instead and
 where you can put other configuration options):
 .PP
 .Vb 2
 \&   #define EV_STANDALONE 1
 \&   ev_vars.h
 \&   ev_wrap.h
 \&
 \&   ev_win32.c      required on win32 platforms only
 \&
-\&   ev_select.c     only when select backend is enabled (which is enabled by default)
+\&   ev_select.c     only when select backend is enabled
-\&   ev_poll.c       only when poll backend is enabled (disabled by default)
+\&   ev_poll.c       only when poll backend is enabled
-\&   ev_epoll.c      only when the epoll backend is enabled (disabled by default)
+\&   ev_epoll.c      only when the epoll backend is enabled
-\&   ev_kqueue.c     only when the kqueue backend is enabled (disabled by default)
+\&   ev_kqueue.c     only when the kqueue backend is enabled
-\&   ev_port.c       only when the solaris port backend is enabled (disabled by default)
+\&   ev_port.c       only when the solaris port backend is enabled
 .Ve
 .PP
 \&\fIev.c\fR includes the backend files directly when enabled, so you only need
 to compile this single file.
 .PP
-\fI\s-1LIBEVENT\s0 \s-1COMPATIBILITY\s0 \s-1API\s0\fR
+\fI\s-1LIBEVENT COMPATIBILITY API\s0\fR
 .IX Subsection "LIBEVENT COMPATIBILITY API"
 .PP
-To include the libevent compatibility \s-1API\s0, also include:
+To include the libevent compatibility \s-1API,\s0 also include:
 .PP
 .Vb 1
 \&   #include "event.c"
 .Ve
 .PP
 .PP
 .Vb 1
 \&   #include "event.h"
 .Ve
 .PP
-in the files that want to use the libevent \s-1API\s0. This also includes \fIev.h\fR.
+in the files that want to use the libevent \s-1API.\s0 This also includes \fIev.h\fR.
 .PP
 You need the following additional files for this:
 .PP
 .Vb 2
 \&   event.h
 \&   event.c
 .Ve
 .PP
-\fI\s-1AUTOCONF\s0 \s-1SUPPORT\s0\fR
+\fI\s-1AUTOCONF SUPPORT\s0\fR
 .IX Subsection "AUTOCONF SUPPORT"
 .PP
 Instead of using \f(CW\*(C`EV_STANDALONE=1\*(C'\fR and providing your configuration in
 whatever way you want, you can also \f(CW\*(C`m4_include([libev.m4])\*(C'\fR in your
 \&\fIconfigure.ac\fR and leave \f(CW\*(C`EV_STANDALONE\*(C'\fR undefined. \fIev.c\fR will then
 For this of course you need the m4 file:
 .PP
 .Vb 1
 \&   libev.m4
 .Ve
-.SS "\s-1PREPROCESSOR\s0 \s-1SYMBOLS/MACROS\s0"
+.SS "\s-1PREPROCESSOR SYMBOLS/MACROS\s0"
 .IX Subsection "PREPROCESSOR SYMBOLS/MACROS"
 Libev can be configured via a variety of preprocessor symbols you have to
 define before including (or compiling) any of its files. The default in
 the absence of autoconf is documented for every option.
 .PP
-Symbols marked with \*(L"(h)\*(R" do not change the \s-1ABI\s0, and can have different
+Symbols marked with \*(L"(h)\*(R" do not change the \s-1ABI,\s0 and can have different
 values when compiling libev vs. including \fIev.h\fR, so it is permissible
 to redefine them before including \fIev.h\fR without breaking compatibility
-to a compiled library. All other symbols change the \s-1ABI\s0, which means all
+to a compiled library. All other symbols change the \s-1ABI,\s0 which means all
 users of libev and the libev code itself must be compiled with compatible
 settings.
-.IP "\s-1EV_COMPAT3\s0 (h)" 4
+.IP "\s-1EV_COMPAT3 \s0(h)" 4
 .IX Item "EV_COMPAT3 (h)"
 Backwards compatibility is a major concern for libev. This is why this
 release of libev comes with wrappers for the functions and symbols that
 have been renamed between libev version 3 and 4.
 .Sp
 typedef in that case.
 .Sp
 In some future version, the default for \f(CW\*(C`EV_COMPAT3\*(C'\fR will become \f(CW0\fR,
 and in some even more future version the compatibility code will be
 removed completely.
-.IP "\s-1EV_STANDALONE\s0 (h)" 4
+.IP "\s-1EV_STANDALONE \s0(h)" 4
 .IX Item "EV_STANDALONE (h)"
 Must always be \f(CW1\fR if you do not use autoconf configuration, which
 keeps libev from including \fIconfig.h\fR, and it also defines dummy
 implementations for some libevent functions (such as logging, which is not
 supported). It will also not define any of the structs usually found in
 \&\fIevent.h\fR that are not directly supported by the libev core alone.
 .Sp
 In standalone mode, libev will still try to automatically deduce the
 configuration, but has to be more conservative.
+.IP "\s-1EV_USE_FLOOR\s0" 4
+.IX Item "EV_USE_FLOOR"
+If defined to be \f(CW1\fR, libev will use the \f(CW\*(C`floor ()\*(C'\fR function for its
+periodic reschedule calculations, otherwise libev will fall back on a
+portable (slower) implementation. If you enable this, you usually have to
+link against libm or something equivalent. Enabling this when the \f(CW\*(C`floor\*(C'\fR
+function is not available will fail, so the safe default is to not enable
+this.
 .IP "\s-1EV_USE_MONOTONIC\s0" 4
 .IX Item "EV_USE_MONOTONIC"
 If defined to be \f(CW1\fR, libev will try to detect the availability of the
 monotonic clock option at both compile time and runtime. Otherwise no
 use of the monotonic clock option will be attempted. If you enable this,
 .IX Item "EV_WIN32_CLOSE_FD(fd)"
 If programs implement their own fd to handle mapping on win32, then this
 macro can be used to override the \f(CW\*(C`close\*(C'\fR function, useful to unregister
 file descriptors again. Note that the replacement function has to close
 the underlying \s-1OS\s0 handle.
+.IP "\s-1EV_USE_WSASOCKET\s0" 4
+.IX Item "EV_USE_WSASOCKET"
+If defined to be \f(CW1\fR, libev will use \f(CW\*(C`WSASocket\*(C'\fR to create its internal
+communication socket, which works better in some environments. Otherwise,
+the normal \f(CW\*(C`socket\*(C'\fR function will be used, which works better in other
+environments.
 .IP "\s-1EV_USE_POLL\s0" 4
 .IX Item "EV_USE_POLL"
 If defined to be \f(CW1\fR, libev will compile in support for the \f(CW\*(C`poll\*(C'\fR(2)
 backend. Otherwise it will be enabled on non\-win32 platforms. It
 takes precedence over select.
 .IX Item "EV_USE_INOTIFY"
 If defined to be \f(CW1\fR, libev will compile in support for the Linux inotify
 interface to speed up \f(CW\*(C`ev_stat\*(C'\fR watchers. Its actual availability will
 be detected at runtime. If undefined, it will be enabled if the headers
 indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
+.IP "\s-1EV_NO_SMP\s0" 4
+.IX Item "EV_NO_SMP"
+If defined to be \f(CW1\fR, libev will assume that memory is always coherent
+between threads, that is, threads can be used, but threads never run on
+different cpus (or different cpu cores). This reduces dependencies
+and makes libev faster.
+.IP "\s-1EV_NO_THREADS\s0" 4
+.IX Item "EV_NO_THREADS"
+If defined to be \f(CW1\fR, libev will assume that it will never be called from
+different threads (that includes signal handlers), which is a stronger
+assumption than \f(CW\*(C`EV_NO_SMP\*(C'\fR, above. This reduces dependencies and makes
+libev faster.
 .IP "\s-1EV_ATOMIC_T\s0" 4
 .IX Item "EV_ATOMIC_T"
 Libev requires an integer type (suitable for storing \f(CW0\fR or \f(CW1\fR) whose
-access is atomic with respect to other threads or signal contexts. No such
+access is atomic with respect to other threads or signal contexts. No
-type is easily found in the C language, so you can provide your own type
+such type is easily found in the C language, so you can provide your own
-that you know is safe for your purposes. It is used both for signal handler \*(L"locking\*(R"
+type that you know is safe for your purposes. It is used both for signal
-as well as for signal and thread safety in \f(CW\*(C`ev_async\*(C'\fR watchers.
+handler \*(L"locking\*(R" as well as for signal and thread safety in \f(CW\*(C`ev_async\*(C'\fR
+watchers.
 .Sp
 In the absence of this define, libev will use \f(CW\*(C`sig_atomic_t volatile\*(C'\fR
 (from \fIsignal.h\fR), which is usually good enough on most platforms.
-.IP "\s-1EV_H\s0 (h)" 4
+.IP "\s-1EV_H \s0(h)" 4
 .IX Item "EV_H (h)"
 The name of the \fIev.h\fR header file used to include it. The default if
 undefined is \f(CW"ev.h"\fR in \fIevent.h\fR, \fIev.c\fR and \fIev++.h\fR. This can be
 used to virtually rename the \fIev.h\fR header file in case of conflicts.
-.IP "\s-1EV_CONFIG_H\s0 (h)" 4
+.IP "\s-1EV_CONFIG_H \s0(h)" 4
 .IX Item "EV_CONFIG_H (h)"
 If \f(CW\*(C`EV_STANDALONE\*(C'\fR isn't \f(CW1\fR, this variable can be used to override
 \&\fIev.c\fR's idea of where to find the \fIconfig.h\fR file, similarly to
 \&\f(CW\*(C`EV_H\*(C'\fR, above.
-.IP "\s-1EV_EVENT_H\s0 (h)" 4
+.IP "\s-1EV_EVENT_H \s0(h)" 4
 .IX Item "EV_EVENT_H (h)"
 Similarly to \f(CW\*(C`EV_H\*(C'\fR, this macro can be used to override \fIevent.c\fR's idea
 of how the \fIevent.h\fR header can be found, the default is \f(CW"event.h"\fR.
-.IP "\s-1EV_PROTOTYPES\s0 (h)" 4
+.IP "\s-1EV_PROTOTYPES \s0(h)" 4
 .IX Item "EV_PROTOTYPES (h)"
 If defined to be \f(CW0\fR, then \fIev.h\fR will not define any function
 prototypes, but still define all the structs and other symbols. This is
 occasionally useful if you want to provide your own wrapper functions
 around libev functions.
 If undefined or defined to \f(CW1\fR, then all event-loop-specific functions
 will have the \f(CW\*(C`struct ev_loop *\*(C'\fR as first argument, and you can create
 additional independent event loops. Otherwise there will be no support
 for multiple event loops and there is no first event loop pointer
 argument. Instead, all functions act on the single default loop.
+.Sp
+Note that \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR will no longer provide a
+default loop when multiplicity is switched off \- you always have to
+initialise the loop manually in this case.
 .IP "\s-1EV_MINPRI\s0" 4
 .IX Item "EV_MINPRI"
 .PD 0
 .IP "\s-1EV_MAXPRI\s0" 4
 .IX Item "EV_MAXPRI"
 all the priorities, so having many of them (hundreds) uses a lot of space
 and time, so using the defaults of five priorities (\-2 .. +2) is usually
 fine.
 .Sp
 If your embedding application does not need any priorities, defining these
-both to \f(CW0\fR will save some memory and \s-1CPU\s0.
+both to \f(CW0\fR will save some memory and \s-1CPU.\s0
-.IP "\s-1EV_PERIODIC_ENABLE\s0, \s-1EV_IDLE_ENABLE\s0, \s-1EV_EMBED_ENABLE\s0, \s-1EV_STAT_ENABLE\s0, \s-1EV_PREPARE_ENABLE\s0, \s-1EV_CHECK_ENABLE\s0, \s-1EV_FORK_ENABLE\s0, \s-1EV_SIGNAL_ENABLE\s0, \s-1EV_ASYNC_ENABLE\s0, \s-1EV_CHILD_ENABLE\s0." 4
+.IP "\s-1EV_PERIODIC_ENABLE, EV_IDLE_ENABLE, EV_EMBED_ENABLE, EV_STAT_ENABLE, EV_PREPARE_ENABLE, EV_CHECK_ENABLE, EV_FORK_ENABLE, EV_SIGNAL_ENABLE, EV_ASYNC_ENABLE, EV_CHILD_ENABLE.\s0" 4
 .IX Item "EV_PERIODIC_ENABLE, EV_IDLE_ENABLE, EV_EMBED_ENABLE, EV_STAT_ENABLE, EV_PREPARE_ENABLE, EV_CHECK_ENABLE, EV_FORK_ENABLE, EV_SIGNAL_ENABLE, EV_ASYNC_ENABLE, EV_CHILD_ENABLE."
 If undefined or defined to be \f(CW1\fR (and the platform supports it), then
 the respective watcher type is supported. If defined to be \f(CW0\fR, then it
 is not. Disabling watcher types mainly saves code size.
 .IP "\s-1EV_FEATURES\s0" 4
 \&   #define EV_CHILD_ENABLE 1
 \&   #define EV_ASYNC_ENABLE 1
 .Ve
 .Sp
 The actual value is a bitset, it can be a combination of the following
-values:
+values (by default, all of these are enabled):
 .RS 4
 .ie n .IP "1 \- faster/larger code" 4
 .el .IP "\f(CW1\fR \- faster/larger code" 4
 .IX Item "1 - faster/larger code"
 Use larger code to speed up some operations.
 code size by roughly 30% on amd64).
 .Sp
 When optimising for size, use of compiler flags such as \f(CW\*(C`\-Os\*(C'\fR with
 gcc is recommended, as well as \f(CW\*(C`\-DNDEBUG\*(C'\fR, as libev contains a number of
 assertions.
+.Sp
+The default is off when \f(CW\*(C`_\|_OPTIMIZE_SIZE_\|_\*(C'\fR is defined by your compiler
+(e.g. gcc with \f(CW\*(C`\-Os\*(C'\fR).
 .ie n .IP "2 \- faster/larger data structures" 4
 .el .IP "\f(CW2\fR \- faster/larger data structures" 4
 .IX Item "2 - faster/larger data structures"
 Replaces the small 2\-heap for timer management by a faster 4\-heap, larger
 hash table sizes and so on. This will usually further increase code size
 and can additionally have an effect on the size of data structures at
 runtime.
+.Sp
+The default is off when \f(CW\*(C`_\|_OPTIMIZE_SIZE_\|_\*(C'\fR is defined by your compiler
+(e.g. gcc with \f(CW\*(C`\-Os\*(C'\fR).
 .ie n .IP "4 \- full \s-1API\s0 configuration" 4
 .el .IP "\f(CW4\fR \- full \s-1API\s0 configuration" 4
 .IX Item "4 - full API configuration"
 This enables priorities (sets \f(CW\*(C`EV_MAXPRI\*(C'\fR=2 and \f(CW\*(C`EV_MINPRI\*(C'\fR=\-2), and
 enables multiplicity (\f(CW\*(C`EV_MULTIPLICITY\*(C'\fR=1).
 With an intelligent-enough linker (gcc+binutils are intelligent enough
 when you use \f(CW\*(C`\-Wl,\-\-gc\-sections \-ffunction\-sections\*(C'\fR) functions unused by
 your program might be left out as well \- a binary starting a timer and an
 I/O watcher then might come out at only 5Kb.
 .RE
+.IP "\s-1EV_API_STATIC\s0" 4
+.IX Item "EV_API_STATIC"
+If this symbol is defined (by default it is not), then all identifiers
+will have static linkage. This means that libev will not export any
+identifiers, and you cannot link against libev anymore. This can be useful
+when you embed libev, only want to use libev functions in a single file,
+and do not want its identifiers to be visible.
+.Sp
+To use this, define \f(CW\*(C`EV_API_STATIC\*(C'\fR and include \fIev.c\fR in the file that
+wants to use libev.
+.Sp
+This option only works when libev is compiled with a C compiler, as \*(C+
+doesn't support the required declaration syntax.
 .IP "\s-1EV_AVOID_STDIO\s0" 4
 .IX Item "EV_AVOID_STDIO"
 If this is set to \f(CW1\fR at compiletime, then libev will avoid using stdio
 functions (printf, scanf, perror etc.). This will increase the code size
 somewhat, but if your program doesn't otherwise depend on stdio and your
 .Vb 3
 \&   #define EV_COMMON                       \e
 \&     SV *self; /* contains this struct */  \e
 \&     SV *cb_sv, *fh /* note no trailing ";" */
 .Ve
-.IP "\s-1EV_CB_DECLARE\s0 (type)" 4
+.IP "\s-1EV_CB_DECLARE \s0(type)" 4
 .IX Item "EV_CB_DECLARE (type)"
 .PD 0
-.IP "\s-1EV_CB_INVOKE\s0 (watcher, revents)" 4
+.IP "\s-1EV_CB_INVOKE \s0(watcher, revents)" 4
 .IX Item "EV_CB_INVOKE (watcher, revents)"
 .IP "ev_set_cb (ev, cb)" 4
 .IX Item "ev_set_cb (ev, cb)"
 .PD
 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 \fIev.h\fR header file for
 their default definitions. One possible use for overriding these is to
 avoid the \f(CW\*(C`struct ev_loop *\*(C'\fR as first argument in all cases, or to use
 method calls instead of plain function calls in \*(C+.
-.SS "\s-1EXPORTED\s0 \s-1API\s0 \s-1SYMBOLS\s0"
+.SS "\s-1EXPORTED API SYMBOLS\s0"
 .IX Subsection "EXPORTED API SYMBOLS"
-If you need to re-export the \s-1API\s0 (e.g. via a \s-1DLL\s0) and you need a list of
+If you need to re-export the \s-1API \s0(e.g. via a \s-1DLL\s0) and you need a list of
 exported symbols, you can use the provided \fISymbol.*\fR files which list
 all public symbols, one per line:
 .PP
 .Vb 2
 \&   Symbols.ev      for libev proper
 .PP
 .Vb 2
 \&   #include "ev_cpp.h"
 \&   #include "ev.c"
 .Ve
-.SH "INTERACTION WITH OTHER PROGRAMS OR LIBRARIES"
+.SH "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT"
-.IX Header "INTERACTION WITH OTHER PROGRAMS OR LIBRARIES"
+.IX Header "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT"
-.SS "\s-1THREADS\s0 \s-1AND\s0 \s-1COROUTINES\s0"
+.SS "\s-1THREADS AND COROUTINES\s0"
 .IX Subsection "THREADS AND COROUTINES"
 \fI\s-1THREADS\s0\fR
 .IX Subsection "THREADS"
 .PP
 All libev functions are reentrant and thread-safe unless explicitly
 An example use would be to communicate signals or other events that only
 work in the default loop by registering the signal watcher with the
 default loop and triggering an \f(CW\*(C`ev_async\*(C'\fR watcher from the default loop
 watcher callback into the event loop interested in the signal.
 .PP
-\s-1THREAD\s0 \s-1LOCKING\s0 \s-1EXAMPLE\s0
+See also \*(L"\s-1THREAD LOCKING EXAMPLE\*(R"\s0.
-.IX Subsection "THREAD LOCKING EXAMPLE"
-.PP
-Here is a fictitious example of how to run an event loop in a different
-thread than where callbacks are being invoked and watchers are
-created/added/removed.
-.PP
-For a real-world example, see the \f(CW\*(C`EV::Loop::Async\*(C'\fR perl module,
-which uses exactly this technique (which is suited for many high-level
-languages).
-.PP
-The example uses a pthread mutex to protect the loop data, a condition
-variable to wait for callback invocations, an async watcher to notify the
-event loop thread and an unspecified mechanism to wake up the main thread.
-.PP
-First, you need to associate some data with the event loop:
-.PP
-.Vb 6
-\&   typedef struct {
-\&     mutex_t lock; /* global loop lock */
-\&     ev_async async_w;
-\&     thread_t tid;
-\&     cond_t invoke_cv;
-\&   } userdata;
-\&
-\&   void prepare_loop (EV_P)
-\&   {
-\&      // for simplicity, we use a static userdata struct.
-\&      static userdata u;
-\&
-\&      ev_async_init (&u\->async_w, async_cb);
-\&      ev_async_start (EV_A_ &u\->async_w);
-\&
-\&      pthread_mutex_init (&u\->lock, 0);
-\&      pthread_cond_init (&u\->invoke_cv, 0);
-\&
-\&      // now associate this with the loop
-\&      ev_set_userdata (EV_A_ u);
-\&      ev_set_invoke_pending_cb (EV_A_ l_invoke);
-\&      ev_set_loop_release_cb (EV_A_ l_release, l_acquire);
-\&
-\&      // then create the thread running ev_loop
-\&      pthread_create (&u\->tid, 0, l_run, EV_A);
-\&   }
-.Ve
-.PP
-The callback for the \f(CW\*(C`ev_async\*(C'\fR watcher does nothing: the watcher is used
-solely to wake up the event loop so it takes notice of any new watchers
-that might have been added:
-.PP
-.Vb 5
-\&   static void
-\&   async_cb (EV_P_ ev_async *w, int revents)
-\&   {
-\&      // just used for the side effects
-\&   }
-.Ve
-.PP
-The \f(CW\*(C`l_release\*(C'\fR and \f(CW\*(C`l_acquire\*(C'\fR callbacks simply unlock/lock the mutex
-protecting the loop data, respectively.
-.PP
-.Vb 6
-\&   static void
-\&   l_release (EV_P)
-\&   {
-\&     userdata *u = ev_userdata (EV_A);
-\&     pthread_mutex_unlock (&u\->lock);
-\&   }
-\&
-\&   static void
-\&   l_acquire (EV_P)
-\&   {
-\&     userdata *u = ev_userdata (EV_A);
-\&     pthread_mutex_lock (&u\->lock);
-\&   }
-.Ve
-.PP
-The event loop thread first acquires the mutex, and then jumps straight
-into \f(CW\*(C`ev_run\*(C'\fR:
-.PP
-.Vb 4
-\&   void *
-\&   l_run (void *thr_arg)
-\&   {
-\&     struct ev_loop *loop = (struct ev_loop *)thr_arg;
-\&
-\&     l_acquire (EV_A);
-\&     pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0);
-\&     ev_run (EV_A_ 0);
-\&     l_release (EV_A);
-\&
-\&     return 0;
-\&   }
-.Ve
-.PP
-Instead of invoking all pending watchers, the \f(CW\*(C`l_invoke\*(C'\fR callback will
-signal the main thread via some unspecified mechanism (signals? pipe
-writes? \f(CW\*(C`Async::Interrupt\*(C'\fR?) and then waits until all pending watchers
-have been called (in a while loop because a) spurious wakeups are possible
-and b) skipping inter-thread-communication when there are no pending
-watchers is very beneficial):
-.PP
-.Vb 4
-\&   static void
-\&   l_invoke (EV_P)
-\&   {
-\&     userdata *u = ev_userdata (EV_A);
-\&
-\&     while (ev_pending_count (EV_A))
-\&       {
-\&         wake_up_other_thread_in_some_magic_or_not_so_magic_way ();
-\&         pthread_cond_wait (&u\->invoke_cv, &u\->lock);
-\&       }
-\&   }
-.Ve
-.PP
-Now, whenever the main thread gets told to invoke pending watchers, it
-will grab the lock, call \f(CW\*(C`ev_invoke_pending\*(C'\fR and then signal the loop
-thread to continue:
-.PP
-.Vb 4
-\&   static void
-\&   real_invoke_pending (EV_P)
-\&   {
-\&     userdata *u = ev_userdata (EV_A);
-\&
-\&     pthread_mutex_lock (&u\->lock);
-\&     ev_invoke_pending (EV_A);
-\&     pthread_cond_signal (&u\->invoke_cv);
-\&     pthread_mutex_unlock (&u\->lock);
-\&   }
-.Ve
-.PP
-Whenever you want to start/stop a watcher or do other modifications to an
-event loop, you will now have to lock:
-.PP
-.Vb 2
-\&   ev_timer timeout_watcher;
-\&   userdata *u = ev_userdata (EV_A);
-\&
-\&   ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.);
-\&
-\&   pthread_mutex_lock (&u\->lock);
-\&   ev_timer_start (EV_A_ &timeout_watcher);
-\&   ev_async_send (EV_A_ &u\->async_w);
-\&   pthread_mutex_unlock (&u\->lock);
-.Ve
-.PP
-Note that sending the \f(CW\*(C`ev_async\*(C'\fR watcher is required because otherwise
-an event loop currently blocking in the kernel will have no knowledge
-about the newly added timer. By waking up the loop it will pick up any new
-watchers in the next event loop iteration.
 .PP
 \fI\s-1COROUTINES\s0\fR
 .IX Subsection "COROUTINES"
 .PP
 Libev is very accommodating to coroutines (\*(L"cooperative threads\*(R"):
 that you must not do this from \f(CW\*(C`ev_periodic\*(C'\fR reschedule callbacks.
 .PP
 Care has been taken to ensure that libev does not keep local state inside
 \&\f(CW\*(C`ev_run\*(C'\fR, and other calls do not usually allow for coroutine switches as
 they do not call any callbacks.
-.SS "\s-1COMPILER\s0 \s-1WARNINGS\s0"
+.SS "\s-1COMPILER WARNINGS\s0"
 .IX Subsection "COMPILER WARNINGS"
 Depending on your compiler and compiler settings, you might get no or a
 lot of warnings when compiling libev code. Some people are apparently
 scared by this.
 .PP
 .PP
 If you need, for some reason, empty reports from valgrind for your project
 I suggest using suppression lists.
 .SH "PORTABILITY NOTES"
 .IX Header "PORTABILITY NOTES"
-.SS "\s-1GNU/LINUX\s0 32 \s-1BIT\s0 \s-1LIMITATIONS\s0"
+.SS "\s-1GNU/LINUX 32 BIT LIMITATIONS\s0"
 .IX Subsection "GNU/LINUX 32 BIT LIMITATIONS"
 GNU/Linux is the only common platform that supports 64 bit file/large file
 interfaces but \fIdisables\fR them by default.
 .PP
 That means that libev compiled in the default environment doesn't support
 files larger than 2GiB or so, which mainly affects \f(CW\*(C`ev_stat\*(C'\fR watchers.
 .PP
 Unfortunately, many programs try to work around this GNU/Linux issue
-by enabling the large file \s-1API\s0, which makes them incompatible with the
+by enabling the large file \s-1API,\s0 which makes them incompatible with the
 standard libev compiled for their system.
 .PP
 Likewise, libev cannot enable the large file \s-1API\s0 itself as this would
 suddenly make it incompatible to the default compile time environment,
 i.e. all programs not using special compile switches.
-.SS "\s-1OS/X\s0 \s-1AND\s0 \s-1DARWIN\s0 \s-1BUGS\s0"
+.SS "\s-1OS/X AND DARWIN BUGS\s0"
 .IX Subsection "OS/X AND DARWIN BUGS"
 The whole thing is a bug if you ask me \- basically any system interface
 you touch is broken, whether it is locales, poll, kqueue or even the
 OpenGL drivers.
 .PP
 .PP
 \fI\f(CI\*(C`select\*(C'\fI is buggy\fR
 .IX Subsection "select is buggy"
 .PP
 All that's left is \f(CW\*(C`select\*(C'\fR, and of course Apple found a way to fuck this
-one up as well: On \s-1OS/X\s0, \f(CW\*(C`select\*(C'\fR actively limits the number of file
+one up as well: On \s-1OS/X, \s0\f(CW\*(C`select\*(C'\fR actively limits the number of file
 descriptors you can pass in to 1024 \- your program suddenly crashes when
 you use more.
 .PP
 There is an undocumented \*(L"workaround\*(R" for this \- defining
 \&\f(CW\*(C`_DARWIN_UNLIMITED_SELECT\*(C'\fR, which libev tries to use, so select \fIshould\fR
-work on \s-1OS/X\s0.
+work on \s-1OS/X.\s0
-.SS "\s-1SOLARIS\s0 \s-1PROBLEMS\s0 \s-1AND\s0 \s-1WORKAROUNDS\s0"
+.SS "\s-1SOLARIS PROBLEMS AND WORKAROUNDS\s0"
 .IX Subsection "SOLARIS PROBLEMS AND WORKAROUNDS"
 \fI\f(CI\*(C`errno\*(C'\fI reentrancy\fR
 .IX Subsection "errno reentrancy"
 .PP
 The default compile environment on Solaris is unfortunately so
 great.
 .PP
 If you can't get it to work, you can try running the program by setting
 the environment variable \f(CW\*(C`LIBEV_FLAGS=3\*(C'\fR to only allow \f(CW\*(C`poll\*(C'\fR and
 \&\f(CW\*(C`select\*(C'\fR backends.
-.SS "\s-1AIX\s0 \s-1POLL\s0 \s-1BUG\s0"
+.SS "\s-1AIX POLL BUG\s0"
 .IX Subsection "AIX POLL BUG"
 \&\s-1AIX\s0 unfortunately has a broken \f(CW\*(C`poll.h\*(C'\fR header. Libev works around
 this by trying to avoid the poll backend altogether (i.e. it's not even
 compiled in), which normally isn't a big problem as \f(CW\*(C`select\*(C'\fR works fine
-with large bitsets on \s-1AIX\s0, and \s-1AIX\s0 is dead anyway.
+with large bitsets on \s-1AIX,\s0 and \s-1AIX\s0 is dead anyway.
-.SS "\s-1WIN32\s0 \s-1PLATFORM\s0 \s-1LIMITATIONS\s0 \s-1AND\s0 \s-1WORKAROUNDS\s0"
+.SS "\s-1WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS\s0"
 .IX Subsection "WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS"
 \fIGeneral issues\fR
 .IX Subsection "General issues"
 .PP
 Win32 doesn't support any of the standards (e.g. \s-1POSIX\s0) that libev
 requires, and its I/O model is fundamentally incompatible with the \s-1POSIX\s0
 model. Libev still offers limited functionality on this platform in
 the form of the \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR backend, and only supports socket
 descriptors. This only applies when using Win32 natively, not when using
 e.g. cygwin. Actually, it only applies to the microsofts own compilers,
-as every compielr comes with a slightly differently broken/incompatible
+as every compiler comes with a slightly differently broken/incompatible
 environment.
 .PP
 Lifting these limitations would basically require the full
 re-implementation of the I/O system. If you are into this kind of thing,
 then note that glib does exactly that for you in a very portable way (note
 \&   #define EV_USE_SELECT 1
 \&   #define EV_SELECT_IS_WINSOCKET 1   /* forces EV_SELECT_USE_FD_SET, too */
 .Ve
 .PP
 Note that winsockets handling of fd sets is O(n), so you can easily get a
-complexity in the O(nA\*^X) range when using win32.
+complexity in the O(nX) range when using win32.
 .PP
 \fILimited number of file descriptors\fR
 .IX Subsection "Limited number of file descriptors"
 .PP
 Windows has numerous arbitrary (and low) limits on things.
 by calling \f(CW\*(C`_setmaxstdio\*(C'\fR, which can increase this limit to \f(CW2048\fR
 (another arbitrary limit), but is broken in many versions of the Microsoft
 runtime libraries. This might get you to about \f(CW512\fR or \f(CW2048\fR sockets
 (depending on windows version and/or the phase of the moon). To get more,
 you need to wrap all I/O functions and provide your own fd management, but
-the cost of calling select (O(nA\*^X)) will likely make this unworkable.
+the cost of calling select (O(nX)) will likely make this unworkable.
-.SS "\s-1PORTABILITY\s0 \s-1REQUIREMENTS\s0"
+.SS "\s-1PORTABILITY REQUIREMENTS\s0"
 .IX Subsection "PORTABILITY REQUIREMENTS"
 In addition to a working ISO-C implementation and of course the
 backend-specific APIs, libev relies on a few additional extensions:
 .ie n .IP """void (*)(ev_watcher_type *, int revents)"" must have compatible calling conventions regardless of ""ev_watcher_type *""." 4
 .el .IP "\f(CWvoid (*)(ev_watcher_type *, int revents)\fR must have compatible calling conventions regardless of \f(CWev_watcher_type *\fR." 4
 .IX Item "void (*)(ev_watcher_type *, int revents) must have compatible calling conventions regardless of ev_watcher_type *."
 Libev assumes not only that all watcher pointers have the same internal
-structure (guaranteed by \s-1POSIX\s0 but not by \s-1ISO\s0 C for example), but it also
+structure (guaranteed by \s-1POSIX\s0 but not by \s-1ISO C\s0 for example), but it also
 assumes that the same (machine) code can be used to call any watcher
 callback: The watcher callbacks have different type signatures, but libev
 calls them using an \f(CW\*(C`ev_watcher *\*(C'\fR internally.
+.IP "null pointers and integer zero are represented by 0 bytes" 4
+.IX Item "null pointers and integer zero are represented by 0 bytes"
+Libev uses \f(CW\*(C`memset\*(C'\fR to initialise structs and arrays to \f(CW0\fR bytes, and
+relies on this setting pointers and integers to null.
 .IP "pointer accesses must be thread-atomic" 4
 .IX Item "pointer accesses must be thread-atomic"
 Accessing a pointer value must be atomic, it must both be readable and
 writable in one piece \- this is the case on all current architectures.
 .ie n .IP """sig_atomic_t volatile"" must be thread-atomic as well" 4
 thread\*(R" or will block signals process-wide, both behaviours would
 be compatible with libev. Interaction between \f(CW\*(C`sigprocmask\*(C'\fR and
 \&\f(CW\*(C`pthread_sigmask\*(C'\fR could complicate things, however.
 .Sp
 The most portable way to handle signals is to block signals in all threads
-except the initial one, and run the default loop in the initial thread as
+except the initial one, and run the signal handling loop in the initial
-well.
+thread as well.
 .ie n .IP """long"" must be large enough for common memory allocation sizes" 4
 .el .IP "\f(CWlong\fR must be large enough for common memory allocation sizes" 4
 .IX Item "long must be large enough for common memory allocation sizes"
-To improve portability and simplify its \s-1API\s0, libev uses \f(CW\*(C`long\*(C'\fR internally
+To improve portability and simplify its \s-1API,\s0 libev uses \f(CW\*(C`long\*(C'\fR internally
 instead of \f(CW\*(C`size_t\*(C'\fR when allocating its data structures. On non-POSIX
 systems (Microsoft...) this might be unexpectedly low, but is still at
 least 31 bits everywhere, which is enough for hundreds of millions of
 watchers.
 .ie n .IP """double"" must hold a time value in seconds with enough accuracy" 4
 .IX Item "double must hold a time value in seconds with enough accuracy"
 The type \f(CW\*(C`double\*(C'\fR is used to represent timestamps. It is required to
 have at least 51 bits of mantissa (and 9 bits of exponent), which is
 good enough for at least into the year 4000 with millisecond accuracy
 (the design goal for libev). This requirement is overfulfilled by
-implementations using \s-1IEEE\s0 754, which is basically all existing ones. With
+implementations using \s-1IEEE 754,\s0 which is basically all existing ones.
+.Sp
-\&\s-1IEEE\s0 754 doubles, you get microsecond accuracy until at least 2200.
+With \s-1IEEE 754\s0 doubles, you get microsecond accuracy until at least the
+year 2255 (and millisecond accuracy till the year 287396 \- by then, libev
+is either obsolete or somebody patched it to use \f(CW\*(C`long double\*(C'\fR or
+something like that, just kidding).
 .PP
 If you know of other additional requirements drop me a note.
 .SH "ALGORITHMIC COMPLEXITIES"
 .IX Header "ALGORITHMIC COMPLEXITIES"
 In this section the complexities of (many of) the algorithms used inside
 .IX Item "Processing ev_async_send: O(number_of_async_watchers)"
 .IP "Processing signals: O(max_signal_number)" 4
 .IX Item "Processing signals: O(max_signal_number)"
 .PD
 Sending involves a system call \fIiff\fR there were no other \f(CW\*(C`ev_async_send\*(C'\fR
-calls in the current loop iteration. Checking for async and signal events
+calls in the current loop iteration and the loop is currently
+blocked. Checking for async and signal events involves iterating over all
-involves iterating over all running async watchers or all signal numbers.
+running async watchers or all signal numbers.
 .SH "PORTING FROM LIBEV 3.X TO 4.X"
 .IX Header "PORTING FROM LIBEV 3.X TO 4.X"
-The major version 4 introduced some incompatible changes to the \s-1API\s0.
+The major version 4 introduced some incompatible changes to the \s-1API.\s0
 .PP
 At the moment, the \f(CW\*(C`ev.h\*(C'\fR header file provides compatibility definitions
 for all changes, so most programs should still compile. The compatibility
 layer might be removed in later versions of libev, so better update to the
 new \s-1API\s0 early than late.
 .ie n .IP """EV_COMPAT3"" backwards compatibility mechanism" 4
 .el .IP "\f(CWEV_COMPAT3\fR backwards compatibility mechanism" 4
 .IX Item "EV_COMPAT3 backwards compatibility mechanism"
 The backward compatibility mechanism can be controlled by
-\&\f(CW\*(C`EV_COMPAT3\*(C'\fR. See \*(L"\s-1MACROS\s0\*(R" in \s-1PREPROCESSOR\s0 \s-1SYMBOLS\s0 in the \s-1EMBEDDING\s0
+\&\f(CW\*(C`EV_COMPAT3\*(C'\fR. See \*(L"\s-1PREPROCESSOR SYMBOLS/MACROS\*(R"\s0 in the \*(L"\s-1EMBEDDING\*(R"\s0
 section.
 .ie n .IP """ev_default_destroy"" and ""ev_default_fork"" have been removed" 4
 .el .IP "\f(CWev_default_destroy\fR and \f(CWev_default_fork\fR have been removed" 4
 .IX Item "ev_default_destroy and ev_default_fork have been removed"
 These calls can be replaced easily by their \f(CW\*(C`ev_loop_xxx\*(C'\fR counterparts:
 .SH "GLOSSARY"
 .IX Header "GLOSSARY"
 .IP "active" 4
 .IX Item "active"
 A watcher is active as long as it has been started and not yet stopped.
-See \*(L"\s-1WATCHER\s0 \s-1STATES\s0\*(R" for details.
+See \*(L"\s-1WATCHER STATES\*(R"\s0 for details.
 .IP "application" 4
 .IX Item "application"
 In this document, an application is whatever is using libev.
 .IP "backend" 4
 .IX Item "backend"
 The model used to describe how an event loop handles and processes
 watchers and events.
 .IP "pending" 4
 .IX Item "pending"
 A watcher is pending as soon as the corresponding event has been
-detected. See \*(L"\s-1WATCHER\s0 \s-1STATES\s0\*(R" for details.
+detected. See \*(L"\s-1WATCHER STATES\*(R"\s0 for details.
 .IP "real time" 4
 .IX Item "real time"
 The physical time that is observed. It is apparently strictly monotonic :)
 .IP "wall-clock time" 4
 .IX Item "wall-clock time"
 The time and date as shown on clocks. Unlike real time, it can actually
-be wrong and jump forwards and backwards, e.g. when the you adjust your
+be wrong and jump forwards and backwards, e.g. when you adjust your
 clock.
 .IP "watcher" 4
 .IX Item "watcher"
 A data structure that describes interest in certain events. Watchers need
 to be started (attached to an event loop) before they can receive events.
 .SH "AUTHOR"
 .IX Header "AUTHOR"
 Marc Lehmann <libev@schmorp.de>, with repeated corrections by Mikael
-Magnusson and Emanuele Giaquinta.
+Magnusson and Emanuele Giaquinta, and minor corrections by many others.

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev.3 (file contents): Revision 1.82 by root, Mon Oct 25 10:50:13 2010 UTC vs. Revision 1.108 by root, Sat Jul 28 04:15:15 2018 UTC

Diff Legend

Comparing libev/ev.3 (file contents):
Revision 1.82 by root, Mon Oct 25 10:50:13 2010 UTC vs.
Revision 1.108 by root, Sat Jul 28 04:15:15 2018 UTC