jpayne@68: .\" Automatically generated by Pod::Man 4.11 (Pod::Simple 3.35) jpayne@68: .\" jpayne@68: .\" Standard preamble: jpayne@68: .\" ======================================================================== jpayne@68: .de Sp \" Vertical space (when we can't use .PP) jpayne@68: .if t .sp .5v jpayne@68: .if n .sp jpayne@68: .. jpayne@68: .de Vb \" Begin verbatim text jpayne@68: .ft CW jpayne@68: .nf jpayne@68: .ne \\$1 jpayne@68: .. jpayne@68: .de Ve \" End verbatim text jpayne@68: .ft R jpayne@68: .fi jpayne@68: .. jpayne@68: .\" Set up some character translations and predefined strings. \*(-- will jpayne@68: .\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left jpayne@68: .\" double quote, and \*(R" will give a right double quote. \*(C+ will jpayne@68: .\" give a nicer C++. Capital omega is used to do unbreakable dashes and jpayne@68: .\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff, jpayne@68: .\" nothing in troff, for use with C<>. jpayne@68: .tr \(*W- jpayne@68: .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p' jpayne@68: .ie n \{\ jpayne@68: . ds -- \(*W- jpayne@68: . ds PI pi jpayne@68: . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch jpayne@68: . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch jpayne@68: . ds L" "" jpayne@68: . ds R" "" jpayne@68: . ds C` "" jpayne@68: . ds C' "" jpayne@68: 'br\} jpayne@68: .el\{\ jpayne@68: . ds -- \|\(em\| jpayne@68: . ds PI \(*p jpayne@68: . ds L" `` jpayne@68: . ds R" '' jpayne@68: . ds C` jpayne@68: . ds C' jpayne@68: 'br\} jpayne@68: .\" jpayne@68: .\" Escape single quotes in literal strings from groff's Unicode transform. jpayne@68: .ie \n(.g .ds Aq \(aq jpayne@68: .el .ds Aq ' jpayne@68: .\" jpayne@68: .\" If the F register is >0, we'll generate index entries on stderr for jpayne@68: .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index jpayne@68: .\" entries marked with X<> in POD. Of course, you'll have to process the jpayne@68: .\" output yourself in some meaningful fashion. jpayne@68: .\" jpayne@68: .\" Avoid warning from groff about undefined register 'F'. jpayne@68: .de IX jpayne@68: .. jpayne@68: .nr rF 0 jpayne@68: .if \n(.g .if rF .nr rF 1 jpayne@68: .if (\n(rF:(\n(.g==0)) \{\ jpayne@68: . if \nF \{\ jpayne@68: . de IX jpayne@68: . tm Index:\\$1\t\\n%\t"\\$2" jpayne@68: .. jpayne@68: . if !\nF==2 \{\ jpayne@68: . nr % 0 jpayne@68: . nr F 2 jpayne@68: . \} jpayne@68: . \} jpayne@68: .\} jpayne@68: .rr rF jpayne@68: .\" jpayne@68: .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2). jpayne@68: .\" Fear. Run. Save yourself. No user-serviceable parts. jpayne@68: . \" fudge factors for nroff and troff jpayne@68: .if n \{\ jpayne@68: . ds #H 0 jpayne@68: . ds #V .8m jpayne@68: . ds #F .3m jpayne@68: . ds #[ \f1 jpayne@68: . ds #] \fP jpayne@68: .\} jpayne@68: .if t \{\ jpayne@68: . ds #H ((1u-(\\\\n(.fu%2u))*.13m) jpayne@68: . ds #V .6m jpayne@68: . ds #F 0 jpayne@68: . ds #[ \& jpayne@68: . ds #] \& jpayne@68: .\} jpayne@68: . \" simple accents for nroff and troff jpayne@68: .if n \{\ jpayne@68: . ds ' \& jpayne@68: . ds ` \& jpayne@68: . ds ^ \& jpayne@68: . ds , \& jpayne@68: . ds ~ ~ jpayne@68: . ds / jpayne@68: .\} jpayne@68: .if t \{\ jpayne@68: . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u" jpayne@68: . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u' jpayne@68: . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u' jpayne@68: . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u' jpayne@68: . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u' jpayne@68: . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u' jpayne@68: .\} jpayne@68: . \" troff and (daisy-wheel) nroff accents jpayne@68: .ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V' jpayne@68: .ds 8 \h'\*(#H'\(*b\h'-\*(#H' jpayne@68: .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#] jpayne@68: .ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H' jpayne@68: .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u' jpayne@68: .ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#] jpayne@68: .ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#] jpayne@68: .ds ae a\h'-(\w'a'u*4/10)'e jpayne@68: .ds Ae A\h'-(\w'A'u*4/10)'E jpayne@68: . \" corrections for vroff jpayne@68: .if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u' jpayne@68: .if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u' jpayne@68: . \" for low resolution devices (crt and lpr) jpayne@68: .if \n(.H>23 .if \n(.V>19 \ jpayne@68: \{\ jpayne@68: . ds : e jpayne@68: . ds 8 ss jpayne@68: . ds o a jpayne@68: . ds d- d\h'-1'\(ga jpayne@68: . ds D- D\h'-1'\(hy jpayne@68: . ds th \o'bp' jpayne@68: . ds Th \o'LP' jpayne@68: . ds ae ae jpayne@68: . ds Ae AE jpayne@68: .\} jpayne@68: .rm #[ #] #H #V #F C jpayne@68: .\" ======================================================================== jpayne@68: .\" jpayne@68: .IX Title "LIBEV 3" jpayne@68: .TH LIBEV 3 "2020-03-12" "libev-4.31" "libev - high performance full featured event loop" jpayne@68: .\" For nroff, turn off justification. Always turn off hyphenation; it makes jpayne@68: .\" way too many mistakes in technical documents. jpayne@68: .if n .ad l jpayne@68: .nh jpayne@68: .SH "NAME" jpayne@68: libev \- a high performance full\-featured event loop written in C jpayne@68: .SH "SYNOPSIS" jpayne@68: .IX Header "SYNOPSIS" jpayne@68: .Vb 1 jpayne@68: \& #include jpayne@68: .Ve jpayne@68: .SS "\s-1EXAMPLE PROGRAM\s0" jpayne@68: .IX Subsection "EXAMPLE PROGRAM" jpayne@68: .Vb 2 jpayne@68: \& // a single header file is required jpayne@68: \& #include jpayne@68: \& jpayne@68: \& #include // for puts jpayne@68: \& jpayne@68: \& // every watcher type has its own typedef\*(Aqd struct jpayne@68: \& // with the name ev_TYPE jpayne@68: \& ev_io stdin_watcher; jpayne@68: \& ev_timer timeout_watcher; jpayne@68: \& jpayne@68: \& // all watcher callbacks have a similar signature jpayne@68: \& // this callback is called when data is readable on stdin jpayne@68: \& static void jpayne@68: \& stdin_cb (EV_P_ ev_io *w, int revents) jpayne@68: \& { jpayne@68: \& puts ("stdin ready"); jpayne@68: \& // for one\-shot events, one must manually stop the watcher jpayne@68: \& // with its corresponding stop function. jpayne@68: \& ev_io_stop (EV_A_ w); jpayne@68: \& jpayne@68: \& // this causes all nested ev_run\*(Aqs to stop iterating jpayne@68: \& ev_break (EV_A_ EVBREAK_ALL); jpayne@68: \& } jpayne@68: \& jpayne@68: \& // another callback, this time for a time\-out jpayne@68: \& static void jpayne@68: \& timeout_cb (EV_P_ ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& puts ("timeout"); jpayne@68: \& // this causes the innermost ev_run to stop iterating jpayne@68: \& ev_break (EV_A_ EVBREAK_ONE); jpayne@68: \& } jpayne@68: \& jpayne@68: \& int jpayne@68: \& main (void) jpayne@68: \& { jpayne@68: \& // use the default event loop unless you have special needs jpayne@68: \& struct ev_loop *loop = EV_DEFAULT; jpayne@68: \& jpayne@68: \& // initialise an io watcher, then start it jpayne@68: \& // this one will watch for stdin to become readable jpayne@68: \& ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ); jpayne@68: \& ev_io_start (loop, &stdin_watcher); jpayne@68: \& jpayne@68: \& // initialise a timer watcher, then start it jpayne@68: \& // simple non\-repeating 5.5 second timeout jpayne@68: \& ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.); jpayne@68: \& ev_timer_start (loop, &timeout_watcher); jpayne@68: \& jpayne@68: \& // now wait for events to arrive jpayne@68: \& ev_run (loop, 0); jpayne@68: \& jpayne@68: \& // break was called, so exit jpayne@68: \& return 0; jpayne@68: \& } jpayne@68: .Ve jpayne@68: .SH "ABOUT THIS DOCUMENT" jpayne@68: .IX Header "ABOUT THIS DOCUMENT" jpayne@68: This document documents the libev software package. jpayne@68: .PP jpayne@68: The newest version of this document is also available as an html-formatted jpayne@68: web page you might find easier to navigate when reading it for the first jpayne@68: time: . jpayne@68: .PP jpayne@68: While this document tries to be as complete as possible in documenting jpayne@68: libev, its usage and the rationale behind its design, it is not a tutorial jpayne@68: on event-based programming, nor will it introduce event-based programming jpayne@68: with libev. jpayne@68: .PP jpayne@68: Familiarity with event based programming techniques in general is assumed jpayne@68: throughout this document. jpayne@68: .SH "WHAT TO READ WHEN IN A HURRY" jpayne@68: .IX Header "WHAT TO READ WHEN IN A HURRY" jpayne@68: This manual tries to be very detailed, but unfortunately, this also makes jpayne@68: it very long. If you just want to know the basics of libev, I suggest jpayne@68: reading \*(L"\s-1ANATOMY OF A WATCHER\*(R"\s0, then the \*(L"\s-1EXAMPLE PROGRAM\*(R"\s0 above and jpayne@68: look up the missing functions in \*(L"\s-1GLOBAL FUNCTIONS\*(R"\s0 and the \f(CW\*(C`ev_io\*(C'\fR and jpayne@68: \&\f(CW\*(C`ev_timer\*(C'\fR sections in \*(L"\s-1WATCHER TYPES\*(R"\s0. jpayne@68: .SH "ABOUT LIBEV" jpayne@68: .IX Header "ABOUT LIBEV" jpayne@68: Libev is an event loop: you register interest in certain events (such as a jpayne@68: file descriptor being readable or a timeout occurring), and it will manage jpayne@68: these event sources and provide your program with events. jpayne@68: .PP jpayne@68: To do this, it must take more or less complete control over your process jpayne@68: (or thread) by executing the \fIevent loop\fR handler, and will then jpayne@68: communicate events via a callback mechanism. jpayne@68: .PP jpayne@68: You register interest in certain events by registering so-called \fIevent jpayne@68: watchers\fR, which are relatively small C structures you initialise with the jpayne@68: details of the event, and then hand it over to libev by \fIstarting\fR the jpayne@68: watcher. jpayne@68: .SS "\s-1FEATURES\s0" jpayne@68: .IX Subsection "FEATURES" jpayne@68: Libev supports \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`poll\*(C'\fR, the Linux-specific aio and \f(CW\*(C`epoll\*(C'\fR jpayne@68: interfaces, the BSD-specific \f(CW\*(C`kqueue\*(C'\fR and the Solaris-specific event port jpayne@68: mechanisms for file descriptor events (\f(CW\*(C`ev_io\*(C'\fR), the Linux \f(CW\*(C`inotify\*(C'\fR jpayne@68: interface (for \f(CW\*(C`ev_stat\*(C'\fR), Linux eventfd/signalfd (for faster and cleaner jpayne@68: inter-thread wakeup (\f(CW\*(C`ev_async\*(C'\fR)/signal handling (\f(CW\*(C`ev_signal\*(C'\fR)) relative jpayne@68: timers (\f(CW\*(C`ev_timer\*(C'\fR), absolute timers with customised rescheduling jpayne@68: (\f(CW\*(C`ev_periodic\*(C'\fR), synchronous signals (\f(CW\*(C`ev_signal\*(C'\fR), process status jpayne@68: change events (\f(CW\*(C`ev_child\*(C'\fR), and event watchers dealing with the event jpayne@68: 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 jpayne@68: \&\f(CW\*(C`ev_check\*(C'\fR watchers) as well as file watchers (\f(CW\*(C`ev_stat\*(C'\fR) and even jpayne@68: limited support for fork events (\f(CW\*(C`ev_fork\*(C'\fR). jpayne@68: .PP jpayne@68: It also is quite fast (see this jpayne@68: benchmark comparing it to libevent jpayne@68: for example). jpayne@68: .SS "\s-1CONVENTIONS\s0" jpayne@68: .IX Subsection "CONVENTIONS" jpayne@68: Libev is very configurable. In this manual the default (and most common) jpayne@68: configuration will be described, which supports multiple event loops. For jpayne@68: more info about various configuration options please have a look at jpayne@68: \&\fB\s-1EMBED\s0\fR section in this manual. If libev was configured without support jpayne@68: for multiple event loops, then all functions taking an initial argument of jpayne@68: name \f(CW\*(C`loop\*(C'\fR (which is always of type \f(CW\*(C`struct ev_loop *\*(C'\fR) will not have jpayne@68: this argument. jpayne@68: .SS "\s-1TIME REPRESENTATION\s0" jpayne@68: .IX Subsection "TIME REPRESENTATION" jpayne@68: Libev represents time as a single floating point number, representing jpayne@68: the (fractional) number of seconds since the (\s-1POSIX\s0) epoch (in practice jpayne@68: somewhere near the beginning of 1970, details are complicated, don't jpayne@68: ask). This type is called \f(CW\*(C`ev_tstamp\*(C'\fR, which is what you should use jpayne@68: too. It usually aliases to the \f(CW\*(C`double\*(C'\fR type in C. When you need to do jpayne@68: any calculations on it, you should treat it as some floating point value. jpayne@68: .PP jpayne@68: Unlike the name component \f(CW\*(C`stamp\*(C'\fR might indicate, it is also used for jpayne@68: time differences (e.g. delays) throughout libev. jpayne@68: .SH "ERROR HANDLING" jpayne@68: .IX Header "ERROR HANDLING" jpayne@68: Libev knows three classes of errors: operating system errors, usage errors jpayne@68: and internal errors (bugs). jpayne@68: .PP jpayne@68: When libev catches an operating system error it cannot handle (for example jpayne@68: a system call indicating a condition libev cannot fix), it calls the callback jpayne@68: set via \f(CW\*(C`ev_set_syserr_cb\*(C'\fR, which is supposed to fix the problem or jpayne@68: abort. The default is to print a diagnostic message and to call \f(CW\*(C`abort jpayne@68: ()\*(C'\fR. jpayne@68: .PP jpayne@68: When libev detects a usage error such as a negative timer interval, then jpayne@68: it will print a diagnostic message and abort (via the \f(CW\*(C`assert\*(C'\fR mechanism, jpayne@68: so \f(CW\*(C`NDEBUG\*(C'\fR will disable this checking): these are programming errors in jpayne@68: the libev caller and need to be fixed there. jpayne@68: .PP jpayne@68: Via the \f(CW\*(C`EV_FREQUENT\*(C'\fR macro you can compile in and/or enable extensive jpayne@68: consistency checking code inside libev that can be used to check for jpayne@68: internal inconsistencies, suually caused by application bugs. jpayne@68: .PP jpayne@68: Libev also has a few internal error-checking \f(CW\*(C`assert\*(C'\fRions. These do not jpayne@68: trigger under normal circumstances, as they indicate either a bug in libev jpayne@68: or worse. jpayne@68: .SH "GLOBAL FUNCTIONS" jpayne@68: .IX Header "GLOBAL FUNCTIONS" jpayne@68: These functions can be called anytime, even before initialising the jpayne@68: library in any way. jpayne@68: .IP "ev_tstamp ev_time ()" 4 jpayne@68: .IX Item "ev_tstamp ev_time ()" jpayne@68: Returns the current time as libev would use it. Please note that the jpayne@68: \&\f(CW\*(C`ev_now\*(C'\fR function is usually faster and also often returns the timestamp jpayne@68: you actually want to know. Also interesting is the combination of jpayne@68: \&\f(CW\*(C`ev_now_update\*(C'\fR and \f(CW\*(C`ev_now\*(C'\fR. jpayne@68: .IP "ev_sleep (ev_tstamp interval)" 4 jpayne@68: .IX Item "ev_sleep (ev_tstamp interval)" jpayne@68: Sleep for the given interval: The current thread will be blocked jpayne@68: until either it is interrupted or the given time interval has jpayne@68: passed (approximately \- it might return a bit earlier even if not jpayne@68: interrupted). Returns immediately if \f(CW\*(C`interval <= 0\*(C'\fR. jpayne@68: .Sp jpayne@68: Basically this is a sub-second-resolution \f(CW\*(C`sleep ()\*(C'\fR. jpayne@68: .Sp jpayne@68: The range of the \f(CW\*(C`interval\*(C'\fR is limited \- libev only guarantees to work jpayne@68: with sleep times of up to one day (\f(CW\*(C`interval <= 86400\*(C'\fR). jpayne@68: .IP "int ev_version_major ()" 4 jpayne@68: .IX Item "int ev_version_major ()" jpayne@68: .PD 0 jpayne@68: .IP "int ev_version_minor ()" 4 jpayne@68: .IX Item "int ev_version_minor ()" jpayne@68: .PD jpayne@68: You can find out the major and minor \s-1ABI\s0 version numbers of the library jpayne@68: you linked against by calling the functions \f(CW\*(C`ev_version_major\*(C'\fR and jpayne@68: \&\f(CW\*(C`ev_version_minor\*(C'\fR. If you want, you can compare against the global jpayne@68: symbols \f(CW\*(C`EV_VERSION_MAJOR\*(C'\fR and \f(CW\*(C`EV_VERSION_MINOR\*(C'\fR, which specify the jpayne@68: version of the library your program was compiled against. jpayne@68: .Sp jpayne@68: These version numbers refer to the \s-1ABI\s0 version of the library, not the jpayne@68: release version. jpayne@68: .Sp jpayne@68: Usually, it's a good idea to terminate if the major versions mismatch, jpayne@68: as this indicates an incompatible change. Minor versions are usually jpayne@68: compatible to older versions, so a larger minor version alone is usually jpayne@68: not a problem. jpayne@68: .Sp jpayne@68: Example: Make sure we haven't accidentally been linked against the wrong jpayne@68: version (note, however, that this will not detect other \s-1ABI\s0 mismatches, jpayne@68: such as \s-1LFS\s0 or reentrancy). jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& assert (("libev version mismatch", jpayne@68: \& ev_version_major () == EV_VERSION_MAJOR jpayne@68: \& && ev_version_minor () >= EV_VERSION_MINOR)); jpayne@68: .Ve jpayne@68: .IP "unsigned int ev_supported_backends ()" 4 jpayne@68: .IX Item "unsigned int ev_supported_backends ()" jpayne@68: Return the set of all backends (i.e. their corresponding \f(CW\*(C`EV_BACKEND_*\*(C'\fR jpayne@68: value) compiled into this binary of libev (independent of their jpayne@68: availability on the system you are running on). See \f(CW\*(C`ev_default_loop\*(C'\fR for jpayne@68: a description of the set values. jpayne@68: .Sp jpayne@68: Example: make sure we have the epoll method, because yeah this is cool and jpayne@68: a must have and can we have a torrent of it please!!!11 jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& assert (("sorry, no epoll, no sex", jpayne@68: \& ev_supported_backends () & EVBACKEND_EPOLL)); jpayne@68: .Ve jpayne@68: .IP "unsigned int ev_recommended_backends ()" 4 jpayne@68: .IX Item "unsigned int ev_recommended_backends ()" jpayne@68: Return the set of all backends compiled into this binary of libev and jpayne@68: also recommended for this platform, meaning it will work for most file jpayne@68: descriptor types. This set is often smaller than the one returned by jpayne@68: \&\f(CW\*(C`ev_supported_backends\*(C'\fR, as for example kqueue is broken on most BSDs jpayne@68: and will not be auto-detected unless you explicitly request it (assuming jpayne@68: you know what you are doing). This is the set of backends that libev will jpayne@68: probe for if you specify no backends explicitly. jpayne@68: .IP "unsigned int ev_embeddable_backends ()" 4 jpayne@68: .IX Item "unsigned int ev_embeddable_backends ()" jpayne@68: Returns the set of backends that are embeddable in other event loops. This jpayne@68: value is platform-specific but can include backends not available on the jpayne@68: current system. To find which embeddable backends might be supported on jpayne@68: the current system, you would need to look at \f(CW\*(C`ev_embeddable_backends () jpayne@68: & ev_supported_backends ()\*(C'\fR, likewise for recommended ones. jpayne@68: .Sp jpayne@68: See the description of \f(CW\*(C`ev_embed\*(C'\fR watchers for more info. jpayne@68: .IP "ev_set_allocator (void *(*cb)(void *ptr, long size) throw ())" 4 jpayne@68: .IX Item "ev_set_allocator (void *(*cb)(void *ptr, long size) throw ())" jpayne@68: Sets the allocation function to use (the prototype is similar \- the jpayne@68: semantics are identical to the \f(CW\*(C`realloc\*(C'\fR C89/SuS/POSIX function). It is jpayne@68: used to allocate and free memory (no surprises here). If it returns zero jpayne@68: when memory needs to be allocated (\f(CW\*(C`size != 0\*(C'\fR), the library might abort jpayne@68: or take some potentially destructive action. jpayne@68: .Sp jpayne@68: Since some systems (at least OpenBSD and Darwin) fail to implement jpayne@68: correct \f(CW\*(C`realloc\*(C'\fR semantics, libev will use a wrapper around the system jpayne@68: \&\f(CW\*(C`realloc\*(C'\fR and \f(CW\*(C`free\*(C'\fR functions by default. jpayne@68: .Sp jpayne@68: You could override this function in high-availability programs to, say, jpayne@68: free some memory if it cannot allocate memory, to use a special allocator, jpayne@68: or even to sleep a while and retry until some memory is available. jpayne@68: .Sp jpayne@68: Example: The following is the \f(CW\*(C`realloc\*(C'\fR function that libev itself uses jpayne@68: which should work with \f(CW\*(C`realloc\*(C'\fR and \f(CW\*(C`free\*(C'\fR functions of all kinds and jpayne@68: is probably a good basis for your own implementation. jpayne@68: .Sp jpayne@68: .Vb 5 jpayne@68: \& static void * jpayne@68: \& ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT jpayne@68: \& { jpayne@68: \& if (size) jpayne@68: \& return realloc (ptr, size); jpayne@68: \& jpayne@68: \& free (ptr); jpayne@68: \& return 0; jpayne@68: \& } jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Example: Replace the libev allocator with one that waits a bit and then jpayne@68: retries. jpayne@68: .Sp jpayne@68: .Vb 8 jpayne@68: \& static void * jpayne@68: \& persistent_realloc (void *ptr, size_t size) jpayne@68: \& { jpayne@68: \& if (!size) jpayne@68: \& { jpayne@68: \& free (ptr); jpayne@68: \& return 0; jpayne@68: \& } jpayne@68: \& jpayne@68: \& for (;;) jpayne@68: \& { jpayne@68: \& void *newptr = realloc (ptr, size); jpayne@68: \& jpayne@68: \& if (newptr) jpayne@68: \& return newptr; jpayne@68: \& jpayne@68: \& sleep (60); jpayne@68: \& } jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& ev_set_allocator (persistent_realloc); jpayne@68: .Ve jpayne@68: .IP "ev_set_syserr_cb (void (*cb)(const char *msg) throw ())" 4 jpayne@68: .IX Item "ev_set_syserr_cb (void (*cb)(const char *msg) throw ())" jpayne@68: Set the callback function to call on a retryable system call error (such jpayne@68: as failed select, poll, epoll_wait). The message is a printable string jpayne@68: indicating the system call or subsystem causing the problem. If this jpayne@68: callback is set, then libev will expect it to remedy the situation, no jpayne@68: matter what, when it returns. That is, libev will generally retry the jpayne@68: requested operation, or, if the condition doesn't go away, do bad stuff jpayne@68: (such as abort). jpayne@68: .Sp jpayne@68: Example: This is basically the same thing that libev does internally, too. jpayne@68: .Sp jpayne@68: .Vb 6 jpayne@68: \& static void jpayne@68: \& fatal_error (const char *msg) jpayne@68: \& { jpayne@68: \& perror (msg); jpayne@68: \& abort (); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& ev_set_syserr_cb (fatal_error); jpayne@68: .Ve jpayne@68: .IP "ev_feed_signal (int signum)" 4 jpayne@68: .IX Item "ev_feed_signal (int signum)" jpayne@68: This function can be used to \*(L"simulate\*(R" a signal receive. It is completely jpayne@68: safe to call this function at any time, from any context, including signal jpayne@68: handlers or random threads. jpayne@68: .Sp jpayne@68: Its main use is to customise signal handling in your process, especially jpayne@68: in the presence of threads. For example, you could block signals jpayne@68: by default in all threads (and specifying \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR when jpayne@68: creating any loops), and in one thread, use \f(CW\*(C`sigwait\*(C'\fR or any other jpayne@68: mechanism to wait for signals, then \*(L"deliver\*(R" them to libev by calling jpayne@68: \&\f(CW\*(C`ev_feed_signal\*(C'\fR. jpayne@68: .SH "FUNCTIONS CONTROLLING EVENT LOOPS" jpayne@68: .IX Header "FUNCTIONS CONTROLLING EVENT LOOPS" jpayne@68: An event loop is described by a \f(CW\*(C`struct ev_loop *\*(C'\fR (the \f(CW\*(C`struct\*(C'\fR is jpayne@68: \&\fInot\fR optional in this case unless libev 3 compatibility is disabled, as jpayne@68: libev 3 had an \f(CW\*(C`ev_loop\*(C'\fR function colliding with the struct name). jpayne@68: .PP jpayne@68: The library knows two types of such loops, the \fIdefault\fR loop, which jpayne@68: supports child process events, and dynamically created event loops which jpayne@68: do not. jpayne@68: .IP "struct ev_loop *ev_default_loop (unsigned int flags)" 4 jpayne@68: .IX Item "struct ev_loop *ev_default_loop (unsigned int flags)" jpayne@68: This returns the \*(L"default\*(R" event loop object, which is what you should jpayne@68: normally use when you just need \*(L"the event loop\*(R". Event loop objects and jpayne@68: the \f(CW\*(C`flags\*(C'\fR parameter are described in more detail in the entry for jpayne@68: \&\f(CW\*(C`ev_loop_new\*(C'\fR. jpayne@68: .Sp jpayne@68: If the default loop is already initialised then this function simply jpayne@68: returns it (and ignores the flags. If that is troubling you, check jpayne@68: \&\f(CW\*(C`ev_backend ()\*(C'\fR afterwards). Otherwise it will create it with the given jpayne@68: flags, which should almost always be \f(CW0\fR, unless the caller is also the jpayne@68: one calling \f(CW\*(C`ev_run\*(C'\fR or otherwise qualifies as \*(L"the main program\*(R". jpayne@68: .Sp jpayne@68: If you don't know what event loop to use, use the one returned from this jpayne@68: function (or via the \f(CW\*(C`EV_DEFAULT\*(C'\fR macro). jpayne@68: .Sp jpayne@68: Note that this function is \fInot\fR thread-safe, so if you want to use it jpayne@68: from multiple threads, you have to employ some kind of mutex (note also jpayne@68: that this case is unlikely, as loops cannot be shared easily between jpayne@68: threads anyway). jpayne@68: .Sp jpayne@68: The default loop is the only loop that can handle \f(CW\*(C`ev_child\*(C'\fR watchers, jpayne@68: and to do this, it always registers a handler for \f(CW\*(C`SIGCHLD\*(C'\fR. If this is jpayne@68: a problem for your application you can either create a dynamic loop with jpayne@68: \&\f(CW\*(C`ev_loop_new\*(C'\fR which doesn't do that, or you can simply overwrite the jpayne@68: \&\f(CW\*(C`SIGCHLD\*(C'\fR signal handler \fIafter\fR calling \f(CW\*(C`ev_default_init\*(C'\fR. jpayne@68: .Sp jpayne@68: Example: This is the most typical usage. jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& if (!ev_default_loop (0)) jpayne@68: \& fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?"); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Example: Restrict libev to the select and poll backends, and do not allow jpayne@68: environment settings to be taken into account: jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& ev_default_loop (EVBACKEND_POLL | EVBACKEND_SELECT | EVFLAG_NOENV); jpayne@68: .Ve jpayne@68: .IP "struct ev_loop *ev_loop_new (unsigned int flags)" 4 jpayne@68: .IX Item "struct ev_loop *ev_loop_new (unsigned int flags)" jpayne@68: This will create and initialise a new event loop object. If the loop jpayne@68: could not be initialised, returns false. jpayne@68: .Sp jpayne@68: This function is thread-safe, and one common way to use libev with jpayne@68: threads is indeed to create one loop per thread, and using the default jpayne@68: loop in the \*(L"main\*(R" or \*(L"initial\*(R" thread. jpayne@68: .Sp jpayne@68: The flags argument can be used to specify special behaviour or specific jpayne@68: backends to use, and is usually specified as \f(CW0\fR (or \f(CW\*(C`EVFLAG_AUTO\*(C'\fR). jpayne@68: .Sp jpayne@68: The following flags are supported: jpayne@68: .RS 4 jpayne@68: .ie n .IP """EVFLAG_AUTO""" 4 jpayne@68: .el .IP "\f(CWEVFLAG_AUTO\fR" 4 jpayne@68: .IX Item "EVFLAG_AUTO" jpayne@68: The default flags value. Use this if you have no clue (it's the right jpayne@68: thing, believe me). jpayne@68: .ie n .IP """EVFLAG_NOENV""" 4 jpayne@68: .el .IP "\f(CWEVFLAG_NOENV\fR" 4 jpayne@68: .IX Item "EVFLAG_NOENV" jpayne@68: If this flag bit is or'ed into the flag value (or the program runs setuid jpayne@68: or setgid) then libev will \fInot\fR look at the environment variable jpayne@68: \&\f(CW\*(C`LIBEV_FLAGS\*(C'\fR. Otherwise (the default), this environment variable will jpayne@68: override the flags completely if it is found in the environment. This is jpayne@68: useful to try out specific backends to test their performance, to work jpayne@68: around bugs, or to make libev threadsafe (accessing environment variables jpayne@68: cannot be done in a threadsafe way, but usually it works if no other jpayne@68: thread modifies them). jpayne@68: .ie n .IP """EVFLAG_FORKCHECK""" 4 jpayne@68: .el .IP "\f(CWEVFLAG_FORKCHECK\fR" 4 jpayne@68: .IX Item "EVFLAG_FORKCHECK" jpayne@68: Instead of calling \f(CW\*(C`ev_loop_fork\*(C'\fR manually after a fork, you can also jpayne@68: make libev check for a fork in each iteration by enabling this flag. jpayne@68: .Sp jpayne@68: This works by calling \f(CW\*(C`getpid ()\*(C'\fR on every iteration of the loop, jpayne@68: and thus this might slow down your event loop if you do a lot of loop jpayne@68: iterations and little real work, but is usually not noticeable (on my jpayne@68: GNU/Linux system for example, \f(CW\*(C`getpid\*(C'\fR is actually a simple 5\-insn jpayne@68: sequence without a system call and thus \fIvery\fR fast, but my GNU/Linux jpayne@68: system also has \f(CW\*(C`pthread_atfork\*(C'\fR which is even faster). (Update: glibc jpayne@68: versions 2.25 apparently removed the \f(CW\*(C`getpid\*(C'\fR optimisation again). jpayne@68: .Sp jpayne@68: The big advantage of this flag is that you can forget about fork (and jpayne@68: forget about forgetting to tell libev about forking, although you still jpayne@68: have to ignore \f(CW\*(C`SIGPIPE\*(C'\fR) when you use this flag. jpayne@68: .Sp jpayne@68: This flag setting cannot be overridden or specified in the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR jpayne@68: environment variable. jpayne@68: .ie n .IP """EVFLAG_NOINOTIFY""" 4 jpayne@68: .el .IP "\f(CWEVFLAG_NOINOTIFY\fR" 4 jpayne@68: .IX Item "EVFLAG_NOINOTIFY" jpayne@68: When this flag is specified, then libev will not attempt to use the jpayne@68: \&\fIinotify\fR \s-1API\s0 for its \f(CW\*(C`ev_stat\*(C'\fR watchers. Apart from debugging and jpayne@68: testing, this flag can be useful to conserve inotify file descriptors, as jpayne@68: otherwise each loop using \f(CW\*(C`ev_stat\*(C'\fR watchers consumes one inotify handle. jpayne@68: .ie n .IP """EVFLAG_SIGNALFD""" 4 jpayne@68: .el .IP "\f(CWEVFLAG_SIGNALFD\fR" 4 jpayne@68: .IX Item "EVFLAG_SIGNALFD" jpayne@68: When this flag is specified, then libev will attempt to use the jpayne@68: \&\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 jpayne@68: delivers signals synchronously, which makes it both faster and might make jpayne@68: it possible to get the queued signal data. It can also simplify signal jpayne@68: handling with threads, as long as you properly block signals in your jpayne@68: threads that are not interested in handling them. jpayne@68: .Sp jpayne@68: Signalfd will not be used by default as this changes your signal mask, and jpayne@68: there are a lot of shoddy libraries and programs (glib's threadpool for jpayne@68: example) that can't properly initialise their signal masks. jpayne@68: .ie n .IP """EVFLAG_NOSIGMASK""" 4 jpayne@68: .el .IP "\f(CWEVFLAG_NOSIGMASK\fR" 4 jpayne@68: .IX Item "EVFLAG_NOSIGMASK" jpayne@68: When this flag is specified, then libev will avoid to modify the signal jpayne@68: mask. Specifically, this means you have to make sure signals are unblocked jpayne@68: when you want to receive them. jpayne@68: .Sp jpayne@68: This behaviour is useful when you want to do your own signal handling, or jpayne@68: want to handle signals only in specific threads and want to avoid libev jpayne@68: unblocking the signals. jpayne@68: .Sp jpayne@68: It's also required by \s-1POSIX\s0 in a threaded program, as libev calls jpayne@68: \&\f(CW\*(C`sigprocmask\*(C'\fR, whose behaviour is officially unspecified. jpayne@68: .ie n .IP """EVFLAG_NOTIMERFD""" 4 jpayne@68: .el .IP "\f(CWEVFLAG_NOTIMERFD\fR" 4 jpayne@68: .IX Item "EVFLAG_NOTIMERFD" jpayne@68: When this flag is specified, the libev will avoid using a \f(CW\*(C`timerfd\*(C'\fR to jpayne@68: detect time jumps. It will still be able to detect time jumps, but takes jpayne@68: longer and has a lower accuracy in doing so, but saves a file descriptor jpayne@68: per loop. jpayne@68: .Sp jpayne@68: The current implementation only tries to use a \f(CW\*(C`timerfd\*(C'\fR when the first jpayne@68: \&\f(CW\*(C`ev_periodic\*(C'\fR watcher is started and falls back on other methods if it jpayne@68: cannot be created, but this behaviour might change in the future. jpayne@68: .ie n .IP """EVBACKEND_SELECT"" (value 1, portable select backend)" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_SELECT\fR (value 1, portable select backend)" 4 jpayne@68: .IX Item "EVBACKEND_SELECT (value 1, portable select backend)" jpayne@68: This is your standard \fBselect\fR\|(2) backend. Not \fIcompletely\fR standard, as jpayne@68: libev tries to roll its own fd_set with no limits on the number of fds, jpayne@68: but if that fails, expect a fairly low limit on the number of fds when jpayne@68: using this backend. It doesn't scale too well (O(highest_fd)), but its jpayne@68: usually the fastest backend for a low number of (low-numbered :) fds. jpayne@68: .Sp jpayne@68: To get good performance out of this backend you need a high amount of jpayne@68: parallelism (most of the file descriptors should be busy). If you are jpayne@68: writing a server, you should \f(CW\*(C`accept ()\*(C'\fR in a loop to accept as many jpayne@68: connections as possible during one iteration. You might also want to have jpayne@68: a look at \f(CW\*(C`ev_set_io_collect_interval ()\*(C'\fR to increase the amount of jpayne@68: readiness notifications you get per iteration. jpayne@68: .Sp jpayne@68: 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 jpayne@68: \&\f(CW\*(C`writefds\*(C'\fR set (and to work around Microsoft Windows bugs, also onto the jpayne@68: \&\f(CW\*(C`exceptfds\*(C'\fR set on that platform). jpayne@68: .ie n .IP """EVBACKEND_POLL"" (value 2, poll backend, available everywhere except on windows)" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_POLL\fR (value 2, poll backend, available everywhere except on windows)" 4 jpayne@68: .IX Item "EVBACKEND_POLL (value 2, poll backend, available everywhere except on windows)" jpayne@68: And this is your standard \fBpoll\fR\|(2) backend. It's more complicated jpayne@68: than select, but handles sparse fds better and has no artificial jpayne@68: limit on the number of fds you can use (except it will slow down jpayne@68: considerably with a lot of inactive fds). It scales similarly to select, jpayne@68: i.e. O(total_fds). See the entry for \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR, above, for jpayne@68: performance tips. jpayne@68: .Sp jpayne@68: This backend maps \f(CW\*(C`EV_READ\*(C'\fR to \f(CW\*(C`POLLIN | POLLERR | POLLHUP\*(C'\fR, and jpayne@68: \&\f(CW\*(C`EV_WRITE\*(C'\fR to \f(CW\*(C`POLLOUT | POLLERR | POLLHUP\*(C'\fR. jpayne@68: .ie n .IP """EVBACKEND_EPOLL"" (value 4, Linux)" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_EPOLL\fR (value 4, Linux)" 4 jpayne@68: .IX Item "EVBACKEND_EPOLL (value 4, Linux)" jpayne@68: Use the Linux-specific \fBepoll\fR\|(7) interface (for both pre\- and post\-2.6.9 jpayne@68: kernels). jpayne@68: .Sp jpayne@68: For few fds, this backend is a bit little slower than poll and select, but jpayne@68: it scales phenomenally better. While poll and select usually scale like jpayne@68: O(total_fds) where total_fds is the total number of fds (or the highest jpayne@68: fd), epoll scales either O(1) or O(active_fds). jpayne@68: .Sp jpayne@68: The epoll mechanism deserves honorable mention as the most misdesigned jpayne@68: of the more advanced event mechanisms: mere annoyances include silently jpayne@68: dropping file descriptors, requiring a system call per change per file jpayne@68: descriptor (and unnecessary guessing of parameters), problems with dup, jpayne@68: returning before the timeout value, resulting in additional iterations jpayne@68: (and only giving 5ms accuracy while select on the same platform gives jpayne@68: 0.1ms) and so on. The biggest issue is fork races, however \- if a program jpayne@68: forks then \fIboth\fR parent and child process have to recreate the epoll jpayne@68: set, which can take considerable time (one syscall per file descriptor) jpayne@68: and is of course hard to detect. jpayne@68: .Sp jpayne@68: Epoll is also notoriously buggy \- embedding epoll fds \fIshould\fR work, jpayne@68: but of course \fIdoesn't\fR, and epoll just loves to report events for jpayne@68: totally \fIdifferent\fR file descriptors (even already closed ones, so jpayne@68: one cannot even remove them from the set) than registered in the set jpayne@68: (especially on \s-1SMP\s0 systems). Libev tries to counter these spurious jpayne@68: notifications by employing an additional generation counter and comparing jpayne@68: that against the events to filter out spurious ones, recreating the set jpayne@68: when required. Epoll also erroneously rounds down timeouts, but gives you jpayne@68: no way to know when and by how much, so sometimes you have to busy-wait jpayne@68: because epoll returns immediately despite a nonzero timeout. And last jpayne@68: not least, it also refuses to work with some file descriptors which work jpayne@68: perfectly fine with \f(CW\*(C`select\*(C'\fR (files, many character devices...). jpayne@68: .Sp jpayne@68: Epoll is truly the train wreck among event poll mechanisms, a frankenpoll, jpayne@68: cobbled together in a hurry, no thought to design or interaction with jpayne@68: others. Oh, the pain, will it ever stop... jpayne@68: .Sp jpayne@68: While stopping, setting and starting an I/O watcher in the same iteration jpayne@68: will result in some caching, there is still a system call per such jpayne@68: incident (because the same \fIfile descriptor\fR could point to a different jpayne@68: \&\fIfile description\fR now), so its best to avoid that. Also, \f(CW\*(C`dup ()\*(C'\fR'ed jpayne@68: file descriptors might not work very well if you register events for both jpayne@68: file descriptors. jpayne@68: .Sp jpayne@68: Best performance from this backend is achieved by not unregistering all jpayne@68: watchers for a file descriptor until it has been closed, if possible, jpayne@68: i.e. keep at least one watcher active per fd at all times. Stopping and jpayne@68: starting a watcher (without re-setting it) also usually doesn't cause jpayne@68: extra overhead. A fork can both result in spurious notifications as well jpayne@68: as in libev having to destroy and recreate the epoll object, which can jpayne@68: take considerable time and thus should be avoided. jpayne@68: .Sp jpayne@68: All this means that, in practice, \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR can be as fast or jpayne@68: faster than epoll for maybe up to a hundred file descriptors, depending on jpayne@68: the usage. So sad. jpayne@68: .Sp jpayne@68: While nominally embeddable in other event loops, this feature is broken in jpayne@68: a lot of kernel revisions, but probably(!) works in current versions. jpayne@68: .Sp jpayne@68: This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as jpayne@68: \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR. jpayne@68: .ie n .IP """EVBACKEND_LINUXAIO"" (value 64, Linux)" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_LINUXAIO\fR (value 64, Linux)" 4 jpayne@68: .IX Item "EVBACKEND_LINUXAIO (value 64, Linux)" jpayne@68: Use the Linux-specific Linux \s-1AIO\s0 (\fInot\fR \f(CWaio(7)\fR but \f(CWio_submit(2)\fR) event interface available in post\-4.18 kernels (but libev jpayne@68: only tries to use it in 4.19+). jpayne@68: .Sp jpayne@68: This is another Linux train wreck of an event interface. jpayne@68: .Sp jpayne@68: If this backend works for you (as of this writing, it was very jpayne@68: experimental), it is the best event interface available on Linux and might jpayne@68: be well worth enabling it \- if it isn't available in your kernel this will jpayne@68: be detected and this backend will be skipped. jpayne@68: .Sp jpayne@68: This backend can batch oneshot requests and supports a user-space ring jpayne@68: buffer to receive events. It also doesn't suffer from most of the design jpayne@68: problems of epoll (such as not being able to remove event sources from jpayne@68: the epoll set), and generally sounds too good to be true. Because, this jpayne@68: being the Linux kernel, of course it suffers from a whole new set of jpayne@68: limitations, forcing you to fall back to epoll, inheriting all its design jpayne@68: issues. jpayne@68: .Sp jpayne@68: For one, it is not easily embeddable (but probably could be done using jpayne@68: an event fd at some extra overhead). It also is subject to a system wide jpayne@68: limit that can be configured in \fI/proc/sys/fs/aio\-max\-nr\fR. If no \s-1AIO\s0 jpayne@68: requests are left, this backend will be skipped during initialisation, and jpayne@68: will switch to epoll when the loop is active. jpayne@68: .Sp jpayne@68: Most problematic in practice, however, is that not all file descriptors jpayne@68: work with it. For example, in Linux 5.1, \s-1TCP\s0 sockets, pipes, event fds, jpayne@68: files, \fI/dev/null\fR and many others are supported, but ttys do not work jpayne@68: properly (a known bug that the kernel developers don't care about, see jpayne@68: ), so this is not jpayne@68: (yet?) a generic event polling interface. jpayne@68: .Sp jpayne@68: Overall, it seems the Linux developers just don't want it to have a jpayne@68: generic event handling mechanism other than \f(CW\*(C`select\*(C'\fR or \f(CW\*(C`poll\*(C'\fR. jpayne@68: .Sp jpayne@68: To work around all these problem, the current version of libev uses its jpayne@68: epoll backend as a fallback for file descriptor types that do not work. Or jpayne@68: falls back completely to epoll if the kernel acts up. jpayne@68: .Sp jpayne@68: This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as jpayne@68: \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR. jpayne@68: .ie n .IP """EVBACKEND_KQUEUE"" (value 8, most \s-1BSD\s0 clones)" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_KQUEUE\fR (value 8, most \s-1BSD\s0 clones)" 4 jpayne@68: .IX Item "EVBACKEND_KQUEUE (value 8, most BSD clones)" jpayne@68: Kqueue deserves special mention, as at the time this backend was jpayne@68: implemented, it was broken on all BSDs except NetBSD (usually it doesn't jpayne@68: work reliably with anything but sockets and pipes, except on Darwin, jpayne@68: where of course it's completely useless). Unlike epoll, however, whose jpayne@68: brokenness is by design, these kqueue bugs can be (and mostly have been) jpayne@68: fixed without \s-1API\s0 changes to existing programs. For this reason it's not jpayne@68: being \*(L"auto-detected\*(R" on all platforms unless you explicitly specify it jpayne@68: in the flags (i.e. using \f(CW\*(C`EVBACKEND_KQUEUE\*(C'\fR) or libev was compiled on a jpayne@68: known-to-be-good (\-enough) system like NetBSD. jpayne@68: .Sp jpayne@68: You still can embed kqueue into a normal poll or select backend and use it jpayne@68: only for sockets (after having made sure that sockets work with kqueue on jpayne@68: the target platform). See \f(CW\*(C`ev_embed\*(C'\fR watchers for more info. jpayne@68: .Sp jpayne@68: It scales in the same way as the epoll backend, but the interface to the jpayne@68: kernel is more efficient (which says nothing about its actual speed, of jpayne@68: course). While stopping, setting and starting an I/O watcher does never jpayne@68: cause an extra system call as with \f(CW\*(C`EVBACKEND_EPOLL\*(C'\fR, it still adds up to jpayne@68: two event changes per incident. Support for \f(CW\*(C`fork ()\*(C'\fR is very bad (you jpayne@68: might have to leak fds on fork, but it's more sane than epoll) and it jpayne@68: drops fds silently in similarly hard-to-detect cases. jpayne@68: .Sp jpayne@68: This backend usually performs well under most conditions. jpayne@68: .Sp jpayne@68: While nominally embeddable in other event loops, this doesn't work jpayne@68: everywhere, so you might need to test for this. And since it is broken jpayne@68: almost everywhere, you should only use it when you have a lot of sockets jpayne@68: (for which it usually works), by embedding it into another event loop jpayne@68: (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 jpayne@68: also broken on \s-1OS X\s0)) and, did I mention it, using it only for sockets. jpayne@68: .Sp jpayne@68: This backend maps \f(CW\*(C`EV_READ\*(C'\fR into an \f(CW\*(C`EVFILT_READ\*(C'\fR kevent with jpayne@68: \&\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 jpayne@68: \&\f(CW\*(C`NOTE_EOF\*(C'\fR. jpayne@68: .ie n .IP """EVBACKEND_DEVPOLL"" (value 16, Solaris 8)" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_DEVPOLL\fR (value 16, Solaris 8)" 4 jpayne@68: .IX Item "EVBACKEND_DEVPOLL (value 16, Solaris 8)" jpayne@68: This is not implemented yet (and might never be, unless you send me an jpayne@68: implementation). According to reports, \f(CW\*(C`/dev/poll\*(C'\fR only supports sockets jpayne@68: and is not embeddable, which would limit the usefulness of this backend jpayne@68: immensely. jpayne@68: .ie n .IP """EVBACKEND_PORT"" (value 32, Solaris 10)" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_PORT\fR (value 32, Solaris 10)" 4 jpayne@68: .IX Item "EVBACKEND_PORT (value 32, Solaris 10)" jpayne@68: This uses the Solaris 10 event port mechanism. As with everything on Solaris, jpayne@68: it's really slow, but it still scales very well (O(active_fds)). jpayne@68: .Sp jpayne@68: While this backend scales well, it requires one system call per active jpayne@68: file descriptor per loop iteration. For small and medium numbers of file jpayne@68: descriptors a \*(L"slow\*(R" \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR backend jpayne@68: might perform better. jpayne@68: .Sp jpayne@68: On the positive side, this backend actually performed fully to jpayne@68: specification in all tests and is fully embeddable, which is a rare feat jpayne@68: among the OS-specific backends (I vastly prefer correctness over speed jpayne@68: hacks). jpayne@68: .Sp jpayne@68: On the negative side, the interface is \fIbizarre\fR \- so bizarre that jpayne@68: even sun itself gets it wrong in their code examples: The event polling jpayne@68: function sometimes returns events to the caller even though an error jpayne@68: occurred, but with no indication whether it has done so or not (yes, it's jpayne@68: even documented that way) \- deadly for edge-triggered interfaces where you jpayne@68: absolutely have to know whether an event occurred or not because you have jpayne@68: to re-arm the watcher. jpayne@68: .Sp jpayne@68: Fortunately libev seems to be able to work around these idiocies. jpayne@68: .Sp jpayne@68: This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as jpayne@68: \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR. jpayne@68: .ie n .IP """EVBACKEND_ALL""" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_ALL\fR" 4 jpayne@68: .IX Item "EVBACKEND_ALL" jpayne@68: Try all backends (even potentially broken ones that wouldn't be tried jpayne@68: with \f(CW\*(C`EVFLAG_AUTO\*(C'\fR). Since this is a mask, you can do stuff such as jpayne@68: \&\f(CW\*(C`EVBACKEND_ALL & ~EVBACKEND_KQUEUE\*(C'\fR. jpayne@68: .Sp jpayne@68: It is definitely not recommended to use this flag, use whatever jpayne@68: \&\f(CW\*(C`ev_recommended_backends ()\*(C'\fR returns, or simply do not specify a backend jpayne@68: at all. jpayne@68: .ie n .IP """EVBACKEND_MASK""" 4 jpayne@68: .el .IP "\f(CWEVBACKEND_MASK\fR" 4 jpayne@68: .IX Item "EVBACKEND_MASK" jpayne@68: Not a backend at all, but a mask to select all backend bits from a jpayne@68: \&\f(CW\*(C`flags\*(C'\fR value, in case you want to mask out any backends from a flags jpayne@68: value (e.g. when modifying the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR environment variable). jpayne@68: .RE jpayne@68: .RS 4 jpayne@68: .Sp jpayne@68: If one or more of the backend flags are or'ed into the flags value, jpayne@68: then only these backends will be tried (in the reverse order as listed jpayne@68: here). If none are specified, all backends in \f(CW\*(C`ev_recommended_backends jpayne@68: ()\*(C'\fR will be tried. jpayne@68: .Sp jpayne@68: Example: Try to create a event loop that uses epoll and nothing else. jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& struct ev_loop *epoller = ev_loop_new (EVBACKEND_EPOLL | EVFLAG_NOENV); jpayne@68: \& if (!epoller) jpayne@68: \& fatal ("no epoll found here, maybe it hides under your chair"); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Example: Use whatever libev has to offer, but make sure that kqueue is jpayne@68: used if available. jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& struct ev_loop *loop = ev_loop_new (ev_recommended_backends () | EVBACKEND_KQUEUE); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Example: Similarly, on linux, you mgiht want to take advantage of the jpayne@68: linux aio backend if possible, but fall back to something else if that jpayne@68: isn't available. jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& struct ev_loop *loop = ev_loop_new (ev_recommended_backends () | EVBACKEND_LINUXAIO); jpayne@68: .Ve jpayne@68: .RE jpayne@68: .IP "ev_loop_destroy (loop)" 4 jpayne@68: .IX Item "ev_loop_destroy (loop)" jpayne@68: Destroys an event loop object (frees all memory and kernel state jpayne@68: etc.). None of the active event watchers will be stopped in the normal jpayne@68: sense, so e.g. \f(CW\*(C`ev_is_active\*(C'\fR might still return true. It is your jpayne@68: responsibility to either stop all watchers cleanly yourself \fIbefore\fR jpayne@68: calling this function, or cope with the fact afterwards (which is usually jpayne@68: the easiest thing, you can just ignore the watchers and/or \f(CW\*(C`free ()\*(C'\fR them jpayne@68: for example). jpayne@68: .Sp jpayne@68: Note that certain global state, such as signal state (and installed signal jpayne@68: handlers), will not be freed by this function, and related watchers (such jpayne@68: as signal and child watchers) would need to be stopped manually. jpayne@68: .Sp jpayne@68: This function is normally used on loop objects allocated by jpayne@68: \&\f(CW\*(C`ev_loop_new\*(C'\fR, but it can also be used on the default loop returned by jpayne@68: \&\f(CW\*(C`ev_default_loop\*(C'\fR, in which case it is not thread-safe. jpayne@68: .Sp jpayne@68: Note that it is not advisable to call this function on the default loop jpayne@68: except in the rare occasion where you really need to free its resources. jpayne@68: If you need dynamically allocated loops it is better to use \f(CW\*(C`ev_loop_new\*(C'\fR jpayne@68: and \f(CW\*(C`ev_loop_destroy\*(C'\fR. jpayne@68: .IP "ev_loop_fork (loop)" 4 jpayne@68: .IX Item "ev_loop_fork (loop)" jpayne@68: This function sets a flag that causes subsequent \f(CW\*(C`ev_run\*(C'\fR iterations jpayne@68: to reinitialise the kernel state for backends that have one. Despite jpayne@68: the name, you can call it anytime you are allowed to start or stop jpayne@68: watchers (except inside an \f(CW\*(C`ev_prepare\*(C'\fR callback), but it makes most jpayne@68: sense after forking, in the child process. You \fImust\fR call it (or use jpayne@68: \&\f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR) in the child before resuming or calling \f(CW\*(C`ev_run\*(C'\fR. jpayne@68: .Sp jpayne@68: In addition, if you want to reuse a loop (via this function or jpayne@68: \&\f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR), you \fIalso\fR have to ignore \f(CW\*(C`SIGPIPE\*(C'\fR. jpayne@68: .Sp jpayne@68: Again, you \fIhave\fR to call it on \fIany\fR loop that you want to re-use after jpayne@68: a fork, \fIeven if you do not plan to use the loop in the parent\fR. This is jpayne@68: because some kernel interfaces *cough* \fIkqueue\fR *cough* do funny things jpayne@68: during fork. jpayne@68: .Sp jpayne@68: On the other hand, you only need to call this function in the child jpayne@68: process if and only if you want to use the event loop in the child. If jpayne@68: you just fork+exec or create a new loop in the child, you don't have to jpayne@68: call it at all (in fact, \f(CW\*(C`epoll\*(C'\fR is so badly broken that it makes a jpayne@68: difference, but libev will usually detect this case on its own and do a jpayne@68: costly reset of the backend). jpayne@68: .Sp jpayne@68: The function itself is quite fast and it's usually not a problem to call jpayne@68: it just in case after a fork. jpayne@68: .Sp jpayne@68: Example: Automate calling \f(CW\*(C`ev_loop_fork\*(C'\fR on the default loop when jpayne@68: using pthreads. jpayne@68: .Sp jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& post_fork_child (void) jpayne@68: \& { jpayne@68: \& ev_loop_fork (EV_DEFAULT); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& pthread_atfork (0, 0, post_fork_child); jpayne@68: .Ve jpayne@68: .IP "int ev_is_default_loop (loop)" 4 jpayne@68: .IX Item "int ev_is_default_loop (loop)" jpayne@68: Returns true when the given loop is, in fact, the default loop, and false jpayne@68: otherwise. jpayne@68: .IP "unsigned int ev_iteration (loop)" 4 jpayne@68: .IX Item "unsigned int ev_iteration (loop)" jpayne@68: Returns the current iteration count for the event loop, which is identical jpayne@68: to the number of times libev did poll for new events. It starts at \f(CW0\fR jpayne@68: and happily wraps around with enough iterations. jpayne@68: .Sp jpayne@68: This value can sometimes be useful as a generation counter of sorts (it jpayne@68: \&\*(L"ticks\*(R" the number of loop iterations), as it roughly corresponds with jpayne@68: \&\f(CW\*(C`ev_prepare\*(C'\fR and \f(CW\*(C`ev_check\*(C'\fR calls \- and is incremented between the jpayne@68: prepare and check phases. jpayne@68: .IP "unsigned int ev_depth (loop)" 4 jpayne@68: .IX Item "unsigned int ev_depth (loop)" jpayne@68: Returns the number of times \f(CW\*(C`ev_run\*(C'\fR was entered minus the number of jpayne@68: times \f(CW\*(C`ev_run\*(C'\fR was exited normally, in other words, the recursion depth. jpayne@68: .Sp jpayne@68: Outside \f(CW\*(C`ev_run\*(C'\fR, this number is zero. In a callback, this number is jpayne@68: \&\f(CW1\fR, unless \f(CW\*(C`ev_run\*(C'\fR was invoked recursively (or from another thread), jpayne@68: in which case it is higher. jpayne@68: .Sp jpayne@68: Leaving \f(CW\*(C`ev_run\*(C'\fR abnormally (setjmp/longjmp, cancelling the thread, jpayne@68: throwing an exception etc.), doesn't count as \*(L"exit\*(R" \- consider this jpayne@68: as a hint to avoid such ungentleman-like behaviour unless it's really jpayne@68: convenient, in which case it is fully supported. jpayne@68: .IP "unsigned int ev_backend (loop)" 4 jpayne@68: .IX Item "unsigned int ev_backend (loop)" jpayne@68: Returns one of the \f(CW\*(C`EVBACKEND_*\*(C'\fR flags indicating the event backend in jpayne@68: use. jpayne@68: .IP "ev_tstamp ev_now (loop)" 4 jpayne@68: .IX Item "ev_tstamp ev_now (loop)" jpayne@68: Returns the current \*(L"event loop time\*(R", which is the time the event loop jpayne@68: received events and started processing them. This timestamp does not jpayne@68: change as long as callbacks are being processed, and this is also the base jpayne@68: time used for relative timers. You can treat it as the timestamp of the jpayne@68: event occurring (or more correctly, libev finding out about it). jpayne@68: .IP "ev_now_update (loop)" 4 jpayne@68: .IX Item "ev_now_update (loop)" jpayne@68: Establishes the current time by querying the kernel, updating the time jpayne@68: returned by \f(CW\*(C`ev_now ()\*(C'\fR in the progress. This is a costly operation and jpayne@68: is usually done automatically within \f(CW\*(C`ev_run ()\*(C'\fR. jpayne@68: .Sp jpayne@68: This function is rarely useful, but when some event callback runs for a jpayne@68: very long time without entering the event loop, updating libev's idea of jpayne@68: the current time is a good idea. jpayne@68: .Sp jpayne@68: See also \*(L"The special problem of time updates\*(R" in the \f(CW\*(C`ev_timer\*(C'\fR section. jpayne@68: .IP "ev_suspend (loop)" 4 jpayne@68: .IX Item "ev_suspend (loop)" jpayne@68: .PD 0 jpayne@68: .IP "ev_resume (loop)" 4 jpayne@68: .IX Item "ev_resume (loop)" jpayne@68: .PD jpayne@68: These two functions suspend and resume an event loop, for use when the jpayne@68: loop is not used for a while and timeouts should not be processed. jpayne@68: .Sp jpayne@68: A typical use case would be an interactive program such as a game: When jpayne@68: the user presses \f(CW\*(C`^Z\*(C'\fR to suspend the game and resumes it an hour later it jpayne@68: would be best to handle timeouts as if no time had actually passed while jpayne@68: the program was suspended. This can be achieved by calling \f(CW\*(C`ev_suspend\*(C'\fR jpayne@68: in your \f(CW\*(C`SIGTSTP\*(C'\fR handler, sending yourself a \f(CW\*(C`SIGSTOP\*(C'\fR and calling jpayne@68: \&\f(CW\*(C`ev_resume\*(C'\fR directly afterwards to resume timer processing. jpayne@68: .Sp jpayne@68: Effectively, all \f(CW\*(C`ev_timer\*(C'\fR watchers will be delayed by the time spend jpayne@68: between \f(CW\*(C`ev_suspend\*(C'\fR and \f(CW\*(C`ev_resume\*(C'\fR, and all \f(CW\*(C`ev_periodic\*(C'\fR watchers jpayne@68: will be rescheduled (that is, they will lose any events that would have jpayne@68: occurred while suspended). jpayne@68: .Sp jpayne@68: After calling \f(CW\*(C`ev_suspend\*(C'\fR you \fBmust not\fR call \fIany\fR function on the jpayne@68: given loop other than \f(CW\*(C`ev_resume\*(C'\fR, and you \fBmust not\fR call \f(CW\*(C`ev_resume\*(C'\fR jpayne@68: without a previous call to \f(CW\*(C`ev_suspend\*(C'\fR. jpayne@68: .Sp jpayne@68: Calling \f(CW\*(C`ev_suspend\*(C'\fR/\f(CW\*(C`ev_resume\*(C'\fR has the side effect of updating the jpayne@68: event loop time (see \f(CW\*(C`ev_now_update\*(C'\fR). jpayne@68: .IP "bool ev_run (loop, int flags)" 4 jpayne@68: .IX Item "bool ev_run (loop, int flags)" jpayne@68: Finally, this is it, the event handler. This function usually is called jpayne@68: after you have initialised all your watchers and you want to start jpayne@68: handling events. It will ask the operating system for any new events, call jpayne@68: the watcher callbacks, and then repeat the whole process indefinitely: This jpayne@68: is why event loops are called \fIloops\fR. jpayne@68: .Sp jpayne@68: If the flags argument is specified as \f(CW0\fR, it will keep handling events jpayne@68: until either no event watchers are active anymore or \f(CW\*(C`ev_break\*(C'\fR was jpayne@68: called. jpayne@68: .Sp jpayne@68: The return value is false if there are no more active watchers (which jpayne@68: usually means \*(L"all jobs done\*(R" or \*(L"deadlock\*(R"), and true in all other cases jpayne@68: (which usually means " you should call \f(CW\*(C`ev_run\*(C'\fR again"). jpayne@68: .Sp jpayne@68: Please note that an explicit \f(CW\*(C`ev_break\*(C'\fR is usually better than jpayne@68: relying on all watchers to be stopped when deciding when a program has jpayne@68: finished (especially in interactive programs), but having a program jpayne@68: that automatically loops as long as it has to and no longer by virtue jpayne@68: of relying on its watchers stopping correctly, that is truly a thing of jpayne@68: beauty. jpayne@68: .Sp jpayne@68: This function is \fImostly\fR exception-safe \- you can break out of a jpayne@68: \&\f(CW\*(C`ev_run\*(C'\fR call by calling \f(CW\*(C`longjmp\*(C'\fR in a callback, throwing a \*(C+ jpayne@68: exception and so on. This does not decrement the \f(CW\*(C`ev_depth\*(C'\fR value, nor jpayne@68: will it clear any outstanding \f(CW\*(C`EVBREAK_ONE\*(C'\fR breaks. jpayne@68: .Sp jpayne@68: A flags value of \f(CW\*(C`EVRUN_NOWAIT\*(C'\fR will look for new events, will handle jpayne@68: those events and any already outstanding ones, but will not wait and jpayne@68: block your process in case there are no events and will return after one jpayne@68: iteration of the loop. This is sometimes useful to poll and handle new jpayne@68: events while doing lengthy calculations, to keep the program responsive. jpayne@68: .Sp jpayne@68: A flags value of \f(CW\*(C`EVRUN_ONCE\*(C'\fR will look for new events (waiting if jpayne@68: necessary) and will handle those and any already outstanding ones. It jpayne@68: will block your process until at least one new event arrives (which could jpayne@68: be an event internal to libev itself, so there is no guarantee that a jpayne@68: user-registered callback will be called), and will return after one jpayne@68: iteration of the loop. jpayne@68: .Sp jpayne@68: This is useful if you are waiting for some external event in conjunction jpayne@68: with something not expressible using other libev watchers (i.e. "roll your jpayne@68: 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 jpayne@68: usually a better approach for this kind of thing. jpayne@68: .Sp jpayne@68: Here are the gory details of what \f(CW\*(C`ev_run\*(C'\fR does (this is for your jpayne@68: understanding, not a guarantee that things will work exactly like this in jpayne@68: future versions): jpayne@68: .Sp jpayne@68: .Vb 10 jpayne@68: \& \- Increment loop depth. jpayne@68: \& \- Reset the ev_break status. jpayne@68: \& \- Before the first iteration, call any pending watchers. jpayne@68: \& LOOP: jpayne@68: \& \- If EVFLAG_FORKCHECK was used, check for a fork. jpayne@68: \& \- If a fork was detected (by any means), queue and call all fork watchers. jpayne@68: \& \- Queue and call all prepare watchers. jpayne@68: \& \- If ev_break was called, goto FINISH. jpayne@68: \& \- If we have been forked, detach and recreate the kernel state jpayne@68: \& as to not disturb the other process. jpayne@68: \& \- Update the kernel state with all outstanding changes. jpayne@68: \& \- Update the "event loop time" (ev_now ()). jpayne@68: \& \- Calculate for how long to sleep or block, if at all jpayne@68: \& (active idle watchers, EVRUN_NOWAIT or not having jpayne@68: \& any active watchers at all will result in not sleeping). jpayne@68: \& \- Sleep if the I/O and timer collect interval say so. jpayne@68: \& \- Increment loop iteration counter. jpayne@68: \& \- Block the process, waiting for any events. jpayne@68: \& \- Queue all outstanding I/O (fd) events. jpayne@68: \& \- Update the "event loop time" (ev_now ()), and do time jump adjustments. jpayne@68: \& \- Queue all expired timers. jpayne@68: \& \- Queue all expired periodics. jpayne@68: \& \- Queue all idle watchers with priority higher than that of pending events. jpayne@68: \& \- Queue all check watchers. jpayne@68: \& \- Call all queued watchers in reverse order (i.e. check watchers first). jpayne@68: \& Signals and child watchers are implemented as I/O watchers, and will jpayne@68: \& be handled here by queueing them when their watcher gets executed. jpayne@68: \& \- If ev_break has been called, or EVRUN_ONCE or EVRUN_NOWAIT jpayne@68: \& were used, or there are no active watchers, goto FINISH, otherwise jpayne@68: \& continue with step LOOP. jpayne@68: \& FINISH: jpayne@68: \& \- Reset the ev_break status iff it was EVBREAK_ONE. jpayne@68: \& \- Decrement the loop depth. jpayne@68: \& \- Return. jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Example: Queue some jobs and then loop until no events are outstanding jpayne@68: anymore. jpayne@68: .Sp jpayne@68: .Vb 4 jpayne@68: \& ... queue jobs here, make sure they register event watchers as long jpayne@68: \& ... as they still have work to do (even an idle watcher will do..) jpayne@68: \& ev_run (my_loop, 0); jpayne@68: \& ... jobs done or somebody called break. yeah! jpayne@68: .Ve jpayne@68: .IP "ev_break (loop, how)" 4 jpayne@68: .IX Item "ev_break (loop, how)" jpayne@68: Can be used to make a call to \f(CW\*(C`ev_run\*(C'\fR return early (but only after it jpayne@68: has processed all outstanding events). The \f(CW\*(C`how\*(C'\fR argument must be either jpayne@68: \&\f(CW\*(C`EVBREAK_ONE\*(C'\fR, which will make the innermost \f(CW\*(C`ev_run\*(C'\fR call return, or jpayne@68: \&\f(CW\*(C`EVBREAK_ALL\*(C'\fR, which will make all nested \f(CW\*(C`ev_run\*(C'\fR calls return. jpayne@68: .Sp jpayne@68: This \*(L"break state\*(R" will be cleared on the next call to \f(CW\*(C`ev_run\*(C'\fR. jpayne@68: .Sp jpayne@68: 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 jpayne@68: which case it will have no effect. jpayne@68: .IP "ev_ref (loop)" 4 jpayne@68: .IX Item "ev_ref (loop)" jpayne@68: .PD 0 jpayne@68: .IP "ev_unref (loop)" 4 jpayne@68: .IX Item "ev_unref (loop)" jpayne@68: .PD jpayne@68: Ref/unref can be used to add or remove a reference count on the event jpayne@68: loop: Every watcher keeps one reference, and as long as the reference jpayne@68: count is nonzero, \f(CW\*(C`ev_run\*(C'\fR will not return on its own. jpayne@68: .Sp jpayne@68: This is useful when you have a watcher that you never intend to jpayne@68: unregister, but that nevertheless should not keep \f(CW\*(C`ev_run\*(C'\fR from jpayne@68: returning. In such a case, call \f(CW\*(C`ev_unref\*(C'\fR after starting, and \f(CW\*(C`ev_ref\*(C'\fR jpayne@68: before stopping it. jpayne@68: .Sp jpayne@68: As an example, libev itself uses this for its internal signal pipe: It jpayne@68: is not visible to the libev user and should not keep \f(CW\*(C`ev_run\*(C'\fR from jpayne@68: exiting if no event watchers registered by it are active. It is also an jpayne@68: excellent way to do this for generic recurring timers or from within jpayne@68: third-party libraries. Just remember to \fIunref after start\fR and \fIref jpayne@68: before stop\fR (but only if the watcher wasn't active before, or was active jpayne@68: before, respectively. Note also that libev might stop watchers itself jpayne@68: (e.g. non-repeating timers) in which case you have to \f(CW\*(C`ev_ref\*(C'\fR jpayne@68: in the callback). jpayne@68: .Sp jpayne@68: Example: Create a signal watcher, but keep it from keeping \f(CW\*(C`ev_run\*(C'\fR jpayne@68: running when nothing else is active. jpayne@68: .Sp jpayne@68: .Vb 4 jpayne@68: \& ev_signal exitsig; jpayne@68: \& ev_signal_init (&exitsig, sig_cb, SIGINT); jpayne@68: \& ev_signal_start (loop, &exitsig); jpayne@68: \& ev_unref (loop); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Example: For some weird reason, unregister the above signal handler again. jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& ev_ref (loop); jpayne@68: \& ev_signal_stop (loop, &exitsig); jpayne@68: .Ve jpayne@68: .IP "ev_set_io_collect_interval (loop, ev_tstamp interval)" 4 jpayne@68: .IX Item "ev_set_io_collect_interval (loop, ev_tstamp interval)" jpayne@68: .PD 0 jpayne@68: .IP "ev_set_timeout_collect_interval (loop, ev_tstamp interval)" 4 jpayne@68: .IX Item "ev_set_timeout_collect_interval (loop, ev_tstamp interval)" jpayne@68: .PD jpayne@68: These advanced functions influence the time that libev will spend waiting jpayne@68: for events. Both time intervals are by default \f(CW0\fR, meaning that libev jpayne@68: will try to invoke timer/periodic callbacks and I/O callbacks with minimum jpayne@68: latency. jpayne@68: .Sp jpayne@68: Setting these to a higher value (the \f(CW\*(C`interval\*(C'\fR \fImust\fR be >= \f(CW0\fR) jpayne@68: allows libev to delay invocation of I/O and timer/periodic callbacks jpayne@68: to increase efficiency of loop iterations (or to increase power-saving jpayne@68: opportunities). jpayne@68: .Sp jpayne@68: The idea is that sometimes your program runs just fast enough to handle jpayne@68: one (or very few) event(s) per loop iteration. While this makes the jpayne@68: program responsive, it also wastes a lot of \s-1CPU\s0 time to poll for new jpayne@68: events, especially with backends like \f(CW\*(C`select ()\*(C'\fR which have a high jpayne@68: overhead for the actual polling but can deliver many events at once. jpayne@68: .Sp jpayne@68: By setting a higher \fIio collect interval\fR you allow libev to spend more jpayne@68: time collecting I/O events, so you can handle more events per iteration, jpayne@68: at the cost of increasing latency. Timeouts (both \f(CW\*(C`ev_periodic\*(C'\fR and jpayne@68: \&\f(CW\*(C`ev_timer\*(C'\fR) will not be affected. Setting this to a non-null value will jpayne@68: introduce an additional \f(CW\*(C`ev_sleep ()\*(C'\fR call into most loop iterations. The jpayne@68: sleep time ensures that libev will not poll for I/O events more often then jpayne@68: once per this interval, on average (as long as the host time resolution is jpayne@68: good enough). jpayne@68: .Sp jpayne@68: Likewise, by setting a higher \fItimeout collect interval\fR you allow libev jpayne@68: to spend more time collecting timeouts, at the expense of increased jpayne@68: latency/jitter/inexactness (the watcher callback will be called jpayne@68: later). \f(CW\*(C`ev_io\*(C'\fR watchers will not be affected. Setting this to a non-null jpayne@68: value will not introduce any overhead in libev. jpayne@68: .Sp jpayne@68: Many (busy) programs can usually benefit by setting the I/O collect jpayne@68: interval to a value near \f(CW0.1\fR or so, which is often enough for jpayne@68: interactive servers (of course not for games), likewise for timeouts. It jpayne@68: usually doesn't make much sense to set it to a lower value than \f(CW0.01\fR, jpayne@68: as this approaches the timing granularity of most systems. Note that if jpayne@68: you do transactions with the outside world and you can't increase the jpayne@68: parallelity, then this setting will limit your transaction rate (if you jpayne@68: need to poll once per transaction and the I/O collect interval is 0.01, jpayne@68: then you can't do more than 100 transactions per second). jpayne@68: .Sp jpayne@68: Setting the \fItimeout collect interval\fR can improve the opportunity for jpayne@68: saving power, as the program will \*(L"bundle\*(R" timer callback invocations that jpayne@68: are \*(L"near\*(R" in time together, by delaying some, thus reducing the number of jpayne@68: times the process sleeps and wakes up again. Another useful technique to jpayne@68: reduce iterations/wake\-ups is to use \f(CW\*(C`ev_periodic\*(C'\fR watchers and make sure jpayne@68: they fire on, say, one-second boundaries only. jpayne@68: .Sp jpayne@68: Example: we only need 0.1s timeout granularity, and we wish not to poll jpayne@68: more often than 100 times per second: jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& ev_set_timeout_collect_interval (EV_DEFAULT_UC_ 0.1); jpayne@68: \& ev_set_io_collect_interval (EV_DEFAULT_UC_ 0.01); jpayne@68: .Ve jpayne@68: .IP "ev_invoke_pending (loop)" 4 jpayne@68: .IX Item "ev_invoke_pending (loop)" jpayne@68: This call will simply invoke all pending watchers while resetting their jpayne@68: pending state. Normally, \f(CW\*(C`ev_run\*(C'\fR does this automatically when required, jpayne@68: but when overriding the invoke callback this call comes handy. This jpayne@68: function can be invoked from a watcher \- this can be useful for example jpayne@68: when you want to do some lengthy calculation and want to pass further jpayne@68: event handling to another thread (you still have to make sure only one jpayne@68: thread executes within \f(CW\*(C`ev_invoke_pending\*(C'\fR or \f(CW\*(C`ev_run\*(C'\fR of course). jpayne@68: .IP "int ev_pending_count (loop)" 4 jpayne@68: .IX Item "int ev_pending_count (loop)" jpayne@68: Returns the number of pending watchers \- zero indicates that no watchers jpayne@68: are pending. jpayne@68: .IP "ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(\s-1EV_P\s0))" 4 jpayne@68: .IX Item "ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(EV_P))" jpayne@68: This overrides the invoke pending functionality of the loop: Instead of jpayne@68: invoking all pending watchers when there are any, \f(CW\*(C`ev_run\*(C'\fR will call jpayne@68: this callback instead. This is useful, for example, when you want to jpayne@68: invoke the actual watchers inside another context (another thread etc.). jpayne@68: .Sp jpayne@68: If you want to reset the callback, use \f(CW\*(C`ev_invoke_pending\*(C'\fR as new jpayne@68: callback. jpayne@68: .IP "ev_set_loop_release_cb (loop, void (*release)(\s-1EV_P\s0) throw (), void (*acquire)(\s-1EV_P\s0) throw ())" 4 jpayne@68: .IX Item "ev_set_loop_release_cb (loop, void (*release)(EV_P) throw (), void (*acquire)(EV_P) throw ())" jpayne@68: Sometimes you want to share the same loop between multiple threads. This jpayne@68: can be done relatively simply by putting mutex_lock/unlock calls around jpayne@68: each call to a libev function. jpayne@68: .Sp jpayne@68: However, \f(CW\*(C`ev_run\*(C'\fR can run an indefinite time, so it is not feasible jpayne@68: to wait for it to return. One way around this is to wake up the event jpayne@68: loop via \f(CW\*(C`ev_break\*(C'\fR and \f(CW\*(C`ev_async_send\*(C'\fR, another way is to set these jpayne@68: \&\fIrelease\fR and \fIacquire\fR callbacks on the loop. jpayne@68: .Sp jpayne@68: When set, then \f(CW\*(C`release\*(C'\fR will be called just before the thread is jpayne@68: suspended waiting for new events, and \f(CW\*(C`acquire\*(C'\fR is called just jpayne@68: afterwards. jpayne@68: .Sp jpayne@68: Ideally, \f(CW\*(C`release\*(C'\fR will just call your mutex_unlock function, and jpayne@68: \&\f(CW\*(C`acquire\*(C'\fR will just call the mutex_lock function again. jpayne@68: .Sp jpayne@68: While event loop modifications are allowed between invocations of jpayne@68: \&\f(CW\*(C`release\*(C'\fR and \f(CW\*(C`acquire\*(C'\fR (that's their only purpose after all), no jpayne@68: modifications done will affect the event loop, i.e. adding watchers will jpayne@68: have no effect on the set of file descriptors being watched, or the time jpayne@68: waited. Use an \f(CW\*(C`ev_async\*(C'\fR watcher to wake up \f(CW\*(C`ev_run\*(C'\fR when you want it jpayne@68: to take note of any changes you made. jpayne@68: .Sp jpayne@68: In theory, threads executing \f(CW\*(C`ev_run\*(C'\fR will be async-cancel safe between jpayne@68: invocations of \f(CW\*(C`release\*(C'\fR and \f(CW\*(C`acquire\*(C'\fR. jpayne@68: .Sp jpayne@68: See also the locking example in the \f(CW\*(C`THREADS\*(C'\fR section later in this jpayne@68: document. jpayne@68: .IP "ev_set_userdata (loop, void *data)" 4 jpayne@68: .IX Item "ev_set_userdata (loop, void *data)" jpayne@68: .PD 0 jpayne@68: .IP "void *ev_userdata (loop)" 4 jpayne@68: .IX Item "void *ev_userdata (loop)" jpayne@68: .PD jpayne@68: Set and retrieve a single \f(CW\*(C`void *\*(C'\fR associated with a loop. When jpayne@68: \&\f(CW\*(C`ev_set_userdata\*(C'\fR has never been called, then \f(CW\*(C`ev_userdata\*(C'\fR returns jpayne@68: \&\f(CW0\fR. jpayne@68: .Sp jpayne@68: These two functions can be used to associate arbitrary data with a loop, jpayne@68: and are intended solely for the \f(CW\*(C`invoke_pending_cb\*(C'\fR, \f(CW\*(C`release\*(C'\fR and jpayne@68: \&\f(CW\*(C`acquire\*(C'\fR callbacks described above, but of course can be (ab\-)used for jpayne@68: any other purpose as well. jpayne@68: .IP "ev_verify (loop)" 4 jpayne@68: .IX Item "ev_verify (loop)" jpayne@68: This function only does something when \f(CW\*(C`EV_VERIFY\*(C'\fR support has been jpayne@68: compiled in, which is the default for non-minimal builds. It tries to go jpayne@68: through all internal structures and checks them for validity. If anything jpayne@68: is found to be inconsistent, it will print an error message to standard jpayne@68: error and call \f(CW\*(C`abort ()\*(C'\fR. jpayne@68: .Sp jpayne@68: This can be used to catch bugs inside libev itself: under normal jpayne@68: circumstances, this function will never abort as of course libev keeps its jpayne@68: data structures consistent. jpayne@68: .SH "ANATOMY OF A WATCHER" jpayne@68: .IX Header "ANATOMY OF A WATCHER" jpayne@68: In the following description, uppercase \f(CW\*(C`TYPE\*(C'\fR in names stands for the jpayne@68: watcher type, e.g. \f(CW\*(C`ev_TYPE_start\*(C'\fR can mean \f(CW\*(C`ev_timer_start\*(C'\fR for timer jpayne@68: watchers and \f(CW\*(C`ev_io_start\*(C'\fR for I/O watchers. jpayne@68: .PP jpayne@68: A watcher is an opaque structure that you allocate and register to record jpayne@68: your interest in some event. To make a concrete example, imagine you want jpayne@68: to wait for \s-1STDIN\s0 to become readable, you would create an \f(CW\*(C`ev_io\*(C'\fR watcher jpayne@68: for that: jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void my_cb (struct ev_loop *loop, ev_io *w, int revents) jpayne@68: \& { jpayne@68: \& ev_io_stop (w); jpayne@68: \& ev_break (loop, EVBREAK_ALL); jpayne@68: \& } jpayne@68: \& jpayne@68: \& struct ev_loop *loop = ev_default_loop (0); jpayne@68: \& jpayne@68: \& ev_io stdin_watcher; jpayne@68: \& jpayne@68: \& ev_init (&stdin_watcher, my_cb); jpayne@68: \& ev_io_set (&stdin_watcher, STDIN_FILENO, EV_READ); jpayne@68: \& ev_io_start (loop, &stdin_watcher); jpayne@68: \& jpayne@68: \& ev_run (loop, 0); jpayne@68: .Ve jpayne@68: .PP jpayne@68: As you can see, you are responsible for allocating the memory for your jpayne@68: watcher structures (and it is \fIusually\fR a bad idea to do this on the jpayne@68: stack). jpayne@68: .PP jpayne@68: Each watcher has an associated watcher structure (called \f(CW\*(C`struct ev_TYPE\*(C'\fR jpayne@68: or simply \f(CW\*(C`ev_TYPE\*(C'\fR, as typedefs are provided for all watcher structs). jpayne@68: .PP jpayne@68: Each watcher structure must be initialised by a call to \f(CW\*(C`ev_init (watcher jpayne@68: *, callback)\*(C'\fR, which expects a callback to be provided. This callback is jpayne@68: invoked each time the event occurs (or, in the case of I/O watchers, each jpayne@68: time the event loop detects that the file descriptor given is readable jpayne@68: and/or writable). jpayne@68: .PP jpayne@68: Each watcher type further has its own \f(CW\*(C`ev_TYPE_set (watcher *, ...)\*(C'\fR jpayne@68: macro to configure it, with arguments specific to the watcher type. There jpayne@68: is also a macro to combine initialisation and setting in one call: \f(CW\*(C`ev_TYPE_init (watcher *, callback, ...)\*(C'\fR. jpayne@68: .PP jpayne@68: To make the watcher actually watch out for events, you have to start it jpayne@68: with a watcher-specific start function (\f(CW\*(C`ev_TYPE_start (loop, watcher jpayne@68: *)\*(C'\fR), and you can stop watching for events at any time by calling the jpayne@68: corresponding stop function (\f(CW\*(C`ev_TYPE_stop (loop, watcher *)\*(C'\fR. jpayne@68: .PP jpayne@68: As long as your watcher is active (has been started but not stopped) you jpayne@68: must not touch the values stored in it except when explicitly documented jpayne@68: otherwise. Most specifically you must never reinitialise it or call its jpayne@68: \&\f(CW\*(C`ev_TYPE_set\*(C'\fR macro. jpayne@68: .PP jpayne@68: Each and every callback receives the event loop pointer as first, the jpayne@68: registered watcher structure as second, and a bitset of received events as jpayne@68: third argument. jpayne@68: .PP jpayne@68: The received events usually include a single bit per event type received jpayne@68: (you can receive multiple events at the same time). The possible bit masks jpayne@68: are: jpayne@68: .ie n .IP """EV_READ""" 4 jpayne@68: .el .IP "\f(CWEV_READ\fR" 4 jpayne@68: .IX Item "EV_READ" jpayne@68: .PD 0 jpayne@68: .ie n .IP """EV_WRITE""" 4 jpayne@68: .el .IP "\f(CWEV_WRITE\fR" 4 jpayne@68: .IX Item "EV_WRITE" jpayne@68: .PD jpayne@68: The file descriptor in the \f(CW\*(C`ev_io\*(C'\fR watcher has become readable and/or jpayne@68: writable. jpayne@68: .ie n .IP """EV_TIMER""" 4 jpayne@68: .el .IP "\f(CWEV_TIMER\fR" 4 jpayne@68: .IX Item "EV_TIMER" jpayne@68: The \f(CW\*(C`ev_timer\*(C'\fR watcher has timed out. jpayne@68: .ie n .IP """EV_PERIODIC""" 4 jpayne@68: .el .IP "\f(CWEV_PERIODIC\fR" 4 jpayne@68: .IX Item "EV_PERIODIC" jpayne@68: The \f(CW\*(C`ev_periodic\*(C'\fR watcher has timed out. jpayne@68: .ie n .IP """EV_SIGNAL""" 4 jpayne@68: .el .IP "\f(CWEV_SIGNAL\fR" 4 jpayne@68: .IX Item "EV_SIGNAL" jpayne@68: The signal specified in the \f(CW\*(C`ev_signal\*(C'\fR watcher has been received by a thread. jpayne@68: .ie n .IP """EV_CHILD""" 4 jpayne@68: .el .IP "\f(CWEV_CHILD\fR" 4 jpayne@68: .IX Item "EV_CHILD" jpayne@68: The pid specified in the \f(CW\*(C`ev_child\*(C'\fR watcher has received a status change. jpayne@68: .ie n .IP """EV_STAT""" 4 jpayne@68: .el .IP "\f(CWEV_STAT\fR" 4 jpayne@68: .IX Item "EV_STAT" jpayne@68: The path specified in the \f(CW\*(C`ev_stat\*(C'\fR watcher changed its attributes somehow. jpayne@68: .ie n .IP """EV_IDLE""" 4 jpayne@68: .el .IP "\f(CWEV_IDLE\fR" 4 jpayne@68: .IX Item "EV_IDLE" jpayne@68: The \f(CW\*(C`ev_idle\*(C'\fR watcher has determined that you have nothing better to do. jpayne@68: .ie n .IP """EV_PREPARE""" 4 jpayne@68: .el .IP "\f(CWEV_PREPARE\fR" 4 jpayne@68: .IX Item "EV_PREPARE" jpayne@68: .PD 0 jpayne@68: .ie n .IP """EV_CHECK""" 4 jpayne@68: .el .IP "\f(CWEV_CHECK\fR" 4 jpayne@68: .IX Item "EV_CHECK" jpayne@68: .PD jpayne@68: All \f(CW\*(C`ev_prepare\*(C'\fR watchers are invoked just \fIbefore\fR \f(CW\*(C`ev_run\*(C'\fR starts to jpayne@68: gather new events, and all \f(CW\*(C`ev_check\*(C'\fR watchers are queued (not invoked) jpayne@68: just after \f(CW\*(C`ev_run\*(C'\fR has gathered them, but before it queues any callbacks jpayne@68: for any received events. That means \f(CW\*(C`ev_prepare\*(C'\fR watchers are the last jpayne@68: watchers invoked before the event loop sleeps or polls for new events, and jpayne@68: \&\f(CW\*(C`ev_check\*(C'\fR watchers will be invoked before any other watchers of the same jpayne@68: or lower priority within an event loop iteration. jpayne@68: .Sp jpayne@68: Callbacks of both watcher types can start and stop as many watchers as jpayne@68: they want, and all of them will be taken into account (for example, a jpayne@68: \&\f(CW\*(C`ev_prepare\*(C'\fR watcher might start an idle watcher to keep \f(CW\*(C`ev_run\*(C'\fR from jpayne@68: blocking). jpayne@68: .ie n .IP """EV_EMBED""" 4 jpayne@68: .el .IP "\f(CWEV_EMBED\fR" 4 jpayne@68: .IX Item "EV_EMBED" jpayne@68: The embedded event loop specified in the \f(CW\*(C`ev_embed\*(C'\fR watcher needs attention. jpayne@68: .ie n .IP """EV_FORK""" 4 jpayne@68: .el .IP "\f(CWEV_FORK\fR" 4 jpayne@68: .IX Item "EV_FORK" jpayne@68: The event loop has been resumed in the child process after fork (see jpayne@68: \&\f(CW\*(C`ev_fork\*(C'\fR). jpayne@68: .ie n .IP """EV_CLEANUP""" 4 jpayne@68: .el .IP "\f(CWEV_CLEANUP\fR" 4 jpayne@68: .IX Item "EV_CLEANUP" jpayne@68: The event loop is about to be destroyed (see \f(CW\*(C`ev_cleanup\*(C'\fR). jpayne@68: .ie n .IP """EV_ASYNC""" 4 jpayne@68: .el .IP "\f(CWEV_ASYNC\fR" 4 jpayne@68: .IX Item "EV_ASYNC" jpayne@68: The given async watcher has been asynchronously notified (see \f(CW\*(C`ev_async\*(C'\fR). jpayne@68: .ie n .IP """EV_CUSTOM""" 4 jpayne@68: .el .IP "\f(CWEV_CUSTOM\fR" 4 jpayne@68: .IX Item "EV_CUSTOM" jpayne@68: Not ever sent (or otherwise used) by libev itself, but can be freely used jpayne@68: by libev users to signal watchers (e.g. via \f(CW\*(C`ev_feed_event\*(C'\fR). jpayne@68: .ie n .IP """EV_ERROR""" 4 jpayne@68: .el .IP "\f(CWEV_ERROR\fR" 4 jpayne@68: .IX Item "EV_ERROR" jpayne@68: An unspecified error has occurred, the watcher has been stopped. This might jpayne@68: happen because the watcher could not be properly started because libev jpayne@68: ran out of memory, a file descriptor was found to be closed or any other jpayne@68: problem. Libev considers these application bugs. jpayne@68: .Sp jpayne@68: You best act on it by reporting the problem and somehow coping with the jpayne@68: watcher being stopped. Note that well-written programs should not receive jpayne@68: an error ever, so when your watcher receives it, this usually indicates a jpayne@68: bug in your program. jpayne@68: .Sp jpayne@68: Libev will usually signal a few \*(L"dummy\*(R" events together with an error, for jpayne@68: example it might indicate that a fd is readable or writable, and if your jpayne@68: callbacks is well-written it can just attempt the operation and cope with jpayne@68: the error from \fBread()\fR or \fBwrite()\fR. This will not work in multi-threaded jpayne@68: programs, though, as the fd could already be closed and reused for another jpayne@68: thing, so beware. jpayne@68: .SS "\s-1GENERIC WATCHER FUNCTIONS\s0" jpayne@68: .IX Subsection "GENERIC WATCHER FUNCTIONS" jpayne@68: .ie n .IP """ev_init"" (ev_TYPE *watcher, callback)" 4 jpayne@68: .el .IP "\f(CWev_init\fR (ev_TYPE *watcher, callback)" 4 jpayne@68: .IX Item "ev_init (ev_TYPE *watcher, callback)" jpayne@68: This macro initialises the generic portion of a watcher. The contents jpayne@68: of the watcher object can be arbitrary (so \f(CW\*(C`malloc\*(C'\fR will do). Only jpayne@68: the generic parts of the watcher are initialised, you \fIneed\fR to call jpayne@68: the type-specific \f(CW\*(C`ev_TYPE_set\*(C'\fR macro afterwards to initialise the jpayne@68: type-specific parts. For each type there is also a \f(CW\*(C`ev_TYPE_init\*(C'\fR macro jpayne@68: which rolls both calls into one. jpayne@68: .Sp jpayne@68: You can reinitialise a watcher at any time as long as it has been stopped jpayne@68: (or never started) and there are no pending events outstanding. jpayne@68: .Sp jpayne@68: The callback is always of type \f(CW\*(C`void (*)(struct ev_loop *loop, ev_TYPE *watcher, jpayne@68: int revents)\*(C'\fR. jpayne@68: .Sp jpayne@68: Example: Initialise an \f(CW\*(C`ev_io\*(C'\fR watcher in two steps. jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& ev_io w; jpayne@68: \& ev_init (&w, my_cb); jpayne@68: \& ev_io_set (&w, STDIN_FILENO, EV_READ); jpayne@68: .Ve jpayne@68: .ie n .IP """ev_TYPE_set"" (ev_TYPE *watcher, [args])" 4 jpayne@68: .el .IP "\f(CWev_TYPE_set\fR (ev_TYPE *watcher, [args])" 4 jpayne@68: .IX Item "ev_TYPE_set (ev_TYPE *watcher, [args])" jpayne@68: This macro initialises the type-specific parts of a watcher. You need to jpayne@68: call \f(CW\*(C`ev_init\*(C'\fR at least once before you call this macro, but you can jpayne@68: call \f(CW\*(C`ev_TYPE_set\*(C'\fR any number of times. You must not, however, call this jpayne@68: macro on a watcher that is active (it can be pending, however, which is a jpayne@68: difference to the \f(CW\*(C`ev_init\*(C'\fR macro). jpayne@68: .Sp jpayne@68: Although some watcher types do not have type-specific arguments jpayne@68: (e.g. \f(CW\*(C`ev_prepare\*(C'\fR) you still need to call its \f(CW\*(C`set\*(C'\fR macro. jpayne@68: .Sp jpayne@68: See \f(CW\*(C`ev_init\*(C'\fR, above, for an example. jpayne@68: .ie n .IP """ev_TYPE_init"" (ev_TYPE *watcher, callback, [args])" 4 jpayne@68: .el .IP "\f(CWev_TYPE_init\fR (ev_TYPE *watcher, callback, [args])" 4 jpayne@68: .IX Item "ev_TYPE_init (ev_TYPE *watcher, callback, [args])" jpayne@68: This convenience macro rolls both \f(CW\*(C`ev_init\*(C'\fR and \f(CW\*(C`ev_TYPE_set\*(C'\fR macro jpayne@68: calls into a single call. This is the most convenient method to initialise jpayne@68: a watcher. The same limitations apply, of course. jpayne@68: .Sp jpayne@68: Example: Initialise and set an \f(CW\*(C`ev_io\*(C'\fR watcher in one step. jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& ev_io_init (&w, my_cb, STDIN_FILENO, EV_READ); jpayne@68: .Ve jpayne@68: .ie n .IP """ev_TYPE_start"" (loop, ev_TYPE *watcher)" 4 jpayne@68: .el .IP "\f(CWev_TYPE_start\fR (loop, ev_TYPE *watcher)" 4 jpayne@68: .IX Item "ev_TYPE_start (loop, ev_TYPE *watcher)" jpayne@68: Starts (activates) the given watcher. Only active watchers will receive jpayne@68: events. If the watcher is already active nothing will happen. jpayne@68: .Sp jpayne@68: Example: Start the \f(CW\*(C`ev_io\*(C'\fR watcher that is being abused as example in this jpayne@68: whole section. jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& ev_io_start (EV_DEFAULT_UC, &w); jpayne@68: .Ve jpayne@68: .ie n .IP """ev_TYPE_stop"" (loop, ev_TYPE *watcher)" 4 jpayne@68: .el .IP "\f(CWev_TYPE_stop\fR (loop, ev_TYPE *watcher)" 4 jpayne@68: .IX Item "ev_TYPE_stop (loop, ev_TYPE *watcher)" jpayne@68: Stops the given watcher if active, and clears the pending status (whether jpayne@68: the watcher was active or not). jpayne@68: .Sp jpayne@68: It is possible that stopped watchers are pending \- for example, jpayne@68: non-repeating timers are being stopped when they become pending \- but jpayne@68: calling \f(CW\*(C`ev_TYPE_stop\*(C'\fR ensures that the watcher is neither active nor jpayne@68: pending. If you want to free or reuse the memory used by the watcher it is jpayne@68: therefore a good idea to always call its \f(CW\*(C`ev_TYPE_stop\*(C'\fR function. jpayne@68: .IP "bool ev_is_active (ev_TYPE *watcher)" 4 jpayne@68: .IX Item "bool ev_is_active (ev_TYPE *watcher)" jpayne@68: Returns a true value iff the watcher is active (i.e. it has been started jpayne@68: and not yet been stopped). As long as a watcher is active you must not modify jpayne@68: it. jpayne@68: .IP "bool ev_is_pending (ev_TYPE *watcher)" 4 jpayne@68: .IX Item "bool ev_is_pending (ev_TYPE *watcher)" jpayne@68: Returns a true value iff the watcher is pending, (i.e. it has outstanding jpayne@68: events but its callback has not yet been invoked). As long as a watcher jpayne@68: is pending (but not active) you must not call an init function on it (but jpayne@68: \&\f(CW\*(C`ev_TYPE_set\*(C'\fR is safe), you must not change its priority, and you must jpayne@68: make sure the watcher is available to libev (e.g. you cannot \f(CW\*(C`free ()\*(C'\fR jpayne@68: it). jpayne@68: .IP "callback ev_cb (ev_TYPE *watcher)" 4 jpayne@68: .IX Item "callback ev_cb (ev_TYPE *watcher)" jpayne@68: Returns the callback currently set on the watcher. jpayne@68: .IP "ev_set_cb (ev_TYPE *watcher, callback)" 4 jpayne@68: .IX Item "ev_set_cb (ev_TYPE *watcher, callback)" jpayne@68: Change the callback. You can change the callback at virtually any time jpayne@68: (modulo threads). jpayne@68: .IP "ev_set_priority (ev_TYPE *watcher, int priority)" 4 jpayne@68: .IX Item "ev_set_priority (ev_TYPE *watcher, int priority)" jpayne@68: .PD 0 jpayne@68: .IP "int ev_priority (ev_TYPE *watcher)" 4 jpayne@68: .IX Item "int ev_priority (ev_TYPE *watcher)" jpayne@68: .PD jpayne@68: Set and query the priority of the watcher. The priority is a small jpayne@68: integer between \f(CW\*(C`EV_MAXPRI\*(C'\fR (default: \f(CW2\fR) and \f(CW\*(C`EV_MINPRI\*(C'\fR jpayne@68: (default: \f(CW\*(C`\-2\*(C'\fR). Pending watchers with higher priority will be invoked jpayne@68: before watchers with lower priority, but priority will not keep watchers jpayne@68: from being executed (except for \f(CW\*(C`ev_idle\*(C'\fR watchers). jpayne@68: .Sp jpayne@68: If you need to suppress invocation when higher priority events are pending jpayne@68: you need to look at \f(CW\*(C`ev_idle\*(C'\fR watchers, which provide this functionality. jpayne@68: .Sp jpayne@68: You \fImust not\fR change the priority of a watcher as long as it is active or jpayne@68: pending. jpayne@68: .Sp jpayne@68: Setting a priority outside the range of \f(CW\*(C`EV_MINPRI\*(C'\fR to \f(CW\*(C`EV_MAXPRI\*(C'\fR is jpayne@68: fine, as long as you do not mind that the priority value you query might jpayne@68: or might not have been clamped to the valid range. jpayne@68: .Sp jpayne@68: The default priority used by watchers when no priority has been set is jpayne@68: always \f(CW0\fR, which is supposed to not be too high and not be too low :). jpayne@68: .Sp jpayne@68: See \*(L"\s-1WATCHER PRIORITY MODELS\*(R"\s0, below, for a more thorough treatment of jpayne@68: priorities. jpayne@68: .IP "ev_invoke (loop, ev_TYPE *watcher, int revents)" 4 jpayne@68: .IX Item "ev_invoke (loop, ev_TYPE *watcher, int revents)" jpayne@68: 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 jpayne@68: \&\f(CW\*(C`loop\*(C'\fR nor \f(CW\*(C`revents\*(C'\fR need to be valid as long as the watcher callback jpayne@68: can deal with that fact, as both are simply passed through to the jpayne@68: callback. jpayne@68: .IP "int ev_clear_pending (loop, ev_TYPE *watcher)" 4 jpayne@68: .IX Item "int ev_clear_pending (loop, ev_TYPE *watcher)" jpayne@68: If the watcher is pending, this function clears its pending status and jpayne@68: returns its \f(CW\*(C`revents\*(C'\fR bitset (as if its callback was invoked). If the jpayne@68: watcher isn't pending it does nothing and returns \f(CW0\fR. jpayne@68: .Sp jpayne@68: Sometimes it can be useful to \*(L"poll\*(R" a watcher instead of waiting for its jpayne@68: callback to be invoked, which can be accomplished with this function. jpayne@68: .IP "ev_feed_event (loop, ev_TYPE *watcher, int revents)" 4 jpayne@68: .IX Item "ev_feed_event (loop, ev_TYPE *watcher, int revents)" jpayne@68: Feeds the given event set into the event loop, as if the specified event jpayne@68: had happened for the specified watcher (which must be a pointer to an jpayne@68: initialised but not necessarily started event watcher). Obviously you must jpayne@68: not free the watcher as long as it has pending events. jpayne@68: .Sp jpayne@68: Stopping the watcher, letting libev invoke it, or calling jpayne@68: \&\f(CW\*(C`ev_clear_pending\*(C'\fR will clear the pending event, even if the watcher was jpayne@68: not started in the first place. jpayne@68: .Sp jpayne@68: See also \f(CW\*(C`ev_feed_fd_event\*(C'\fR and \f(CW\*(C`ev_feed_signal_event\*(C'\fR for related jpayne@68: functions that do not need a watcher. jpayne@68: .PP jpayne@68: See also the \*(L"\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\*(R"\s0 and \*(L"\s-1BUILDING YOUR jpayne@68: OWN COMPOSITE WATCHERS\*(R"\s0 idioms. jpayne@68: .SS "\s-1WATCHER STATES\s0" jpayne@68: .IX Subsection "WATCHER STATES" jpayne@68: There are various watcher states mentioned throughout this manual \- jpayne@68: active, pending and so on. In this section these states and the rules to jpayne@68: transition between them will be described in more detail \- and while these jpayne@68: rules might look complicated, they usually do \*(L"the right thing\*(R". jpayne@68: .IP "initialised" 4 jpayne@68: .IX Item "initialised" jpayne@68: Before a watcher can be registered with the event loop it has to be jpayne@68: initialised. This can be done with a call to \f(CW\*(C`ev_TYPE_init\*(C'\fR, or calls to jpayne@68: \&\f(CW\*(C`ev_init\*(C'\fR followed by the watcher-specific \f(CW\*(C`ev_TYPE_set\*(C'\fR function. jpayne@68: .Sp jpayne@68: In this state it is simply some block of memory that is suitable for jpayne@68: use in an event loop. It can be moved around, freed, reused etc. at jpayne@68: will \- as long as you either keep the memory contents intact, or call jpayne@68: \&\f(CW\*(C`ev_TYPE_init\*(C'\fR again. jpayne@68: .IP "started/running/active" 4 jpayne@68: .IX Item "started/running/active" jpayne@68: Once a watcher has been started with a call to \f(CW\*(C`ev_TYPE_start\*(C'\fR it becomes jpayne@68: property of the event loop, and is actively waiting for events. While in jpayne@68: this state it cannot be accessed (except in a few documented ways), moved, jpayne@68: freed or anything else \- the only legal thing is to keep a pointer to it, jpayne@68: and call libev functions on it that are documented to work on active watchers. jpayne@68: .IP "pending" 4 jpayne@68: .IX Item "pending" jpayne@68: If a watcher is active and libev determines that an event it is interested jpayne@68: in has occurred (such as a timer expiring), it will become pending. It will jpayne@68: stay in this pending state until either it is stopped or its callback is jpayne@68: about to be invoked, so it is not normally pending inside the watcher jpayne@68: callback. jpayne@68: .Sp jpayne@68: The watcher might or might not be active while it is pending (for example, jpayne@68: an expired non-repeating timer can be pending but no longer active). If it jpayne@68: is stopped, it can be freely accessed (e.g. by calling \f(CW\*(C`ev_TYPE_set\*(C'\fR), jpayne@68: but it is still property of the event loop at this time, so cannot be jpayne@68: moved, freed or reused. And if it is active the rules described in the jpayne@68: previous item still apply. jpayne@68: .Sp jpayne@68: It is also possible to feed an event on a watcher that is not active (e.g. jpayne@68: via \f(CW\*(C`ev_feed_event\*(C'\fR), in which case it becomes pending without being jpayne@68: active. jpayne@68: .IP "stopped" 4 jpayne@68: .IX Item "stopped" jpayne@68: A watcher can be stopped implicitly by libev (in which case it might still jpayne@68: be pending), or explicitly by calling its \f(CW\*(C`ev_TYPE_stop\*(C'\fR function. The jpayne@68: latter will clear any pending state the watcher might be in, regardless jpayne@68: of whether it was active or not, so stopping a watcher explicitly before jpayne@68: freeing it is often a good idea. jpayne@68: .Sp jpayne@68: While stopped (and not pending) the watcher is essentially in the jpayne@68: initialised state, that is, it can be reused, moved, modified in any way jpayne@68: you wish (but when you trash the memory block, you need to \f(CW\*(C`ev_TYPE_init\*(C'\fR jpayne@68: it again). jpayne@68: .SS "\s-1WATCHER PRIORITY MODELS\s0" jpayne@68: .IX Subsection "WATCHER PRIORITY MODELS" jpayne@68: Many event loops support \fIwatcher priorities\fR, which are usually small jpayne@68: integers that influence the ordering of event callback invocation jpayne@68: between watchers in some way, all else being equal. jpayne@68: .PP jpayne@68: In libev, watcher priorities can be set using \f(CW\*(C`ev_set_priority\*(C'\fR. See its jpayne@68: description for the more technical details such as the actual priority jpayne@68: range. jpayne@68: .PP jpayne@68: There are two common ways how these these priorities are being interpreted jpayne@68: by event loops: jpayne@68: .PP jpayne@68: In the more common lock-out model, higher priorities \*(L"lock out\*(R" invocation jpayne@68: of lower priority watchers, which means as long as higher priority jpayne@68: watchers receive events, lower priority watchers are not being invoked. jpayne@68: .PP jpayne@68: The less common only-for-ordering model uses priorities solely to order jpayne@68: callback invocation within a single event loop iteration: Higher priority jpayne@68: watchers are invoked before lower priority ones, but they all get invoked jpayne@68: before polling for new events. jpayne@68: .PP jpayne@68: Libev uses the second (only-for-ordering) model for all its watchers jpayne@68: except for idle watchers (which use the lock-out model). jpayne@68: .PP jpayne@68: The rationale behind this is that implementing the lock-out model for jpayne@68: watchers is not well supported by most kernel interfaces, and most event jpayne@68: libraries will just poll for the same events again and again as long as jpayne@68: their callbacks have not been executed, which is very inefficient in the jpayne@68: common case of one high-priority watcher locking out a mass of lower jpayne@68: priority ones. jpayne@68: .PP jpayne@68: Static (ordering) priorities are most useful when you have two or more jpayne@68: watchers handling the same resource: a typical usage example is having an jpayne@68: \&\f(CW\*(C`ev_io\*(C'\fR watcher to receive data, and an associated \f(CW\*(C`ev_timer\*(C'\fR to handle jpayne@68: timeouts. Under load, data might be received while the program handles jpayne@68: other jobs, but since timers normally get invoked first, the timeout jpayne@68: handler will be executed before checking for data. In that case, giving jpayne@68: the timer a lower priority than the I/O watcher ensures that I/O will be jpayne@68: handled first even under adverse conditions (which is usually, but not jpayne@68: always, what you want). jpayne@68: .PP jpayne@68: Since idle watchers use the \*(L"lock-out\*(R" model, meaning that idle watchers jpayne@68: will only be executed when no same or higher priority watchers have jpayne@68: received events, they can be used to implement the \*(L"lock-out\*(R" model when jpayne@68: required. jpayne@68: .PP jpayne@68: For example, to emulate how many other event libraries handle priorities, jpayne@68: you can associate an \f(CW\*(C`ev_idle\*(C'\fR watcher to each such watcher, and in jpayne@68: the normal watcher callback, you just start the idle watcher. The real jpayne@68: processing is done in the idle watcher callback. This causes libev to jpayne@68: continuously poll and process kernel event data for the watcher, but when jpayne@68: the lock-out case is known to be rare (which in turn is rare :), this is jpayne@68: workable. jpayne@68: .PP jpayne@68: Usually, however, the lock-out model implemented that way will perform jpayne@68: miserably under the type of load it was designed to handle. In that case, jpayne@68: it might be preferable to stop the real watcher before starting the jpayne@68: idle watcher, so the kernel will not have to process the event in case jpayne@68: the actual processing will be delayed for considerable time. jpayne@68: .PP jpayne@68: Here is an example of an I/O watcher that should run at a strictly lower jpayne@68: priority than the default, and which should only process data when no jpayne@68: other events are pending: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& ev_idle idle; // actual processing watcher jpayne@68: \& ev_io io; // actual event watcher jpayne@68: \& jpayne@68: \& static void jpayne@68: \& io_cb (EV_P_ ev_io *w, int revents) jpayne@68: \& { jpayne@68: \& // stop the I/O watcher, we received the event, but jpayne@68: \& // are not yet ready to handle it. jpayne@68: \& ev_io_stop (EV_A_ w); jpayne@68: \& jpayne@68: \& // start the idle watcher to handle the actual event. jpayne@68: \& // it will not be executed as long as other watchers jpayne@68: \& // with the default priority are receiving events. jpayne@68: \& ev_idle_start (EV_A_ &idle); jpayne@68: \& } jpayne@68: \& jpayne@68: \& static void jpayne@68: \& idle_cb (EV_P_ ev_idle *w, int revents) jpayne@68: \& { jpayne@68: \& // actual processing jpayne@68: \& read (STDIN_FILENO, ...); jpayne@68: \& jpayne@68: \& // have to start the I/O watcher again, as jpayne@68: \& // we have handled the event jpayne@68: \& ev_io_start (EV_P_ &io); jpayne@68: \& } jpayne@68: \& jpayne@68: \& // initialisation jpayne@68: \& ev_idle_init (&idle, idle_cb); jpayne@68: \& ev_io_init (&io, io_cb, STDIN_FILENO, EV_READ); jpayne@68: \& ev_io_start (EV_DEFAULT_ &io); jpayne@68: .Ve jpayne@68: .PP jpayne@68: In the \*(L"real\*(R" world, it might also be beneficial to start a timer, so that jpayne@68: low-priority connections can not be locked out forever under load. This jpayne@68: enables your program to keep a lower latency for important connections jpayne@68: during short periods of high load, while not completely locking out less jpayne@68: important ones. jpayne@68: .SH "WATCHER TYPES" jpayne@68: .IX Header "WATCHER TYPES" jpayne@68: This section describes each watcher in detail, but will not repeat jpayne@68: information given in the last section. Any initialisation/set macros, jpayne@68: functions and members specific to the watcher type are explained. jpayne@68: .PP jpayne@68: Most members are additionally marked with either \fI[read\-only]\fR, meaning jpayne@68: that, while the watcher is active, you can look at the member and expect jpayne@68: some sensible content, but you must not modify it (you can modify it while jpayne@68: the watcher is stopped to your hearts content), or \fI[read\-write]\fR, which jpayne@68: means you can expect it to have some sensible content while the watcher is jpayne@68: active, but you can also modify it (within the same thread as the event jpayne@68: loop, i.e. without creating data races). Modifying it may not do something jpayne@68: sensible or take immediate effect (or do anything at all), but libev will jpayne@68: not crash or malfunction in any way. jpayne@68: .PP jpayne@68: In any case, the documentation for each member will explain what the jpayne@68: effects are, and if there are any additional access restrictions. jpayne@68: .ie n .SS """ev_io"" \- is this file descriptor readable or writable?" jpayne@68: .el .SS "\f(CWev_io\fP \- is this file descriptor readable or writable?" jpayne@68: .IX Subsection "ev_io - is this file descriptor readable or writable?" jpayne@68: I/O watchers check whether a file descriptor is readable or writable jpayne@68: in each iteration of the event loop, or, more precisely, when reading jpayne@68: would not block the process and writing would at least be able to write jpayne@68: some data. This behaviour is called level-triggering because you keep jpayne@68: receiving events as long as the condition persists. Remember you can stop jpayne@68: the watcher if you don't want to act on the event and neither want to jpayne@68: receive future events. jpayne@68: .PP jpayne@68: In general you can register as many read and/or write event watchers per jpayne@68: fd as you want (as long as you don't confuse yourself). Setting all file jpayne@68: descriptors to non-blocking mode is also usually a good idea (but not jpayne@68: required if you know what you are doing). jpayne@68: .PP jpayne@68: Another thing you have to watch out for is that it is quite easy to jpayne@68: receive \*(L"spurious\*(R" readiness notifications, that is, your callback might jpayne@68: be called with \f(CW\*(C`EV_READ\*(C'\fR but a subsequent \f(CW\*(C`read\*(C'\fR(2) will actually block jpayne@68: because there is no data. It is very easy to get into this situation even jpayne@68: with a relatively standard program structure. Thus it is best to always jpayne@68: use non-blocking I/O: An extra \f(CW\*(C`read\*(C'\fR(2) returning \f(CW\*(C`EAGAIN\*(C'\fR is far jpayne@68: preferable to a program hanging until some data arrives. jpayne@68: .PP jpayne@68: If you cannot run the fd in non-blocking mode (for example you should jpayne@68: not play around with an Xlib connection), then you have to separately jpayne@68: re-test whether a file descriptor is really ready with a known-to-be good jpayne@68: interface such as poll (fortunately in the case of Xlib, it already does jpayne@68: this on its own, so its quite safe to use). Some people additionally jpayne@68: use \f(CW\*(C`SIGALRM\*(C'\fR and an interval timer, just to be sure you won't block jpayne@68: indefinitely. jpayne@68: .PP jpayne@68: But really, best use non-blocking mode. jpayne@68: .PP jpayne@68: \fIThe special problem of disappearing file descriptors\fR jpayne@68: .IX Subsection "The special problem of disappearing file descriptors" jpayne@68: .PP jpayne@68: Some backends (e.g. kqueue, epoll, linuxaio) need to be told about closing jpayne@68: a file descriptor (either due to calling \f(CW\*(C`close\*(C'\fR explicitly or any other jpayne@68: means, such as \f(CW\*(C`dup2\*(C'\fR). The reason is that you register interest in some jpayne@68: file descriptor, but when it goes away, the operating system will silently jpayne@68: drop this interest. If another file descriptor with the same number then jpayne@68: is registered with libev, there is no efficient way to see that this is, jpayne@68: in fact, a different file descriptor. jpayne@68: .PP jpayne@68: To avoid having to explicitly tell libev about such cases, libev follows jpayne@68: the following policy: Each time \f(CW\*(C`ev_io_set\*(C'\fR is being called, libev jpayne@68: will assume that this is potentially a new file descriptor, otherwise jpayne@68: it is assumed that the file descriptor stays the same. That means that jpayne@68: you \fIhave\fR to call \f(CW\*(C`ev_io_set\*(C'\fR (or \f(CW\*(C`ev_io_init\*(C'\fR) when you change the jpayne@68: descriptor even if the file descriptor number itself did not change. jpayne@68: .PP jpayne@68: This is how one would do it normally anyway, the important point is that jpayne@68: the libev application should not optimise around libev but should leave jpayne@68: optimisations to libev. jpayne@68: .PP jpayne@68: \fIThe special problem of dup'ed file descriptors\fR jpayne@68: .IX Subsection "The special problem of dup'ed file descriptors" jpayne@68: .PP jpayne@68: Some backends (e.g. epoll), cannot register events for file descriptors, jpayne@68: but only events for the underlying file descriptions. That means when you jpayne@68: have \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors or weirder constellations, and register jpayne@68: events for them, only one file descriptor might actually receive events. jpayne@68: .PP jpayne@68: There is no workaround possible except not registering events jpayne@68: for potentially \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors, or to resort to jpayne@68: \&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR. jpayne@68: .PP jpayne@68: \fIThe special problem of files\fR jpayne@68: .IX Subsection "The special problem of files" jpayne@68: .PP jpayne@68: Many people try to use \f(CW\*(C`select\*(C'\fR (or libev) on file descriptors jpayne@68: representing files, and expect it to become ready when their program jpayne@68: doesn't block on disk accesses (which can take a long time on their own). jpayne@68: .PP jpayne@68: However, this cannot ever work in the \*(L"expected\*(R" way \- you get a readiness jpayne@68: notification as soon as the kernel knows whether and how much data is jpayne@68: there, and in the case of open files, that's always the case, so you jpayne@68: always get a readiness notification instantly, and your read (or possibly jpayne@68: write) will still block on the disk I/O. jpayne@68: .PP jpayne@68: Another way to view it is that in the case of sockets, pipes, character jpayne@68: devices and so on, there is another party (the sender) that delivers data jpayne@68: on its own, but in the case of files, there is no such thing: the disk jpayne@68: will not send data on its own, simply because it doesn't know what you jpayne@68: wish to read \- you would first have to request some data. jpayne@68: .PP jpayne@68: Since files are typically not-so-well supported by advanced notification jpayne@68: mechanism, libev tries hard to emulate \s-1POSIX\s0 behaviour with respect jpayne@68: to files, even though you should not use it. The reason for this is jpayne@68: convenience: sometimes you want to watch \s-1STDIN\s0 or \s-1STDOUT,\s0 which is jpayne@68: usually a tty, often a pipe, but also sometimes files or special devices jpayne@68: (for example, \f(CW\*(C`epoll\*(C'\fR on Linux works with \fI/dev/random\fR but not with jpayne@68: \&\fI/dev/urandom\fR), and even though the file might better be served with jpayne@68: asynchronous I/O instead of with non-blocking I/O, it is still useful when jpayne@68: it \*(L"just works\*(R" instead of freezing. jpayne@68: .PP jpayne@68: So avoid file descriptors pointing to files when you know it (e.g. use jpayne@68: libeio), but use them when it is convenient, e.g. for \s-1STDIN/STDOUT,\s0 or jpayne@68: when you rarely read from a file instead of from a socket, and want to jpayne@68: reuse the same code path. jpayne@68: .PP jpayne@68: \fIThe special problem of fork\fR jpayne@68: .IX Subsection "The special problem of fork" jpayne@68: .PP jpayne@68: Some backends (epoll, kqueue, linuxaio, iouring) do not support \f(CW\*(C`fork ()\*(C'\fR jpayne@68: at all or exhibit useless behaviour. Libev fully supports fork, but needs jpayne@68: to be told about it in the child if you want to continue to use it in the jpayne@68: child. jpayne@68: .PP jpayne@68: To support fork in your child processes, you have to call \f(CW\*(C`ev_loop_fork jpayne@68: ()\*(C'\fR after a fork in the child, enable \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR, or resort to jpayne@68: \&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR. jpayne@68: .PP jpayne@68: \fIThe special problem of \s-1SIGPIPE\s0\fR jpayne@68: .IX Subsection "The special problem of SIGPIPE" jpayne@68: .PP jpayne@68: While not really specific to libev, it is easy to forget about \f(CW\*(C`SIGPIPE\*(C'\fR: jpayne@68: when writing to a pipe whose other end has been closed, your program gets jpayne@68: sent a \s-1SIGPIPE,\s0 which, by default, aborts your program. For most programs jpayne@68: this is sensible behaviour, for daemons, this is usually undesirable. jpayne@68: .PP jpayne@68: So when you encounter spurious, unexplained daemon exits, make sure you jpayne@68: ignore \s-1SIGPIPE\s0 (and maybe make sure you log the exit status of your daemon jpayne@68: somewhere, as that would have given you a big clue). jpayne@68: .PP jpayne@68: \fIThe special problem of \f(BIaccept()\fIing when you can't\fR jpayne@68: .IX Subsection "The special problem of accept()ing when you can't" jpayne@68: .PP jpayne@68: Many implementations of the \s-1POSIX\s0 \f(CW\*(C`accept\*(C'\fR function (for example, jpayne@68: found in post\-2004 Linux) have the peculiar behaviour of not removing a jpayne@68: connection from the pending queue in all error cases. jpayne@68: .PP jpayne@68: For example, larger servers often run out of file descriptors (because jpayne@68: of resource limits), causing \f(CW\*(C`accept\*(C'\fR to fail with \f(CW\*(C`ENFILE\*(C'\fR but not jpayne@68: rejecting the connection, leading to libev signalling readiness on jpayne@68: the next iteration again (the connection still exists after all), and jpayne@68: typically causing the program to loop at 100% \s-1CPU\s0 usage. jpayne@68: .PP jpayne@68: Unfortunately, the set of errors that cause this issue differs between jpayne@68: operating systems, there is usually little the app can do to remedy the jpayne@68: situation, and no known thread-safe method of removing the connection to jpayne@68: cope with overload is known (to me). jpayne@68: .PP jpayne@68: One of the easiest ways to handle this situation is to just ignore it jpayne@68: \&\- when the program encounters an overload, it will just loop until the jpayne@68: situation is over. While this is a form of busy waiting, no \s-1OS\s0 offers an jpayne@68: event-based way to handle this situation, so it's the best one can do. jpayne@68: .PP jpayne@68: A better way to handle the situation is to log any errors other than jpayne@68: \&\f(CW\*(C`EAGAIN\*(C'\fR and \f(CW\*(C`EWOULDBLOCK\*(C'\fR, making sure not to flood the log with such jpayne@68: messages, and continue as usual, which at least gives the user an idea of jpayne@68: what could be wrong (\*(L"raise the ulimit!\*(R"). For extra points one could stop jpayne@68: the \f(CW\*(C`ev_io\*(C'\fR watcher on the listening fd \*(L"for a while\*(R", which reduces \s-1CPU\s0 jpayne@68: usage. jpayne@68: .PP jpayne@68: If your program is single-threaded, then you could also keep a dummy file jpayne@68: descriptor for overload situations (e.g. by opening \fI/dev/null\fR), and jpayne@68: when you run into \f(CW\*(C`ENFILE\*(C'\fR or \f(CW\*(C`EMFILE\*(C'\fR, close it, run \f(CW\*(C`accept\*(C'\fR, jpayne@68: close that fd, and create a new dummy fd. This will gracefully refuse jpayne@68: clients under typical overload conditions. jpayne@68: .PP jpayne@68: The last way to handle it is to simply log the error and \f(CW\*(C`exit\*(C'\fR, as jpayne@68: is often done with \f(CW\*(C`malloc\*(C'\fR failures, but this results in an easy jpayne@68: opportunity for a DoS attack. jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions\fR jpayne@68: .IX Subsection "Watcher-Specific Functions" jpayne@68: .IP "ev_io_init (ev_io *, callback, int fd, int events)" 4 jpayne@68: .IX Item "ev_io_init (ev_io *, callback, int fd, int events)" jpayne@68: .PD 0 jpayne@68: .IP "ev_io_set (ev_io *, int fd, int events)" 4 jpayne@68: .IX Item "ev_io_set (ev_io *, int fd, int events)" jpayne@68: .PD jpayne@68: Configures an \f(CW\*(C`ev_io\*(C'\fR watcher. The \f(CW\*(C`fd\*(C'\fR is the file descriptor to jpayne@68: receive events for and \f(CW\*(C`events\*(C'\fR is either \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR, both jpayne@68: \&\f(CW\*(C`EV_READ | EV_WRITE\*(C'\fR or \f(CW0\fR, to express the desire to receive the given jpayne@68: events. jpayne@68: .Sp jpayne@68: Note that setting the \f(CW\*(C`events\*(C'\fR to \f(CW0\fR and starting the watcher is jpayne@68: supported, but not specially optimized \- if your program sometimes happens jpayne@68: to generate this combination this is fine, but if it is easy to avoid jpayne@68: starting an io watcher watching for no events you should do so. jpayne@68: .IP "ev_io_modify (ev_io *, int events)" 4 jpayne@68: .IX Item "ev_io_modify (ev_io *, int events)" jpayne@68: Similar to \f(CW\*(C`ev_io_set\*(C'\fR, but only changes the requested events. Using this jpayne@68: might be faster with some backends, as libev can assume that the \f(CW\*(C`fd\*(C'\fR jpayne@68: still refers to the same underlying file description, something it cannot jpayne@68: do when using \f(CW\*(C`ev_io_set\*(C'\fR. jpayne@68: .IP "int fd [no\-modify]" 4 jpayne@68: .IX Item "int fd [no-modify]" jpayne@68: The file descriptor being watched. While it can be read at any time, you jpayne@68: must not modify this member even when the watcher is stopped \- always use jpayne@68: \&\f(CW\*(C`ev_io_set\*(C'\fR for that. jpayne@68: .IP "int events [no\-modify]" 4 jpayne@68: .IX Item "int events [no-modify]" jpayne@68: The set of events the fd is being watched for, among other flags. Remember jpayne@68: that this is a bit set \- to test for \f(CW\*(C`EV_READ\*(C'\fR, use \f(CW\*(C`w\->events & jpayne@68: EV_READ\*(C'\fR, and similarly for \f(CW\*(C`EV_WRITE\*(C'\fR. jpayne@68: .Sp jpayne@68: As with \f(CW\*(C`fd\*(C'\fR, you must not modify this member even when the watcher is jpayne@68: stopped, always use \f(CW\*(C`ev_io_set\*(C'\fR or \f(CW\*(C`ev_io_modify\*(C'\fR for that. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: Call \f(CW\*(C`stdin_readable_cb\*(C'\fR when \s-1STDIN_FILENO\s0 has become, well jpayne@68: readable, but only once. Since it is likely line-buffered, you could jpayne@68: attempt to read a whole line in the callback. jpayne@68: .PP jpayne@68: .Vb 6 jpayne@68: \& static void jpayne@68: \& stdin_readable_cb (struct ev_loop *loop, ev_io *w, int revents) jpayne@68: \& { jpayne@68: \& ev_io_stop (loop, w); jpayne@68: \& .. read from stdin here (or from w\->fd) and handle any I/O errors jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& struct ev_loop *loop = ev_default_init (0); jpayne@68: \& ev_io stdin_readable; jpayne@68: \& ev_io_init (&stdin_readable, stdin_readable_cb, STDIN_FILENO, EV_READ); jpayne@68: \& ev_io_start (loop, &stdin_readable); jpayne@68: \& ev_run (loop, 0); jpayne@68: .Ve jpayne@68: .ie n .SS """ev_timer"" \- relative and optionally repeating timeouts" jpayne@68: .el .SS "\f(CWev_timer\fP \- relative and optionally repeating timeouts" jpayne@68: .IX Subsection "ev_timer - relative and optionally repeating timeouts" jpayne@68: Timer watchers are simple relative timers that generate an event after a jpayne@68: given time, and optionally repeating in regular intervals after that. jpayne@68: .PP jpayne@68: The timers are based on real time, that is, if you register an event that jpayne@68: times out after an hour and you reset your system clock to January last jpayne@68: year, it will still time out after (roughly) one hour. \*(L"Roughly\*(R" because jpayne@68: detecting time jumps is hard, and some inaccuracies are unavoidable (the jpayne@68: monotonic clock option helps a lot here). jpayne@68: .PP jpayne@68: The callback is guaranteed to be invoked only \fIafter\fR its timeout has jpayne@68: passed (not \fIat\fR, so on systems with very low-resolution clocks this jpayne@68: might introduce a small delay, see \*(L"the special problem of being too jpayne@68: early\*(R", below). If multiple timers become ready during the same loop jpayne@68: iteration then the ones with earlier time-out values are invoked before jpayne@68: ones of the same priority with later time-out values (but this is no jpayne@68: longer true when a callback calls \f(CW\*(C`ev_run\*(C'\fR recursively). jpayne@68: .PP jpayne@68: \fIBe smart about timeouts\fR jpayne@68: .IX Subsection "Be smart about timeouts" jpayne@68: .PP jpayne@68: Many real-world problems involve some kind of timeout, usually for error jpayne@68: recovery. A typical example is an \s-1HTTP\s0 request \- if the other side hangs, jpayne@68: you want to raise some error after a while. jpayne@68: .PP jpayne@68: What follows are some ways to handle this problem, from obvious and jpayne@68: inefficient to smart and efficient. jpayne@68: .PP jpayne@68: In the following, a 60 second activity timeout is assumed \- a timeout that jpayne@68: gets reset to 60 seconds each time there is activity (e.g. each time some jpayne@68: data or other life sign was received). jpayne@68: .IP "1. Use a timer and stop, reinitialise and start it on activity." 4 jpayne@68: .IX Item "1. Use a timer and stop, reinitialise and start it on activity." jpayne@68: This is the most obvious, but not the most simple way: In the beginning, jpayne@68: start the watcher: jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& ev_timer_init (timer, callback, 60., 0.); jpayne@68: \& ev_timer_start (loop, timer); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Then, each time there is some activity, \f(CW\*(C`ev_timer_stop\*(C'\fR it, initialise it jpayne@68: and start it again: jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& ev_timer_stop (loop, timer); jpayne@68: \& ev_timer_set (timer, 60., 0.); jpayne@68: \& ev_timer_start (loop, timer); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: This is relatively simple to implement, but means that each time there is jpayne@68: some activity, libev will first have to remove the timer from its internal jpayne@68: data structure and then add it again. Libev tries to be fast, but it's jpayne@68: still not a constant-time operation. jpayne@68: .ie n .IP "2. Use a timer and re-start it with ""ev_timer_again"" inactivity." 4 jpayne@68: .el .IP "2. Use a timer and re-start it with \f(CWev_timer_again\fR inactivity." 4 jpayne@68: .IX Item "2. Use a timer and re-start it with ev_timer_again inactivity." jpayne@68: This is the easiest way, and involves using \f(CW\*(C`ev_timer_again\*(C'\fR instead of jpayne@68: \&\f(CW\*(C`ev_timer_start\*(C'\fR. jpayne@68: .Sp jpayne@68: To implement this, configure an \f(CW\*(C`ev_timer\*(C'\fR with a \f(CW\*(C`repeat\*(C'\fR value jpayne@68: of \f(CW60\fR and then call \f(CW\*(C`ev_timer_again\*(C'\fR at start and each time you jpayne@68: successfully read or write some data. If you go into an idle state where jpayne@68: you do not expect data to travel on the socket, you can \f(CW\*(C`ev_timer_stop\*(C'\fR jpayne@68: the timer, and \f(CW\*(C`ev_timer_again\*(C'\fR will automatically restart it if need be. jpayne@68: .Sp jpayne@68: That means you can ignore both the \f(CW\*(C`ev_timer_start\*(C'\fR function and the jpayne@68: \&\f(CW\*(C`after\*(C'\fR argument to \f(CW\*(C`ev_timer_set\*(C'\fR, and only ever use the \f(CW\*(C`repeat\*(C'\fR jpayne@68: member and \f(CW\*(C`ev_timer_again\*(C'\fR. jpayne@68: .Sp jpayne@68: At start: jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& ev_init (timer, callback); jpayne@68: \& timer\->repeat = 60.; jpayne@68: \& ev_timer_again (loop, timer); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Each time there is some activity: jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& ev_timer_again (loop, timer); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: It is even possible to change the time-out on the fly, regardless of jpayne@68: whether the watcher is active or not: jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& timer\->repeat = 30.; jpayne@68: \& ev_timer_again (loop, timer); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: This is slightly more efficient then stopping/starting the timer each time jpayne@68: you want to modify its timeout value, as libev does not have to completely jpayne@68: remove and re-insert the timer from/into its internal data structure. jpayne@68: .Sp jpayne@68: It is, however, even simpler than the \*(L"obvious\*(R" way to do it. jpayne@68: .IP "3. Let the timer time out, but then re-arm it as required." 4 jpayne@68: .IX Item "3. Let the timer time out, but then re-arm it as required." jpayne@68: This method is more tricky, but usually most efficient: Most timeouts are jpayne@68: relatively long compared to the intervals between other activity \- in jpayne@68: our example, within 60 seconds, there are usually many I/O events with jpayne@68: associated activity resets. jpayne@68: .Sp jpayne@68: In this case, it would be more efficient to leave the \f(CW\*(C`ev_timer\*(C'\fR alone, jpayne@68: but remember the time of last activity, and check for a real timeout only jpayne@68: within the callback: jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& ev_tstamp timeout = 60.; jpayne@68: \& ev_tstamp last_activity; // time of last activity jpayne@68: \& ev_timer timer; jpayne@68: \& jpayne@68: \& static void jpayne@68: \& callback (EV_P_ ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& // calculate when the timeout would happen jpayne@68: \& ev_tstamp after = last_activity \- ev_now (EV_A) + timeout; jpayne@68: \& jpayne@68: \& // if negative, it means we the timeout already occurred jpayne@68: \& if (after < 0.) jpayne@68: \& { jpayne@68: \& // timeout occurred, take action jpayne@68: \& } jpayne@68: \& else jpayne@68: \& { jpayne@68: \& // callback was invoked, but there was some recent jpayne@68: \& // activity. simply restart the timer to time out jpayne@68: \& // after "after" seconds, which is the earliest time jpayne@68: \& // the timeout can occur. jpayne@68: \& ev_timer_set (w, after, 0.); jpayne@68: \& ev_timer_start (EV_A_ w); jpayne@68: \& } jpayne@68: \& } jpayne@68: .Ve jpayne@68: .Sp jpayne@68: To summarise the callback: first calculate in how many seconds the jpayne@68: timeout will occur (by calculating the absolute time when it would occur, jpayne@68: \&\f(CW\*(C`last_activity + timeout\*(C'\fR, and subtracting the current time, \f(CW\*(C`ev_now jpayne@68: (EV_A)\*(C'\fR from that). jpayne@68: .Sp jpayne@68: If this value is negative, then we are already past the timeout, i.e. we jpayne@68: timed out, and need to do whatever is needed in this case. jpayne@68: .Sp jpayne@68: Otherwise, we now the earliest time at which the timeout would trigger, jpayne@68: and simply start the timer with this timeout value. jpayne@68: .Sp jpayne@68: In other words, each time the callback is invoked it will check whether jpayne@68: the timeout occurred. If not, it will simply reschedule itself to check jpayne@68: again at the earliest time it could time out. Rinse. Repeat. jpayne@68: .Sp jpayne@68: This scheme causes more callback invocations (about one every 60 seconds jpayne@68: minus half the average time between activity), but virtually no calls to jpayne@68: libev to change the timeout. jpayne@68: .Sp jpayne@68: To start the machinery, simply initialise the watcher and set jpayne@68: \&\f(CW\*(C`last_activity\*(C'\fR to the current time (meaning there was some activity just jpayne@68: now), then call the callback, which will \*(L"do the right thing\*(R" and start jpayne@68: the timer: jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& last_activity = ev_now (EV_A); jpayne@68: \& ev_init (&timer, callback); jpayne@68: \& callback (EV_A_ &timer, 0); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: When there is some activity, simply store the current time in jpayne@68: \&\f(CW\*(C`last_activity\*(C'\fR, no libev calls at all: jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& if (activity detected) jpayne@68: \& last_activity = ev_now (EV_A); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: When your timeout value changes, then the timeout can be changed by simply jpayne@68: providing a new value, stopping the timer and calling the callback, which jpayne@68: will again do the right thing (for example, time out immediately :). jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& timeout = new_value; jpayne@68: \& ev_timer_stop (EV_A_ &timer); jpayne@68: \& callback (EV_A_ &timer, 0); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: This technique is slightly more complex, but in most cases where the jpayne@68: time-out is unlikely to be triggered, much more efficient. jpayne@68: .IP "4. Wee, just use a double-linked list for your timeouts." 4 jpayne@68: .IX Item "4. Wee, just use a double-linked list for your timeouts." jpayne@68: If there is not one request, but many thousands (millions...), all jpayne@68: employing some kind of timeout with the same timeout value, then one can jpayne@68: do even better: jpayne@68: .Sp jpayne@68: When starting the timeout, calculate the timeout value and put the timeout jpayne@68: at the \fIend\fR of the list. jpayne@68: .Sp jpayne@68: Then use an \f(CW\*(C`ev_timer\*(C'\fR to fire when the timeout at the \fIbeginning\fR of jpayne@68: the list is expected to fire (for example, using the technique #3). jpayne@68: .Sp jpayne@68: When there is some activity, remove the timer from the list, recalculate jpayne@68: the timeout, append it to the end of the list again, and make sure to jpayne@68: update the \f(CW\*(C`ev_timer\*(C'\fR if it was taken from the beginning of the list. jpayne@68: .Sp jpayne@68: This way, one can manage an unlimited number of timeouts in O(1) time for jpayne@68: starting, stopping and updating the timers, at the expense of a major jpayne@68: complication, and having to use a constant timeout. The constant timeout jpayne@68: ensures that the list stays sorted. jpayne@68: .PP jpayne@68: So which method the best? jpayne@68: .PP jpayne@68: Method #2 is a simple no-brain-required solution that is adequate in most jpayne@68: situations. Method #3 requires a bit more thinking, but handles many cases jpayne@68: better, and isn't very complicated either. In most case, choosing either jpayne@68: one is fine, with #3 being better in typical situations. jpayne@68: .PP jpayne@68: Method #1 is almost always a bad idea, and buys you nothing. Method #4 is jpayne@68: rather complicated, but extremely efficient, something that really pays jpayne@68: off after the first million or so of active timers, i.e. it's usually jpayne@68: overkill :) jpayne@68: .PP jpayne@68: \fIThe special problem of being too early\fR jpayne@68: .IX Subsection "The special problem of being too early" jpayne@68: .PP jpayne@68: If you ask a timer to call your callback after three seconds, then jpayne@68: you expect it to be invoked after three seconds \- but of course, this jpayne@68: cannot be guaranteed to infinite precision. Less obviously, it cannot be jpayne@68: guaranteed to any precision by libev \- imagine somebody suspending the jpayne@68: process with a \s-1STOP\s0 signal for a few hours for example. jpayne@68: .PP jpayne@68: So, libev tries to invoke your callback as soon as possible \fIafter\fR the jpayne@68: delay has occurred, but cannot guarantee this. jpayne@68: .PP jpayne@68: A less obvious failure mode is calling your callback too early: many event jpayne@68: loops compare timestamps with a \*(L"elapsed delay >= requested delay\*(R", but jpayne@68: this can cause your callback to be invoked much earlier than you would jpayne@68: expect. jpayne@68: .PP jpayne@68: To see why, imagine a system with a clock that only offers full second jpayne@68: resolution (think windows if you can't come up with a broken enough \s-1OS\s0 jpayne@68: yourself). If you schedule a one-second timer at the time 500.9, then the jpayne@68: event loop will schedule your timeout to elapse at a system time of 500 jpayne@68: (500.9 truncated to the resolution) + 1, or 501. jpayne@68: .PP jpayne@68: If an event library looks at the timeout 0.1s later, it will see \*(L"501 >= jpayne@68: 501\*(R" and invoke the callback 0.1s after it was started, even though a jpayne@68: one-second delay was requested \- this is being \*(L"too early\*(R", despite best jpayne@68: intentions. jpayne@68: .PP jpayne@68: This is the reason why libev will never invoke the callback if the elapsed jpayne@68: delay equals the requested delay, but only when the elapsed delay is jpayne@68: larger than the requested delay. In the example above, libev would only invoke jpayne@68: the callback at system time 502, or 1.1s after the timer was started. jpayne@68: .PP jpayne@68: So, while libev cannot guarantee that your callback will be invoked jpayne@68: exactly when requested, it \fIcan\fR and \fIdoes\fR guarantee that the requested jpayne@68: delay has actually elapsed, or in other words, it always errs on the \*(L"too jpayne@68: late\*(R" side of things. jpayne@68: .PP jpayne@68: \fIThe special problem of time updates\fR jpayne@68: .IX Subsection "The special problem of time updates" jpayne@68: .PP jpayne@68: Establishing the current time is a costly operation (it usually takes jpayne@68: at least one system call): \s-1EV\s0 therefore updates its idea of the current jpayne@68: time only before and after \f(CW\*(C`ev_run\*(C'\fR collects new events, which causes a jpayne@68: growing difference between \f(CW\*(C`ev_now ()\*(C'\fR and \f(CW\*(C`ev_time ()\*(C'\fR when handling jpayne@68: lots of events in one iteration. jpayne@68: .PP jpayne@68: The relative timeouts are calculated relative to the \f(CW\*(C`ev_now ()\*(C'\fR jpayne@68: time. This is usually the right thing as this timestamp refers to the time jpayne@68: of the event triggering whatever timeout you are modifying/starting. If jpayne@68: you suspect event processing to be delayed and you \fIneed\fR to base the jpayne@68: timeout on the current time, use something like the following to adjust jpayne@68: for it: jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& ev_timer_set (&timer, after + (ev_time () \- ev_now ()), 0.); jpayne@68: .Ve jpayne@68: .PP jpayne@68: If the event loop is suspended for a long time, you can also force an jpayne@68: update of the time returned by \f(CW\*(C`ev_now ()\*(C'\fR by calling \f(CW\*(C`ev_now_update jpayne@68: ()\*(C'\fR, although that will push the event time of all outstanding events jpayne@68: further into the future. jpayne@68: .PP jpayne@68: \fIThe special problem of unsynchronised clocks\fR jpayne@68: .IX Subsection "The special problem of unsynchronised clocks" jpayne@68: .PP jpayne@68: Modern systems have a variety of clocks \- libev itself uses the normal jpayne@68: \&\*(L"wall clock\*(R" clock and, if available, the monotonic clock (to avoid time jpayne@68: jumps). jpayne@68: .PP jpayne@68: Neither of these clocks is synchronised with each other or any other clock jpayne@68: on the system, so \f(CW\*(C`ev_time ()\*(C'\fR might return a considerably different time jpayne@68: than \f(CW\*(C`gettimeofday ()\*(C'\fR or \f(CW\*(C`time ()\*(C'\fR. On a GNU/Linux system, for example, jpayne@68: a call to \f(CW\*(C`gettimeofday\*(C'\fR might return a second count that is one higher jpayne@68: than a directly following call to \f(CW\*(C`time\*(C'\fR. jpayne@68: .PP jpayne@68: The moral of this is to only compare libev-related timestamps with jpayne@68: \&\f(CW\*(C`ev_time ()\*(C'\fR and \f(CW\*(C`ev_now ()\*(C'\fR, at least if you want better precision than jpayne@68: a second or so. jpayne@68: .PP jpayne@68: One more problem arises due to this lack of synchronisation: if libev uses jpayne@68: the system monotonic clock and you compare timestamps from \f(CW\*(C`ev_time\*(C'\fR jpayne@68: or \f(CW\*(C`ev_now\*(C'\fR from when you started your timer and when your callback is jpayne@68: invoked, you will find that sometimes the callback is a bit \*(L"early\*(R". jpayne@68: .PP jpayne@68: This is because \f(CW\*(C`ev_timer\*(C'\fRs work in real time, not wall clock time, so jpayne@68: libev makes sure your callback is not invoked before the delay happened, jpayne@68: \&\fImeasured according to the real time\fR, not the system clock. jpayne@68: .PP jpayne@68: If your timeouts are based on a physical timescale (e.g. \*(L"time out this jpayne@68: connection after 100 seconds\*(R") then this shouldn't bother you as it is jpayne@68: exactly the right behaviour. jpayne@68: .PP jpayne@68: If you want to compare wall clock/system timestamps to your timers, then jpayne@68: you need to use \f(CW\*(C`ev_periodic\*(C'\fRs, as these are based on the wall clock jpayne@68: time, where your comparisons will always generate correct results. jpayne@68: .PP jpayne@68: \fIThe special problems of suspended animation\fR jpayne@68: .IX Subsection "The special problems of suspended animation" jpayne@68: .PP jpayne@68: When you leave the server world it is quite customary to hit machines that jpayne@68: can suspend/hibernate \- what happens to the clocks during such a suspend? jpayne@68: .PP jpayne@68: Some quick tests made with a Linux 2.6.28 indicate that a suspend freezes jpayne@68: all processes, while the clocks (\f(CW\*(C`times\*(C'\fR, \f(CW\*(C`CLOCK_MONOTONIC\*(C'\fR) continue jpayne@68: to run until the system is suspended, but they will not advance while the jpayne@68: system is suspended. That means, on resume, it will be as if the program jpayne@68: was frozen for a few seconds, but the suspend time will not be counted jpayne@68: towards \f(CW\*(C`ev_timer\*(C'\fR when a monotonic clock source is used. The real time jpayne@68: clock advanced as expected, but if it is used as sole clocksource, then a jpayne@68: long suspend would be detected as a time jump by libev, and timers would jpayne@68: be adjusted accordingly. jpayne@68: .PP jpayne@68: I would not be surprised to see different behaviour in different between jpayne@68: operating systems, \s-1OS\s0 versions or even different hardware. jpayne@68: .PP jpayne@68: The other form of suspend (job control, or sending a \s-1SIGSTOP\s0) will see a jpayne@68: time jump in the monotonic clocks and the realtime clock. If the program jpayne@68: is suspended for a very long time, and monotonic clock sources are in use, jpayne@68: then you can expect \f(CW\*(C`ev_timer\*(C'\fRs to expire as the full suspension time jpayne@68: will be counted towards the timers. When no monotonic clock source is in jpayne@68: use, then libev will again assume a timejump and adjust accordingly. jpayne@68: .PP jpayne@68: It might be beneficial for this latter case to call \f(CW\*(C`ev_suspend\*(C'\fR jpayne@68: and \f(CW\*(C`ev_resume\*(C'\fR in code that handles \f(CW\*(C`SIGTSTP\*(C'\fR, to at least get jpayne@68: deterministic behaviour in this case (you can do nothing against jpayne@68: \&\f(CW\*(C`SIGSTOP\*(C'\fR). jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)" 4 jpayne@68: .IX Item "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)" jpayne@68: .PD 0 jpayne@68: .IP "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)" 4 jpayne@68: .IX Item "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)" jpayne@68: .PD jpayne@68: Configure the timer to trigger after \f(CW\*(C`after\*(C'\fR seconds (fractional and jpayne@68: negative values are supported). If \f(CW\*(C`repeat\*(C'\fR is \f(CW0.\fR, then it will jpayne@68: automatically be stopped once the timeout is reached. If it is positive, jpayne@68: then the timer will automatically be configured to trigger again \f(CW\*(C`repeat\*(C'\fR jpayne@68: seconds later, again, and again, until stopped manually. jpayne@68: .Sp jpayne@68: The timer itself will do a best-effort at avoiding drift, that is, if jpayne@68: you configure a timer to trigger every 10 seconds, then it will normally jpayne@68: trigger at exactly 10 second intervals. If, however, your program cannot jpayne@68: keep up with the timer (because it takes longer than those 10 seconds to jpayne@68: do stuff) the timer will not fire more than once per event loop iteration. jpayne@68: .IP "ev_timer_again (loop, ev_timer *)" 4 jpayne@68: .IX Item "ev_timer_again (loop, ev_timer *)" jpayne@68: This will act as if the timer timed out, and restarts it again if it is jpayne@68: repeating. It basically works like calling \f(CW\*(C`ev_timer_stop\*(C'\fR, updating the jpayne@68: timeout to the \f(CW\*(C`repeat\*(C'\fR value and calling \f(CW\*(C`ev_timer_start\*(C'\fR. jpayne@68: .Sp jpayne@68: The exact semantics are as in the following rules, all of which will be jpayne@68: applied to the watcher: jpayne@68: .RS 4 jpayne@68: .IP "If the timer is pending, the pending status is always cleared." 4 jpayne@68: .IX Item "If the timer is pending, the pending status is always cleared." jpayne@68: .PD 0 jpayne@68: .IP "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)." 4 jpayne@68: .IX Item "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)." jpayne@68: .ie n .IP "If the timer is repeating, make the ""repeat"" value the new timeout and start the timer, if necessary." 4 jpayne@68: .el .IP "If the timer is repeating, make the \f(CWrepeat\fR value the new timeout and start the timer, if necessary." 4 jpayne@68: .IX Item "If the timer is repeating, make the repeat value the new timeout and start the timer, if necessary." jpayne@68: .RE jpayne@68: .RS 4 jpayne@68: .PD jpayne@68: .Sp jpayne@68: This sounds a bit complicated, see \*(L"Be smart about timeouts\*(R", above, for a jpayne@68: usage example. jpayne@68: .RE jpayne@68: .IP "ev_tstamp ev_timer_remaining (loop, ev_timer *)" 4 jpayne@68: .IX Item "ev_tstamp ev_timer_remaining (loop, ev_timer *)" jpayne@68: Returns the remaining time until a timer fires. If the timer is active, jpayne@68: then this time is relative to the current event loop time, otherwise it's jpayne@68: the timeout value currently configured. jpayne@68: .Sp jpayne@68: That is, after an \f(CW\*(C`ev_timer_set (w, 5, 7)\*(C'\fR, \f(CW\*(C`ev_timer_remaining\*(C'\fR returns jpayne@68: \&\f(CW5\fR. When the timer is started and one second passes, \f(CW\*(C`ev_timer_remaining\*(C'\fR jpayne@68: will return \f(CW4\fR. When the timer expires and is restarted, it will return jpayne@68: roughly \f(CW7\fR (likely slightly less as callback invocation takes some time, jpayne@68: too), and so on. jpayne@68: .IP "ev_tstamp repeat [read\-write]" 4 jpayne@68: .IX Item "ev_tstamp repeat [read-write]" jpayne@68: The current \f(CW\*(C`repeat\*(C'\fR value. Will be used each time the watcher times out jpayne@68: or \f(CW\*(C`ev_timer_again\*(C'\fR is called, and determines the next timeout (if any), jpayne@68: which is also when any modifications are taken into account. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: Create a timer that fires after 60 seconds. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& one_minute_cb (struct ev_loop *loop, ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& .. one minute over, w is actually stopped right here jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_timer mytimer; jpayne@68: \& ev_timer_init (&mytimer, one_minute_cb, 60., 0.); jpayne@68: \& ev_timer_start (loop, &mytimer); jpayne@68: .Ve jpayne@68: .PP jpayne@68: Example: Create a timeout timer that times out after 10 seconds of jpayne@68: inactivity. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& timeout_cb (struct ev_loop *loop, ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& .. ten seconds without any activity jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_timer mytimer; jpayne@68: \& ev_timer_init (&mytimer, timeout_cb, 0., 10.); /* note, only repeat used */ jpayne@68: \& ev_timer_again (&mytimer); /* start timer */ jpayne@68: \& ev_run (loop, 0); jpayne@68: \& jpayne@68: \& // and in some piece of code that gets executed on any "activity": jpayne@68: \& // reset the timeout to start ticking again at 10 seconds jpayne@68: \& ev_timer_again (&mytimer); jpayne@68: .Ve jpayne@68: .ie n .SS """ev_periodic"" \- to cron or not to cron?" jpayne@68: .el .SS "\f(CWev_periodic\fP \- to cron or not to cron?" jpayne@68: .IX Subsection "ev_periodic - to cron or not to cron?" jpayne@68: Periodic watchers are also timers of a kind, but they are very versatile jpayne@68: (and unfortunately a bit complex). jpayne@68: .PP jpayne@68: Unlike \f(CW\*(C`ev_timer\*(C'\fR, periodic watchers are not based on real time (or jpayne@68: relative time, the physical time that passes) but on wall clock time jpayne@68: (absolute time, the thing you can read on your calendar or clock). The jpayne@68: difference is that wall clock time can run faster or slower than real jpayne@68: time, and time jumps are not uncommon (e.g. when you adjust your jpayne@68: wrist-watch). jpayne@68: .PP jpayne@68: You can tell a periodic watcher to trigger after some specific point jpayne@68: in time: for example, if you tell a periodic watcher to trigger \*(L"in 10 jpayne@68: seconds\*(R" (by specifying e.g. \f(CW\*(C`ev_now () + 10.\*(C'\fR, that is, an absolute time jpayne@68: not a delay) and then reset your system clock to January of the previous jpayne@68: year, then it will take a year or more to trigger the event (unlike an jpayne@68: \&\f(CW\*(C`ev_timer\*(C'\fR, which would still trigger roughly 10 seconds after starting jpayne@68: it, as it uses a relative timeout). jpayne@68: .PP jpayne@68: \&\f(CW\*(C`ev_periodic\*(C'\fR watchers can also be used to implement vastly more complex jpayne@68: timers, such as triggering an event on each \*(L"midnight, local time\*(R", or jpayne@68: other complicated rules. This cannot easily be done with \f(CW\*(C`ev_timer\*(C'\fR jpayne@68: watchers, as those cannot react to time jumps. jpayne@68: .PP jpayne@68: As with timers, the callback is guaranteed to be invoked only when the jpayne@68: point in time where it is supposed to trigger has passed. If multiple jpayne@68: timers become ready during the same loop iteration then the ones with jpayne@68: earlier time-out values are invoked before ones with later time-out values jpayne@68: (but this is no longer true when a callback calls \f(CW\*(C`ev_run\*(C'\fR recursively). jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_periodic_init (ev_periodic *, callback, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" 4 jpayne@68: .IX Item "ev_periodic_init (ev_periodic *, callback, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" jpayne@68: .PD 0 jpayne@68: .IP "ev_periodic_set (ev_periodic *, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" 4 jpayne@68: .IX Item "ev_periodic_set (ev_periodic *, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" jpayne@68: .PD jpayne@68: Lots of arguments, let's sort it out... There are basically three modes of jpayne@68: operation, and we will explain them from simplest to most complex: jpayne@68: .RS 4 jpayne@68: .IP "\(bu" 4 jpayne@68: absolute timer (offset = absolute time, interval = 0, reschedule_cb = 0) jpayne@68: .Sp jpayne@68: In this configuration the watcher triggers an event after the wall clock jpayne@68: time \f(CW\*(C`offset\*(C'\fR has passed. It will not repeat and will not adjust when a jpayne@68: time jump occurs, that is, if it is to be run at January 1st 2011 then it jpayne@68: will be stopped and invoked when the system clock reaches or surpasses jpayne@68: this point in time. jpayne@68: .IP "\(bu" 4 jpayne@68: repeating interval timer (offset = offset within interval, interval > 0, reschedule_cb = 0) jpayne@68: .Sp jpayne@68: In this mode the watcher will always be scheduled to time out at the next jpayne@68: \&\f(CW\*(C`offset + N * interval\*(C'\fR time (for some integer N, which can also be jpayne@68: negative) and then repeat, regardless of any time jumps. The \f(CW\*(C`offset\*(C'\fR jpayne@68: argument is merely an offset into the \f(CW\*(C`interval\*(C'\fR periods. jpayne@68: .Sp jpayne@68: This can be used to create timers that do not drift with respect to the jpayne@68: system clock, for example, here is an \f(CW\*(C`ev_periodic\*(C'\fR that triggers each jpayne@68: hour, on the hour (with respect to \s-1UTC\s0): jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& ev_periodic_set (&periodic, 0., 3600., 0); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: This doesn't mean there will always be 3600 seconds in between triggers, jpayne@68: but only that the callback will be called when the system time shows a jpayne@68: full hour (\s-1UTC\s0), or more correctly, when the system time is evenly divisible jpayne@68: by 3600. jpayne@68: .Sp jpayne@68: Another way to think about it (for the mathematically inclined) is that jpayne@68: \&\f(CW\*(C`ev_periodic\*(C'\fR will try to run the callback in this mode at the next possible jpayne@68: time where \f(CW\*(C`time = offset (mod interval)\*(C'\fR, regardless of any time jumps. jpayne@68: .Sp jpayne@68: The \f(CW\*(C`interval\*(C'\fR \fI\s-1MUST\s0\fR be positive, and for numerical stability, the jpayne@68: interval value should be higher than \f(CW\*(C`1/8192\*(C'\fR (which is around 100 jpayne@68: microseconds) and \f(CW\*(C`offset\*(C'\fR should be higher than \f(CW0\fR and should have jpayne@68: at most a similar magnitude as the current time (say, within a factor of jpayne@68: ten). Typical values for offset are, in fact, \f(CW0\fR or something between jpayne@68: \&\f(CW0\fR and \f(CW\*(C`interval\*(C'\fR, which is also the recommended range. jpayne@68: .Sp jpayne@68: Note also that there is an upper limit to how often a timer can fire (\s-1CPU\s0 jpayne@68: speed for example), so if \f(CW\*(C`interval\*(C'\fR is very small then timing stability jpayne@68: will of course deteriorate. Libev itself tries to be exact to be about one jpayne@68: millisecond (if the \s-1OS\s0 supports it and the machine is fast enough). jpayne@68: .IP "\(bu" 4 jpayne@68: manual reschedule mode (offset ignored, interval ignored, reschedule_cb = callback) jpayne@68: .Sp jpayne@68: In this mode the values for \f(CW\*(C`interval\*(C'\fR and \f(CW\*(C`offset\*(C'\fR are both being jpayne@68: ignored. Instead, each time the periodic watcher gets scheduled, the jpayne@68: reschedule callback will be called with the watcher as first, and the jpayne@68: current time as second argument. jpayne@68: .Sp jpayne@68: \&\s-1NOTE:\s0 \fIThis callback \s-1MUST NOT\s0 stop or destroy any periodic watcher, ever, jpayne@68: or make \s-1ANY\s0 other event loop modifications whatsoever, unless explicitly jpayne@68: allowed by documentation here\fR. jpayne@68: .Sp jpayne@68: If you need to stop it, return \f(CW\*(C`now + 1e30\*(C'\fR (or so, fudge fudge) and stop jpayne@68: it afterwards (e.g. by starting an \f(CW\*(C`ev_prepare\*(C'\fR watcher, which is the jpayne@68: only event loop modification you are allowed to do). jpayne@68: .Sp jpayne@68: The callback prototype is \f(CW\*(C`ev_tstamp (*reschedule_cb)(ev_periodic jpayne@68: *w, ev_tstamp now)\*(C'\fR, e.g.: jpayne@68: .Sp jpayne@68: .Vb 5 jpayne@68: \& static ev_tstamp jpayne@68: \& my_rescheduler (ev_periodic *w, ev_tstamp now) jpayne@68: \& { jpayne@68: \& return now + 60.; jpayne@68: \& } jpayne@68: .Ve jpayne@68: .Sp jpayne@68: It must return the next time to trigger, based on the passed time value jpayne@68: (that is, the lowest time value larger than to the second argument). It jpayne@68: will usually be called just before the callback will be triggered, but jpayne@68: might be called at other times, too. jpayne@68: .Sp jpayne@68: \&\s-1NOTE:\s0 \fIThis callback must always return a time that is higher than or jpayne@68: equal to the passed \f(CI\*(C`now\*(C'\fI value\fR. jpayne@68: .Sp jpayne@68: This can be used to create very complex timers, such as a timer that jpayne@68: triggers on \*(L"next midnight, local time\*(R". To do this, you would calculate jpayne@68: the next midnight after \f(CW\*(C`now\*(C'\fR and return the timestamp value for jpayne@68: this. Here is a (completely untested, no error checking) example on how to jpayne@68: do this: jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& #include jpayne@68: \& jpayne@68: \& static ev_tstamp jpayne@68: \& my_rescheduler (ev_periodic *w, ev_tstamp now) jpayne@68: \& { jpayne@68: \& time_t tnow = (time_t)now; jpayne@68: \& struct tm tm; jpayne@68: \& localtime_r (&tnow, &tm); jpayne@68: \& jpayne@68: \& tm.tm_sec = tm.tm_min = tm.tm_hour = 0; // midnight current day jpayne@68: \& ++tm.tm_mday; // midnight next day jpayne@68: \& jpayne@68: \& return mktime (&tm); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Note: this code might run into trouble on days that have more then two jpayne@68: midnights (beginning and end). jpayne@68: .RE jpayne@68: .RS 4 jpayne@68: .RE jpayne@68: .IP "ev_periodic_again (loop, ev_periodic *)" 4 jpayne@68: .IX Item "ev_periodic_again (loop, ev_periodic *)" jpayne@68: Simply stops and restarts the periodic watcher again. This is only useful jpayne@68: when you changed some parameters or the reschedule callback would return jpayne@68: a different time than the last time it was called (e.g. in a crond like jpayne@68: program when the crontabs have changed). jpayne@68: .IP "ev_tstamp ev_periodic_at (ev_periodic *)" 4 jpayne@68: .IX Item "ev_tstamp ev_periodic_at (ev_periodic *)" jpayne@68: When active, returns the absolute time that the watcher is supposed jpayne@68: to trigger next. This is not the same as the \f(CW\*(C`offset\*(C'\fR argument to jpayne@68: \&\f(CW\*(C`ev_periodic_set\*(C'\fR, but indeed works even in interval and manual jpayne@68: rescheduling modes. jpayne@68: .IP "ev_tstamp offset [read\-write]" 4 jpayne@68: .IX Item "ev_tstamp offset [read-write]" jpayne@68: When repeating, this contains the offset value, otherwise this is the jpayne@68: absolute point in time (the \f(CW\*(C`offset\*(C'\fR value passed to \f(CW\*(C`ev_periodic_set\*(C'\fR, jpayne@68: although libev might modify this value for better numerical stability). jpayne@68: .Sp jpayne@68: Can be modified any time, but changes only take effect when the periodic jpayne@68: timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being called. jpayne@68: .IP "ev_tstamp interval [read\-write]" 4 jpayne@68: .IX Item "ev_tstamp interval [read-write]" jpayne@68: The current interval value. Can be modified any time, but changes only jpayne@68: take effect when the periodic timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being jpayne@68: called. jpayne@68: .IP "ev_tstamp (*reschedule_cb)(ev_periodic *w, ev_tstamp now) [read\-write]" 4 jpayne@68: .IX Item "ev_tstamp (*reschedule_cb)(ev_periodic *w, ev_tstamp now) [read-write]" jpayne@68: The current reschedule callback, or \f(CW0\fR, if this functionality is jpayne@68: switched off. Can be changed any time, but changes only take effect when jpayne@68: the periodic timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being called. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: Call a callback every hour, or, more precisely, whenever the jpayne@68: system time is divisible by 3600. The callback invocation times have jpayne@68: potentially a lot of jitter, but good long-term stability. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& clock_cb (struct ev_loop *loop, ev_periodic *w, int revents) jpayne@68: \& { jpayne@68: \& ... its now a full hour (UTC, or TAI or whatever your clock follows) jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_periodic hourly_tick; jpayne@68: \& ev_periodic_init (&hourly_tick, clock_cb, 0., 3600., 0); jpayne@68: \& ev_periodic_start (loop, &hourly_tick); jpayne@68: .Ve jpayne@68: .PP jpayne@68: Example: The same as above, but use a reschedule callback to do it: jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& #include jpayne@68: \& jpayne@68: \& static ev_tstamp jpayne@68: \& my_scheduler_cb (ev_periodic *w, ev_tstamp now) jpayne@68: \& { jpayne@68: \& return now + (3600. \- fmod (now, 3600.)); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_periodic_init (&hourly_tick, clock_cb, 0., 0., my_scheduler_cb); jpayne@68: .Ve jpayne@68: .PP jpayne@68: Example: Call a callback every hour, starting now: jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& ev_periodic hourly_tick; jpayne@68: \& ev_periodic_init (&hourly_tick, clock_cb, jpayne@68: \& fmod (ev_now (loop), 3600.), 3600., 0); jpayne@68: \& ev_periodic_start (loop, &hourly_tick); jpayne@68: .Ve jpayne@68: .ie n .SS """ev_signal"" \- signal me when a signal gets signalled!" jpayne@68: .el .SS "\f(CWev_signal\fP \- signal me when a signal gets signalled!" jpayne@68: .IX Subsection "ev_signal - signal me when a signal gets signalled!" jpayne@68: Signal watchers will trigger an event when the process receives a specific jpayne@68: signal one or more times. Even though signals are very asynchronous, libev jpayne@68: will try its best to deliver signals synchronously, i.e. as part of the jpayne@68: normal event processing, like any other event. jpayne@68: .PP jpayne@68: If you want signals to be delivered truly asynchronously, just use jpayne@68: \&\f(CW\*(C`sigaction\*(C'\fR as you would do without libev and forget about sharing jpayne@68: the signal. You can even use \f(CW\*(C`ev_async\*(C'\fR from a signal handler to jpayne@68: synchronously wake up an event loop. jpayne@68: .PP jpayne@68: You can configure as many watchers as you like for the same signal, but jpayne@68: only within the same loop, i.e. you can watch for \f(CW\*(C`SIGINT\*(C'\fR in your jpayne@68: default loop and for \f(CW\*(C`SIGIO\*(C'\fR in another loop, but you cannot watch for jpayne@68: \&\f(CW\*(C`SIGINT\*(C'\fR in both the default loop and another loop at the same time. At jpayne@68: the moment, \f(CW\*(C`SIGCHLD\*(C'\fR is permanently tied to the default loop. jpayne@68: .PP jpayne@68: Only after the first watcher for a signal is started will libev actually jpayne@68: register something with the kernel. It thus coexists with your own signal jpayne@68: handlers as long as you don't register any with libev for the same signal. jpayne@68: .PP jpayne@68: If possible and supported, libev will install its handlers with jpayne@68: \&\f(CW\*(C`SA_RESTART\*(C'\fR (or equivalent) behaviour enabled, so system calls should jpayne@68: not be unduly interrupted. If you have a problem with system calls getting jpayne@68: interrupted by signals you can block all signals in an \f(CW\*(C`ev_check\*(C'\fR watcher jpayne@68: and unblock them in an \f(CW\*(C`ev_prepare\*(C'\fR watcher. jpayne@68: .PP jpayne@68: \fIThe special problem of inheritance over fork/execve/pthread_create\fR jpayne@68: .IX Subsection "The special problem of inheritance over fork/execve/pthread_create" jpayne@68: .PP jpayne@68: Both the signal mask (\f(CW\*(C`sigprocmask\*(C'\fR) and the signal disposition jpayne@68: (\f(CW\*(C`sigaction\*(C'\fR) are unspecified after starting a signal watcher (and after jpayne@68: stopping it again), that is, libev might or might not block the signal, jpayne@68: and might or might not set or restore the installed signal handler (but jpayne@68: see \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR). jpayne@68: .PP jpayne@68: While this does not matter for the signal disposition (libev never jpayne@68: sets signals to \f(CW\*(C`SIG_IGN\*(C'\fR, so handlers will be reset to \f(CW\*(C`SIG_DFL\*(C'\fR on jpayne@68: \&\f(CW\*(C`execve\*(C'\fR), this matters for the signal mask: many programs do not expect jpayne@68: certain signals to be blocked. jpayne@68: .PP jpayne@68: This means that before calling \f(CW\*(C`exec\*(C'\fR (from the child) you should reset jpayne@68: the signal mask to whatever \*(L"default\*(R" you expect (all clear is a good jpayne@68: choice usually). jpayne@68: .PP jpayne@68: The simplest way to ensure that the signal mask is reset in the child is jpayne@68: to install a fork handler with \f(CW\*(C`pthread_atfork\*(C'\fR that resets it. That will jpayne@68: catch fork calls done by libraries (such as the libc) as well. jpayne@68: .PP jpayne@68: In current versions of libev, the signal will not be blocked indefinitely jpayne@68: unless you use the \f(CW\*(C`signalfd\*(C'\fR \s-1API\s0 (\f(CW\*(C`EV_SIGNALFD\*(C'\fR). While this reduces jpayne@68: the window of opportunity for problems, it will not go away, as libev jpayne@68: \&\fIhas\fR to modify the signal mask, at least temporarily. jpayne@68: .PP jpayne@68: So I can't stress this enough: \fIIf you do not reset your signal mask when jpayne@68: you expect it to be empty, you have a race condition in your code\fR. This jpayne@68: is not a libev-specific thing, this is true for most event libraries. jpayne@68: .PP jpayne@68: \fIThe special problem of threads signal handling\fR jpayne@68: .IX Subsection "The special problem of threads signal handling" jpayne@68: .PP jpayne@68: \&\s-1POSIX\s0 threads has problematic signal handling semantics, specifically, jpayne@68: a lot of functionality (sigfd, sigwait etc.) only really works if all jpayne@68: threads in a process block signals, which is hard to achieve. jpayne@68: .PP jpayne@68: When you want to use sigwait (or mix libev signal handling with your own jpayne@68: for the same signals), you can tackle this problem by globally blocking jpayne@68: all signals before creating any threads (or creating them with a fully set jpayne@68: sigprocmask) and also specifying the \f(CW\*(C`EVFLAG_NOSIGMASK\*(C'\fR when creating jpayne@68: loops. Then designate one thread as \*(L"signal receiver thread\*(R" which handles jpayne@68: these signals. You can pass on any signals that libev might be interested jpayne@68: in by calling \f(CW\*(C`ev_feed_signal\*(C'\fR. jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_signal_init (ev_signal *, callback, int signum)" 4 jpayne@68: .IX Item "ev_signal_init (ev_signal *, callback, int signum)" jpayne@68: .PD 0 jpayne@68: .IP "ev_signal_set (ev_signal *, int signum)" 4 jpayne@68: .IX Item "ev_signal_set (ev_signal *, int signum)" jpayne@68: .PD jpayne@68: Configures the watcher to trigger on the given signal number (usually one jpayne@68: of the \f(CW\*(C`SIGxxx\*(C'\fR constants). jpayne@68: .IP "int signum [read\-only]" 4 jpayne@68: .IX Item "int signum [read-only]" jpayne@68: The signal the watcher watches out for. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: Try to exit cleanly on \s-1SIGINT.\s0 jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& sigint_cb (struct ev_loop *loop, ev_signal *w, int revents) jpayne@68: \& { jpayne@68: \& ev_break (loop, EVBREAK_ALL); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_signal signal_watcher; jpayne@68: \& ev_signal_init (&signal_watcher, sigint_cb, SIGINT); jpayne@68: \& ev_signal_start (loop, &signal_watcher); jpayne@68: .Ve jpayne@68: .ie n .SS """ev_child"" \- watch out for process status changes" jpayne@68: .el .SS "\f(CWev_child\fP \- watch out for process status changes" jpayne@68: .IX Subsection "ev_child - watch out for process status changes" jpayne@68: Child watchers trigger when your process receives a \s-1SIGCHLD\s0 in response to jpayne@68: some child status changes (most typically when a child of yours dies or jpayne@68: exits). It is permissible to install a child watcher \fIafter\fR the child jpayne@68: has been forked (which implies it might have already exited), as long jpayne@68: as the event loop isn't entered (or is continued from a watcher), i.e., jpayne@68: forking and then immediately registering a watcher for the child is fine, jpayne@68: but forking and registering a watcher a few event loop iterations later or jpayne@68: in the next callback invocation is not. jpayne@68: .PP jpayne@68: Only the default event loop is capable of handling signals, and therefore jpayne@68: you can only register child watchers in the default event loop. jpayne@68: .PP jpayne@68: Due to some design glitches inside libev, child watchers will always be jpayne@68: handled at maximum priority (their priority is set to \f(CW\*(C`EV_MAXPRI\*(C'\fR by jpayne@68: libev) jpayne@68: .PP jpayne@68: \fIProcess Interaction\fR jpayne@68: .IX Subsection "Process Interaction" jpayne@68: .PP jpayne@68: Libev grabs \f(CW\*(C`SIGCHLD\*(C'\fR as soon as the default event loop is jpayne@68: initialised. This is necessary to guarantee proper behaviour even if the jpayne@68: first child watcher is started after the child exits. The occurrence jpayne@68: of \f(CW\*(C`SIGCHLD\*(C'\fR is recorded asynchronously, but child reaping is done jpayne@68: synchronously as part of the event loop processing. Libev always reaps all jpayne@68: children, even ones not watched. jpayne@68: .PP jpayne@68: \fIOverriding the Built-In Processing\fR jpayne@68: .IX Subsection "Overriding the Built-In Processing" jpayne@68: .PP jpayne@68: Libev offers no special support for overriding the built-in child jpayne@68: processing, but if your application collides with libev's default child jpayne@68: handler, you can override it easily by installing your own handler for jpayne@68: \&\f(CW\*(C`SIGCHLD\*(C'\fR after initialising the default loop, and making sure the jpayne@68: default loop never gets destroyed. You are encouraged, however, to use an jpayne@68: event-based approach to child reaping and thus use libev's support for jpayne@68: that, so other libev users can use \f(CW\*(C`ev_child\*(C'\fR watchers freely. jpayne@68: .PP jpayne@68: \fIStopping the Child Watcher\fR jpayne@68: .IX Subsection "Stopping the Child Watcher" jpayne@68: .PP jpayne@68: Currently, the child watcher never gets stopped, even when the jpayne@68: child terminates, so normally one needs to stop the watcher in the jpayne@68: callback. Future versions of libev might stop the watcher automatically jpayne@68: when a child exit is detected (calling \f(CW\*(C`ev_child_stop\*(C'\fR twice is not a jpayne@68: problem). jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_child_init (ev_child *, callback, int pid, int trace)" 4 jpayne@68: .IX Item "ev_child_init (ev_child *, callback, int pid, int trace)" jpayne@68: .PD 0 jpayne@68: .IP "ev_child_set (ev_child *, int pid, int trace)" 4 jpayne@68: .IX Item "ev_child_set (ev_child *, int pid, int trace)" jpayne@68: .PD jpayne@68: Configures the watcher to wait for status changes of process \f(CW\*(C`pid\*(C'\fR (or jpayne@68: \&\fIany\fR process if \f(CW\*(C`pid\*(C'\fR is specified as \f(CW0\fR). The callback can look jpayne@68: at the \f(CW\*(C`rstatus\*(C'\fR member of the \f(CW\*(C`ev_child\*(C'\fR watcher structure to see jpayne@68: the status word (use the macros from \f(CW\*(C`sys/wait.h\*(C'\fR and see your systems jpayne@68: \&\f(CW\*(C`waitpid\*(C'\fR documentation). The \f(CW\*(C`rpid\*(C'\fR member contains the pid of the jpayne@68: process causing the status change. \f(CW\*(C`trace\*(C'\fR must be either \f(CW0\fR (only jpayne@68: activate the watcher when the process terminates) or \f(CW1\fR (additionally jpayne@68: activate the watcher when the process is stopped or continued). jpayne@68: .IP "int pid [read\-only]" 4 jpayne@68: .IX Item "int pid [read-only]" jpayne@68: The process id this watcher watches out for, or \f(CW0\fR, meaning any process id. jpayne@68: .IP "int rpid [read\-write]" 4 jpayne@68: .IX Item "int rpid [read-write]" jpayne@68: The process id that detected a status change. jpayne@68: .IP "int rstatus [read\-write]" 4 jpayne@68: .IX Item "int rstatus [read-write]" jpayne@68: The process exit/trace status caused by \f(CW\*(C`rpid\*(C'\fR (see your systems jpayne@68: \&\f(CW\*(C`waitpid\*(C'\fR and \f(CW\*(C`sys/wait.h\*(C'\fR documentation for details). jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: \f(CW\*(C`fork()\*(C'\fR a new process and install a child handler to wait for jpayne@68: its completion. jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& ev_child cw; jpayne@68: \& jpayne@68: \& static void jpayne@68: \& child_cb (EV_P_ ev_child *w, int revents) jpayne@68: \& { jpayne@68: \& ev_child_stop (EV_A_ w); jpayne@68: \& printf ("process %d exited with status %x\en", w\->rpid, w\->rstatus); jpayne@68: \& } jpayne@68: \& jpayne@68: \& pid_t pid = fork (); jpayne@68: \& jpayne@68: \& if (pid < 0) jpayne@68: \& // error jpayne@68: \& else if (pid == 0) jpayne@68: \& { jpayne@68: \& // the forked child executes here jpayne@68: \& exit (1); jpayne@68: \& } jpayne@68: \& else jpayne@68: \& { jpayne@68: \& ev_child_init (&cw, child_cb, pid, 0); jpayne@68: \& ev_child_start (EV_DEFAULT_ &cw); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .ie n .SS """ev_stat"" \- did the file attributes just change?" jpayne@68: .el .SS "\f(CWev_stat\fP \- did the file attributes just change?" jpayne@68: .IX Subsection "ev_stat - did the file attributes just change?" jpayne@68: This watches a file system path for attribute changes. That is, it calls jpayne@68: \&\f(CW\*(C`stat\*(C'\fR on that path in regular intervals (or when the \s-1OS\s0 says it changed) jpayne@68: and sees if it changed compared to the last time, invoking the callback jpayne@68: if it did. Starting the watcher \f(CW\*(C`stat\*(C'\fR's the file, so only changes that jpayne@68: happen after the watcher has been started will be reported. jpayne@68: .PP jpayne@68: The path does not need to exist: changing from \*(L"path exists\*(R" to \*(L"path does jpayne@68: not exist\*(R" is a status change like any other. The condition \*(L"path does not jpayne@68: exist\*(R" (or more correctly \*(L"path cannot be stat'ed\*(R") is signified by the jpayne@68: \&\f(CW\*(C`st_nlink\*(C'\fR field being zero (which is otherwise always forced to be at jpayne@68: least one) and all the other fields of the stat buffer having unspecified jpayne@68: contents. jpayne@68: .PP jpayne@68: The path \fImust not\fR end in a slash or contain special components such as jpayne@68: \&\f(CW\*(C`.\*(C'\fR or \f(CW\*(C`..\*(C'\fR. The path \fIshould\fR be absolute: If it is relative and jpayne@68: your working directory changes, then the behaviour is undefined. jpayne@68: .PP jpayne@68: Since there is no portable change notification interface available, the jpayne@68: portable implementation simply calls \f(CWstat(2)\fR regularly on the path jpayne@68: to see if it changed somehow. You can specify a recommended polling jpayne@68: interval for this case. If you specify a polling interval of \f(CW0\fR (highly jpayne@68: recommended!) then a \fIsuitable, unspecified default\fR value will be used jpayne@68: (which you can expect to be around five seconds, although this might jpayne@68: change dynamically). Libev will also impose a minimum interval which is jpayne@68: currently around \f(CW0.1\fR, but that's usually overkill. jpayne@68: .PP jpayne@68: This watcher type is not meant for massive numbers of stat watchers, jpayne@68: as even with OS-supported change notifications, this can be jpayne@68: resource-intensive. jpayne@68: .PP jpayne@68: At the time of this writing, the only OS-specific interface implemented jpayne@68: is the Linux inotify interface (implementing kqueue support is left as an jpayne@68: exercise for the reader. Note, however, that the author sees no way of jpayne@68: implementing \f(CW\*(C`ev_stat\*(C'\fR semantics with kqueue, except as a hint). jpayne@68: .PP jpayne@68: \fI\s-1ABI\s0 Issues (Largefile Support)\fR jpayne@68: .IX Subsection "ABI Issues (Largefile Support)" jpayne@68: .PP jpayne@68: Libev by default (unless the user overrides this) uses the default jpayne@68: compilation environment, which means that on systems with large file jpayne@68: support disabled by default, you get the 32 bit version of the stat jpayne@68: structure. When using the library from programs that change the \s-1ABI\s0 to jpayne@68: use 64 bit file offsets the programs will fail. In that case you have to jpayne@68: compile libev with the same flags to get binary compatibility. This is jpayne@68: obviously the case with any flags that change the \s-1ABI,\s0 but the problem is jpayne@68: most noticeably displayed with ev_stat and large file support. jpayne@68: .PP jpayne@68: The solution for this is to lobby your distribution maker to make large jpayne@68: file interfaces available by default (as e.g. FreeBSD does) and not jpayne@68: optional. Libev cannot simply switch on large file support because it has jpayne@68: to exchange stat structures with application programs compiled using the jpayne@68: default compilation environment. jpayne@68: .PP jpayne@68: \fIInotify and Kqueue\fR jpayne@68: .IX Subsection "Inotify and Kqueue" jpayne@68: .PP jpayne@68: When \f(CW\*(C`inotify (7)\*(C'\fR support has been compiled into libev and present at jpayne@68: runtime, it will be used to speed up change detection where possible. The jpayne@68: inotify descriptor will be created lazily when the first \f(CW\*(C`ev_stat\*(C'\fR jpayne@68: watcher is being started. jpayne@68: .PP jpayne@68: Inotify presence does not change the semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers jpayne@68: except that changes might be detected earlier, and in some cases, to avoid jpayne@68: making regular \f(CW\*(C`stat\*(C'\fR calls. Even in the presence of inotify support jpayne@68: there are many cases where libev has to resort to regular \f(CW\*(C`stat\*(C'\fR polling, jpayne@68: but as long as kernel 2.6.25 or newer is used (2.6.24 and older have too jpayne@68: many bugs), the path exists (i.e. stat succeeds), and the path resides on jpayne@68: a local filesystem (libev currently assumes only ext2/3, jfs, reiserfs and jpayne@68: xfs are fully working) libev usually gets away without polling. jpayne@68: .PP jpayne@68: There is no support for kqueue, as apparently it cannot be used to jpayne@68: implement this functionality, due to the requirement of having a file jpayne@68: descriptor open on the object at all times, and detecting renames, unlinks jpayne@68: etc. is difficult. jpayne@68: .PP jpayne@68: \fI\f(CI\*(C`stat ()\*(C'\fI is a synchronous operation\fR jpayne@68: .IX Subsection "stat () is a synchronous operation" jpayne@68: .PP jpayne@68: Libev doesn't normally do any kind of I/O itself, and so is not blocking jpayne@68: the process. The exception are \f(CW\*(C`ev_stat\*(C'\fR watchers \- those call \f(CW\*(C`stat jpayne@68: ()\*(C'\fR, which is a synchronous operation. jpayne@68: .PP jpayne@68: For local paths, this usually doesn't matter: unless the system is very jpayne@68: busy or the intervals between stat's are large, a stat call will be fast, jpayne@68: as the path data is usually in memory already (except when starting the jpayne@68: watcher). jpayne@68: .PP jpayne@68: For networked file systems, calling \f(CW\*(C`stat ()\*(C'\fR can block an indefinite jpayne@68: time due to network issues, and even under good conditions, a stat call jpayne@68: often takes multiple milliseconds. jpayne@68: .PP jpayne@68: Therefore, it is best to avoid using \f(CW\*(C`ev_stat\*(C'\fR watchers on networked jpayne@68: paths, although this is fully supported by libev. jpayne@68: .PP jpayne@68: \fIThe special problem of stat time resolution\fR jpayne@68: .IX Subsection "The special problem of stat time resolution" jpayne@68: .PP jpayne@68: The \f(CW\*(C`stat ()\*(C'\fR system call only supports full-second resolution portably, jpayne@68: and even on systems where the resolution is higher, most file systems jpayne@68: still only support whole seconds. jpayne@68: .PP jpayne@68: That means that, if the time is the only thing that changes, you can jpayne@68: easily miss updates: on the first update, \f(CW\*(C`ev_stat\*(C'\fR detects a change and jpayne@68: calls your callback, which does something. When there is another update jpayne@68: within the same second, \f(CW\*(C`ev_stat\*(C'\fR will be unable to detect unless the jpayne@68: stat data does change in other ways (e.g. file size). jpayne@68: .PP jpayne@68: The solution to this is to delay acting on a change for slightly more jpayne@68: than a second (or till slightly after the next full second boundary), using jpayne@68: a roughly one-second-delay \f(CW\*(C`ev_timer\*(C'\fR (e.g. \f(CW\*(C`ev_timer_set (w, 0., 1.02); jpayne@68: ev_timer_again (loop, w)\*(C'\fR). jpayne@68: .PP jpayne@68: The \f(CW.02\fR offset is added to work around small timing inconsistencies jpayne@68: of some operating systems (where the second counter of the current time jpayne@68: might be be delayed. One such system is the Linux kernel, where a call to jpayne@68: \&\f(CW\*(C`gettimeofday\*(C'\fR might return a timestamp with a full second later than jpayne@68: a subsequent \f(CW\*(C`time\*(C'\fR call \- if the equivalent of \f(CW\*(C`time ()\*(C'\fR is used to jpayne@68: update file times then there will be a small window where the kernel uses jpayne@68: the previous second to update file times but libev might already execute jpayne@68: the timer callback). jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)" 4 jpayne@68: .IX Item "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)" jpayne@68: .PD 0 jpayne@68: .IP "ev_stat_set (ev_stat *, const char *path, ev_tstamp interval)" 4 jpayne@68: .IX Item "ev_stat_set (ev_stat *, const char *path, ev_tstamp interval)" jpayne@68: .PD jpayne@68: Configures the watcher to wait for status changes of the given jpayne@68: \&\f(CW\*(C`path\*(C'\fR. The \f(CW\*(C`interval\*(C'\fR is a hint on how quickly a change is expected to jpayne@68: be detected and should normally be specified as \f(CW0\fR to let libev choose jpayne@68: a suitable value. The memory pointed to by \f(CW\*(C`path\*(C'\fR must point to the same jpayne@68: path for as long as the watcher is active. jpayne@68: .Sp jpayne@68: The callback will receive an \f(CW\*(C`EV_STAT\*(C'\fR event when a change was detected, jpayne@68: relative to the attributes at the time the watcher was started (or the jpayne@68: last change was detected). jpayne@68: .IP "ev_stat_stat (loop, ev_stat *)" 4 jpayne@68: .IX Item "ev_stat_stat (loop, ev_stat *)" jpayne@68: Updates the stat buffer immediately with new values. If you change the jpayne@68: watched path in your callback, you could call this function to avoid jpayne@68: detecting this change (while introducing a race condition if you are not jpayne@68: the only one changing the path). Can also be useful simply to find out the jpayne@68: new values. jpayne@68: .IP "ev_statdata attr [read\-only]" 4 jpayne@68: .IX Item "ev_statdata attr [read-only]" jpayne@68: The most-recently detected attributes of the file. Although the type is jpayne@68: \&\f(CW\*(C`ev_statdata\*(C'\fR, this is usually the (or one of the) \f(CW\*(C`struct stat\*(C'\fR types jpayne@68: suitable for your system, but you can only rely on the POSIX-standardised jpayne@68: members to be present. If the \f(CW\*(C`st_nlink\*(C'\fR member is \f(CW0\fR, then there was jpayne@68: some error while \f(CW\*(C`stat\*(C'\fRing the file. jpayne@68: .IP "ev_statdata prev [read\-only]" 4 jpayne@68: .IX Item "ev_statdata prev [read-only]" jpayne@68: The previous attributes of the file. The callback gets invoked whenever jpayne@68: \&\f(CW\*(C`prev\*(C'\fR != \f(CW\*(C`attr\*(C'\fR, or, more precisely, one or more of these members jpayne@68: differ: \f(CW\*(C`st_dev\*(C'\fR, \f(CW\*(C`st_ino\*(C'\fR, \f(CW\*(C`st_mode\*(C'\fR, \f(CW\*(C`st_nlink\*(C'\fR, \f(CW\*(C`st_uid\*(C'\fR, jpayne@68: \&\f(CW\*(C`st_gid\*(C'\fR, \f(CW\*(C`st_rdev\*(C'\fR, \f(CW\*(C`st_size\*(C'\fR, \f(CW\*(C`st_atime\*(C'\fR, \f(CW\*(C`st_mtime\*(C'\fR, \f(CW\*(C`st_ctime\*(C'\fR. jpayne@68: .IP "ev_tstamp interval [read\-only]" 4 jpayne@68: .IX Item "ev_tstamp interval [read-only]" jpayne@68: The specified interval. jpayne@68: .IP "const char *path [read\-only]" 4 jpayne@68: .IX Item "const char *path [read-only]" jpayne@68: The file system path that is being watched. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: Watch \f(CW\*(C`/etc/passwd\*(C'\fR for attribute changes. jpayne@68: .PP jpayne@68: .Vb 10 jpayne@68: \& static void jpayne@68: \& passwd_cb (struct ev_loop *loop, ev_stat *w, int revents) jpayne@68: \& { jpayne@68: \& /* /etc/passwd changed in some way */ jpayne@68: \& if (w\->attr.st_nlink) jpayne@68: \& { jpayne@68: \& printf ("passwd current size %ld\en", (long)w\->attr.st_size); jpayne@68: \& printf ("passwd current atime %ld\en", (long)w\->attr.st_mtime); jpayne@68: \& printf ("passwd current mtime %ld\en", (long)w\->attr.st_mtime); jpayne@68: \& } jpayne@68: \& else jpayne@68: \& /* you shalt not abuse printf for puts */ jpayne@68: \& puts ("wow, /etc/passwd is not there, expect problems. " jpayne@68: \& "if this is windows, they already arrived\en"); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& ev_stat passwd; jpayne@68: \& jpayne@68: \& ev_stat_init (&passwd, passwd_cb, "/etc/passwd", 0.); jpayne@68: \& ev_stat_start (loop, &passwd); jpayne@68: .Ve jpayne@68: .PP jpayne@68: Example: Like above, but additionally use a one-second delay so we do not jpayne@68: miss updates (however, frequent updates will delay processing, too, so jpayne@68: one might do the work both on \f(CW\*(C`ev_stat\*(C'\fR callback invocation \fIand\fR on jpayne@68: \&\f(CW\*(C`ev_timer\*(C'\fR callback invocation). jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& static ev_stat passwd; jpayne@68: \& static ev_timer timer; jpayne@68: \& jpayne@68: \& static void jpayne@68: \& timer_cb (EV_P_ ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& ev_timer_stop (EV_A_ w); jpayne@68: \& jpayne@68: \& /* now it\*(Aqs one second after the most recent passwd change */ jpayne@68: \& } jpayne@68: \& jpayne@68: \& static void jpayne@68: \& stat_cb (EV_P_ ev_stat *w, int revents) jpayne@68: \& { jpayne@68: \& /* reset the one\-second timer */ jpayne@68: \& ev_timer_again (EV_A_ &timer); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& ev_stat_init (&passwd, stat_cb, "/etc/passwd", 0.); jpayne@68: \& ev_stat_start (loop, &passwd); jpayne@68: \& ev_timer_init (&timer, timer_cb, 0., 1.02); jpayne@68: .Ve jpayne@68: .ie n .SS """ev_idle"" \- when you've got nothing better to do..." jpayne@68: .el .SS "\f(CWev_idle\fP \- when you've got nothing better to do..." jpayne@68: .IX Subsection "ev_idle - when you've got nothing better to do..." jpayne@68: Idle watchers trigger events when no other events of the same or higher jpayne@68: priority are pending (prepare, check and other idle watchers do not count jpayne@68: as receiving \*(L"events\*(R"). jpayne@68: .PP jpayne@68: That is, as long as your process is busy handling sockets or timeouts jpayne@68: (or even signals, imagine) of the same or higher priority it will not be jpayne@68: triggered. But when your process is idle (or only lower-priority watchers jpayne@68: are pending), the idle watchers are being called once per event loop jpayne@68: iteration \- until stopped, that is, or your process receives more events jpayne@68: and becomes busy again with higher priority stuff. jpayne@68: .PP jpayne@68: The most noteworthy effect is that as long as any idle watchers are jpayne@68: active, the process will not block when waiting for new events. jpayne@68: .PP jpayne@68: Apart from keeping your process non-blocking (which is a useful jpayne@68: effect on its own sometimes), idle watchers are a good place to do jpayne@68: \&\*(L"pseudo-background processing\*(R", or delay processing stuff to after the jpayne@68: event loop has handled all outstanding events. jpayne@68: .PP jpayne@68: \fIAbusing an \f(CI\*(C`ev_idle\*(C'\fI watcher for its side-effect\fR jpayne@68: .IX Subsection "Abusing an ev_idle watcher for its side-effect" jpayne@68: .PP jpayne@68: As long as there is at least one active idle watcher, libev will never jpayne@68: sleep unnecessarily. Or in other words, it will loop as fast as possible. jpayne@68: For this to work, the idle watcher doesn't need to be invoked at all \- the jpayne@68: lowest priority will do. jpayne@68: .PP jpayne@68: This mode of operation can be useful together with an \f(CW\*(C`ev_check\*(C'\fR watcher, jpayne@68: to do something on each event loop iteration \- for example to balance load jpayne@68: between different connections. jpayne@68: .PP jpayne@68: See \*(L"Abusing an ev_check watcher for its side-effect\*(R" for a longer jpayne@68: example. jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_idle_init (ev_idle *, callback)" 4 jpayne@68: .IX Item "ev_idle_init (ev_idle *, callback)" jpayne@68: Initialises and configures the idle watcher \- it has no parameters of any jpayne@68: kind. There is a \f(CW\*(C`ev_idle_set\*(C'\fR macro, but using it is utterly pointless, jpayne@68: believe me. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: Dynamically allocate an \f(CW\*(C`ev_idle\*(C'\fR watcher, start it, and in the jpayne@68: callback, free it. Also, use no error checking, as usual. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& idle_cb (struct ev_loop *loop, ev_idle *w, int revents) jpayne@68: \& { jpayne@68: \& // stop the watcher jpayne@68: \& ev_idle_stop (loop, w); jpayne@68: \& jpayne@68: \& // now we can free it jpayne@68: \& free (w); jpayne@68: \& jpayne@68: \& // now do something you wanted to do when the program has jpayne@68: \& // no longer anything immediate to do. jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_idle *idle_watcher = malloc (sizeof (ev_idle)); jpayne@68: \& ev_idle_init (idle_watcher, idle_cb); jpayne@68: \& ev_idle_start (loop, idle_watcher); jpayne@68: .Ve jpayne@68: .ie n .SS """ev_prepare"" and ""ev_check"" \- customise your event loop!" jpayne@68: .el .SS "\f(CWev_prepare\fP and \f(CWev_check\fP \- customise your event loop!" jpayne@68: .IX Subsection "ev_prepare and ev_check - customise your event loop!" jpayne@68: Prepare and check watchers are often (but not always) used in pairs: jpayne@68: prepare watchers get invoked before the process blocks and check watchers jpayne@68: afterwards. jpayne@68: .PP jpayne@68: You \fImust not\fR call \f(CW\*(C`ev_run\*(C'\fR (or similar functions that enter the jpayne@68: current event loop) or \f(CW\*(C`ev_loop_fork\*(C'\fR from either \f(CW\*(C`ev_prepare\*(C'\fR or jpayne@68: \&\f(CW\*(C`ev_check\*(C'\fR watchers. Other loops than the current one are fine, jpayne@68: however. The rationale behind this is that you do not need to check jpayne@68: for recursion in those watchers, i.e. the sequence will always be jpayne@68: \&\f(CW\*(C`ev_prepare\*(C'\fR, blocking, \f(CW\*(C`ev_check\*(C'\fR so if you have one watcher of each jpayne@68: kind they will always be called in pairs bracketing the blocking call. jpayne@68: .PP jpayne@68: Their main purpose is to integrate other event mechanisms into libev and jpayne@68: their use is somewhat advanced. They could be used, for example, to track jpayne@68: variable changes, implement your own watchers, integrate net-snmp or a jpayne@68: coroutine library and lots more. They are also occasionally useful if jpayne@68: you cache some data and want to flush it before blocking (for example, jpayne@68: in X programs you might want to do an \f(CW\*(C`XFlush ()\*(C'\fR in an \f(CW\*(C`ev_prepare\*(C'\fR jpayne@68: watcher). jpayne@68: .PP jpayne@68: This is done by examining in each prepare call which file descriptors jpayne@68: need to be watched by the other library, registering \f(CW\*(C`ev_io\*(C'\fR watchers jpayne@68: for them and starting an \f(CW\*(C`ev_timer\*(C'\fR watcher for any timeouts (many jpayne@68: libraries provide exactly this functionality). Then, in the check watcher, jpayne@68: you check for any events that occurred (by checking the pending status jpayne@68: of all watchers and stopping them) and call back into the library. The jpayne@68: I/O and timer callbacks will never actually be called (but must be valid jpayne@68: nevertheless, because you never know, you know?). jpayne@68: .PP jpayne@68: As another example, the Perl Coro module uses these hooks to integrate jpayne@68: coroutines into libev programs, by yielding to other active coroutines jpayne@68: during each prepare and only letting the process block if no coroutines jpayne@68: are ready to run (it's actually more complicated: it only runs coroutines jpayne@68: with priority higher than or equal to the event loop and one coroutine jpayne@68: of lower priority, but only once, using idle watchers to keep the event jpayne@68: loop from blocking if lower-priority coroutines are active, thus mapping jpayne@68: low-priority coroutines to idle/background tasks). jpayne@68: .PP jpayne@68: When used for this purpose, it is recommended to give \f(CW\*(C`ev_check\*(C'\fR watchers jpayne@68: highest (\f(CW\*(C`EV_MAXPRI\*(C'\fR) priority, to ensure that they are being run before jpayne@68: any other watchers after the poll (this doesn't matter for \f(CW\*(C`ev_prepare\*(C'\fR jpayne@68: watchers). jpayne@68: .PP jpayne@68: Also, \f(CW\*(C`ev_check\*(C'\fR watchers (and \f(CW\*(C`ev_prepare\*(C'\fR watchers, too) should not jpayne@68: activate (\*(L"feed\*(R") events into libev. While libev fully supports this, they jpayne@68: might get executed before other \f(CW\*(C`ev_check\*(C'\fR watchers did their job. As jpayne@68: \&\f(CW\*(C`ev_check\*(C'\fR watchers are often used to embed other (non-libev) event jpayne@68: loops those other event loops might be in an unusable state until their jpayne@68: \&\f(CW\*(C`ev_check\*(C'\fR watcher ran (always remind yourself to coexist peacefully with jpayne@68: others). jpayne@68: .PP jpayne@68: \fIAbusing an \f(CI\*(C`ev_check\*(C'\fI watcher for its side-effect\fR jpayne@68: .IX Subsection "Abusing an ev_check watcher for its side-effect" jpayne@68: .PP jpayne@68: \&\f(CW\*(C`ev_check\*(C'\fR (and less often also \f(CW\*(C`ev_prepare\*(C'\fR) watchers can also be jpayne@68: useful because they are called once per event loop iteration. For jpayne@68: example, if you want to handle a large number of connections fairly, you jpayne@68: normally only do a bit of work for each active connection, and if there jpayne@68: is more work to do, you wait for the next event loop iteration, so other jpayne@68: connections have a chance of making progress. jpayne@68: .PP jpayne@68: Using an \f(CW\*(C`ev_check\*(C'\fR watcher is almost enough: it will be called on the jpayne@68: next event loop iteration. However, that isn't as soon as possible \- jpayne@68: without external events, your \f(CW\*(C`ev_check\*(C'\fR watcher will not be invoked. jpayne@68: .PP jpayne@68: This is where \f(CW\*(C`ev_idle\*(C'\fR watchers come in handy \- all you need is a jpayne@68: single global idle watcher that is active as long as you have one active jpayne@68: \&\f(CW\*(C`ev_check\*(C'\fR watcher. The \f(CW\*(C`ev_idle\*(C'\fR watcher makes sure the event loop jpayne@68: will not sleep, and the \f(CW\*(C`ev_check\*(C'\fR watcher makes sure a callback gets jpayne@68: invoked. Neither watcher alone can do that. jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_prepare_init (ev_prepare *, callback)" 4 jpayne@68: .IX Item "ev_prepare_init (ev_prepare *, callback)" jpayne@68: .PD 0 jpayne@68: .IP "ev_check_init (ev_check *, callback)" 4 jpayne@68: .IX Item "ev_check_init (ev_check *, callback)" jpayne@68: .PD jpayne@68: Initialises and configures the prepare or check watcher \- they have no jpayne@68: parameters of any kind. There are \f(CW\*(C`ev_prepare_set\*(C'\fR and \f(CW\*(C`ev_check_set\*(C'\fR jpayne@68: macros, but using them is utterly, utterly, utterly and completely jpayne@68: pointless. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: There are a number of principal ways to embed other event loops or modules jpayne@68: into libev. Here are some ideas on how to include libadns into libev jpayne@68: (there is a Perl module named \f(CW\*(C`EV::ADNS\*(C'\fR that does this, which you could jpayne@68: use as a working example. Another Perl module named \f(CW\*(C`EV::Glib\*(C'\fR embeds a jpayne@68: Glib main context into libev, and finally, \f(CW\*(C`Glib::EV\*(C'\fR embeds \s-1EV\s0 into the jpayne@68: Glib event loop). jpayne@68: .PP jpayne@68: Method 1: Add \s-1IO\s0 watchers and a timeout watcher in a prepare handler, jpayne@68: and in a check watcher, destroy them and call into libadns. What follows jpayne@68: is pseudo-code only of course. This requires you to either use a low jpayne@68: priority for the check watcher or use \f(CW\*(C`ev_clear_pending\*(C'\fR explicitly, as jpayne@68: the callbacks for the IO/timeout watchers might not have been called yet. jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& static ev_io iow [nfd]; jpayne@68: \& static ev_timer tw; jpayne@68: \& jpayne@68: \& static void jpayne@68: \& io_cb (struct ev_loop *loop, ev_io *w, int revents) jpayne@68: \& { jpayne@68: \& } jpayne@68: \& jpayne@68: \& // create io watchers for each fd and a timer before blocking jpayne@68: \& static void jpayne@68: \& adns_prepare_cb (struct ev_loop *loop, ev_prepare *w, int revents) jpayne@68: \& { jpayne@68: \& int timeout = 3600000; jpayne@68: \& struct pollfd fds [nfd]; jpayne@68: \& // actual code will need to loop here and realloc etc. jpayne@68: \& adns_beforepoll (ads, fds, &nfd, &timeout, timeval_from (ev_time ())); jpayne@68: \& jpayne@68: \& /* the callback is illegal, but won\*(Aqt be called as we stop during check */ jpayne@68: \& ev_timer_init (&tw, 0, timeout * 1e\-3, 0.); jpayne@68: \& ev_timer_start (loop, &tw); jpayne@68: \& jpayne@68: \& // create one ev_io per pollfd jpayne@68: \& for (int i = 0; i < nfd; ++i) jpayne@68: \& { jpayne@68: \& ev_io_init (iow + i, io_cb, fds [i].fd, jpayne@68: \& ((fds [i].events & POLLIN ? EV_READ : 0) jpayne@68: \& | (fds [i].events & POLLOUT ? EV_WRITE : 0))); jpayne@68: \& jpayne@68: \& fds [i].revents = 0; jpayne@68: \& ev_io_start (loop, iow + i); jpayne@68: \& } jpayne@68: \& } jpayne@68: \& jpayne@68: \& // stop all watchers after blocking jpayne@68: \& static void jpayne@68: \& adns_check_cb (struct ev_loop *loop, ev_check *w, int revents) jpayne@68: \& { jpayne@68: \& ev_timer_stop (loop, &tw); jpayne@68: \& jpayne@68: \& for (int i = 0; i < nfd; ++i) jpayne@68: \& { jpayne@68: \& // set the relevant poll flags jpayne@68: \& // could also call adns_processreadable etc. here jpayne@68: \& struct pollfd *fd = fds + i; jpayne@68: \& int revents = ev_clear_pending (iow + i); jpayne@68: \& if (revents & EV_READ ) fd\->revents |= fd\->events & POLLIN; jpayne@68: \& if (revents & EV_WRITE) fd\->revents |= fd\->events & POLLOUT; jpayne@68: \& jpayne@68: \& // now stop the watcher jpayne@68: \& ev_io_stop (loop, iow + i); jpayne@68: \& } jpayne@68: \& jpayne@68: \& adns_afterpoll (adns, fds, nfd, timeval_from (ev_now (loop)); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: Method 2: This would be just like method 1, but you run \f(CW\*(C`adns_afterpoll\*(C'\fR jpayne@68: in the prepare watcher and would dispose of the check watcher. jpayne@68: .PP jpayne@68: Method 3: If the module to be embedded supports explicit event jpayne@68: notification (libadns does), you can also make use of the actual watcher jpayne@68: callbacks, and only destroy/create the watchers in the prepare watcher. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& timer_cb (EV_P_ ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& adns_state ads = (adns_state)w\->data; jpayne@68: \& update_now (EV_A); jpayne@68: \& jpayne@68: \& adns_processtimeouts (ads, &tv_now); jpayne@68: \& } jpayne@68: \& jpayne@68: \& static void jpayne@68: \& io_cb (EV_P_ ev_io *w, int revents) jpayne@68: \& { jpayne@68: \& adns_state ads = (adns_state)w\->data; jpayne@68: \& update_now (EV_A); jpayne@68: \& jpayne@68: \& if (revents & EV_READ ) adns_processreadable (ads, w\->fd, &tv_now); jpayne@68: \& if (revents & EV_WRITE) adns_processwriteable (ads, w\->fd, &tv_now); jpayne@68: \& } jpayne@68: \& jpayne@68: \& // do not ever call adns_afterpoll jpayne@68: .Ve jpayne@68: .PP jpayne@68: Method 4: Do not use a prepare or check watcher because the module you jpayne@68: want to embed is not flexible enough to support it. Instead, you can jpayne@68: override their poll function. The drawback with this solution is that the jpayne@68: main loop is now no longer controllable by \s-1EV.\s0 The \f(CW\*(C`Glib::EV\*(C'\fR module uses jpayne@68: this approach, effectively embedding \s-1EV\s0 as a client into the horrible jpayne@68: libglib event loop. jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& static gint jpayne@68: \& event_poll_func (GPollFD *fds, guint nfds, gint timeout) jpayne@68: \& { jpayne@68: \& int got_events = 0; jpayne@68: \& jpayne@68: \& for (n = 0; n < nfds; ++n) jpayne@68: \& // create/start io watcher that sets the relevant bits in fds[n] and increment got_events jpayne@68: \& jpayne@68: \& if (timeout >= 0) jpayne@68: \& // create/start timer jpayne@68: \& jpayne@68: \& // poll jpayne@68: \& ev_run (EV_A_ 0); jpayne@68: \& jpayne@68: \& // stop timer again jpayne@68: \& if (timeout >= 0) jpayne@68: \& ev_timer_stop (EV_A_ &to); jpayne@68: \& jpayne@68: \& // stop io watchers again \- their callbacks should have set jpayne@68: \& for (n = 0; n < nfds; ++n) jpayne@68: \& ev_io_stop (EV_A_ iow [n]); jpayne@68: \& jpayne@68: \& return got_events; jpayne@68: \& } jpayne@68: .Ve jpayne@68: .ie n .SS """ev_embed"" \- when one backend isn't enough..." jpayne@68: .el .SS "\f(CWev_embed\fP \- when one backend isn't enough..." jpayne@68: .IX Subsection "ev_embed - when one backend isn't enough..." jpayne@68: This is a rather advanced watcher type that lets you embed one event loop jpayne@68: into another (currently only \f(CW\*(C`ev_io\*(C'\fR events are supported in the embedded jpayne@68: loop, other types of watchers might be handled in a delayed or incorrect jpayne@68: fashion and must not be used). jpayne@68: .PP jpayne@68: There are primarily two reasons you would want that: work around bugs and jpayne@68: prioritise I/O. jpayne@68: .PP jpayne@68: As an example for a bug workaround, the kqueue backend might only support jpayne@68: sockets on some platform, so it is unusable as generic backend, but you jpayne@68: still want to make use of it because you have many sockets and it scales jpayne@68: so nicely. In this case, you would create a kqueue-based loop and embed jpayne@68: it into your default loop (which might use e.g. poll). Overall operation jpayne@68: will be a bit slower because first libev has to call \f(CW\*(C`poll\*(C'\fR and then jpayne@68: \&\f(CW\*(C`kevent\*(C'\fR, but at least you can use both mechanisms for what they are jpayne@68: best: \f(CW\*(C`kqueue\*(C'\fR for scalable sockets and \f(CW\*(C`poll\*(C'\fR if you want it to work :) jpayne@68: .PP jpayne@68: As for prioritising I/O: under rare circumstances you have the case where jpayne@68: some fds have to be watched and handled very quickly (with low latency), jpayne@68: and even priorities and idle watchers might have too much overhead. In jpayne@68: this case you would put all the high priority stuff in one loop and all jpayne@68: the rest in a second one, and embed the second one in the first. jpayne@68: .PP jpayne@68: As long as the watcher is active, the callback will be invoked every jpayne@68: time there might be events pending in the embedded loop. The callback jpayne@68: must then call \f(CW\*(C`ev_embed_sweep (mainloop, watcher)\*(C'\fR to make a single jpayne@68: sweep and invoke their callbacks (the callback doesn't need to invoke the jpayne@68: \&\f(CW\*(C`ev_embed_sweep\*(C'\fR function directly, it could also start an idle watcher jpayne@68: to give the embedded loop strictly lower priority for example). jpayne@68: .PP jpayne@68: You can also set the callback to \f(CW0\fR, in which case the embed watcher jpayne@68: will automatically execute the embedded loop sweep whenever necessary. jpayne@68: .PP jpayne@68: Fork detection will be handled transparently while the \f(CW\*(C`ev_embed\*(C'\fR watcher jpayne@68: is active, i.e., the embedded loop will automatically be forked when the jpayne@68: embedding loop forks. In other cases, the user is responsible for calling jpayne@68: \&\f(CW\*(C`ev_loop_fork\*(C'\fR on the embedded loop. jpayne@68: .PP jpayne@68: Unfortunately, not all backends are embeddable: only the ones returned by jpayne@68: \&\f(CW\*(C`ev_embeddable_backends\*(C'\fR are, which, unfortunately, does not include any jpayne@68: portable one. jpayne@68: .PP jpayne@68: So when you want to use this feature you will always have to be prepared jpayne@68: that you cannot get an embeddable loop. The recommended way to get around jpayne@68: this is to have a separate variables for your embeddable loop, try to jpayne@68: create it, and if that fails, use the normal loop for everything. jpayne@68: .PP jpayne@68: \fI\f(CI\*(C`ev_embed\*(C'\fI and fork\fR jpayne@68: .IX Subsection "ev_embed and fork" jpayne@68: .PP jpayne@68: While the \f(CW\*(C`ev_embed\*(C'\fR watcher is running, forks in the embedding loop will jpayne@68: automatically be applied to the embedded loop as well, so no special jpayne@68: fork handling is required in that case. When the watcher is not running, jpayne@68: however, it is still the task of the libev user to call \f(CW\*(C`ev_loop_fork ()\*(C'\fR jpayne@68: as applicable. jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)" 4 jpayne@68: .IX Item "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)" jpayne@68: .PD 0 jpayne@68: .IP "ev_embed_set (ev_embed *, struct ev_loop *embedded_loop)" 4 jpayne@68: .IX Item "ev_embed_set (ev_embed *, struct ev_loop *embedded_loop)" jpayne@68: .PD jpayne@68: Configures the watcher to embed the given loop, which must be jpayne@68: embeddable. If the callback is \f(CW0\fR, then \f(CW\*(C`ev_embed_sweep\*(C'\fR will be jpayne@68: invoked automatically, otherwise it is the responsibility of the callback jpayne@68: to invoke it (it will continue to be called until the sweep has been done, jpayne@68: if you do not want that, you need to temporarily stop the embed watcher). jpayne@68: .IP "ev_embed_sweep (loop, ev_embed *)" 4 jpayne@68: .IX Item "ev_embed_sweep (loop, ev_embed *)" jpayne@68: Make a single, non-blocking sweep over the embedded loop. This works jpayne@68: similarly to \f(CW\*(C`ev_run (embedded_loop, EVRUN_NOWAIT)\*(C'\fR, but in the most jpayne@68: appropriate way for embedded loops. jpayne@68: .IP "struct ev_loop *other [read\-only]" 4 jpayne@68: .IX Item "struct ev_loop *other [read-only]" jpayne@68: The embedded event loop. jpayne@68: .PP jpayne@68: \fIExamples\fR jpayne@68: .IX Subsection "Examples" jpayne@68: .PP jpayne@68: Example: Try to get an embeddable event loop and embed it into the default jpayne@68: event loop. If that is not possible, use the default loop. The default jpayne@68: loop is stored in \f(CW\*(C`loop_hi\*(C'\fR, while the embeddable loop is stored in jpayne@68: \&\f(CW\*(C`loop_lo\*(C'\fR (which is \f(CW\*(C`loop_hi\*(C'\fR in the case no embeddable loop can be jpayne@68: used). jpayne@68: .PP jpayne@68: .Vb 3 jpayne@68: \& struct ev_loop *loop_hi = ev_default_init (0); jpayne@68: \& struct ev_loop *loop_lo = 0; jpayne@68: \& ev_embed embed; jpayne@68: \& jpayne@68: \& // see if there is a chance of getting one that works jpayne@68: \& // (remember that a flags value of 0 means autodetection) jpayne@68: \& loop_lo = ev_embeddable_backends () & ev_recommended_backends () jpayne@68: \& ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ()) jpayne@68: \& : 0; jpayne@68: \& jpayne@68: \& // if we got one, then embed it, otherwise default to loop_hi jpayne@68: \& if (loop_lo) jpayne@68: \& { jpayne@68: \& ev_embed_init (&embed, 0, loop_lo); jpayne@68: \& ev_embed_start (loop_hi, &embed); jpayne@68: \& } jpayne@68: \& else jpayne@68: \& loop_lo = loop_hi; jpayne@68: .Ve jpayne@68: .PP jpayne@68: Example: Check if kqueue is available but not recommended and create jpayne@68: a kqueue backend for use with sockets (which usually work with any jpayne@68: kqueue implementation). Store the kqueue/socket\-only event loop in jpayne@68: \&\f(CW\*(C`loop_socket\*(C'\fR. (One might optionally use \f(CW\*(C`EVFLAG_NOENV\*(C'\fR, too). jpayne@68: .PP jpayne@68: .Vb 3 jpayne@68: \& struct ev_loop *loop = ev_default_init (0); jpayne@68: \& struct ev_loop *loop_socket = 0; jpayne@68: \& ev_embed embed; jpayne@68: \& jpayne@68: \& if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE) jpayne@68: \& if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE)) jpayne@68: \& { jpayne@68: \& ev_embed_init (&embed, 0, loop_socket); jpayne@68: \& ev_embed_start (loop, &embed); jpayne@68: \& } jpayne@68: \& jpayne@68: \& if (!loop_socket) jpayne@68: \& loop_socket = loop; jpayne@68: \& jpayne@68: \& // now use loop_socket for all sockets, and loop for everything else jpayne@68: .Ve jpayne@68: .ie n .SS """ev_fork"" \- the audacity to resume the event loop after a fork" jpayne@68: .el .SS "\f(CWev_fork\fP \- the audacity to resume the event loop after a fork" jpayne@68: .IX Subsection "ev_fork - the audacity to resume the event loop after a fork" jpayne@68: Fork watchers are called when a \f(CW\*(C`fork ()\*(C'\fR was detected (usually because jpayne@68: whoever is a good citizen cared to tell libev about it by calling jpayne@68: \&\f(CW\*(C`ev_loop_fork\*(C'\fR). The invocation is done before the event loop blocks next jpayne@68: and before \f(CW\*(C`ev_check\*(C'\fR watchers are being called, and only in the child jpayne@68: after the fork. If whoever good citizen calling \f(CW\*(C`ev_default_fork\*(C'\fR cheats jpayne@68: and calls it in the wrong process, the fork handlers will be invoked, too, jpayne@68: of course. jpayne@68: .PP jpayne@68: \fIThe special problem of life after fork \- how is it possible?\fR jpayne@68: .IX Subsection "The special problem of life after fork - how is it possible?" jpayne@68: .PP jpayne@68: Most uses of \f(CW\*(C`fork ()\*(C'\fR consist of forking, then some simple calls to set jpayne@68: up/change the process environment, followed by a call to \f(CW\*(C`exec()\*(C'\fR. This jpayne@68: sequence should be handled by libev without any problems. jpayne@68: .PP jpayne@68: This changes when the application actually wants to do event handling jpayne@68: in the child, or both parent in child, in effect \*(L"continuing\*(R" after the jpayne@68: fork. jpayne@68: .PP jpayne@68: The default mode of operation (for libev, with application help to detect jpayne@68: forks) is to duplicate all the state in the child, as would be expected jpayne@68: when \fIeither\fR the parent \fIor\fR the child process continues. jpayne@68: .PP jpayne@68: When both processes want to continue using libev, then this is usually the jpayne@68: wrong result. In that case, usually one process (typically the parent) is jpayne@68: supposed to continue with all watchers in place as before, while the other jpayne@68: process typically wants to start fresh, i.e. without any active watchers. jpayne@68: .PP jpayne@68: The cleanest and most efficient way to achieve that with libev is to jpayne@68: simply create a new event loop, which of course will be \*(L"empty\*(R", and jpayne@68: use that for new watchers. This has the advantage of not touching more jpayne@68: memory than necessary, and thus avoiding the copy-on-write, and the jpayne@68: disadvantage of having to use multiple event loops (which do not support jpayne@68: signal watchers). jpayne@68: .PP jpayne@68: When this is not possible, or you want to use the default loop for jpayne@68: other reasons, then in the process that wants to start \*(L"fresh\*(R", call jpayne@68: \&\f(CW\*(C`ev_loop_destroy (EV_DEFAULT)\*(C'\fR followed by \f(CW\*(C`ev_default_loop (...)\*(C'\fR. jpayne@68: Destroying the default loop will \*(L"orphan\*(R" (not stop) all registered jpayne@68: watchers, so you have to be careful not to execute code that modifies jpayne@68: those watchers. Note also that in that case, you have to re-register any jpayne@68: signal watchers. jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_fork_init (ev_fork *, callback)" 4 jpayne@68: .IX Item "ev_fork_init (ev_fork *, callback)" jpayne@68: Initialises and configures the fork watcher \- it has no parameters of any jpayne@68: kind. There is a \f(CW\*(C`ev_fork_set\*(C'\fR macro, but using it is utterly pointless, jpayne@68: really. jpayne@68: .ie n .SS """ev_cleanup"" \- even the best things end" jpayne@68: .el .SS "\f(CWev_cleanup\fP \- even the best things end" jpayne@68: .IX Subsection "ev_cleanup - even the best things end" jpayne@68: Cleanup watchers are called just before the event loop is being destroyed jpayne@68: by a call to \f(CW\*(C`ev_loop_destroy\*(C'\fR. jpayne@68: .PP jpayne@68: While there is no guarantee that the event loop gets destroyed, cleanup jpayne@68: watchers provide a convenient method to install cleanup hooks for your jpayne@68: program, worker threads and so on \- you just to make sure to destroy the jpayne@68: loop when you want them to be invoked. jpayne@68: .PP jpayne@68: Cleanup watchers are invoked in the same way as any other watcher. Unlike jpayne@68: all other watchers, they do not keep a reference to the event loop (which jpayne@68: makes a lot of sense if you think about it). Like all other watchers, you jpayne@68: can call libev functions in the callback, except \f(CW\*(C`ev_cleanup_start\*(C'\fR. jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_cleanup_init (ev_cleanup *, callback)" 4 jpayne@68: .IX Item "ev_cleanup_init (ev_cleanup *, callback)" jpayne@68: Initialises and configures the cleanup watcher \- it has no parameters of jpayne@68: any kind. There is a \f(CW\*(C`ev_cleanup_set\*(C'\fR macro, but using it is utterly jpayne@68: pointless, I assure you. jpayne@68: .PP jpayne@68: Example: Register an atexit handler to destroy the default loop, so any jpayne@68: cleanup functions are called. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& program_exits (void) jpayne@68: \& { jpayne@68: \& ev_loop_destroy (EV_DEFAULT_UC); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& atexit (program_exits); jpayne@68: .Ve jpayne@68: .ie n .SS """ev_async"" \- how to wake up an event loop" jpayne@68: .el .SS "\f(CWev_async\fP \- how to wake up an event loop" jpayne@68: .IX Subsection "ev_async - how to wake up an event loop" jpayne@68: In general, you cannot use an \f(CW\*(C`ev_loop\*(C'\fR from multiple threads or other jpayne@68: asynchronous sources such as signal handlers (as opposed to multiple event jpayne@68: loops \- those are of course safe to use in different threads). jpayne@68: .PP jpayne@68: Sometimes, however, you need to wake up an event loop you do not control, jpayne@68: for example because it belongs to another thread. This is what \f(CW\*(C`ev_async\*(C'\fR jpayne@68: watchers do: as long as the \f(CW\*(C`ev_async\*(C'\fR watcher is active, you can signal jpayne@68: it by calling \f(CW\*(C`ev_async_send\*(C'\fR, which is thread\- and signal safe. jpayne@68: .PP jpayne@68: This functionality is very similar to \f(CW\*(C`ev_signal\*(C'\fR watchers, as signals, jpayne@68: too, are asynchronous in nature, and signals, too, will be compressed jpayne@68: (i.e. the number of callback invocations may be less than the number of jpayne@68: \&\f(CW\*(C`ev_async_send\*(C'\fR calls). In fact, you could use signal watchers as a kind jpayne@68: of \*(L"global async watchers\*(R" by using a watcher on an otherwise unused jpayne@68: signal, and \f(CW\*(C`ev_feed_signal\*(C'\fR to signal this watcher from another thread, jpayne@68: even without knowing which loop owns the signal. jpayne@68: .PP jpayne@68: \fIQueueing\fR jpayne@68: .IX Subsection "Queueing" jpayne@68: .PP jpayne@68: \&\f(CW\*(C`ev_async\*(C'\fR does not support queueing of data in any way. The reason jpayne@68: is that the author does not know of a simple (or any) algorithm for a jpayne@68: multiple-writer-single-reader queue that works in all cases and doesn't jpayne@68: need elaborate support such as pthreads or unportable memory access jpayne@68: semantics. jpayne@68: .PP jpayne@68: That means that if you want to queue data, you have to provide your own jpayne@68: queue. But at least I can tell you how to implement locking around your jpayne@68: queue: jpayne@68: .IP "queueing from a signal handler context" 4 jpayne@68: .IX Item "queueing from a signal handler context" jpayne@68: To implement race-free queueing, you simply add to the queue in the signal jpayne@68: handler but you block the signal handler in the watcher callback. Here is jpayne@68: an example that does that for some fictitious \s-1SIGUSR1\s0 handler: jpayne@68: .Sp jpayne@68: .Vb 1 jpayne@68: \& static ev_async mysig; jpayne@68: \& jpayne@68: \& static void jpayne@68: \& sigusr1_handler (void) jpayne@68: \& { jpayne@68: \& sometype data; jpayne@68: \& jpayne@68: \& // no locking etc. jpayne@68: \& queue_put (data); jpayne@68: \& ev_async_send (EV_DEFAULT_ &mysig); jpayne@68: \& } jpayne@68: \& jpayne@68: \& static void jpayne@68: \& mysig_cb (EV_P_ ev_async *w, int revents) jpayne@68: \& { jpayne@68: \& sometype data; jpayne@68: \& sigset_t block, prev; jpayne@68: \& jpayne@68: \& sigemptyset (&block); jpayne@68: \& sigaddset (&block, SIGUSR1); jpayne@68: \& sigprocmask (SIG_BLOCK, &block, &prev); jpayne@68: \& jpayne@68: \& while (queue_get (&data)) jpayne@68: \& process (data); jpayne@68: \& jpayne@68: \& if (sigismember (&prev, SIGUSR1) jpayne@68: \& sigprocmask (SIG_UNBLOCK, &block, 0); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .Sp jpayne@68: (Note: pthreads in theory requires you to use \f(CW\*(C`pthread_setmask\*(C'\fR jpayne@68: instead of \f(CW\*(C`sigprocmask\*(C'\fR when you use threads, but libev doesn't do it jpayne@68: either...). jpayne@68: .IP "queueing from a thread context" 4 jpayne@68: .IX Item "queueing from a thread context" jpayne@68: The strategy for threads is different, as you cannot (easily) block jpayne@68: threads but you can easily preempt them, so to queue safely you need to jpayne@68: employ a traditional mutex lock, such as in this pthread example: jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& static ev_async mysig; jpayne@68: \& static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER; jpayne@68: \& jpayne@68: \& static void jpayne@68: \& otherthread (void) jpayne@68: \& { jpayne@68: \& // only need to lock the actual queueing operation jpayne@68: \& pthread_mutex_lock (&mymutex); jpayne@68: \& queue_put (data); jpayne@68: \& pthread_mutex_unlock (&mymutex); jpayne@68: \& jpayne@68: \& ev_async_send (EV_DEFAULT_ &mysig); jpayne@68: \& } jpayne@68: \& jpayne@68: \& static void jpayne@68: \& mysig_cb (EV_P_ ev_async *w, int revents) jpayne@68: \& { jpayne@68: \& pthread_mutex_lock (&mymutex); jpayne@68: \& jpayne@68: \& while (queue_get (&data)) jpayne@68: \& process (data); jpayne@68: \& jpayne@68: \& pthread_mutex_unlock (&mymutex); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: \fIWatcher-Specific Functions and Data Members\fR jpayne@68: .IX Subsection "Watcher-Specific Functions and Data Members" jpayne@68: .IP "ev_async_init (ev_async *, callback)" 4 jpayne@68: .IX Item "ev_async_init (ev_async *, callback)" jpayne@68: Initialises and configures the async watcher \- it has no parameters of any jpayne@68: kind. There is a \f(CW\*(C`ev_async_set\*(C'\fR macro, but using it is utterly pointless, jpayne@68: trust me. jpayne@68: .IP "ev_async_send (loop, ev_async *)" 4 jpayne@68: .IX Item "ev_async_send (loop, ev_async *)" jpayne@68: Sends/signals/activates the given \f(CW\*(C`ev_async\*(C'\fR watcher, that is, feeds jpayne@68: an \f(CW\*(C`EV_ASYNC\*(C'\fR event on the watcher into the event loop, and instantly jpayne@68: returns. jpayne@68: .Sp jpayne@68: Unlike \f(CW\*(C`ev_feed_event\*(C'\fR, this call is safe to do from other threads, jpayne@68: signal or similar contexts (see the discussion of \f(CW\*(C`EV_ATOMIC_T\*(C'\fR in the jpayne@68: embedding section below on what exactly this means). jpayne@68: .Sp jpayne@68: Note that, as with other watchers in libev, multiple events might get jpayne@68: compressed into a single callback invocation (another way to look at jpayne@68: this is that \f(CW\*(C`ev_async\*(C'\fR watchers are level-triggered: they are set on jpayne@68: \&\f(CW\*(C`ev_async_send\*(C'\fR, reset when the event loop detects that). jpayne@68: .Sp jpayne@68: This call incurs the overhead of at most one extra system call per event jpayne@68: loop iteration, if the event loop is blocked, and no syscall at all if jpayne@68: the event loop (or your program) is processing events. That means that jpayne@68: repeated calls are basically free (there is no need to avoid calls for jpayne@68: performance reasons) and that the overhead becomes smaller (typically jpayne@68: zero) under load. jpayne@68: .IP "bool = ev_async_pending (ev_async *)" 4 jpayne@68: .IX Item "bool = ev_async_pending (ev_async *)" jpayne@68: Returns a non-zero value when \f(CW\*(C`ev_async_send\*(C'\fR has been called on the jpayne@68: watcher but the event has not yet been processed (or even noted) by the jpayne@68: event loop. jpayne@68: .Sp jpayne@68: \&\f(CW\*(C`ev_async_send\*(C'\fR sets a flag in the watcher and wakes up the loop. When jpayne@68: the loop iterates next and checks for the watcher to have become active, jpayne@68: it will reset the flag again. \f(CW\*(C`ev_async_pending\*(C'\fR can be used to very jpayne@68: quickly check whether invoking the loop might be a good idea. jpayne@68: .Sp jpayne@68: Not that this does \fInot\fR check whether the watcher itself is pending, jpayne@68: only whether it has been requested to make this watcher pending: there jpayne@68: is a time window between the event loop checking and resetting the async jpayne@68: notification, and the callback being invoked. jpayne@68: .SH "OTHER FUNCTIONS" jpayne@68: .IX Header "OTHER FUNCTIONS" jpayne@68: There are some other functions of possible interest. Described. Here. Now. jpayne@68: .IP "ev_once (loop, int fd, int events, ev_tstamp timeout, callback, arg)" 4 jpayne@68: .IX Item "ev_once (loop, int fd, int events, ev_tstamp timeout, callback, arg)" jpayne@68: This function combines a simple timer and an I/O watcher, calls your jpayne@68: callback on whichever event happens first and automatically stops both jpayne@68: watchers. This is useful if you want to wait for a single event on an fd jpayne@68: or timeout without having to allocate/configure/start/stop/free one or jpayne@68: more watchers yourself. jpayne@68: .Sp jpayne@68: If \f(CW\*(C`fd\*(C'\fR is less than 0, then no I/O watcher will be started and the jpayne@68: \&\f(CW\*(C`events\*(C'\fR argument is being ignored. Otherwise, an \f(CW\*(C`ev_io\*(C'\fR watcher for jpayne@68: the given \f(CW\*(C`fd\*(C'\fR and \f(CW\*(C`events\*(C'\fR set will be created and started. jpayne@68: .Sp jpayne@68: If \f(CW\*(C`timeout\*(C'\fR is less than 0, then no timeout watcher will be jpayne@68: started. Otherwise an \f(CW\*(C`ev_timer\*(C'\fR watcher with after = \f(CW\*(C`timeout\*(C'\fR (and jpayne@68: repeat = 0) will be started. \f(CW0\fR is a valid timeout. jpayne@68: .Sp jpayne@68: The callback has the type \f(CW\*(C`void (*cb)(int revents, void *arg)\*(C'\fR and is jpayne@68: passed an \f(CW\*(C`revents\*(C'\fR set like normal event callbacks (a combination of jpayne@68: \&\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 jpayne@68: value passed to \f(CW\*(C`ev_once\*(C'\fR. Note that it is possible to receive \fIboth\fR jpayne@68: a timeout and an io event at the same time \- you probably should give io jpayne@68: events precedence. jpayne@68: .Sp jpayne@68: Example: wait up to ten seconds for data to appear on \s-1STDIN_FILENO.\s0 jpayne@68: .Sp jpayne@68: .Vb 7 jpayne@68: \& static void stdin_ready (int revents, void *arg) jpayne@68: \& { jpayne@68: \& if (revents & EV_READ) jpayne@68: \& /* stdin might have data for us, joy! */; jpayne@68: \& else if (revents & EV_TIMER) jpayne@68: \& /* doh, nothing entered */; jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0); jpayne@68: .Ve jpayne@68: .IP "ev_feed_fd_event (loop, int fd, int revents)" 4 jpayne@68: .IX Item "ev_feed_fd_event (loop, int fd, int revents)" jpayne@68: Feed an event on the given fd, as if a file descriptor backend detected jpayne@68: the given events. jpayne@68: .IP "ev_feed_signal_event (loop, int signum)" 4 jpayne@68: .IX Item "ev_feed_signal_event (loop, int signum)" jpayne@68: Feed an event as if the given signal occurred. See also \f(CW\*(C`ev_feed_signal\*(C'\fR, jpayne@68: which is async-safe. jpayne@68: .SH "COMMON OR USEFUL IDIOMS (OR BOTH)" jpayne@68: .IX Header "COMMON OR USEFUL IDIOMS (OR BOTH)" jpayne@68: This section explains some common idioms that are not immediately jpayne@68: obvious. Note that examples are sprinkled over the whole manual, and this jpayne@68: section only contains stuff that wouldn't fit anywhere else. jpayne@68: .SS "\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\s0" jpayne@68: .IX Subsection "ASSOCIATING CUSTOM DATA WITH A WATCHER" jpayne@68: Each watcher has, by default, a \f(CW\*(C`void *data\*(C'\fR member that you can read jpayne@68: or modify at any time: libev will completely ignore it. This can be used jpayne@68: to associate arbitrary data with your watcher. If you need more data and jpayne@68: don't want to allocate memory separately and store a pointer to it in that jpayne@68: data member, you can also \*(L"subclass\*(R" the watcher type and provide your own jpayne@68: data: jpayne@68: .PP jpayne@68: .Vb 7 jpayne@68: \& struct my_io jpayne@68: \& { jpayne@68: \& ev_io io; jpayne@68: \& int otherfd; jpayne@68: \& void *somedata; jpayne@68: \& struct whatever *mostinteresting; jpayne@68: \& }; jpayne@68: \& jpayne@68: \& ... jpayne@68: \& struct my_io w; jpayne@68: \& ev_io_init (&w.io, my_cb, fd, EV_READ); jpayne@68: .Ve jpayne@68: .PP jpayne@68: And since your callback will be called with a pointer to the watcher, you jpayne@68: can cast it back to your own type: jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void my_cb (struct ev_loop *loop, ev_io *w_, int revents) jpayne@68: \& { jpayne@68: \& struct my_io *w = (struct my_io *)w_; jpayne@68: \& ... jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: More interesting and less C\-conformant ways of casting your callback jpayne@68: function type instead have been omitted. jpayne@68: .SS "\s-1BUILDING YOUR OWN COMPOSITE WATCHERS\s0" jpayne@68: .IX Subsection "BUILDING YOUR OWN COMPOSITE WATCHERS" jpayne@68: Another common scenario is to use some data structure with multiple jpayne@68: embedded watchers, in effect creating your own watcher that combines jpayne@68: multiple libev event sources into one \*(L"super-watcher\*(R": jpayne@68: .PP jpayne@68: .Vb 6 jpayne@68: \& struct my_biggy jpayne@68: \& { jpayne@68: \& int some_data; jpayne@68: \& ev_timer t1; jpayne@68: \& ev_timer t2; jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: In this case getting the pointer to \f(CW\*(C`my_biggy\*(C'\fR is a bit more jpayne@68: complicated: Either you store the address of your \f(CW\*(C`my_biggy\*(C'\fR struct in jpayne@68: the \f(CW\*(C`data\*(C'\fR member of the watcher (for woozies or \*(C+ coders), or you need jpayne@68: to use some pointer arithmetic using \f(CW\*(C`offsetof\*(C'\fR inside your watchers (for jpayne@68: real programmers): jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& #include jpayne@68: \& jpayne@68: \& static void jpayne@68: \& t1_cb (EV_P_ ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& struct my_biggy big = (struct my_biggy *) jpayne@68: \& (((char *)w) \- offsetof (struct my_biggy, t1)); jpayne@68: \& } jpayne@68: \& jpayne@68: \& static void jpayne@68: \& t2_cb (EV_P_ ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& struct my_biggy big = (struct my_biggy *) jpayne@68: \& (((char *)w) \- offsetof (struct my_biggy, t2)); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .SS "\s-1AVOIDING FINISHING BEFORE RETURNING\s0" jpayne@68: .IX Subsection "AVOIDING FINISHING BEFORE RETURNING" jpayne@68: Often you have structures like this in event-based programs: jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& callback () jpayne@68: \& { jpayne@68: \& free (request); jpayne@68: \& } jpayne@68: \& jpayne@68: \& request = start_new_request (..., callback); jpayne@68: .Ve jpayne@68: .PP jpayne@68: The intent is to start some \*(L"lengthy\*(R" operation. The \f(CW\*(C`request\*(C'\fR could be jpayne@68: used to cancel the operation, or do other things with it. jpayne@68: .PP jpayne@68: It's not uncommon to have code paths in \f(CW\*(C`start_new_request\*(C'\fR that jpayne@68: immediately invoke the callback, for example, to report errors. Or you add jpayne@68: some caching layer that finds that it can skip the lengthy aspects of the jpayne@68: operation and simply invoke the callback with the result. jpayne@68: .PP jpayne@68: The problem here is that this will happen \fIbefore\fR \f(CW\*(C`start_new_request\*(C'\fR jpayne@68: has returned, so \f(CW\*(C`request\*(C'\fR is not set. jpayne@68: .PP jpayne@68: Even if you pass the request by some safer means to the callback, you jpayne@68: might want to do something to the request after starting it, such as jpayne@68: canceling it, which probably isn't working so well when the callback has jpayne@68: already been invoked. jpayne@68: .PP jpayne@68: A common way around all these issues is to make sure that jpayne@68: \&\f(CW\*(C`start_new_request\*(C'\fR \fIalways\fR returns before the callback is invoked. If jpayne@68: \&\f(CW\*(C`start_new_request\*(C'\fR immediately knows the result, it can artificially jpayne@68: delay invoking the callback by using a \f(CW\*(C`prepare\*(C'\fR or \f(CW\*(C`idle\*(C'\fR watcher for jpayne@68: example, or more sneakily, by reusing an existing (stopped) watcher and jpayne@68: pushing it into the pending queue: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& ev_set_cb (watcher, callback); jpayne@68: \& ev_feed_event (EV_A_ watcher, 0); jpayne@68: .Ve jpayne@68: .PP jpayne@68: This way, \f(CW\*(C`start_new_request\*(C'\fR can safely return before the callback is jpayne@68: invoked, while not delaying callback invocation too much. jpayne@68: .SS "\s-1MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS\s0" jpayne@68: .IX Subsection "MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS" jpayne@68: Often (especially in \s-1GUI\s0 toolkits) there are places where you have jpayne@68: \&\fImodal\fR interaction, which is most easily implemented by recursively jpayne@68: invoking \f(CW\*(C`ev_run\*(C'\fR. jpayne@68: .PP jpayne@68: This brings the problem of exiting \- a callback might want to finish the jpayne@68: main \f(CW\*(C`ev_run\*(C'\fR call, but not the nested one (e.g. user clicked \*(L"Quit\*(R", but jpayne@68: a modal \*(L"Are you sure?\*(R" dialog is still waiting), or just the nested one jpayne@68: and not the main one (e.g. user clocked \*(L"Ok\*(R" in a modal dialog), or some jpayne@68: other combination: In these cases, a simple \f(CW\*(C`ev_break\*(C'\fR will not work. jpayne@68: .PP jpayne@68: The solution is to maintain \*(L"break this loop\*(R" variable for each \f(CW\*(C`ev_run\*(C'\fR jpayne@68: invocation, and use a loop around \f(CW\*(C`ev_run\*(C'\fR until the condition is jpayne@68: triggered, using \f(CW\*(C`EVRUN_ONCE\*(C'\fR: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& // main loop jpayne@68: \& int exit_main_loop = 0; jpayne@68: \& jpayne@68: \& while (!exit_main_loop) jpayne@68: \& ev_run (EV_DEFAULT_ EVRUN_ONCE); jpayne@68: \& jpayne@68: \& // in a modal watcher jpayne@68: \& int exit_nested_loop = 0; jpayne@68: \& jpayne@68: \& while (!exit_nested_loop) jpayne@68: \& ev_run (EV_A_ EVRUN_ONCE); jpayne@68: .Ve jpayne@68: .PP jpayne@68: To exit from any of these loops, just set the corresponding exit variable: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& // exit modal loop jpayne@68: \& exit_nested_loop = 1; jpayne@68: \& jpayne@68: \& // exit main program, after modal loop is finished jpayne@68: \& exit_main_loop = 1; jpayne@68: \& jpayne@68: \& // exit both jpayne@68: \& exit_main_loop = exit_nested_loop = 1; jpayne@68: .Ve jpayne@68: .SS "\s-1THREAD LOCKING EXAMPLE\s0" jpayne@68: .IX Subsection "THREAD LOCKING EXAMPLE" jpayne@68: Here is a fictitious example of how to run an event loop in a different jpayne@68: thread from where callbacks are being invoked and watchers are jpayne@68: created/added/removed. jpayne@68: .PP jpayne@68: For a real-world example, see the \f(CW\*(C`EV::Loop::Async\*(C'\fR perl module, jpayne@68: which uses exactly this technique (which is suited for many high-level jpayne@68: languages). jpayne@68: .PP jpayne@68: The example uses a pthread mutex to protect the loop data, a condition jpayne@68: variable to wait for callback invocations, an async watcher to notify the jpayne@68: event loop thread and an unspecified mechanism to wake up the main thread. jpayne@68: .PP jpayne@68: First, you need to associate some data with the event loop: jpayne@68: .PP jpayne@68: .Vb 6 jpayne@68: \& typedef struct { jpayne@68: \& mutex_t lock; /* global loop lock */ jpayne@68: \& ev_async async_w; jpayne@68: \& thread_t tid; jpayne@68: \& cond_t invoke_cv; jpayne@68: \& } userdata; jpayne@68: \& jpayne@68: \& void prepare_loop (EV_P) jpayne@68: \& { jpayne@68: \& // for simplicity, we use a static userdata struct. jpayne@68: \& static userdata u; jpayne@68: \& jpayne@68: \& ev_async_init (&u\->async_w, async_cb); jpayne@68: \& ev_async_start (EV_A_ &u\->async_w); jpayne@68: \& jpayne@68: \& pthread_mutex_init (&u\->lock, 0); jpayne@68: \& pthread_cond_init (&u\->invoke_cv, 0); jpayne@68: \& jpayne@68: \& // now associate this with the loop jpayne@68: \& ev_set_userdata (EV_A_ u); jpayne@68: \& ev_set_invoke_pending_cb (EV_A_ l_invoke); jpayne@68: \& ev_set_loop_release_cb (EV_A_ l_release, l_acquire); jpayne@68: \& jpayne@68: \& // then create the thread running ev_run jpayne@68: \& pthread_create (&u\->tid, 0, l_run, EV_A); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: The callback for the \f(CW\*(C`ev_async\*(C'\fR watcher does nothing: the watcher is used jpayne@68: solely to wake up the event loop so it takes notice of any new watchers jpayne@68: that might have been added: jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& async_cb (EV_P_ ev_async *w, int revents) jpayne@68: \& { jpayne@68: \& // just used for the side effects jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: The \f(CW\*(C`l_release\*(C'\fR and \f(CW\*(C`l_acquire\*(C'\fR callbacks simply unlock/lock the mutex jpayne@68: protecting the loop data, respectively. jpayne@68: .PP jpayne@68: .Vb 6 jpayne@68: \& static void jpayne@68: \& l_release (EV_P) jpayne@68: \& { jpayne@68: \& userdata *u = ev_userdata (EV_A); jpayne@68: \& pthread_mutex_unlock (&u\->lock); jpayne@68: \& } jpayne@68: \& jpayne@68: \& static void jpayne@68: \& l_acquire (EV_P) jpayne@68: \& { jpayne@68: \& userdata *u = ev_userdata (EV_A); jpayne@68: \& pthread_mutex_lock (&u\->lock); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: The event loop thread first acquires the mutex, and then jumps straight jpayne@68: into \f(CW\*(C`ev_run\*(C'\fR: jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& void * jpayne@68: \& l_run (void *thr_arg) jpayne@68: \& { jpayne@68: \& struct ev_loop *loop = (struct ev_loop *)thr_arg; jpayne@68: \& jpayne@68: \& l_acquire (EV_A); jpayne@68: \& pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0); jpayne@68: \& ev_run (EV_A_ 0); jpayne@68: \& l_release (EV_A); jpayne@68: \& jpayne@68: \& return 0; jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: Instead of invoking all pending watchers, the \f(CW\*(C`l_invoke\*(C'\fR callback will jpayne@68: signal the main thread via some unspecified mechanism (signals? pipe jpayne@68: writes? \f(CW\*(C`Async::Interrupt\*(C'\fR?) and then waits until all pending watchers jpayne@68: have been called (in a while loop because a) spurious wakeups are possible jpayne@68: and b) skipping inter-thread-communication when there are no pending jpayne@68: watchers is very beneficial): jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& static void jpayne@68: \& l_invoke (EV_P) jpayne@68: \& { jpayne@68: \& userdata *u = ev_userdata (EV_A); jpayne@68: \& jpayne@68: \& while (ev_pending_count (EV_A)) jpayne@68: \& { jpayne@68: \& wake_up_other_thread_in_some_magic_or_not_so_magic_way (); jpayne@68: \& pthread_cond_wait (&u\->invoke_cv, &u\->lock); jpayne@68: \& } jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: Now, whenever the main thread gets told to invoke pending watchers, it jpayne@68: will grab the lock, call \f(CW\*(C`ev_invoke_pending\*(C'\fR and then signal the loop jpayne@68: thread to continue: jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& static void jpayne@68: \& real_invoke_pending (EV_P) jpayne@68: \& { jpayne@68: \& userdata *u = ev_userdata (EV_A); jpayne@68: \& jpayne@68: \& pthread_mutex_lock (&u\->lock); jpayne@68: \& ev_invoke_pending (EV_A); jpayne@68: \& pthread_cond_signal (&u\->invoke_cv); jpayne@68: \& pthread_mutex_unlock (&u\->lock); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: Whenever you want to start/stop a watcher or do other modifications to an jpayne@68: event loop, you will now have to lock: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& ev_timer timeout_watcher; jpayne@68: \& userdata *u = ev_userdata (EV_A); jpayne@68: \& jpayne@68: \& ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.); jpayne@68: \& jpayne@68: \& pthread_mutex_lock (&u\->lock); jpayne@68: \& ev_timer_start (EV_A_ &timeout_watcher); jpayne@68: \& ev_async_send (EV_A_ &u\->async_w); jpayne@68: \& pthread_mutex_unlock (&u\->lock); jpayne@68: .Ve jpayne@68: .PP jpayne@68: Note that sending the \f(CW\*(C`ev_async\*(C'\fR watcher is required because otherwise jpayne@68: an event loop currently blocking in the kernel will have no knowledge jpayne@68: about the newly added timer. By waking up the loop it will pick up any new jpayne@68: watchers in the next event loop iteration. jpayne@68: .SS "\s-1THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS\s0" jpayne@68: .IX Subsection "THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS" jpayne@68: While the overhead of a callback that e.g. schedules a thread is small, it jpayne@68: is still an overhead. If you embed libev, and your main usage is with some jpayne@68: kind of threads or coroutines, you might want to customise libev so that jpayne@68: doesn't need callbacks anymore. jpayne@68: .PP jpayne@68: Imagine you have coroutines that you can switch to using a function jpayne@68: \&\f(CW\*(C`switch_to (coro)\*(C'\fR, that libev runs in a coroutine called \f(CW\*(C`libev_coro\*(C'\fR jpayne@68: and that due to some magic, the currently active coroutine is stored in a jpayne@68: global called \f(CW\*(C`current_coro\*(C'\fR. Then you can build your own \*(L"wait for libev jpayne@68: event\*(R" primitive by changing \f(CW\*(C`EV_CB_DECLARE\*(C'\fR and \f(CW\*(C`EV_CB_INVOKE\*(C'\fR (note jpayne@68: the differing \f(CW\*(C`;\*(C'\fR conventions): jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& #define EV_CB_DECLARE(type) struct my_coro *cb; jpayne@68: \& #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb) jpayne@68: .Ve jpayne@68: .PP jpayne@68: That means instead of having a C callback function, you store the jpayne@68: coroutine to switch to in each watcher, and instead of having libev call jpayne@68: your callback, you instead have it switch to that coroutine. jpayne@68: .PP jpayne@68: A coroutine might now wait for an event with a function called jpayne@68: \&\f(CW\*(C`wait_for_event\*(C'\fR. (the watcher needs to be started, as always, but it doesn't jpayne@68: matter when, or whether the watcher is active or not when this function is jpayne@68: called): jpayne@68: .PP jpayne@68: .Vb 6 jpayne@68: \& void jpayne@68: \& wait_for_event (ev_watcher *w) jpayne@68: \& { jpayne@68: \& ev_set_cb (w, current_coro); jpayne@68: \& switch_to (libev_coro); jpayne@68: \& } jpayne@68: .Ve jpayne@68: .PP jpayne@68: That basically suspends the coroutine inside \f(CW\*(C`wait_for_event\*(C'\fR and jpayne@68: continues the libev coroutine, which, when appropriate, switches back to jpayne@68: this or any other coroutine. jpayne@68: .PP jpayne@68: You can do similar tricks if you have, say, threads with an event queue \- jpayne@68: instead of storing a coroutine, you store the queue object and instead of jpayne@68: switching to a coroutine, you push the watcher onto the queue and notify jpayne@68: any waiters. jpayne@68: .PP jpayne@68: To embed libev, see \*(L"\s-1EMBEDDING\*(R"\s0, but in short, it's easiest to create two jpayne@68: files, \fImy_ev.h\fR and \fImy_ev.c\fR that include the respective libev files: jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& // my_ev.h jpayne@68: \& #define EV_CB_DECLARE(type) struct my_coro *cb; jpayne@68: \& #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb) jpayne@68: \& #include "../libev/ev.h" jpayne@68: \& jpayne@68: \& // my_ev.c jpayne@68: \& #define EV_H "my_ev.h" jpayne@68: \& #include "../libev/ev.c" jpayne@68: .Ve jpayne@68: .PP jpayne@68: And then use \fImy_ev.h\fR when you would normally use \fIev.h\fR, and compile jpayne@68: \&\fImy_ev.c\fR into your project. When properly specifying include paths, you jpayne@68: can even use \fIev.h\fR as header file name directly. jpayne@68: .SH "LIBEVENT EMULATION" jpayne@68: .IX Header "LIBEVENT EMULATION" jpayne@68: Libev offers a compatibility emulation layer for libevent. It cannot jpayne@68: emulate the internals of libevent, so here are some usage hints: jpayne@68: .IP "\(bu" 4 jpayne@68: Only the libevent\-1.4.1\-beta \s-1API\s0 is being emulated. jpayne@68: .Sp jpayne@68: This was the newest libevent version available when libev was implemented, jpayne@68: and is still mostly unchanged in 2010. jpayne@68: .IP "\(bu" 4 jpayne@68: Use it by including , as usual. jpayne@68: .IP "\(bu" 4 jpayne@68: The following members are fully supported: ev_base, ev_callback, jpayne@68: ev_arg, ev_fd, ev_res, ev_events. jpayne@68: .IP "\(bu" 4 jpayne@68: Avoid using ev_flags and the EVLIST_*\-macros, while it is jpayne@68: maintained by libev, it does not work exactly the same way as in libevent (consider jpayne@68: it a private \s-1API\s0). jpayne@68: .IP "\(bu" 4 jpayne@68: Priorities are not currently supported. Initialising priorities jpayne@68: will fail and all watchers will have the same priority, even though there jpayne@68: is an ev_pri field. jpayne@68: .IP "\(bu" 4 jpayne@68: In libevent, the last base created gets the signals, in libev, the jpayne@68: base that registered the signal gets the signals. jpayne@68: .IP "\(bu" 4 jpayne@68: Other members are not supported. jpayne@68: .IP "\(bu" 4 jpayne@68: The libev emulation is \fInot\fR \s-1ABI\s0 compatible to libevent, you need jpayne@68: to use the libev header file and library. jpayne@68: .SH "\*(C+ SUPPORT" jpayne@68: .IX Header " SUPPORT" jpayne@68: .SS "C \s-1API\s0" jpayne@68: .IX Subsection "C API" jpayne@68: The normal C \s-1API\s0 should work fine when used from \*(C+: both ev.h and the jpayne@68: libev sources can be compiled as \*(C+. Therefore, code that uses the C \s-1API\s0 jpayne@68: will work fine. jpayne@68: .PP jpayne@68: Proper exception specifications might have to be added to callbacks passed jpayne@68: to libev: exceptions may be thrown only from watcher callbacks, all other jpayne@68: callbacks (allocator, syserr, loop acquire/release and periodic reschedule jpayne@68: callbacks) must not throw exceptions, and might need a \f(CW\*(C`noexcept\*(C'\fR jpayne@68: specification. If you have code that needs to be compiled as both C and jpayne@68: \&\*(C+ you can use the \f(CW\*(C`EV_NOEXCEPT\*(C'\fR macro for this: jpayne@68: .PP jpayne@68: .Vb 6 jpayne@68: \& static void jpayne@68: \& fatal_error (const char *msg) EV_NOEXCEPT jpayne@68: \& { jpayne@68: \& perror (msg); jpayne@68: \& abort (); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ... jpayne@68: \& ev_set_syserr_cb (fatal_error); jpayne@68: .Ve jpayne@68: .PP jpayne@68: The only \s-1API\s0 functions that can currently throw exceptions are \f(CW\*(C`ev_run\*(C'\fR, jpayne@68: \&\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 jpayne@68: because it runs cleanup watchers). jpayne@68: .PP jpayne@68: Throwing exceptions in watcher callbacks is only supported if libev itself jpayne@68: is compiled with a \*(C+ compiler or your C and \*(C+ environments allow jpayne@68: throwing exceptions through C libraries (most do). jpayne@68: .SS "\*(C+ \s-1API\s0" jpayne@68: .IX Subsection " API" jpayne@68: Libev comes with some simplistic wrapper classes for \*(C+ that mainly allow jpayne@68: you to use some convenience methods to start/stop watchers and also change jpayne@68: the callback model to a model using method callbacks on objects. jpayne@68: .PP jpayne@68: To use it, jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& #include jpayne@68: .Ve jpayne@68: .PP jpayne@68: This automatically includes \fIev.h\fR and puts all of its definitions (many jpayne@68: of them macros) into the global namespace. All \*(C+ specific things are jpayne@68: put into the \f(CW\*(C`ev\*(C'\fR namespace. It should support all the same embedding jpayne@68: options as \fIev.h\fR, most notably \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR. jpayne@68: .PP jpayne@68: Care has been taken to keep the overhead low. The only data member the \*(C+ jpayne@68: classes add (compared to plain C\-style watchers) is the event loop pointer jpayne@68: that the watcher is associated with (or no additional members at all if jpayne@68: you disable \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR when embedding libev). jpayne@68: .PP jpayne@68: Currently, functions, static and non-static member functions and classes jpayne@68: with \f(CW\*(C`operator ()\*(C'\fR can be used as callbacks. Other types should be easy jpayne@68: to add as long as they only need one additional pointer for context. If jpayne@68: you need support for other types of functors please contact the author jpayne@68: (preferably after implementing it). jpayne@68: .PP jpayne@68: For all this to work, your \*(C+ compiler either has to use the same calling jpayne@68: conventions as your C compiler (for static member functions), or you have jpayne@68: to embed libev and compile libev itself as \*(C+. jpayne@68: .PP jpayne@68: Here is a list of things available in the \f(CW\*(C`ev\*(C'\fR namespace: jpayne@68: .ie n .IP """ev::READ"", ""ev::WRITE"" etc." 4 jpayne@68: .el .IP "\f(CWev::READ\fR, \f(CWev::WRITE\fR etc." 4 jpayne@68: .IX Item "ev::READ, ev::WRITE etc." jpayne@68: These are just enum values with the same values as the \f(CW\*(C`EV_READ\*(C'\fR etc. jpayne@68: macros from \fIev.h\fR. jpayne@68: .ie n .IP """ev::tstamp"", ""ev::now""" 4 jpayne@68: .el .IP "\f(CWev::tstamp\fR, \f(CWev::now\fR" 4 jpayne@68: .IX Item "ev::tstamp, ev::now" jpayne@68: Aliases to the same types/functions as with the \f(CW\*(C`ev_\*(C'\fR prefix. jpayne@68: .ie n .IP """ev::io"", ""ev::timer"", ""ev::periodic"", ""ev::idle"", ""ev::sig"" etc." 4 jpayne@68: .el .IP "\f(CWev::io\fR, \f(CWev::timer\fR, \f(CWev::periodic\fR, \f(CWev::idle\fR, \f(CWev::sig\fR etc." 4 jpayne@68: .IX Item "ev::io, ev::timer, ev::periodic, ev::idle, ev::sig etc." jpayne@68: For each \f(CW\*(C`ev_TYPE\*(C'\fR watcher in \fIev.h\fR there is a corresponding class of jpayne@68: the same name in the \f(CW\*(C`ev\*(C'\fR namespace, with the exception of \f(CW\*(C`ev_signal\*(C'\fR jpayne@68: which is called \f(CW\*(C`ev::sig\*(C'\fR to avoid clashes with the \f(CW\*(C`signal\*(C'\fR macro jpayne@68: defined by many implementations. jpayne@68: .Sp jpayne@68: All of those classes have these methods: jpayne@68: .RS 4 jpayne@68: .IP "ev::TYPE::TYPE ()" 4 jpayne@68: .IX Item "ev::TYPE::TYPE ()" jpayne@68: .PD 0 jpayne@68: .IP "ev::TYPE::TYPE (loop)" 4 jpayne@68: .IX Item "ev::TYPE::TYPE (loop)" jpayne@68: .IP "ev::TYPE::~TYPE" 4 jpayne@68: .IX Item "ev::TYPE::~TYPE" jpayne@68: .PD jpayne@68: The constructor (optionally) takes an event loop to associate the watcher jpayne@68: with. If it is omitted, it will use \f(CW\*(C`EV_DEFAULT\*(C'\fR. jpayne@68: .Sp jpayne@68: The constructor calls \f(CW\*(C`ev_init\*(C'\fR for you, which means you have to call the jpayne@68: \&\f(CW\*(C`set\*(C'\fR method before starting it. jpayne@68: .Sp jpayne@68: It will not set a callback, however: You have to call the templated \f(CW\*(C`set\*(C'\fR jpayne@68: method to set a callback before you can start the watcher. jpayne@68: .Sp jpayne@68: (The reason why you have to use a method is a limitation in \*(C+ which does jpayne@68: not allow explicit template arguments for constructors). jpayne@68: .Sp jpayne@68: The destructor automatically stops the watcher if it is active. jpayne@68: .IP "w\->set (object *)" 4 jpayne@68: .IX Item "w->set (object *)" jpayne@68: This method sets the callback method to call. The method has to have a jpayne@68: signature of \f(CW\*(C`void (*)(ev_TYPE &, int)\*(C'\fR, it receives the watcher as jpayne@68: first argument and the \f(CW\*(C`revents\*(C'\fR as second. The object must be given as jpayne@68: parameter and is stored in the \f(CW\*(C`data\*(C'\fR member of the watcher. jpayne@68: .Sp jpayne@68: This method synthesizes efficient thunking code to call your method from jpayne@68: the C callback that libev requires. If your compiler can inline your jpayne@68: callback (i.e. it is visible to it at the place of the \f(CW\*(C`set\*(C'\fR call and jpayne@68: your compiler is good :), then the method will be fully inlined into the jpayne@68: thunking function, making it as fast as a direct C callback. jpayne@68: .Sp jpayne@68: Example: simple class declaration and watcher initialisation jpayne@68: .Sp jpayne@68: .Vb 4 jpayne@68: \& struct myclass jpayne@68: \& { jpayne@68: \& void io_cb (ev::io &w, int revents) { } jpayne@68: \& } jpayne@68: \& jpayne@68: \& myclass obj; jpayne@68: \& ev::io iow; jpayne@68: \& iow.set (&obj); jpayne@68: .Ve jpayne@68: .IP "w\->set (object *)" 4 jpayne@68: .IX Item "w->set (object *)" jpayne@68: This is a variation of a method callback \- leaving out the method to call jpayne@68: will default the method to \f(CW\*(C`operator ()\*(C'\fR, which makes it possible to use jpayne@68: functor objects without having to manually specify the \f(CW\*(C`operator ()\*(C'\fR all jpayne@68: the time. Incidentally, you can then also leave out the template argument jpayne@68: list. jpayne@68: .Sp jpayne@68: The \f(CW\*(C`operator ()\*(C'\fR method prototype must be \f(CW\*(C`void operator ()(watcher &w, jpayne@68: int revents)\*(C'\fR. jpayne@68: .Sp jpayne@68: See the method\-\f(CW\*(C`set\*(C'\fR above for more details. jpayne@68: .Sp jpayne@68: Example: use a functor object as callback. jpayne@68: .Sp jpayne@68: .Vb 7 jpayne@68: \& struct myfunctor jpayne@68: \& { jpayne@68: \& void operator() (ev::io &w, int revents) jpayne@68: \& { jpayne@68: \& ... jpayne@68: \& } jpayne@68: \& } jpayne@68: \& jpayne@68: \& myfunctor f; jpayne@68: \& jpayne@68: \& ev::io w; jpayne@68: \& w.set (&f); jpayne@68: .Ve jpayne@68: .IP "w\->set (void *data = 0)" 4 jpayne@68: .IX Item "w->set (void *data = 0)" jpayne@68: Also sets a callback, but uses a static method or plain function as jpayne@68: callback. The optional \f(CW\*(C`data\*(C'\fR argument will be stored in the watcher's jpayne@68: \&\f(CW\*(C`data\*(C'\fR member and is free for you to use. jpayne@68: .Sp jpayne@68: The prototype of the \f(CW\*(C`function\*(C'\fR must be \f(CW\*(C`void (*)(ev::TYPE &w, int)\*(C'\fR. jpayne@68: .Sp jpayne@68: See the method\-\f(CW\*(C`set\*(C'\fR above for more details. jpayne@68: .Sp jpayne@68: Example: Use a plain function as callback. jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& static void io_cb (ev::io &w, int revents) { } jpayne@68: \& iow.set (); jpayne@68: .Ve jpayne@68: .IP "w\->set (loop)" 4 jpayne@68: .IX Item "w->set (loop)" jpayne@68: Associates a different \f(CW\*(C`struct ev_loop\*(C'\fR with this watcher. You can only jpayne@68: do this when the watcher is inactive (and not pending either). jpayne@68: .IP "w\->set ([arguments])" 4 jpayne@68: .IX Item "w->set ([arguments])" jpayne@68: Basically the same as \f(CW\*(C`ev_TYPE_set\*(C'\fR (except for \f(CW\*(C`ev::embed\*(C'\fR watchers>), jpayne@68: with the same arguments. Either this method or a suitable start method jpayne@68: must be called at least once. Unlike the C counterpart, an active watcher jpayne@68: gets automatically stopped and restarted when reconfiguring it with this jpayne@68: method. jpayne@68: .Sp jpayne@68: For \f(CW\*(C`ev::embed\*(C'\fR watchers this method is called \f(CW\*(C`set_embed\*(C'\fR, to avoid jpayne@68: clashing with the \f(CW\*(C`set (loop)\*(C'\fR method. jpayne@68: .Sp jpayne@68: For \f(CW\*(C`ev::io\*(C'\fR watchers there is an additional \f(CW\*(C`set\*(C'\fR method that acepts a jpayne@68: new event mask only, and internally calls \f(CW\*(C`ev_io_modfify\*(C'\fR. jpayne@68: .IP "w\->start ()" 4 jpayne@68: .IX Item "w->start ()" jpayne@68: Starts the watcher. Note that there is no \f(CW\*(C`loop\*(C'\fR argument, as the jpayne@68: constructor already stores the event loop. jpayne@68: .IP "w\->start ([arguments])" 4 jpayne@68: .IX Item "w->start ([arguments])" jpayne@68: Instead of calling \f(CW\*(C`set\*(C'\fR and \f(CW\*(C`start\*(C'\fR methods separately, it is often jpayne@68: convenient to wrap them in one call. Uses the same type of arguments as jpayne@68: the configure \f(CW\*(C`set\*(C'\fR method of the watcher. jpayne@68: .IP "w\->stop ()" 4 jpayne@68: .IX Item "w->stop ()" jpayne@68: Stops the watcher if it is active. Again, no \f(CW\*(C`loop\*(C'\fR argument. jpayne@68: .ie n .IP "w\->again () (""ev::timer"", ""ev::periodic"" only)" 4 jpayne@68: .el .IP "w\->again () (\f(CWev::timer\fR, \f(CWev::periodic\fR only)" 4 jpayne@68: .IX Item "w->again () (ev::timer, ev::periodic only)" jpayne@68: For \f(CW\*(C`ev::timer\*(C'\fR and \f(CW\*(C`ev::periodic\*(C'\fR, this invokes the corresponding jpayne@68: \&\f(CW\*(C`ev_TYPE_again\*(C'\fR function. jpayne@68: .ie n .IP "w\->sweep () (""ev::embed"" only)" 4 jpayne@68: .el .IP "w\->sweep () (\f(CWev::embed\fR only)" 4 jpayne@68: .IX Item "w->sweep () (ev::embed only)" jpayne@68: Invokes \f(CW\*(C`ev_embed_sweep\*(C'\fR. jpayne@68: .ie n .IP "w\->update () (""ev::stat"" only)" 4 jpayne@68: .el .IP "w\->update () (\f(CWev::stat\fR only)" 4 jpayne@68: .IX Item "w->update () (ev::stat only)" jpayne@68: Invokes \f(CW\*(C`ev_stat_stat\*(C'\fR. jpayne@68: .RE jpayne@68: .RS 4 jpayne@68: .RE jpayne@68: .PP jpayne@68: Example: Define a class with two I/O and idle watchers, start the I/O jpayne@68: watchers in the constructor. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& class myclass jpayne@68: \& { jpayne@68: \& ev::io io ; void io_cb (ev::io &w, int revents); jpayne@68: \& ev::io io2 ; void io2_cb (ev::io &w, int revents); jpayne@68: \& ev::idle idle; void idle_cb (ev::idle &w, int revents); jpayne@68: \& jpayne@68: \& myclass (int fd) jpayne@68: \& { jpayne@68: \& io .set (this); jpayne@68: \& io2 .set (this); jpayne@68: \& idle.set (this); jpayne@68: \& jpayne@68: \& io.set (fd, ev::WRITE); // configure the watcher jpayne@68: \& io.start (); // start it whenever convenient jpayne@68: \& jpayne@68: \& io2.start (fd, ev::READ); // set + start in one call jpayne@68: \& } jpayne@68: \& }; jpayne@68: .Ve jpayne@68: .SH "OTHER LANGUAGE BINDINGS" jpayne@68: .IX Header "OTHER LANGUAGE BINDINGS" jpayne@68: Libev does not offer other language bindings itself, but bindings for a jpayne@68: number of languages exist in the form of third-party packages. If you know jpayne@68: any interesting language binding in addition to the ones listed here, drop jpayne@68: me a note. jpayne@68: .IP "Perl" 4 jpayne@68: .IX Item "Perl" jpayne@68: The \s-1EV\s0 module implements the full libev \s-1API\s0 and is actually used to test jpayne@68: libev. \s-1EV\s0 is developed together with libev. Apart from the \s-1EV\s0 core module, jpayne@68: there are additional modules that implement libev-compatible interfaces jpayne@68: 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), jpayne@68: \&\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 jpayne@68: and \f(CW\*(C`EV::Glib\*(C'\fR). jpayne@68: .Sp jpayne@68: It can be found and installed via \s-1CPAN,\s0 its homepage is at jpayne@68: . jpayne@68: .IP "Python" 4 jpayne@68: .IX Item "Python" jpayne@68: Python bindings can be found at . It jpayne@68: seems to be quite complete and well-documented. jpayne@68: .IP "Ruby" 4 jpayne@68: .IX Item "Ruby" jpayne@68: Tony Arcieri has written a ruby extension that offers access to a subset jpayne@68: of the libev \s-1API\s0 and adds file handle abstractions, asynchronous \s-1DNS\s0 and jpayne@68: more on top of it. It can be found via gem servers. Its homepage is at jpayne@68: . jpayne@68: .Sp jpayne@68: Roger Pack reports that using the link order \f(CW\*(C`\-lws2_32 \-lmsvcrt\-ruby\-190\*(C'\fR jpayne@68: makes rev work even on mingw. jpayne@68: .IP "Haskell" 4 jpayne@68: .IX Item "Haskell" jpayne@68: A haskell binding to libev is available at jpayne@68: . jpayne@68: .IP "D" 4 jpayne@68: .IX Item "D" jpayne@68: Leandro Lucarella has written a D language binding (\fIev.d\fR) for libev, to jpayne@68: be found at . jpayne@68: .IP "Ocaml" 4 jpayne@68: .IX Item "Ocaml" jpayne@68: Erkki Seppala has written Ocaml bindings for libev, to be found at jpayne@68: . jpayne@68: .IP "Lua" 4 jpayne@68: .IX Item "Lua" jpayne@68: Brian Maher has written a partial interface to libev for lua (at the jpayne@68: time of this writing, only \f(CW\*(C`ev_io\*(C'\fR and \f(CW\*(C`ev_timer\*(C'\fR), to be found at jpayne@68: . jpayne@68: .IP "Javascript" 4 jpayne@68: .IX Item "Javascript" jpayne@68: Node.js () uses libev as the underlying event library. jpayne@68: .IP "Others" 4 jpayne@68: .IX Item "Others" jpayne@68: There are others, and I stopped counting. jpayne@68: .SH "MACRO MAGIC" jpayne@68: .IX Header "MACRO MAGIC" jpayne@68: Libev can be compiled with a variety of options, the most fundamental jpayne@68: of which is \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR. This option determines whether (most) jpayne@68: functions and callbacks have an initial \f(CW\*(C`struct ev_loop *\*(C'\fR argument. jpayne@68: .PP jpayne@68: To make it easier to write programs that cope with either variant, the jpayne@68: following macros are defined: jpayne@68: .ie n .IP """EV_A"", ""EV_A_""" 4 jpayne@68: .el .IP "\f(CWEV_A\fR, \f(CWEV_A_\fR" 4 jpayne@68: .IX Item "EV_A, EV_A_" jpayne@68: This provides the loop \fIargument\fR for functions, if one is required (\*(L"ev jpayne@68: loop argument\*(R"). The \f(CW\*(C`EV_A\*(C'\fR form is used when this is the sole argument, jpayne@68: \&\f(CW\*(C`EV_A_\*(C'\fR is used when other arguments are following. Example: jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& ev_unref (EV_A); jpayne@68: \& ev_timer_add (EV_A_ watcher); jpayne@68: \& ev_run (EV_A_ 0); jpayne@68: .Ve jpayne@68: .Sp jpayne@68: It assumes the variable \f(CW\*(C`loop\*(C'\fR of type \f(CW\*(C`struct ev_loop *\*(C'\fR is in scope, jpayne@68: which is often provided by the following macro. jpayne@68: .ie n .IP """EV_P"", ""EV_P_""" 4 jpayne@68: .el .IP "\f(CWEV_P\fR, \f(CWEV_P_\fR" 4 jpayne@68: .IX Item "EV_P, EV_P_" jpayne@68: This provides the loop \fIparameter\fR for functions, if one is required (\*(L"ev jpayne@68: loop parameter\*(R"). The \f(CW\*(C`EV_P\*(C'\fR form is used when this is the sole parameter, jpayne@68: \&\f(CW\*(C`EV_P_\*(C'\fR is used when other parameters are following. Example: jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& // this is how ev_unref is being declared jpayne@68: \& static void ev_unref (EV_P); jpayne@68: \& jpayne@68: \& // this is how you can declare your typical callback jpayne@68: \& static void cb (EV_P_ ev_timer *w, int revents) jpayne@68: .Ve jpayne@68: .Sp jpayne@68: It declares a parameter \f(CW\*(C`loop\*(C'\fR of type \f(CW\*(C`struct ev_loop *\*(C'\fR, quite jpayne@68: suitable for use with \f(CW\*(C`EV_A\*(C'\fR. jpayne@68: .ie n .IP """EV_DEFAULT"", ""EV_DEFAULT_""" 4 jpayne@68: .el .IP "\f(CWEV_DEFAULT\fR, \f(CWEV_DEFAULT_\fR" 4 jpayne@68: .IX Item "EV_DEFAULT, EV_DEFAULT_" jpayne@68: Similar to the other two macros, this gives you the value of the default jpayne@68: loop, if multiple loops are supported (\*(L"ev loop default\*(R"). The default loop jpayne@68: will be initialised if it isn't already initialised. jpayne@68: .Sp jpayne@68: For non-multiplicity builds, these macros do nothing, so you always have jpayne@68: to initialise the loop somewhere. jpayne@68: .ie n .IP """EV_DEFAULT_UC"", ""EV_DEFAULT_UC_""" 4 jpayne@68: .el .IP "\f(CWEV_DEFAULT_UC\fR, \f(CWEV_DEFAULT_UC_\fR" 4 jpayne@68: .IX Item "EV_DEFAULT_UC, EV_DEFAULT_UC_" jpayne@68: Usage identical to \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR, but requires that the jpayne@68: default loop has been initialised (\f(CW\*(C`UC\*(C'\fR == unchecked). Their behaviour jpayne@68: is undefined when the default loop has not been initialised by a previous jpayne@68: execution of \f(CW\*(C`EV_DEFAULT\*(C'\fR, \f(CW\*(C`EV_DEFAULT_\*(C'\fR or \f(CW\*(C`ev_default_init (...)\*(C'\fR. jpayne@68: .Sp jpayne@68: It is often prudent to use \f(CW\*(C`EV_DEFAULT\*(C'\fR when initialising the first jpayne@68: watcher in a function but use \f(CW\*(C`EV_DEFAULT_UC\*(C'\fR afterwards. jpayne@68: .PP jpayne@68: Example: Declare and initialise a check watcher, utilising the above jpayne@68: macros so it will work regardless of whether multiple loops are supported jpayne@68: or not. jpayne@68: .PP jpayne@68: .Vb 5 jpayne@68: \& static void jpayne@68: \& check_cb (EV_P_ ev_timer *w, int revents) jpayne@68: \& { jpayne@68: \& ev_check_stop (EV_A_ w); jpayne@68: \& } jpayne@68: \& jpayne@68: \& ev_check check; jpayne@68: \& ev_check_init (&check, check_cb); jpayne@68: \& ev_check_start (EV_DEFAULT_ &check); jpayne@68: \& ev_run (EV_DEFAULT_ 0); jpayne@68: .Ve jpayne@68: .SH "EMBEDDING" jpayne@68: .IX Header "EMBEDDING" jpayne@68: Libev can (and often is) directly embedded into host jpayne@68: applications. Examples of applications that embed it include the Deliantra jpayne@68: Game Server, the \s-1EV\s0 perl module, the \s-1GNU\s0 Virtual Private Ethernet (gvpe) jpayne@68: and rxvt-unicode. jpayne@68: .PP jpayne@68: The goal is to enable you to just copy the necessary files into your jpayne@68: source directory without having to change even a single line in them, so jpayne@68: you can easily upgrade by simply copying (or having a checked-out copy of jpayne@68: libev somewhere in your source tree). jpayne@68: .SS "\s-1FILESETS\s0" jpayne@68: .IX Subsection "FILESETS" jpayne@68: Depending on what features you need you need to include one or more sets of files jpayne@68: in your application. jpayne@68: .PP jpayne@68: \fI\s-1CORE EVENT LOOP\s0\fR jpayne@68: .IX Subsection "CORE EVENT LOOP" jpayne@68: .PP jpayne@68: To include only the libev core (all the \f(CW\*(C`ev_*\*(C'\fR functions), with manual jpayne@68: configuration (no autoconf): jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& #define EV_STANDALONE 1 jpayne@68: \& #include "ev.c" jpayne@68: .Ve jpayne@68: .PP jpayne@68: This will automatically include \fIev.h\fR, too, and should be done in a jpayne@68: single C source file only to provide the function implementations. To use jpayne@68: it, do the same for \fIev.h\fR in all files wishing to use this \s-1API\s0 (best jpayne@68: done by writing a wrapper around \fIev.h\fR that you can include instead and jpayne@68: where you can put other configuration options): jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& #define EV_STANDALONE 1 jpayne@68: \& #include "ev.h" jpayne@68: .Ve jpayne@68: .PP jpayne@68: Both header files and implementation files can be compiled with a \*(C+ jpayne@68: compiler (at least, that's a stated goal, and breakage will be treated jpayne@68: as a bug). jpayne@68: .PP jpayne@68: You need the following files in your source tree, or in a directory jpayne@68: in your include path (e.g. in libev/ when using \-Ilibev): jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& ev.h jpayne@68: \& ev.c jpayne@68: \& ev_vars.h jpayne@68: \& ev_wrap.h jpayne@68: \& jpayne@68: \& ev_win32.c required on win32 platforms only jpayne@68: \& jpayne@68: \& ev_select.c only when select backend is enabled jpayne@68: \& ev_poll.c only when poll backend is enabled jpayne@68: \& ev_epoll.c only when the epoll backend is enabled jpayne@68: \& ev_linuxaio.c only when the linux aio backend is enabled jpayne@68: \& ev_iouring.c only when the linux io_uring backend is enabled jpayne@68: \& ev_kqueue.c only when the kqueue backend is enabled jpayne@68: \& ev_port.c only when the solaris port backend is enabled jpayne@68: .Ve jpayne@68: .PP jpayne@68: \&\fIev.c\fR includes the backend files directly when enabled, so you only need jpayne@68: to compile this single file. jpayne@68: .PP jpayne@68: \fI\s-1LIBEVENT COMPATIBILITY API\s0\fR jpayne@68: .IX Subsection "LIBEVENT COMPATIBILITY API" jpayne@68: .PP jpayne@68: To include the libevent compatibility \s-1API,\s0 also include: jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& #include "event.c" jpayne@68: .Ve jpayne@68: .PP jpayne@68: in the file including \fIev.c\fR, and: jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& #include "event.h" jpayne@68: .Ve jpayne@68: .PP jpayne@68: in the files that want to use the libevent \s-1API.\s0 This also includes \fIev.h\fR. jpayne@68: .PP jpayne@68: You need the following additional files for this: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& event.h jpayne@68: \& event.c jpayne@68: .Ve jpayne@68: .PP jpayne@68: \fI\s-1AUTOCONF SUPPORT\s0\fR jpayne@68: .IX Subsection "AUTOCONF SUPPORT" jpayne@68: .PP jpayne@68: Instead of using \f(CW\*(C`EV_STANDALONE=1\*(C'\fR and providing your configuration in jpayne@68: whatever way you want, you can also \f(CW\*(C`m4_include([libev.m4])\*(C'\fR in your jpayne@68: \&\fIconfigure.ac\fR and leave \f(CW\*(C`EV_STANDALONE\*(C'\fR undefined. \fIev.c\fR will then jpayne@68: include \fIconfig.h\fR and configure itself accordingly. jpayne@68: .PP jpayne@68: For this of course you need the m4 file: jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& libev.m4 jpayne@68: .Ve jpayne@68: .SS "\s-1PREPROCESSOR SYMBOLS/MACROS\s0" jpayne@68: .IX Subsection "PREPROCESSOR SYMBOLS/MACROS" jpayne@68: Libev can be configured via a variety of preprocessor symbols you have to jpayne@68: define before including (or compiling) any of its files. The default in jpayne@68: the absence of autoconf is documented for every option. jpayne@68: .PP jpayne@68: Symbols marked with \*(L"(h)\*(R" do not change the \s-1ABI,\s0 and can have different jpayne@68: values when compiling libev vs. including \fIev.h\fR, so it is permissible jpayne@68: to redefine them before including \fIev.h\fR without breaking compatibility jpayne@68: to a compiled library. All other symbols change the \s-1ABI,\s0 which means all jpayne@68: users of libev and the libev code itself must be compiled with compatible jpayne@68: settings. jpayne@68: .IP "\s-1EV_COMPAT3\s0 (h)" 4 jpayne@68: .IX Item "EV_COMPAT3 (h)" jpayne@68: Backwards compatibility is a major concern for libev. This is why this jpayne@68: release of libev comes with wrappers for the functions and symbols that jpayne@68: have been renamed between libev version 3 and 4. jpayne@68: .Sp jpayne@68: You can disable these wrappers (to test compatibility with future jpayne@68: versions) by defining \f(CW\*(C`EV_COMPAT3\*(C'\fR to \f(CW0\fR when compiling your jpayne@68: sources. This has the additional advantage that you can drop the \f(CW\*(C`struct\*(C'\fR jpayne@68: from \f(CW\*(C`struct ev_loop\*(C'\fR declarations, as libev will provide an \f(CW\*(C`ev_loop\*(C'\fR jpayne@68: typedef in that case. jpayne@68: .Sp jpayne@68: In some future version, the default for \f(CW\*(C`EV_COMPAT3\*(C'\fR will become \f(CW0\fR, jpayne@68: and in some even more future version the compatibility code will be jpayne@68: removed completely. jpayne@68: .IP "\s-1EV_STANDALONE\s0 (h)" 4 jpayne@68: .IX Item "EV_STANDALONE (h)" jpayne@68: Must always be \f(CW1\fR if you do not use autoconf configuration, which jpayne@68: keeps libev from including \fIconfig.h\fR, and it also defines dummy jpayne@68: implementations for some libevent functions (such as logging, which is not jpayne@68: supported). It will also not define any of the structs usually found in jpayne@68: \&\fIevent.h\fR that are not directly supported by the libev core alone. jpayne@68: .Sp jpayne@68: In standalone mode, libev will still try to automatically deduce the jpayne@68: configuration, but has to be more conservative. jpayne@68: .IP "\s-1EV_USE_FLOOR\s0" 4 jpayne@68: .IX Item "EV_USE_FLOOR" jpayne@68: If defined to be \f(CW1\fR, libev will use the \f(CW\*(C`floor ()\*(C'\fR function for its jpayne@68: periodic reschedule calculations, otherwise libev will fall back on a jpayne@68: portable (slower) implementation. If you enable this, you usually have to jpayne@68: link against libm or something equivalent. Enabling this when the \f(CW\*(C`floor\*(C'\fR jpayne@68: function is not available will fail, so the safe default is to not enable jpayne@68: this. jpayne@68: .IP "\s-1EV_USE_MONOTONIC\s0" 4 jpayne@68: .IX Item "EV_USE_MONOTONIC" jpayne@68: If defined to be \f(CW1\fR, libev will try to detect the availability of the jpayne@68: monotonic clock option at both compile time and runtime. Otherwise no jpayne@68: use of the monotonic clock option will be attempted. If you enable this, jpayne@68: you usually have to link against librt or something similar. Enabling it jpayne@68: when the functionality isn't available is safe, though, although you have jpayne@68: to make sure you link against any libraries where the \f(CW\*(C`clock_gettime\*(C'\fR jpayne@68: function is hiding in (often \fI\-lrt\fR). See also \f(CW\*(C`EV_USE_CLOCK_SYSCALL\*(C'\fR. jpayne@68: .IP "\s-1EV_USE_REALTIME\s0" 4 jpayne@68: .IX Item "EV_USE_REALTIME" jpayne@68: If defined to be \f(CW1\fR, libev will try to detect the availability of the jpayne@68: real-time clock option at compile time (and assume its availability jpayne@68: at runtime if successful). Otherwise no use of the real-time clock jpayne@68: option will be attempted. This effectively replaces \f(CW\*(C`gettimeofday\*(C'\fR jpayne@68: by \f(CW\*(C`clock_get (CLOCK_REALTIME, ...)\*(C'\fR and will not normally affect jpayne@68: correctness. See the note about libraries in the description of jpayne@68: \&\f(CW\*(C`EV_USE_MONOTONIC\*(C'\fR, though. Defaults to the opposite value of jpayne@68: \&\f(CW\*(C`EV_USE_CLOCK_SYSCALL\*(C'\fR. jpayne@68: .IP "\s-1EV_USE_CLOCK_SYSCALL\s0" 4 jpayne@68: .IX Item "EV_USE_CLOCK_SYSCALL" jpayne@68: If defined to be \f(CW1\fR, libev will try to use a direct syscall instead jpayne@68: of calling the system-provided \f(CW\*(C`clock_gettime\*(C'\fR function. This option jpayne@68: exists because on GNU/Linux, \f(CW\*(C`clock_gettime\*(C'\fR is in \f(CW\*(C`librt\*(C'\fR, but \f(CW\*(C`librt\*(C'\fR jpayne@68: unconditionally pulls in \f(CW\*(C`libpthread\*(C'\fR, slowing down single-threaded jpayne@68: programs needlessly. Using a direct syscall is slightly slower (in jpayne@68: theory), because no optimised vdso implementation can be used, but avoids jpayne@68: the pthread dependency. Defaults to \f(CW1\fR on GNU/Linux with glibc 2.x or jpayne@68: higher, as it simplifies linking (no need for \f(CW\*(C`\-lrt\*(C'\fR). jpayne@68: .IP "\s-1EV_USE_NANOSLEEP\s0" 4 jpayne@68: .IX Item "EV_USE_NANOSLEEP" jpayne@68: If defined to be \f(CW1\fR, libev will assume that \f(CW\*(C`nanosleep ()\*(C'\fR is available jpayne@68: and will use it for delays. Otherwise it will use \f(CW\*(C`select ()\*(C'\fR. jpayne@68: .IP "\s-1EV_USE_EVENTFD\s0" 4 jpayne@68: .IX Item "EV_USE_EVENTFD" jpayne@68: If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is jpayne@68: available and will probe for kernel support at runtime. This will improve jpayne@68: \&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption. jpayne@68: If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc jpayne@68: 2.7 or newer, otherwise disabled. jpayne@68: .IP "\s-1EV_USE_SIGNALFD\s0" 4 jpayne@68: .IX Item "EV_USE_SIGNALFD" jpayne@68: If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`signalfd ()\*(C'\fR is jpayne@68: available and will probe for kernel support at runtime. This enables jpayne@68: the use of \s-1EVFLAG_SIGNALFD\s0 for faster and simpler signal handling. If jpayne@68: undefined, it will be enabled if the headers indicate GNU/Linux + Glibc jpayne@68: 2.7 or newer, otherwise disabled. jpayne@68: .IP "\s-1EV_USE_TIMERFD\s0" 4 jpayne@68: .IX Item "EV_USE_TIMERFD" jpayne@68: If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`timerfd ()\*(C'\fR is jpayne@68: available and will probe for kernel support at runtime. This allows jpayne@68: libev to detect time jumps accurately. If undefined, it will be enabled jpayne@68: if the headers indicate GNU/Linux + Glibc 2.8 or newer and define jpayne@68: \&\f(CW\*(C`TFD_TIMER_CANCEL_ON_SET\*(C'\fR, otherwise disabled. jpayne@68: .IP "\s-1EV_USE_EVENTFD\s0" 4 jpayne@68: .IX Item "EV_USE_EVENTFD" jpayne@68: If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is jpayne@68: available and will probe for kernel support at runtime. This will improve jpayne@68: \&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption. jpayne@68: If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc jpayne@68: 2.7 or newer, otherwise disabled. jpayne@68: .IP "\s-1EV_USE_SELECT\s0" 4 jpayne@68: .IX Item "EV_USE_SELECT" jpayne@68: If undefined or defined to be \f(CW1\fR, libev will compile in support for the jpayne@68: \&\f(CW\*(C`select\*(C'\fR(2) backend. No attempt at auto-detection will be done: if no jpayne@68: other method takes over, select will be it. Otherwise the select backend jpayne@68: will not be compiled in. jpayne@68: .IP "\s-1EV_SELECT_USE_FD_SET\s0" 4 jpayne@68: .IX Item "EV_SELECT_USE_FD_SET" jpayne@68: If defined to \f(CW1\fR, then the select backend will use the system \f(CW\*(C`fd_set\*(C'\fR jpayne@68: structure. This is useful if libev doesn't compile due to a missing jpayne@68: \&\f(CW\*(C`NFDBITS\*(C'\fR or \f(CW\*(C`fd_mask\*(C'\fR definition or it mis-guesses the bitset layout jpayne@68: on exotic systems. This usually limits the range of file descriptors to jpayne@68: some low limit such as 1024 or might have other limitations (winsocket jpayne@68: only allows 64 sockets). The \f(CW\*(C`FD_SETSIZE\*(C'\fR macro, set before compilation, jpayne@68: configures the maximum size of the \f(CW\*(C`fd_set\*(C'\fR. jpayne@68: .IP "\s-1EV_SELECT_IS_WINSOCKET\s0" 4 jpayne@68: .IX Item "EV_SELECT_IS_WINSOCKET" jpayne@68: When defined to \f(CW1\fR, the select backend will assume that jpayne@68: select/socket/connect etc. don't understand file descriptors but jpayne@68: wants osf handles on win32 (this is the case when the select to jpayne@68: be used is the winsock select). This means that it will call jpayne@68: \&\f(CW\*(C`_get_osfhandle\*(C'\fR on the fd to convert it to an \s-1OS\s0 handle. Otherwise, jpayne@68: it is assumed that all these functions actually work on fds, even jpayne@68: on win32. Should not be defined on non\-win32 platforms. jpayne@68: .IP "\s-1EV_FD_TO_WIN32_HANDLE\s0(fd)" 4 jpayne@68: .IX Item "EV_FD_TO_WIN32_HANDLE(fd)" jpayne@68: If \f(CW\*(C`EV_SELECT_IS_WINSOCKET\*(C'\fR is enabled, then libev needs a way to map jpayne@68: file descriptors to socket handles. When not defining this symbol (the jpayne@68: default), then libev will call \f(CW\*(C`_get_osfhandle\*(C'\fR, which is usually jpayne@68: correct. In some cases, programs use their own file descriptor management, jpayne@68: in which case they can provide this function to map fds to socket handles. jpayne@68: .IP "\s-1EV_WIN32_HANDLE_TO_FD\s0(handle)" 4 jpayne@68: .IX Item "EV_WIN32_HANDLE_TO_FD(handle)" jpayne@68: If \f(CW\*(C`EV_SELECT_IS_WINSOCKET\*(C'\fR then libev maps handles to file descriptors jpayne@68: using the standard \f(CW\*(C`_open_osfhandle\*(C'\fR function. For programs implementing jpayne@68: their own fd to handle mapping, overwriting this function makes it easier jpayne@68: to do so. This can be done by defining this macro to an appropriate value. jpayne@68: .IP "\s-1EV_WIN32_CLOSE_FD\s0(fd)" 4 jpayne@68: .IX Item "EV_WIN32_CLOSE_FD(fd)" jpayne@68: If programs implement their own fd to handle mapping on win32, then this jpayne@68: macro can be used to override the \f(CW\*(C`close\*(C'\fR function, useful to unregister jpayne@68: file descriptors again. Note that the replacement function has to close jpayne@68: the underlying \s-1OS\s0 handle. jpayne@68: .IP "\s-1EV_USE_WSASOCKET\s0" 4 jpayne@68: .IX Item "EV_USE_WSASOCKET" jpayne@68: If defined to be \f(CW1\fR, libev will use \f(CW\*(C`WSASocket\*(C'\fR to create its internal jpayne@68: communication socket, which works better in some environments. Otherwise, jpayne@68: the normal \f(CW\*(C`socket\*(C'\fR function will be used, which works better in other jpayne@68: environments. jpayne@68: .IP "\s-1EV_USE_POLL\s0" 4 jpayne@68: .IX Item "EV_USE_POLL" jpayne@68: If defined to be \f(CW1\fR, libev will compile in support for the \f(CW\*(C`poll\*(C'\fR(2) jpayne@68: backend. Otherwise it will be enabled on non\-win32 platforms. It jpayne@68: takes precedence over select. jpayne@68: .IP "\s-1EV_USE_EPOLL\s0" 4 jpayne@68: .IX Item "EV_USE_EPOLL" jpayne@68: If defined to be \f(CW1\fR, libev will compile in support for the Linux jpayne@68: \&\f(CW\*(C`epoll\*(C'\fR(7) backend. Its availability will be detected at runtime, jpayne@68: otherwise another method will be used as fallback. This is the preferred jpayne@68: backend for GNU/Linux systems. If undefined, it will be enabled if the jpayne@68: headers indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled. jpayne@68: .IP "\s-1EV_USE_LINUXAIO\s0" 4 jpayne@68: .IX Item "EV_USE_LINUXAIO" jpayne@68: If defined to be \f(CW1\fR, libev will compile in support for the Linux aio jpayne@68: backend (\f(CW\*(C`EV_USE_EPOLL\*(C'\fR must also be enabled). If undefined, it will be jpayne@68: enabled on linux, otherwise disabled. jpayne@68: .IP "\s-1EV_USE_IOURING\s0" 4 jpayne@68: .IX Item "EV_USE_IOURING" jpayne@68: If defined to be \f(CW1\fR, libev will compile in support for the Linux jpayne@68: io_uring backend (\f(CW\*(C`EV_USE_EPOLL\*(C'\fR must also be enabled). Due to it's jpayne@68: current limitations it has to be requested explicitly. If undefined, it jpayne@68: will be enabled on linux, otherwise disabled. jpayne@68: .IP "\s-1EV_USE_KQUEUE\s0" 4 jpayne@68: .IX Item "EV_USE_KQUEUE" jpayne@68: If defined to be \f(CW1\fR, libev will compile in support for the \s-1BSD\s0 style jpayne@68: \&\f(CW\*(C`kqueue\*(C'\fR(2) backend. Its actual availability will be detected at runtime, jpayne@68: otherwise another method will be used as fallback. This is the preferred jpayne@68: backend for \s-1BSD\s0 and BSD-like systems, although on most BSDs kqueue only jpayne@68: supports some types of fds correctly (the only platform we found that jpayne@68: supports ptys for example was NetBSD), so kqueue might be compiled in, but jpayne@68: not be used unless explicitly requested. The best way to use it is to find jpayne@68: out whether kqueue supports your type of fd properly and use an embedded jpayne@68: kqueue loop. jpayne@68: .IP "\s-1EV_USE_PORT\s0" 4 jpayne@68: .IX Item "EV_USE_PORT" jpayne@68: If defined to be \f(CW1\fR, libev will compile in support for the Solaris jpayne@68: 10 port style backend. Its availability will be detected at runtime, jpayne@68: otherwise another method will be used as fallback. This is the preferred jpayne@68: backend for Solaris 10 systems. jpayne@68: .IP "\s-1EV_USE_DEVPOLL\s0" 4 jpayne@68: .IX Item "EV_USE_DEVPOLL" jpayne@68: Reserved for future expansion, works like the \s-1USE\s0 symbols above. jpayne@68: .IP "\s-1EV_USE_INOTIFY\s0" 4 jpayne@68: .IX Item "EV_USE_INOTIFY" jpayne@68: If defined to be \f(CW1\fR, libev will compile in support for the Linux inotify jpayne@68: interface to speed up \f(CW\*(C`ev_stat\*(C'\fR watchers. Its actual availability will jpayne@68: be detected at runtime. If undefined, it will be enabled if the headers jpayne@68: indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled. jpayne@68: .IP "\s-1EV_NO_SMP\s0" 4 jpayne@68: .IX Item "EV_NO_SMP" jpayne@68: If defined to be \f(CW1\fR, libev will assume that memory is always coherent jpayne@68: between threads, that is, threads can be used, but threads never run on jpayne@68: different cpus (or different cpu cores). This reduces dependencies jpayne@68: and makes libev faster. jpayne@68: .IP "\s-1EV_NO_THREADS\s0" 4 jpayne@68: .IX Item "EV_NO_THREADS" jpayne@68: If defined to be \f(CW1\fR, libev will assume that it will never be called from jpayne@68: different threads (that includes signal handlers), which is a stronger jpayne@68: assumption than \f(CW\*(C`EV_NO_SMP\*(C'\fR, above. This reduces dependencies and makes jpayne@68: libev faster. jpayne@68: .IP "\s-1EV_ATOMIC_T\s0" 4 jpayne@68: .IX Item "EV_ATOMIC_T" jpayne@68: Libev requires an integer type (suitable for storing \f(CW0\fR or \f(CW1\fR) whose jpayne@68: access is atomic with respect to other threads or signal contexts. No jpayne@68: such type is easily found in the C language, so you can provide your own jpayne@68: type that you know is safe for your purposes. It is used both for signal jpayne@68: handler \*(L"locking\*(R" as well as for signal and thread safety in \f(CW\*(C`ev_async\*(C'\fR jpayne@68: watchers. jpayne@68: .Sp jpayne@68: In the absence of this define, libev will use \f(CW\*(C`sig_atomic_t volatile\*(C'\fR jpayne@68: (from \fIsignal.h\fR), which is usually good enough on most platforms. jpayne@68: .IP "\s-1EV_H\s0 (h)" 4 jpayne@68: .IX Item "EV_H (h)" jpayne@68: The name of the \fIev.h\fR header file used to include it. The default if jpayne@68: undefined is \f(CW"ev.h"\fR in \fIevent.h\fR, \fIev.c\fR and \fIev++.h\fR. This can be jpayne@68: used to virtually rename the \fIev.h\fR header file in case of conflicts. jpayne@68: .IP "\s-1EV_CONFIG_H\s0 (h)" 4 jpayne@68: .IX Item "EV_CONFIG_H (h)" jpayne@68: If \f(CW\*(C`EV_STANDALONE\*(C'\fR isn't \f(CW1\fR, this variable can be used to override jpayne@68: \&\fIev.c\fR's idea of where to find the \fIconfig.h\fR file, similarly to jpayne@68: \&\f(CW\*(C`EV_H\*(C'\fR, above. jpayne@68: .IP "\s-1EV_EVENT_H\s0 (h)" 4 jpayne@68: .IX Item "EV_EVENT_H (h)" jpayne@68: Similarly to \f(CW\*(C`EV_H\*(C'\fR, this macro can be used to override \fIevent.c\fR's idea jpayne@68: of how the \fIevent.h\fR header can be found, the default is \f(CW"event.h"\fR. jpayne@68: .IP "\s-1EV_PROTOTYPES\s0 (h)" 4 jpayne@68: .IX Item "EV_PROTOTYPES (h)" jpayne@68: If defined to be \f(CW0\fR, then \fIev.h\fR will not define any function jpayne@68: prototypes, but still define all the structs and other symbols. This is jpayne@68: occasionally useful if you want to provide your own wrapper functions jpayne@68: around libev functions. jpayne@68: .IP "\s-1EV_MULTIPLICITY\s0" 4 jpayne@68: .IX Item "EV_MULTIPLICITY" jpayne@68: If undefined or defined to \f(CW1\fR, then all event-loop-specific functions jpayne@68: will have the \f(CW\*(C`struct ev_loop *\*(C'\fR as first argument, and you can create jpayne@68: additional independent event loops. Otherwise there will be no support jpayne@68: for multiple event loops and there is no first event loop pointer jpayne@68: argument. Instead, all functions act on the single default loop. jpayne@68: .Sp jpayne@68: Note that \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR will no longer provide a jpayne@68: default loop when multiplicity is switched off \- you always have to jpayne@68: initialise the loop manually in this case. jpayne@68: .IP "\s-1EV_MINPRI\s0" 4 jpayne@68: .IX Item "EV_MINPRI" jpayne@68: .PD 0 jpayne@68: .IP "\s-1EV_MAXPRI\s0" 4 jpayne@68: .IX Item "EV_MAXPRI" jpayne@68: .PD jpayne@68: The range of allowed priorities. \f(CW\*(C`EV_MINPRI\*(C'\fR must be smaller or equal to jpayne@68: \&\f(CW\*(C`EV_MAXPRI\*(C'\fR, but otherwise there are no non-obvious limitations. You can jpayne@68: provide for more priorities by overriding those symbols (usually defined jpayne@68: to be \f(CW\*(C`\-2\*(C'\fR and \f(CW2\fR, respectively). jpayne@68: .Sp jpayne@68: When doing priority-based operations, libev usually has to linearly search jpayne@68: all the priorities, so having many of them (hundreds) uses a lot of space jpayne@68: and time, so using the defaults of five priorities (\-2 .. +2) is usually jpayne@68: fine. jpayne@68: .Sp jpayne@68: If your embedding application does not need any priorities, defining these jpayne@68: both to \f(CW0\fR will save some memory and \s-1CPU.\s0 jpayne@68: .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 jpayne@68: .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." jpayne@68: If undefined or defined to be \f(CW1\fR (and the platform supports it), then jpayne@68: the respective watcher type is supported. If defined to be \f(CW0\fR, then it jpayne@68: is not. Disabling watcher types mainly saves code size. jpayne@68: .IP "\s-1EV_FEATURES\s0" 4 jpayne@68: .IX Item "EV_FEATURES" jpayne@68: If you need to shave off some kilobytes of code at the expense of some jpayne@68: speed (but with the full \s-1API\s0), you can define this symbol to request jpayne@68: certain subsets of functionality. The default is to enable all features jpayne@68: that can be enabled on the platform. jpayne@68: .Sp jpayne@68: A typical way to use this symbol is to define it to \f(CW0\fR (or to a bitset jpayne@68: with some broad features you want) and then selectively re-enable jpayne@68: additional parts you want, for example if you want everything minimal, jpayne@68: but multiple event loop support, async and child watchers and the poll jpayne@68: backend, use this: jpayne@68: .Sp jpayne@68: .Vb 5 jpayne@68: \& #define EV_FEATURES 0 jpayne@68: \& #define EV_MULTIPLICITY 1 jpayne@68: \& #define EV_USE_POLL 1 jpayne@68: \& #define EV_CHILD_ENABLE 1 jpayne@68: \& #define EV_ASYNC_ENABLE 1 jpayne@68: .Ve jpayne@68: .Sp jpayne@68: The actual value is a bitset, it can be a combination of the following jpayne@68: values (by default, all of these are enabled): jpayne@68: .RS 4 jpayne@68: .ie n .IP "1 \- faster/larger code" 4 jpayne@68: .el .IP "\f(CW1\fR \- faster/larger code" 4 jpayne@68: .IX Item "1 - faster/larger code" jpayne@68: Use larger code to speed up some operations. jpayne@68: .Sp jpayne@68: Currently this is used to override some inlining decisions (enlarging the jpayne@68: code size by roughly 30% on amd64). jpayne@68: .Sp jpayne@68: When optimising for size, use of compiler flags such as \f(CW\*(C`\-Os\*(C'\fR with jpayne@68: gcc is recommended, as well as \f(CW\*(C`\-DNDEBUG\*(C'\fR, as libev contains a number of jpayne@68: assertions. jpayne@68: .Sp jpayne@68: The default is off when \f(CW\*(C`_\|_OPTIMIZE_SIZE_\|_\*(C'\fR is defined by your compiler jpayne@68: (e.g. gcc with \f(CW\*(C`\-Os\*(C'\fR). jpayne@68: .ie n .IP "2 \- faster/larger data structures" 4 jpayne@68: .el .IP "\f(CW2\fR \- faster/larger data structures" 4 jpayne@68: .IX Item "2 - faster/larger data structures" jpayne@68: Replaces the small 2\-heap for timer management by a faster 4\-heap, larger jpayne@68: hash table sizes and so on. This will usually further increase code size jpayne@68: and can additionally have an effect on the size of data structures at jpayne@68: runtime. jpayne@68: .Sp jpayne@68: The default is off when \f(CW\*(C`_\|_OPTIMIZE_SIZE_\|_\*(C'\fR is defined by your compiler jpayne@68: (e.g. gcc with \f(CW\*(C`\-Os\*(C'\fR). jpayne@68: .ie n .IP "4 \- full \s-1API\s0 configuration" 4 jpayne@68: .el .IP "\f(CW4\fR \- full \s-1API\s0 configuration" 4 jpayne@68: .IX Item "4 - full API configuration" jpayne@68: This enables priorities (sets \f(CW\*(C`EV_MAXPRI\*(C'\fR=2 and \f(CW\*(C`EV_MINPRI\*(C'\fR=\-2), and jpayne@68: enables multiplicity (\f(CW\*(C`EV_MULTIPLICITY\*(C'\fR=1). jpayne@68: .ie n .IP "8 \- full \s-1API\s0" 4 jpayne@68: .el .IP "\f(CW8\fR \- full \s-1API\s0" 4 jpayne@68: .IX Item "8 - full API" jpayne@68: This enables a lot of the \*(L"lesser used\*(R" \s-1API\s0 functions. See \f(CW\*(C`ev.h\*(C'\fR for jpayne@68: details on which parts of the \s-1API\s0 are still available without this jpayne@68: feature, and do not complain if this subset changes over time. jpayne@68: .ie n .IP "16 \- enable all optional watcher types" 4 jpayne@68: .el .IP "\f(CW16\fR \- enable all optional watcher types" 4 jpayne@68: .IX Item "16 - enable all optional watcher types" jpayne@68: Enables all optional watcher types. If you want to selectively enable jpayne@68: only some watcher types other than I/O and timers (e.g. prepare, jpayne@68: embed, async, child...) you can enable them manually by defining jpayne@68: \&\f(CW\*(C`EV_watchertype_ENABLE\*(C'\fR to \f(CW1\fR instead. jpayne@68: .ie n .IP "32 \- enable all backends" 4 jpayne@68: .el .IP "\f(CW32\fR \- enable all backends" 4 jpayne@68: .IX Item "32 - enable all backends" jpayne@68: This enables all backends \- without this feature, you need to enable at jpayne@68: least one backend manually (\f(CW\*(C`EV_USE_SELECT\*(C'\fR is a good choice). jpayne@68: .ie n .IP "64 \- enable OS-specific ""helper"" APIs" 4 jpayne@68: .el .IP "\f(CW64\fR \- enable OS-specific ``helper'' APIs" 4 jpayne@68: .IX Item "64 - enable OS-specific helper APIs" jpayne@68: Enable inotify, eventfd, signalfd and similar OS-specific helper APIs by jpayne@68: default. jpayne@68: .RE jpayne@68: .RS 4 jpayne@68: .Sp jpayne@68: Compiling with \f(CW\*(C`gcc \-Os \-DEV_STANDALONE \-DEV_USE_EPOLL=1 \-DEV_FEATURES=0\*(C'\fR jpayne@68: reduces the compiled size of libev from 24.7Kb code/2.8Kb data to 6.5Kb jpayne@68: code/0.3Kb data on my GNU/Linux amd64 system, while still giving you I/O jpayne@68: watchers, timers and monotonic clock support. jpayne@68: .Sp jpayne@68: With an intelligent-enough linker (gcc+binutils are intelligent enough jpayne@68: when you use \f(CW\*(C`\-Wl,\-\-gc\-sections \-ffunction\-sections\*(C'\fR) functions unused by jpayne@68: your program might be left out as well \- a binary starting a timer and an jpayne@68: I/O watcher then might come out at only 5Kb. jpayne@68: .RE jpayne@68: .IP "\s-1EV_API_STATIC\s0" 4 jpayne@68: .IX Item "EV_API_STATIC" jpayne@68: If this symbol is defined (by default it is not), then all identifiers jpayne@68: will have static linkage. This means that libev will not export any jpayne@68: identifiers, and you cannot link against libev anymore. This can be useful jpayne@68: when you embed libev, only want to use libev functions in a single file, jpayne@68: and do not want its identifiers to be visible. jpayne@68: .Sp jpayne@68: To use this, define \f(CW\*(C`EV_API_STATIC\*(C'\fR and include \fIev.c\fR in the file that jpayne@68: wants to use libev. jpayne@68: .Sp jpayne@68: This option only works when libev is compiled with a C compiler, as \*(C+ jpayne@68: doesn't support the required declaration syntax. jpayne@68: .IP "\s-1EV_AVOID_STDIO\s0" 4 jpayne@68: .IX Item "EV_AVOID_STDIO" jpayne@68: If this is set to \f(CW1\fR at compiletime, then libev will avoid using stdio jpayne@68: functions (printf, scanf, perror etc.). This will increase the code size jpayne@68: somewhat, but if your program doesn't otherwise depend on stdio and your jpayne@68: libc allows it, this avoids linking in the stdio library which is quite jpayne@68: big. jpayne@68: .Sp jpayne@68: Note that error messages might become less precise when this option is jpayne@68: enabled. jpayne@68: .IP "\s-1EV_NSIG\s0" 4 jpayne@68: .IX Item "EV_NSIG" jpayne@68: The highest supported signal number, +1 (or, the number of jpayne@68: signals): Normally, libev tries to deduce the maximum number of signals jpayne@68: automatically, but sometimes this fails, in which case it can be jpayne@68: specified. Also, using a lower number than detected (\f(CW32\fR should be jpayne@68: good for about any system in existence) can save some memory, as libev jpayne@68: statically allocates some 12\-24 bytes per signal number. jpayne@68: .IP "\s-1EV_PID_HASHSIZE\s0" 4 jpayne@68: .IX Item "EV_PID_HASHSIZE" jpayne@68: \&\f(CW\*(C`ev_child\*(C'\fR watchers use a small hash table to distribute workload by jpayne@68: pid. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\*(C`EV_FEATURES\*(C'\fR disabled), jpayne@68: usually more than enough. If you need to manage thousands of children you jpayne@68: might want to increase this value (\fImust\fR be a power of two). jpayne@68: .IP "\s-1EV_INOTIFY_HASHSIZE\s0" 4 jpayne@68: .IX Item "EV_INOTIFY_HASHSIZE" jpayne@68: \&\f(CW\*(C`ev_stat\*(C'\fR watchers use a small hash table to distribute workload by jpayne@68: inotify watch id. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\*(C`EV_FEATURES\*(C'\fR jpayne@68: disabled), usually more than enough. If you need to manage thousands of jpayne@68: \&\f(CW\*(C`ev_stat\*(C'\fR watchers you might want to increase this value (\fImust\fR be a jpayne@68: power of two). jpayne@68: .IP "\s-1EV_USE_4HEAP\s0" 4 jpayne@68: .IX Item "EV_USE_4HEAP" jpayne@68: Heaps are not very cache-efficient. To improve the cache-efficiency of the jpayne@68: timer and periodics heaps, libev uses a 4\-heap when this symbol is defined jpayne@68: to \f(CW1\fR. The 4\-heap uses more complicated (longer) code but has noticeably jpayne@68: faster performance with many (thousands) of watchers. jpayne@68: .Sp jpayne@68: The default is \f(CW1\fR, unless \f(CW\*(C`EV_FEATURES\*(C'\fR overrides it, in which case it jpayne@68: will be \f(CW0\fR. jpayne@68: .IP "\s-1EV_HEAP_CACHE_AT\s0" 4 jpayne@68: .IX Item "EV_HEAP_CACHE_AT" jpayne@68: Heaps are not very cache-efficient. To improve the cache-efficiency of the jpayne@68: timer and periodics heaps, libev can cache the timestamp (\fIat\fR) within jpayne@68: the heap structure (selected by defining \f(CW\*(C`EV_HEAP_CACHE_AT\*(C'\fR to \f(CW1\fR), jpayne@68: which uses 8\-12 bytes more per watcher and a few hundred bytes more code, jpayne@68: but avoids random read accesses on heap changes. This improves performance jpayne@68: noticeably with many (hundreds) of watchers. jpayne@68: .Sp jpayne@68: The default is \f(CW1\fR, unless \f(CW\*(C`EV_FEATURES\*(C'\fR overrides it, in which case it jpayne@68: will be \f(CW0\fR. jpayne@68: .IP "\s-1EV_VERIFY\s0" 4 jpayne@68: .IX Item "EV_VERIFY" jpayne@68: Controls how much internal verification (see \f(CW\*(C`ev_verify ()\*(C'\fR) will jpayne@68: be done: If set to \f(CW0\fR, no internal verification code will be compiled jpayne@68: in. If set to \f(CW1\fR, then verification code will be compiled in, but not jpayne@68: called. If set to \f(CW2\fR, then the internal verification code will be jpayne@68: called once per loop, which can slow down libev. If set to \f(CW3\fR, then the jpayne@68: verification code will be called very frequently, which will slow down jpayne@68: libev considerably. jpayne@68: .Sp jpayne@68: Verification errors are reported via C's \f(CW\*(C`assert\*(C'\fR mechanism, so if you jpayne@68: disable that (e.g. by defining \f(CW\*(C`NDEBUG\*(C'\fR) then no errors will be reported. jpayne@68: .Sp jpayne@68: The default is \f(CW1\fR, unless \f(CW\*(C`EV_FEATURES\*(C'\fR overrides it, in which case it jpayne@68: will be \f(CW0\fR. jpayne@68: .IP "\s-1EV_COMMON\s0" 4 jpayne@68: .IX Item "EV_COMMON" jpayne@68: By default, all watchers have a \f(CW\*(C`void *data\*(C'\fR member. By redefining jpayne@68: this macro to something else you can include more and other types of jpayne@68: members. You have to define it each time you include one of the files, jpayne@68: though, and it must be identical each time. jpayne@68: .Sp jpayne@68: For example, the perl \s-1EV\s0 module uses something like this: jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& #define EV_COMMON \e jpayne@68: \& SV *self; /* contains this struct */ \e jpayne@68: \& SV *cb_sv, *fh /* note no trailing ";" */ jpayne@68: .Ve jpayne@68: .IP "\s-1EV_CB_DECLARE\s0 (type)" 4 jpayne@68: .IX Item "EV_CB_DECLARE (type)" jpayne@68: .PD 0 jpayne@68: .IP "\s-1EV_CB_INVOKE\s0 (watcher, revents)" 4 jpayne@68: .IX Item "EV_CB_INVOKE (watcher, revents)" jpayne@68: .IP "ev_set_cb (ev, cb)" 4 jpayne@68: .IX Item "ev_set_cb (ev, cb)" jpayne@68: .PD jpayne@68: Can be used to change the callback member declaration in each watcher, jpayne@68: and the way callbacks are invoked and set. Must expand to a struct member jpayne@68: definition and a statement, respectively. See the \fIev.h\fR header file for jpayne@68: their default definitions. One possible use for overriding these is to jpayne@68: avoid the \f(CW\*(C`struct ev_loop *\*(C'\fR as first argument in all cases, or to use jpayne@68: method calls instead of plain function calls in \*(C+. jpayne@68: .SS "\s-1EXPORTED API SYMBOLS\s0" jpayne@68: .IX Subsection "EXPORTED API SYMBOLS" jpayne@68: If you need to re-export the \s-1API\s0 (e.g. via a \s-1DLL\s0) and you need a list of jpayne@68: exported symbols, you can use the provided \fISymbol.*\fR files which list jpayne@68: all public symbols, one per line: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& Symbols.ev for libev proper jpayne@68: \& Symbols.event for the libevent emulation jpayne@68: .Ve jpayne@68: .PP jpayne@68: This can also be used to rename all public symbols to avoid clashes with jpayne@68: multiple versions of libev linked together (which is obviously bad in jpayne@68: itself, but sometimes it is inconvenient to avoid this). jpayne@68: .PP jpayne@68: A sed command like this will create wrapper \f(CW\*(C`#define\*(C'\fR's that you need to jpayne@68: include before including \fIev.h\fR: jpayne@68: .PP jpayne@68: .Vb 1 jpayne@68: \& wrap.h jpayne@68: .Ve jpayne@68: .PP jpayne@68: This would create a file \fIwrap.h\fR which essentially looks like this: jpayne@68: .PP jpayne@68: .Vb 4 jpayne@68: \& #define ev_backend myprefix_ev_backend jpayne@68: \& #define ev_check_start myprefix_ev_check_start jpayne@68: \& #define ev_check_stop myprefix_ev_check_stop jpayne@68: \& ... jpayne@68: .Ve jpayne@68: .SS "\s-1EXAMPLES\s0" jpayne@68: .IX Subsection "EXAMPLES" jpayne@68: For a real-world example of a program the includes libev jpayne@68: verbatim, you can have a look at the \s-1EV\s0 perl module jpayne@68: (). It has the libev files in jpayne@68: the \fIlibev/\fR subdirectory and includes them in the \fI\s-1EV/EVAPI\s0.h\fR (public jpayne@68: interface) and \fI\s-1EV\s0.xs\fR (implementation) files. Only the \fI\s-1EV\s0.xs\fR file jpayne@68: will be compiled. It is pretty complex because it provides its own header jpayne@68: file. jpayne@68: .PP jpayne@68: The usage in rxvt-unicode is simpler. It has a \fIev_cpp.h\fR header file jpayne@68: that everybody includes and which overrides some configure choices: jpayne@68: .PP jpayne@68: .Vb 8 jpayne@68: \& #define EV_FEATURES 8 jpayne@68: \& #define EV_USE_SELECT 1 jpayne@68: \& #define EV_PREPARE_ENABLE 1 jpayne@68: \& #define EV_IDLE_ENABLE 1 jpayne@68: \& #define EV_SIGNAL_ENABLE 1 jpayne@68: \& #define EV_CHILD_ENABLE 1 jpayne@68: \& #define EV_USE_STDEXCEPT 0 jpayne@68: \& #define EV_CONFIG_H jpayne@68: \& jpayne@68: \& #include "ev++.h" jpayne@68: .Ve jpayne@68: .PP jpayne@68: And a \fIev_cpp.C\fR implementation file that contains libev proper and is compiled: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& #include "ev_cpp.h" jpayne@68: \& #include "ev.c" jpayne@68: .Ve jpayne@68: .SH "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT" jpayne@68: .IX Header "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT" jpayne@68: .SS "\s-1THREADS AND COROUTINES\s0" jpayne@68: .IX Subsection "THREADS AND COROUTINES" jpayne@68: \fI\s-1THREADS\s0\fR jpayne@68: .IX Subsection "THREADS" jpayne@68: .PP jpayne@68: All libev functions are reentrant and thread-safe unless explicitly jpayne@68: documented otherwise, but libev implements no locking itself. This means jpayne@68: that you can use as many loops as you want in parallel, as long as there jpayne@68: are no concurrent calls into any libev function with the same loop jpayne@68: parameter (\f(CW\*(C`ev_default_*\*(C'\fR calls have an implicit default loop parameter, jpayne@68: of course): libev guarantees that different event loops share no data jpayne@68: structures that need any locking. jpayne@68: .PP jpayne@68: Or to put it differently: calls with different loop parameters can be done jpayne@68: concurrently from multiple threads, calls with the same loop parameter jpayne@68: must be done serially (but can be done from different threads, as long as jpayne@68: only one thread ever is inside a call at any point in time, e.g. by using jpayne@68: a mutex per loop). jpayne@68: .PP jpayne@68: Specifically to support threads (and signal handlers), libev implements jpayne@68: so-called \f(CW\*(C`ev_async\*(C'\fR watchers, which allow some limited form of jpayne@68: concurrency on the same event loop, namely waking it up \*(L"from the jpayne@68: outside\*(R". jpayne@68: .PP jpayne@68: If you want to know which design (one loop, locking, or multiple loops jpayne@68: without or something else still) is best for your problem, then I cannot jpayne@68: help you, but here is some generic advice: jpayne@68: .IP "\(bu" 4 jpayne@68: most applications have a main thread: use the default libev loop jpayne@68: in that thread, or create a separate thread running only the default loop. jpayne@68: .Sp jpayne@68: This helps integrating other libraries or software modules that use libev jpayne@68: themselves and don't care/know about threading. jpayne@68: .IP "\(bu" 4 jpayne@68: one loop per thread is usually a good model. jpayne@68: .Sp jpayne@68: Doing this is almost never wrong, sometimes a better-performance model jpayne@68: exists, but it is always a good start. jpayne@68: .IP "\(bu" 4 jpayne@68: other models exist, such as the leader/follower pattern, where one jpayne@68: loop is handed through multiple threads in a kind of round-robin fashion. jpayne@68: .Sp jpayne@68: Choosing a model is hard \- look around, learn, know that usually you can do jpayne@68: better than you currently do :\-) jpayne@68: .IP "\(bu" 4 jpayne@68: often you need to talk to some other thread which blocks in the jpayne@68: event loop. jpayne@68: .Sp jpayne@68: \&\f(CW\*(C`ev_async\*(C'\fR watchers can be used to wake them up from other threads safely jpayne@68: (or from signal contexts...). jpayne@68: .Sp jpayne@68: An example use would be to communicate signals or other events that only jpayne@68: work in the default loop by registering the signal watcher with the jpayne@68: default loop and triggering an \f(CW\*(C`ev_async\*(C'\fR watcher from the default loop jpayne@68: watcher callback into the event loop interested in the signal. jpayne@68: .PP jpayne@68: See also \*(L"\s-1THREAD LOCKING EXAMPLE\*(R"\s0. jpayne@68: .PP jpayne@68: \fI\s-1COROUTINES\s0\fR jpayne@68: .IX Subsection "COROUTINES" jpayne@68: .PP jpayne@68: Libev is very accommodating to coroutines (\*(L"cooperative threads\*(R"): jpayne@68: libev fully supports nesting calls to its functions from different jpayne@68: coroutines (e.g. you can call \f(CW\*(C`ev_run\*(C'\fR on the same loop from two jpayne@68: different coroutines, and switch freely between both coroutines running jpayne@68: the loop, as long as you don't confuse yourself). The only exception is jpayne@68: that you must not do this from \f(CW\*(C`ev_periodic\*(C'\fR reschedule callbacks. jpayne@68: .PP jpayne@68: Care has been taken to ensure that libev does not keep local state inside jpayne@68: \&\f(CW\*(C`ev_run\*(C'\fR, and other calls do not usually allow for coroutine switches as jpayne@68: they do not call any callbacks. jpayne@68: .SS "\s-1COMPILER WARNINGS\s0" jpayne@68: .IX Subsection "COMPILER WARNINGS" jpayne@68: Depending on your compiler and compiler settings, you might get no or a jpayne@68: lot of warnings when compiling libev code. Some people are apparently jpayne@68: scared by this. jpayne@68: .PP jpayne@68: However, these are unavoidable for many reasons. For one, each compiler jpayne@68: has different warnings, and each user has different tastes regarding jpayne@68: warning options. \*(L"Warn-free\*(R" code therefore cannot be a goal except when jpayne@68: targeting a specific compiler and compiler-version. jpayne@68: .PP jpayne@68: Another reason is that some compiler warnings require elaborate jpayne@68: workarounds, or other changes to the code that make it less clear and less jpayne@68: maintainable. jpayne@68: .PP jpayne@68: And of course, some compiler warnings are just plain stupid, or simply jpayne@68: wrong (because they don't actually warn about the condition their message jpayne@68: seems to warn about). For example, certain older gcc versions had some jpayne@68: warnings that resulted in an extreme number of false positives. These have jpayne@68: been fixed, but some people still insist on making code warn-free with jpayne@68: such buggy versions. jpayne@68: .PP jpayne@68: While libev is written to generate as few warnings as possible, jpayne@68: \&\*(L"warn-free\*(R" code is not a goal, and it is recommended not to build libev jpayne@68: with any compiler warnings enabled unless you are prepared to cope with jpayne@68: them (e.g. by ignoring them). Remember that warnings are just that: jpayne@68: warnings, not errors, or proof of bugs. jpayne@68: .SS "\s-1VALGRIND\s0" jpayne@68: .IX Subsection "VALGRIND" jpayne@68: Valgrind has a special section here because it is a popular tool that is jpayne@68: highly useful. Unfortunately, valgrind reports are very hard to interpret. jpayne@68: .PP jpayne@68: If you think you found a bug (memory leak, uninitialised data access etc.) jpayne@68: in libev, then check twice: If valgrind reports something like: jpayne@68: .PP jpayne@68: .Vb 3 jpayne@68: \& ==2274== definitely lost: 0 bytes in 0 blocks. jpayne@68: \& ==2274== possibly lost: 0 bytes in 0 blocks. jpayne@68: \& ==2274== still reachable: 256 bytes in 1 blocks. jpayne@68: .Ve jpayne@68: .PP jpayne@68: Then there is no memory leak, just as memory accounted to global variables jpayne@68: is not a memleak \- the memory is still being referenced, and didn't leak. jpayne@68: .PP jpayne@68: Similarly, under some circumstances, valgrind might report kernel bugs jpayne@68: as if it were a bug in libev (e.g. in realloc or in the poll backend, jpayne@68: although an acceptable workaround has been found here), or it might be jpayne@68: confused. jpayne@68: .PP jpayne@68: Keep in mind that valgrind is a very good tool, but only a tool. Don't jpayne@68: make it into some kind of religion. jpayne@68: .PP jpayne@68: If you are unsure about something, feel free to contact the mailing list jpayne@68: with the full valgrind report and an explanation on why you think this jpayne@68: is a bug in libev (best check the archives, too :). However, don't be jpayne@68: annoyed when you get a brisk \*(L"this is no bug\*(R" answer and take the chance jpayne@68: of learning how to interpret valgrind properly. jpayne@68: .PP jpayne@68: If you need, for some reason, empty reports from valgrind for your project jpayne@68: I suggest using suppression lists. jpayne@68: .SH "PORTABILITY NOTES" jpayne@68: .IX Header "PORTABILITY NOTES" jpayne@68: .SS "\s-1GNU/LINUX 32 BIT LIMITATIONS\s0" jpayne@68: .IX Subsection "GNU/LINUX 32 BIT LIMITATIONS" jpayne@68: GNU/Linux is the only common platform that supports 64 bit file/large file jpayne@68: interfaces but \fIdisables\fR them by default. jpayne@68: .PP jpayne@68: That means that libev compiled in the default environment doesn't support jpayne@68: files larger than 2GiB or so, which mainly affects \f(CW\*(C`ev_stat\*(C'\fR watchers. jpayne@68: .PP jpayne@68: Unfortunately, many programs try to work around this GNU/Linux issue jpayne@68: by enabling the large file \s-1API,\s0 which makes them incompatible with the jpayne@68: standard libev compiled for their system. jpayne@68: .PP jpayne@68: Likewise, libev cannot enable the large file \s-1API\s0 itself as this would jpayne@68: suddenly make it incompatible to the default compile time environment, jpayne@68: i.e. all programs not using special compile switches. jpayne@68: .SS "\s-1OS/X AND DARWIN BUGS\s0" jpayne@68: .IX Subsection "OS/X AND DARWIN BUGS" jpayne@68: The whole thing is a bug if you ask me \- basically any system interface jpayne@68: you touch is broken, whether it is locales, poll, kqueue or even the jpayne@68: OpenGL drivers. jpayne@68: .PP jpayne@68: \fI\f(CI\*(C`kqueue\*(C'\fI is buggy\fR jpayne@68: .IX Subsection "kqueue is buggy" jpayne@68: .PP jpayne@68: The kqueue syscall is broken in all known versions \- most versions support jpayne@68: only sockets, many support pipes. jpayne@68: .PP jpayne@68: Libev tries to work around this by not using \f(CW\*(C`kqueue\*(C'\fR by default on this jpayne@68: rotten platform, but of course you can still ask for it when creating a jpayne@68: loop \- embedding a socket-only kqueue loop into a select-based one is jpayne@68: probably going to work well. jpayne@68: .PP jpayne@68: \fI\f(CI\*(C`poll\*(C'\fI is buggy\fR jpayne@68: .IX Subsection "poll is buggy" jpayne@68: .PP jpayne@68: Instead of fixing \f(CW\*(C`kqueue\*(C'\fR, Apple replaced their (working) \f(CW\*(C`poll\*(C'\fR jpayne@68: implementation by something calling \f(CW\*(C`kqueue\*(C'\fR internally around the 10.5.6 jpayne@68: release, so now \f(CW\*(C`kqueue\*(C'\fR \fIand\fR \f(CW\*(C`poll\*(C'\fR are broken. jpayne@68: .PP jpayne@68: Libev tries to work around this by not using \f(CW\*(C`poll\*(C'\fR by default on jpayne@68: this rotten platform, but of course you can still ask for it when creating jpayne@68: a loop. jpayne@68: .PP jpayne@68: \fI\f(CI\*(C`select\*(C'\fI is buggy\fR jpayne@68: .IX Subsection "select is buggy" jpayne@68: .PP jpayne@68: All that's left is \f(CW\*(C`select\*(C'\fR, and of course Apple found a way to fuck this jpayne@68: one up as well: On \s-1OS/X,\s0 \f(CW\*(C`select\*(C'\fR actively limits the number of file jpayne@68: descriptors you can pass in to 1024 \- your program suddenly crashes when jpayne@68: you use more. jpayne@68: .PP jpayne@68: There is an undocumented \*(L"workaround\*(R" for this \- defining jpayne@68: \&\f(CW\*(C`_DARWIN_UNLIMITED_SELECT\*(C'\fR, which libev tries to use, so select \fIshould\fR jpayne@68: work on \s-1OS/X.\s0 jpayne@68: .SS "\s-1SOLARIS PROBLEMS AND WORKAROUNDS\s0" jpayne@68: .IX Subsection "SOLARIS PROBLEMS AND WORKAROUNDS" jpayne@68: \fI\f(CI\*(C`errno\*(C'\fI reentrancy\fR jpayne@68: .IX Subsection "errno reentrancy" jpayne@68: .PP jpayne@68: The default compile environment on Solaris is unfortunately so jpayne@68: thread-unsafe that you can't even use components/libraries compiled jpayne@68: without \f(CW\*(C`\-D_REENTRANT\*(C'\fR in a threaded program, which, of course, isn't jpayne@68: defined by default. A valid, if stupid, implementation choice. jpayne@68: .PP jpayne@68: If you want to use libev in threaded environments you have to make sure jpayne@68: it's compiled with \f(CW\*(C`_REENTRANT\*(C'\fR defined. jpayne@68: .PP jpayne@68: \fIEvent port backend\fR jpayne@68: .IX Subsection "Event port backend" jpayne@68: .PP jpayne@68: The scalable event interface for Solaris is called \*(L"event jpayne@68: ports\*(R". Unfortunately, this mechanism is very buggy in all major jpayne@68: releases. If you run into high \s-1CPU\s0 usage, your program freezes or you get jpayne@68: a large number of spurious wakeups, make sure you have all the relevant jpayne@68: and latest kernel patches applied. No, I don't know which ones, but there jpayne@68: are multiple ones to apply, and afterwards, event ports actually work jpayne@68: great. jpayne@68: .PP jpayne@68: If you can't get it to work, you can try running the program by setting jpayne@68: the environment variable \f(CW\*(C`LIBEV_FLAGS=3\*(C'\fR to only allow \f(CW\*(C`poll\*(C'\fR and jpayne@68: \&\f(CW\*(C`select\*(C'\fR backends. jpayne@68: .SS "\s-1AIX POLL BUG\s0" jpayne@68: .IX Subsection "AIX POLL BUG" jpayne@68: \&\s-1AIX\s0 unfortunately has a broken \f(CW\*(C`poll.h\*(C'\fR header. Libev works around jpayne@68: this by trying to avoid the poll backend altogether (i.e. it's not even jpayne@68: compiled in), which normally isn't a big problem as \f(CW\*(C`select\*(C'\fR works fine jpayne@68: with large bitsets on \s-1AIX,\s0 and \s-1AIX\s0 is dead anyway. jpayne@68: .SS "\s-1WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS\s0" jpayne@68: .IX Subsection "WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS" jpayne@68: \fIGeneral issues\fR jpayne@68: .IX Subsection "General issues" jpayne@68: .PP jpayne@68: Win32 doesn't support any of the standards (e.g. \s-1POSIX\s0) that libev jpayne@68: requires, and its I/O model is fundamentally incompatible with the \s-1POSIX\s0 jpayne@68: model. Libev still offers limited functionality on this platform in jpayne@68: the form of the \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR backend, and only supports socket jpayne@68: descriptors. This only applies when using Win32 natively, not when using jpayne@68: e.g. cygwin. Actually, it only applies to the microsofts own compilers, jpayne@68: as every compiler comes with a slightly differently broken/incompatible jpayne@68: environment. jpayne@68: .PP jpayne@68: Lifting these limitations would basically require the full jpayne@68: re-implementation of the I/O system. If you are into this kind of thing, jpayne@68: then note that glib does exactly that for you in a very portable way (note jpayne@68: also that glib is the slowest event library known to man). jpayne@68: .PP jpayne@68: There is no supported compilation method available on windows except jpayne@68: embedding it into other applications. jpayne@68: .PP jpayne@68: Sensible signal handling is officially unsupported by Microsoft \- libev jpayne@68: tries its best, but under most conditions, signals will simply not work. jpayne@68: .PP jpayne@68: Not a libev limitation but worth mentioning: windows apparently doesn't jpayne@68: accept large writes: instead of resulting in a partial write, windows will jpayne@68: either accept everything or return \f(CW\*(C`ENOBUFS\*(C'\fR if the buffer is too large, jpayne@68: so make sure you only write small amounts into your sockets (less than a jpayne@68: megabyte seems safe, but this apparently depends on the amount of memory jpayne@68: available). jpayne@68: .PP jpayne@68: Due to the many, low, and arbitrary limits on the win32 platform and jpayne@68: the abysmal performance of winsockets, using a large number of sockets jpayne@68: is not recommended (and not reasonable). If your program needs to use jpayne@68: more than a hundred or so sockets, then likely it needs to use a totally jpayne@68: different implementation for windows, as libev offers the \s-1POSIX\s0 readiness jpayne@68: notification model, which cannot be implemented efficiently on windows jpayne@68: (due to Microsoft monopoly games). jpayne@68: .PP jpayne@68: A typical way to use libev under windows is to embed it (see the embedding jpayne@68: section for details) and use the following \fIevwrap.h\fR header file instead jpayne@68: of \fIev.h\fR: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& #define EV_STANDALONE /* keeps ev from requiring config.h */ jpayne@68: \& #define EV_SELECT_IS_WINSOCKET 1 /* configure libev for windows select */ jpayne@68: \& jpayne@68: \& #include "ev.h" jpayne@68: .Ve jpayne@68: .PP jpayne@68: And compile the following \fIevwrap.c\fR file into your project (make sure jpayne@68: you do \fInot\fR compile the \fIev.c\fR or any other embedded source files!): jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& #include "evwrap.h" jpayne@68: \& #include "ev.c" jpayne@68: .Ve jpayne@68: .PP jpayne@68: \fIThe winsocket \f(CI\*(C`select\*(C'\fI function\fR jpayne@68: .IX Subsection "The winsocket select function" jpayne@68: .PP jpayne@68: The winsocket \f(CW\*(C`select\*(C'\fR function doesn't follow \s-1POSIX\s0 in that it jpayne@68: requires socket \fIhandles\fR and not socket \fIfile descriptors\fR (it is jpayne@68: also extremely buggy). This makes select very inefficient, and also jpayne@68: requires a mapping from file descriptors to socket handles (the Microsoft jpayne@68: C runtime provides the function \f(CW\*(C`_open_osfhandle\*(C'\fR for this). See the jpayne@68: discussion of the \f(CW\*(C`EV_SELECT_USE_FD_SET\*(C'\fR, \f(CW\*(C`EV_SELECT_IS_WINSOCKET\*(C'\fR and jpayne@68: \&\f(CW\*(C`EV_FD_TO_WIN32_HANDLE\*(C'\fR preprocessor symbols for more info. jpayne@68: .PP jpayne@68: The configuration for a \*(L"naked\*(R" win32 using the Microsoft runtime jpayne@68: libraries and raw winsocket select is: jpayne@68: .PP jpayne@68: .Vb 2 jpayne@68: \& #define EV_USE_SELECT 1 jpayne@68: \& #define EV_SELECT_IS_WINSOCKET 1 /* forces EV_SELECT_USE_FD_SET, too */ jpayne@68: .Ve jpayne@68: .PP jpayne@68: Note that winsockets handling of fd sets is O(n), so you can easily get a jpayne@68: complexity in the O(nX) range when using win32. jpayne@68: .PP jpayne@68: \fILimited number of file descriptors\fR jpayne@68: .IX Subsection "Limited number of file descriptors" jpayne@68: .PP jpayne@68: Windows has numerous arbitrary (and low) limits on things. jpayne@68: .PP jpayne@68: Early versions of winsocket's select only supported waiting for a maximum jpayne@68: of \f(CW64\fR handles (probably owning to the fact that all windows kernels jpayne@68: can only wait for \f(CW64\fR things at the same time internally; Microsoft jpayne@68: recommends spawning a chain of threads and wait for 63 handles and the jpayne@68: previous thread in each. Sounds great!). jpayne@68: .PP jpayne@68: Newer versions support more handles, but you need to define \f(CW\*(C`FD_SETSIZE\*(C'\fR jpayne@68: to some high number (e.g. \f(CW2048\fR) before compiling the winsocket select jpayne@68: call (which might be in libev or elsewhere, for example, perl and many jpayne@68: other interpreters do their own select emulation on windows). jpayne@68: .PP jpayne@68: Another limit is the number of file descriptors in the Microsoft runtime jpayne@68: libraries, which by default is \f(CW64\fR (there must be a hidden \fI64\fR jpayne@68: fetish or something like this inside Microsoft). You can increase this jpayne@68: by calling \f(CW\*(C`_setmaxstdio\*(C'\fR, which can increase this limit to \f(CW2048\fR jpayne@68: (another arbitrary limit), but is broken in many versions of the Microsoft jpayne@68: runtime libraries. This might get you to about \f(CW512\fR or \f(CW2048\fR sockets jpayne@68: (depending on windows version and/or the phase of the moon). To get more, jpayne@68: you need to wrap all I/O functions and provide your own fd management, but jpayne@68: the cost of calling select (O(nX)) will likely make this unworkable. jpayne@68: .SS "\s-1PORTABILITY REQUIREMENTS\s0" jpayne@68: .IX Subsection "PORTABILITY REQUIREMENTS" jpayne@68: In addition to a working ISO-C implementation and of course the jpayne@68: backend-specific APIs, libev relies on a few additional extensions: jpayne@68: .ie n .IP """void (*)(ev_watcher_type *, int revents)"" must have compatible calling conventions regardless of ""ev_watcher_type *""." 4 jpayne@68: .el .IP "\f(CWvoid (*)(ev_watcher_type *, int revents)\fR must have compatible calling conventions regardless of \f(CWev_watcher_type *\fR." 4 jpayne@68: .IX Item "void (*)(ev_watcher_type *, int revents) must have compatible calling conventions regardless of ev_watcher_type *." jpayne@68: Libev assumes not only that all watcher pointers have the same internal jpayne@68: structure (guaranteed by \s-1POSIX\s0 but not by \s-1ISO C\s0 for example), but it also jpayne@68: assumes that the same (machine) code can be used to call any watcher jpayne@68: callback: The watcher callbacks have different type signatures, but libev jpayne@68: calls them using an \f(CW\*(C`ev_watcher *\*(C'\fR internally. jpayne@68: .IP "null pointers and integer zero are represented by 0 bytes" 4 jpayne@68: .IX Item "null pointers and integer zero are represented by 0 bytes" jpayne@68: Libev uses \f(CW\*(C`memset\*(C'\fR to initialise structs and arrays to \f(CW0\fR bytes, and jpayne@68: relies on this setting pointers and integers to null. jpayne@68: .IP "pointer accesses must be thread-atomic" 4 jpayne@68: .IX Item "pointer accesses must be thread-atomic" jpayne@68: Accessing a pointer value must be atomic, it must both be readable and jpayne@68: writable in one piece \- this is the case on all current architectures. jpayne@68: .ie n .IP """sig_atomic_t volatile"" must be thread-atomic as well" 4 jpayne@68: .el .IP "\f(CWsig_atomic_t volatile\fR must be thread-atomic as well" 4 jpayne@68: .IX Item "sig_atomic_t volatile must be thread-atomic as well" jpayne@68: The type \f(CW\*(C`sig_atomic_t volatile\*(C'\fR (or whatever is defined as jpayne@68: \&\f(CW\*(C`EV_ATOMIC_T\*(C'\fR) must be atomic with respect to accesses from different jpayne@68: threads. This is not part of the specification for \f(CW\*(C`sig_atomic_t\*(C'\fR, but is jpayne@68: believed to be sufficiently portable. jpayne@68: .ie n .IP """sigprocmask"" must work in a threaded environment" 4 jpayne@68: .el .IP "\f(CWsigprocmask\fR must work in a threaded environment" 4 jpayne@68: .IX Item "sigprocmask must work in a threaded environment" jpayne@68: Libev uses \f(CW\*(C`sigprocmask\*(C'\fR to temporarily block signals. This is not jpayne@68: allowed in a threaded program (\f(CW\*(C`pthread_sigmask\*(C'\fR has to be used). Typical jpayne@68: pthread implementations will either allow \f(CW\*(C`sigprocmask\*(C'\fR in the \*(L"main jpayne@68: thread\*(R" or will block signals process-wide, both behaviours would jpayne@68: be compatible with libev. Interaction between \f(CW\*(C`sigprocmask\*(C'\fR and jpayne@68: \&\f(CW\*(C`pthread_sigmask\*(C'\fR could complicate things, however. jpayne@68: .Sp jpayne@68: The most portable way to handle signals is to block signals in all threads jpayne@68: except the initial one, and run the signal handling loop in the initial jpayne@68: thread as well. jpayne@68: .ie n .IP """long"" must be large enough for common memory allocation sizes" 4 jpayne@68: .el .IP "\f(CWlong\fR must be large enough for common memory allocation sizes" 4 jpayne@68: .IX Item "long must be large enough for common memory allocation sizes" jpayne@68: To improve portability and simplify its \s-1API,\s0 libev uses \f(CW\*(C`long\*(C'\fR internally jpayne@68: instead of \f(CW\*(C`size_t\*(C'\fR when allocating its data structures. On non-POSIX jpayne@68: systems (Microsoft...) this might be unexpectedly low, but is still at jpayne@68: least 31 bits everywhere, which is enough for hundreds of millions of jpayne@68: watchers. jpayne@68: .ie n .IP """double"" must hold a time value in seconds with enough accuracy" 4 jpayne@68: .el .IP "\f(CWdouble\fR must hold a time value in seconds with enough accuracy" 4 jpayne@68: .IX Item "double must hold a time value in seconds with enough accuracy" jpayne@68: The type \f(CW\*(C`double\*(C'\fR is used to represent timestamps. It is required to jpayne@68: have at least 51 bits of mantissa (and 9 bits of exponent), which is jpayne@68: good enough for at least into the year 4000 with millisecond accuracy jpayne@68: (the design goal for libev). This requirement is overfulfilled by jpayne@68: implementations using \s-1IEEE 754,\s0 which is basically all existing ones. jpayne@68: .Sp jpayne@68: With \s-1IEEE 754\s0 doubles, you get microsecond accuracy until at least the jpayne@68: year 2255 (and millisecond accuracy till the year 287396 \- by then, libev jpayne@68: is either obsolete or somebody patched it to use \f(CW\*(C`long double\*(C'\fR or jpayne@68: something like that, just kidding). jpayne@68: .PP jpayne@68: If you know of other additional requirements drop me a note. jpayne@68: .SH "ALGORITHMIC COMPLEXITIES" jpayne@68: .IX Header "ALGORITHMIC COMPLEXITIES" jpayne@68: In this section the complexities of (many of) the algorithms used inside jpayne@68: libev will be documented. For complexity discussions about backends see jpayne@68: the documentation for \f(CW\*(C`ev_default_init\*(C'\fR. jpayne@68: .PP jpayne@68: All of the following are about amortised time: If an array needs to be jpayne@68: extended, libev needs to realloc and move the whole array, but this jpayne@68: happens asymptotically rarer with higher number of elements, so O(1) might jpayne@68: mean that libev does a lengthy realloc operation in rare cases, but on jpayne@68: average it is much faster and asymptotically approaches constant time. jpayne@68: .IP "Starting and stopping timer/periodic watchers: O(log skipped_other_timers)" 4 jpayne@68: .IX Item "Starting and stopping timer/periodic watchers: O(log skipped_other_timers)" jpayne@68: This means that, when you have a watcher that triggers in one hour and jpayne@68: there are 100 watchers that would trigger before that, then inserting will jpayne@68: have to skip roughly seven (\f(CW\*(C`ld 100\*(C'\fR) of these watchers. jpayne@68: .IP "Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers)" 4 jpayne@68: .IX Item "Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers)" jpayne@68: That means that changing a timer costs less than removing/adding them, jpayne@68: as only the relative motion in the event queue has to be paid for. jpayne@68: .IP "Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1)" 4 jpayne@68: .IX Item "Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1)" jpayne@68: These just add the watcher into an array or at the head of a list. jpayne@68: .IP "Stopping check/prepare/idle/fork/async watchers: O(1)" 4 jpayne@68: .IX Item "Stopping check/prepare/idle/fork/async watchers: O(1)" jpayne@68: .PD 0 jpayne@68: .IP "Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % \s-1EV_PID_HASHSIZE\s0))" 4 jpayne@68: .IX Item "Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % EV_PID_HASHSIZE))" jpayne@68: .PD jpayne@68: These watchers are stored in lists, so they need to be walked to find the jpayne@68: correct watcher to remove. The lists are usually short (you don't usually jpayne@68: have many watchers waiting for the same fd or signal: one is typical, two jpayne@68: is rare). jpayne@68: .IP "Finding the next timer in each loop iteration: O(1)" 4 jpayne@68: .IX Item "Finding the next timer in each loop iteration: O(1)" jpayne@68: By virtue of using a binary or 4\-heap, the next timer is always found at a jpayne@68: fixed position in the storage array. jpayne@68: .IP "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)" 4 jpayne@68: .IX Item "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)" jpayne@68: A change means an I/O watcher gets started or stopped, which requires jpayne@68: libev to recalculate its status (and possibly tell the kernel, depending jpayne@68: on backend and whether \f(CW\*(C`ev_io_set\*(C'\fR was used). jpayne@68: .IP "Activating one watcher (putting it into the pending state): O(1)" 4 jpayne@68: .IX Item "Activating one watcher (putting it into the pending state): O(1)" jpayne@68: .PD 0 jpayne@68: .IP "Priority handling: O(number_of_priorities)" 4 jpayne@68: .IX Item "Priority handling: O(number_of_priorities)" jpayne@68: .PD jpayne@68: Priorities are implemented by allocating some space for each jpayne@68: priority. When doing priority-based operations, libev usually has to jpayne@68: linearly search all the priorities, but starting/stopping and activating jpayne@68: watchers becomes O(1) with respect to priority handling. jpayne@68: .IP "Sending an ev_async: O(1)" 4 jpayne@68: .IX Item "Sending an ev_async: O(1)" jpayne@68: .PD 0 jpayne@68: .IP "Processing ev_async_send: O(number_of_async_watchers)" 4 jpayne@68: .IX Item "Processing ev_async_send: O(number_of_async_watchers)" jpayne@68: .IP "Processing signals: O(max_signal_number)" 4 jpayne@68: .IX Item "Processing signals: O(max_signal_number)" jpayne@68: .PD jpayne@68: Sending involves a system call \fIiff\fR there were no other \f(CW\*(C`ev_async_send\*(C'\fR jpayne@68: calls in the current loop iteration and the loop is currently jpayne@68: blocked. Checking for async and signal events involves iterating over all jpayne@68: running async watchers or all signal numbers. jpayne@68: .SH "PORTING FROM LIBEV 3.X TO 4.X" jpayne@68: .IX Header "PORTING FROM LIBEV 3.X TO 4.X" jpayne@68: The major version 4 introduced some incompatible changes to the \s-1API.\s0 jpayne@68: .PP jpayne@68: At the moment, the \f(CW\*(C`ev.h\*(C'\fR header file provides compatibility definitions jpayne@68: for all changes, so most programs should still compile. The compatibility jpayne@68: layer might be removed in later versions of libev, so better update to the jpayne@68: new \s-1API\s0 early than late. jpayne@68: .ie n .IP """EV_COMPAT3"" backwards compatibility mechanism" 4 jpayne@68: .el .IP "\f(CWEV_COMPAT3\fR backwards compatibility mechanism" 4 jpayne@68: .IX Item "EV_COMPAT3 backwards compatibility mechanism" jpayne@68: The backward compatibility mechanism can be controlled by jpayne@68: \&\f(CW\*(C`EV_COMPAT3\*(C'\fR. See \*(L"\s-1PREPROCESSOR SYMBOLS/MACROS\*(R"\s0 in the \*(L"\s-1EMBEDDING\*(R"\s0 jpayne@68: section. jpayne@68: .ie n .IP """ev_default_destroy"" and ""ev_default_fork"" have been removed" 4 jpayne@68: .el .IP "\f(CWev_default_destroy\fR and \f(CWev_default_fork\fR have been removed" 4 jpayne@68: .IX Item "ev_default_destroy and ev_default_fork have been removed" jpayne@68: These calls can be replaced easily by their \f(CW\*(C`ev_loop_xxx\*(C'\fR counterparts: jpayne@68: .Sp jpayne@68: .Vb 2 jpayne@68: \& ev_loop_destroy (EV_DEFAULT_UC); jpayne@68: \& ev_loop_fork (EV_DEFAULT); jpayne@68: .Ve jpayne@68: .IP "function/symbol renames" 4 jpayne@68: .IX Item "function/symbol renames" jpayne@68: A number of functions and symbols have been renamed: jpayne@68: .Sp jpayne@68: .Vb 3 jpayne@68: \& ev_loop => ev_run jpayne@68: \& EVLOOP_NONBLOCK => EVRUN_NOWAIT jpayne@68: \& EVLOOP_ONESHOT => EVRUN_ONCE jpayne@68: \& jpayne@68: \& ev_unloop => ev_break jpayne@68: \& EVUNLOOP_CANCEL => EVBREAK_CANCEL jpayne@68: \& EVUNLOOP_ONE => EVBREAK_ONE jpayne@68: \& EVUNLOOP_ALL => EVBREAK_ALL jpayne@68: \& jpayne@68: \& EV_TIMEOUT => EV_TIMER jpayne@68: \& jpayne@68: \& ev_loop_count => ev_iteration jpayne@68: \& ev_loop_depth => ev_depth jpayne@68: \& ev_loop_verify => ev_verify jpayne@68: .Ve jpayne@68: .Sp jpayne@68: Most functions working on \f(CW\*(C`struct ev_loop\*(C'\fR objects don't have an jpayne@68: \&\f(CW\*(C`ev_loop_\*(C'\fR prefix, so it was removed; \f(CW\*(C`ev_loop\*(C'\fR, \f(CW\*(C`ev_unloop\*(C'\fR and jpayne@68: associated constants have been renamed to not collide with the \f(CW\*(C`struct jpayne@68: ev_loop\*(C'\fR anymore and \f(CW\*(C`EV_TIMER\*(C'\fR now follows the same naming scheme jpayne@68: as all other watcher types. Note that \f(CW\*(C`ev_loop_fork\*(C'\fR is still called jpayne@68: \&\f(CW\*(C`ev_loop_fork\*(C'\fR because it would otherwise clash with the \f(CW\*(C`ev_fork\*(C'\fR jpayne@68: typedef. jpayne@68: .ie n .IP """EV_MINIMAL"" mechanism replaced by ""EV_FEATURES""" 4 jpayne@68: .el .IP "\f(CWEV_MINIMAL\fR mechanism replaced by \f(CWEV_FEATURES\fR" 4 jpayne@68: .IX Item "EV_MINIMAL mechanism replaced by EV_FEATURES" jpayne@68: The preprocessor symbol \f(CW\*(C`EV_MINIMAL\*(C'\fR has been replaced by a different jpayne@68: mechanism, \f(CW\*(C`EV_FEATURES\*(C'\fR. Programs using \f(CW\*(C`EV_MINIMAL\*(C'\fR usually compile jpayne@68: and work, but the library code will of course be larger. jpayne@68: .SH "GLOSSARY" jpayne@68: .IX Header "GLOSSARY" jpayne@68: .IP "active" 4 jpayne@68: .IX Item "active" jpayne@68: A watcher is active as long as it has been started and not yet stopped. jpayne@68: See \*(L"\s-1WATCHER STATES\*(R"\s0 for details. jpayne@68: .IP "application" 4 jpayne@68: .IX Item "application" jpayne@68: In this document, an application is whatever is using libev. jpayne@68: .IP "backend" 4 jpayne@68: .IX Item "backend" jpayne@68: The part of the code dealing with the operating system interfaces. jpayne@68: .IP "callback" 4 jpayne@68: .IX Item "callback" jpayne@68: The address of a function that is called when some event has been jpayne@68: detected. Callbacks are being passed the event loop, the watcher that jpayne@68: received the event, and the actual event bitset. jpayne@68: .IP "callback/watcher invocation" 4 jpayne@68: .IX Item "callback/watcher invocation" jpayne@68: The act of calling the callback associated with a watcher. jpayne@68: .IP "event" 4 jpayne@68: .IX Item "event" jpayne@68: A change of state of some external event, such as data now being available jpayne@68: for reading on a file descriptor, time having passed or simply not having jpayne@68: any other events happening anymore. jpayne@68: .Sp jpayne@68: In libev, events are represented as single bits (such as \f(CW\*(C`EV_READ\*(C'\fR or jpayne@68: \&\f(CW\*(C`EV_TIMER\*(C'\fR). jpayne@68: .IP "event library" 4 jpayne@68: .IX Item "event library" jpayne@68: A software package implementing an event model and loop. jpayne@68: .IP "event loop" 4 jpayne@68: .IX Item "event loop" jpayne@68: An entity that handles and processes external events and converts them jpayne@68: into callback invocations. jpayne@68: .IP "event model" 4 jpayne@68: .IX Item "event model" jpayne@68: The model used to describe how an event loop handles and processes jpayne@68: watchers and events. jpayne@68: .IP "pending" 4 jpayne@68: .IX Item "pending" jpayne@68: A watcher is pending as soon as the corresponding event has been jpayne@68: detected. See \*(L"\s-1WATCHER STATES\*(R"\s0 for details. jpayne@68: .IP "real time" 4 jpayne@68: .IX Item "real time" jpayne@68: The physical time that is observed. It is apparently strictly monotonic :) jpayne@68: .IP "wall-clock time" 4 jpayne@68: .IX Item "wall-clock time" jpayne@68: The time and date as shown on clocks. Unlike real time, it can actually jpayne@68: be wrong and jump forwards and backwards, e.g. when you adjust your jpayne@68: clock. jpayne@68: .IP "watcher" 4 jpayne@68: .IX Item "watcher" jpayne@68: A data structure that describes interest in certain events. Watchers need jpayne@68: to be started (attached to an event loop) before they can receive events. jpayne@68: .SH "AUTHOR" jpayne@68: .IX Header "AUTHOR" jpayne@68: Marc Lehmann , with repeated corrections by Mikael jpayne@68: Magnusson and Emanuele Giaquinta, and minor corrections by many others.