csp2: CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/share/man/man3/ev.3 annotate

annotate CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/share/man/man3/ev.3 @ 68:5028fdace37b

planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d

author	jpayne
date	Tue, 18 Mar 2025 16:23:26 -0400
parents
children

rev	line source
jpayne@68	1 .\" Automatically generated by Pod::Man 4.11 (Pod::Simple 3.35)
jpayne@68	2 .\"
jpayne@68	3 .\" Standard preamble:
jpayne@68	4 .\" ========================================================================
jpayne@68	5 .de Sp \" Vertical space (when we can't use .PP)
jpayne@68	6 .if t .sp .5v
jpayne@68	7 .if n .sp
jpayne@68	8 ..
jpayne@68	9 .de Vb \" Begin verbatim text
jpayne@68	10 .ft CW
jpayne@68	11 .nf
jpayne@68	12 .ne \\$1
jpayne@68	13 ..
jpayne@68	14 .de Ve \" End verbatim text
jpayne@68	15 .ft R
jpayne@68	16 .fi
jpayne@68	17 ..
jpayne@68	18 .\" Set up some character translations and predefined strings. \*(-- will
jpayne@68	19 .\" give an unbreakable dash, \(PI will give pi, \(L" will give a left
jpayne@68	20 .\" double quote, and \(R" will give a right double quote. \(C+ will
jpayne@68	21 .\" give a nicer C++. Capital omega is used to do unbreakable dashes and
jpayne@68	22 .\" therefore won't be available. \(C` and \(C' expand to `' in nroff,
jpayne@68	23 .\" nothing in troff, for use with C<>.
jpayne@68	24 .tr \(*W-
jpayne@68	25 .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
jpayne@68	26 .ie n \{\
jpayne@68	27 . ds -- \(*W-
jpayne@68	28 . ds PI pi
jpayne@68	29 . if (\n(.H=4u)&(1m=24u) .ds -- \(W\h'-12u'\(W\h'-12u'-\" diablo 10 pitch
jpayne@68	30 . if (\n(.H=4u)&(1m=20u) .ds -- \(W\h'-12u'\(W\h'-8u'-\" diablo 12 pitch
jpayne@68	31 . ds L" ""
jpayne@68	32 . ds R" ""
jpayne@68	33 . ds C` ""
jpayne@68	34 . ds C' ""
jpayne@68	35 'br\}
jpayne@68	36 .el\{\
jpayne@68	37 . ds -- \\|\(em\\|
jpayne@68	38 . ds PI \(*p
jpayne@68	39 . ds L" ``
jpayne@68	40 . ds R" ''
jpayne@68	41 . ds C`
jpayne@68	42 . ds C'
jpayne@68	43 'br\}
jpayne@68	44 .\"
jpayne@68	45 .\" Escape single quotes in literal strings from groff's Unicode transform.
jpayne@68	46 .ie \n(.g .ds Aq \(aq
jpayne@68	47 .el .ds Aq '
jpayne@68	48 .\"
jpayne@68	49 .\" If the F register is >0, we'll generate index entries on stderr for
jpayne@68	50 .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
jpayne@68	51 .\" entries marked with X<> in POD. Of course, you'll have to process the
jpayne@68	52 .\" output yourself in some meaningful fashion.
jpayne@68	53 .\"
jpayne@68	54 .\" Avoid warning from groff about undefined register 'F'.
jpayne@68	55 .de IX
jpayne@68	56 ..
jpayne@68	57 .nr rF 0
jpayne@68	58 .if \n(.g .if rF .nr rF 1
jpayne@68	59 .if (\n(rF:(\n(.g==0)) \{\
jpayne@68	60 . if \nF \{\
jpayne@68	61 . de IX
jpayne@68	62 . tm Index:\\$1\t\\n%\t"\\$2"
jpayne@68	63 ..
jpayne@68	64 . if !\nF==2 \{\
jpayne@68	65 . nr % 0
jpayne@68	66 . nr F 2
jpayne@68	67 . \}
jpayne@68	68 . \}
jpayne@68	69 .\}
jpayne@68	70 .rr rF
jpayne@68	71 .\"
jpayne@68	72 .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
jpayne@68	73 .\" Fear. Run. Save yourself. No user-serviceable parts.
jpayne@68	74 . \" fudge factors for nroff and troff
jpayne@68	75 .if n \{\
jpayne@68	76 . ds #H 0
jpayne@68	77 . ds #V .8m
jpayne@68	78 . ds #F .3m
jpayne@68	79 . ds #[ \f1
jpayne@68	80 . ds #] \fP
jpayne@68	81 .\}
jpayne@68	82 .if t \{\
jpayne@68	83 . ds #H ((1u-(\\\\n(.fu%2u))*.13m)
jpayne@68	84 . ds #V .6m
jpayne@68	85 . ds #F 0
jpayne@68	86 . ds #[ \&
jpayne@68	87 . ds #] \&
jpayne@68	88 .\}
jpayne@68	89 . \" simple accents for nroff and troff
jpayne@68	90 .if n \{\
jpayne@68	91 . ds ' \&
jpayne@68	92 . ds ` \&
jpayne@68	93 . ds ^ \&
jpayne@68	94 . ds , \&
jpayne@68	95 . ds ~ ~
jpayne@68	96 . ds /
jpayne@68	97 .\}
jpayne@68	98 .if t \{\
jpayne@68	99 . ds ' \\k:\h'-(\\n(.wu8/10-\(#H)'\'\h"\|\\n:u"
jpayne@68	100 . ds ` \\k:\h'-(\\n(.wu8/10-\(#H)'\`\h'\|\\n:u'
jpayne@68	101 . ds ^ \\k:\h'-(\\n(.wu10/11-\(#H)'^\h'\|\\n:u'
jpayne@68	102 . ds , \\k:\h'-(\\n(.wu*8/10)',\h'\|\\n:u'
jpayne@68	103 . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'\|\\n:u'
jpayne@68	104 . ds / \\k:\h'-(\\n(.wu8/10-\(#H)'\z\(sl\h'\|\\n:u'
jpayne@68	105 .\}
jpayne@68	106 . \" troff and (daisy-wheel) nroff accents
jpayne@68	107 .ds : \\k:\h'-(\\n(.wu8/10-\(#H+.1m+\(#F)'\v'-\(#V'\z.\h'.2m+\(#F'.\h'\|\\n:u'\v'\(#V'
jpayne@68	108 .ds 8 \h'\(#H'\(b\h'-\*(#H'
jpayne@68	109 .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\(#H)/2u'\v'-.3n'\(#[\z\(de\v'.3n'\h'\|\\n:u'\*(#]
jpayne@68	110 .ds d- \h'\(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\(#H'
jpayne@68	111 .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'\|\\n:u'
jpayne@68	112 .ds th \(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u2/3)'\s-1o\s+1\*(#]
jpayne@68	113 .ds Th \(#[\s+2I\s-2\h'-\w'I'u3/5'\v'-.3m'o\v'.3m'\*(#]
jpayne@68	114 .ds ae a\h'-(\w'a'u*4/10)'e
jpayne@68	115 .ds Ae A\h'-(\w'A'u*4/10)'E
jpayne@68	116 . \" corrections for vroff
jpayne@68	117 .if v .ds ~ \\k:\h'-(\\n(.wu9/10-\(#H)'\s-2\u~\d\s+2\h'\|\\n:u'
jpayne@68	118 .if v .ds ^ \\k:\h'-(\\n(.wu10/11-\(#H)'\v'-.4m'^\v'.4m'\h'\|\\n:u'
jpayne@68	119 . \" for low resolution devices (crt and lpr)
jpayne@68	120 .if \n(.H>23 .if \n(.V>19 \
jpayne@68	121 \{\
jpayne@68	122 . ds : e
jpayne@68	123 . ds 8 ss
jpayne@68	124 . ds o a
jpayne@68	125 . ds d- d\h'-1'\(ga
jpayne@68	126 . ds D- D\h'-1'\(hy
jpayne@68	127 . ds th \o'bp'
jpayne@68	128 . ds Th \o'LP'
jpayne@68	129 . ds ae ae
jpayne@68	130 . ds Ae AE
jpayne@68	131 .\}
jpayne@68	132 .rm #[ #] #H #V #F C
jpayne@68	133 .\" ========================================================================
jpayne@68	134 .\"
jpayne@68	135 .IX Title "LIBEV 3"
jpayne@68	136 .TH LIBEV 3 "2020-03-12" "libev-4.31" "libev - high performance full featured event loop"
jpayne@68	137 .\" For nroff, turn off justification. Always turn off hyphenation; it makes
jpayne@68	138 .\" way too many mistakes in technical documents.
jpayne@68	139 .if n .ad l
jpayne@68	140 .nh
jpayne@68	141 .SH "NAME"
jpayne@68	142 libev \- a high performance full\-featured event loop written in C
jpayne@68	143 .SH "SYNOPSIS"
jpayne@68	144 .IX Header "SYNOPSIS"
jpayne@68	145 .Vb 1
jpayne@68	146 \& #include <ev.h>
jpayne@68	147 .Ve
jpayne@68	148 .SS "\s-1EXAMPLE PROGRAM\s0"
jpayne@68	149 .IX Subsection "EXAMPLE PROGRAM"
jpayne@68	150 .Vb 2
jpayne@68	151 \& // a single header file is required
jpayne@68	152 \& #include <ev.h>
jpayne@68	153 \&
jpayne@68	154 \& #include <stdio.h> // for puts
jpayne@68	155 \&
jpayne@68	156 \& // every watcher type has its own typedef\*(Aqd struct
jpayne@68	157 \& // with the name ev_TYPE
jpayne@68	158 \& ev_io stdin_watcher;
jpayne@68	159 \& ev_timer timeout_watcher;
jpayne@68	160 \&
jpayne@68	161 \& // all watcher callbacks have a similar signature
jpayne@68	162 \& // this callback is called when data is readable on stdin
jpayne@68	163 \& static void
jpayne@68	164 \& stdin_cb (EV_P_ ev_io *w, int revents)
jpayne@68	165 \& {
jpayne@68	166 \& puts ("stdin ready");
jpayne@68	167 \& // for one\-shot events, one must manually stop the watcher
jpayne@68	168 \& // with its corresponding stop function.
jpayne@68	169 \& ev_io_stop (EV_A_ w);
jpayne@68	170 \&
jpayne@68	171 \& // this causes all nested ev_run\*(Aqs to stop iterating
jpayne@68	172 \& ev_break (EV_A_ EVBREAK_ALL);
jpayne@68	173 \& }
jpayne@68	174 \&
jpayne@68	175 \& // another callback, this time for a time\-out
jpayne@68	176 \& static void
jpayne@68	177 \& timeout_cb (EV_P_ ev_timer *w, int revents)
jpayne@68	178 \& {
jpayne@68	179 \& puts ("timeout");
jpayne@68	180 \& // this causes the innermost ev_run to stop iterating
jpayne@68	181 \& ev_break (EV_A_ EVBREAK_ONE);
jpayne@68	182 \& }
jpayne@68	183 \&
jpayne@68	184 \& int
jpayne@68	185 \& main (void)
jpayne@68	186 \& {
jpayne@68	187 \& // use the default event loop unless you have special needs
jpayne@68	188 \& struct ev_loop *loop = EV_DEFAULT;
jpayne@68	189 \&
jpayne@68	190 \& // initialise an io watcher, then start it
jpayne@68	191 \& // this one will watch for stdin to become readable
jpayne@68	192 \& ev_io_init (&stdin_watcher, stdin_cb, /STDIN_FILENO/ 0, EV_READ);
jpayne@68	193 \& ev_io_start (loop, &stdin_watcher);
jpayne@68	194 \&
jpayne@68	195 \& // initialise a timer watcher, then start it
jpayne@68	196 \& // simple non\-repeating 5.5 second timeout
jpayne@68	197 \& ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.);
jpayne@68	198 \& ev_timer_start (loop, &timeout_watcher);
jpayne@68	199 \&
jpayne@68	200 \& // now wait for events to arrive
jpayne@68	201 \& ev_run (loop, 0);
jpayne@68	202 \&
jpayne@68	203 \& // break was called, so exit
jpayne@68	204 \& return 0;
jpayne@68	205 \& }
jpayne@68	206 .Ve
jpayne@68	207 .SH "ABOUT THIS DOCUMENT"
jpayne@68	208 .IX Header "ABOUT THIS DOCUMENT"
jpayne@68	209 This document documents the libev software package.
jpayne@68	210 .PP
jpayne@68	211 The newest version of this document is also available as an html-formatted
jpayne@68	212 web page you might find easier to navigate when reading it for the first
jpayne@68	213 time: <http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod>.
jpayne@68	214 .PP
jpayne@68	215 While this document tries to be as complete as possible in documenting
jpayne@68	216 libev, its usage and the rationale behind its design, it is not a tutorial
jpayne@68	217 on event-based programming, nor will it introduce event-based programming
jpayne@68	218 with libev.
jpayne@68	219 .PP
jpayne@68	220 Familiarity with event based programming techniques in general is assumed
jpayne@68	221 throughout this document.
jpayne@68	222 .SH "WHAT TO READ WHEN IN A HURRY"
jpayne@68	223 .IX Header "WHAT TO READ WHEN IN A HURRY"
jpayne@68	224 This manual tries to be very detailed, but unfortunately, this also makes
jpayne@68	225 it very long. If you just want to know the basics of libev, I suggest
jpayne@68	226 reading \(L"\s-1ANATOMY OF A WATCHER\(R"\s0, then the \(L"\s-1EXAMPLE PROGRAM\(R"\s0 above and
jpayne@68	227 look up the missing functions in \(L"\s-1GLOBAL FUNCTIONS\(R"\s0 and the \f(CW\(C`ev_io\(C'\fR and
jpayne@68	228 \&\f(CW\(C`ev_timer\(C'\fR sections in \(L"\s-1WATCHER TYPES\(R"\s0.
jpayne@68	229 .SH "ABOUT LIBEV"
jpayne@68	230 .IX Header "ABOUT LIBEV"
jpayne@68	231 Libev is an event loop: you register interest in certain events (such as a
jpayne@68	232 file descriptor being readable or a timeout occurring), and it will manage
jpayne@68	233 these event sources and provide your program with events.
jpayne@68	234 .PP
jpayne@68	235 To do this, it must take more or less complete control over your process
jpayne@68	236 (or thread) by executing the \fIevent loop\fR handler, and will then
jpayne@68	237 communicate events via a callback mechanism.
jpayne@68	238 .PP
jpayne@68	239 You register interest in certain events by registering so-called \fIevent
jpayne@68	240 watchers\fR, which are relatively small C structures you initialise with the
jpayne@68	241 details of the event, and then hand it over to libev by \fIstarting\fR the
jpayne@68	242 watcher.
jpayne@68	243 .SS "\s-1FEATURES\s0"
jpayne@68	244 .IX Subsection "FEATURES"
jpayne@68	245 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	246 interfaces, the BSD-specific \f(CW\(C`kqueue\(C'\fR and the Solaris-specific event port
jpayne@68	247 mechanisms for file descriptor events (\f(CW\(C`ev_io\(C'\fR), the Linux \f(CW\(C`inotify\(C'\fR
jpayne@68	248 interface (for \f(CW\(C`ev_stat\(C'\fR), Linux eventfd/signalfd (for faster and cleaner
jpayne@68	249 inter-thread wakeup (\f(CW\(C`ev_async\(C'\fR)/signal handling (\f(CW\(C`ev_signal\(C'\fR)) relative
jpayne@68	250 timers (\f(CW\(C`ev_timer\(C'\fR), absolute timers with customised rescheduling
jpayne@68	251 (\f(CW\(C`ev_periodic\(C'\fR), synchronous signals (\f(CW\(C`ev_signal\(C'\fR), process status
jpayne@68	252 change events (\f(CW\(C`ev_child\(C'\fR), and event watchers dealing with the event
jpayne@68	253 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	254 \&\f(CW\(C`ev_check\(C'\fR watchers) as well as file watchers (\f(CW\(C`ev_stat\(C'\fR) and even
jpayne@68	255 limited support for fork events (\f(CW\(C`ev_fork\(C'\fR).
jpayne@68	256 .PP
jpayne@68	257 It also is quite fast (see this
jpayne@68	258 benchmark <http://libev.schmorp.de/bench.html> comparing it to libevent
jpayne@68	259 for example).
jpayne@68	260 .SS "\s-1CONVENTIONS\s0"
jpayne@68	261 .IX Subsection "CONVENTIONS"
jpayne@68	262 Libev is very configurable. In this manual the default (and most common)
jpayne@68	263 configuration will be described, which supports multiple event loops. For
jpayne@68	264 more info about various configuration options please have a look at
jpayne@68	265 \&\fB\s-1EMBED\s0\fR section in this manual. If libev was configured without support
jpayne@68	266 for multiple event loops, then all functions taking an initial argument of
jpayne@68	267 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	268 this argument.
jpayne@68	269 .SS "\s-1TIME REPRESENTATION\s0"
jpayne@68	270 .IX Subsection "TIME REPRESENTATION"
jpayne@68	271 Libev represents time as a single floating point number, representing
jpayne@68	272 the (fractional) number of seconds since the (\s-1POSIX\s0) epoch (in practice
jpayne@68	273 somewhere near the beginning of 1970, details are complicated, don't
jpayne@68	274 ask). This type is called \f(CW\(C`ev_tstamp\(C'\fR, which is what you should use
jpayne@68	275 too. It usually aliases to the \f(CW\(C`double\(C'\fR type in C. When you need to do
jpayne@68	276 any calculations on it, you should treat it as some floating point value.
jpayne@68	277 .PP
jpayne@68	278 Unlike the name component \f(CW\(C`stamp\(C'\fR might indicate, it is also used for
jpayne@68	279 time differences (e.g. delays) throughout libev.
jpayne@68	280 .SH "ERROR HANDLING"
jpayne@68	281 .IX Header "ERROR HANDLING"
jpayne@68	282 Libev knows three classes of errors: operating system errors, usage errors
jpayne@68	283 and internal errors (bugs).
jpayne@68	284 .PP
jpayne@68	285 When libev catches an operating system error it cannot handle (for example
jpayne@68	286 a system call indicating a condition libev cannot fix), it calls the callback
jpayne@68	287 set via \f(CW\(C`ev_set_syserr_cb\(C'\fR, which is supposed to fix the problem or
jpayne@68	288 abort. The default is to print a diagnostic message and to call \f(CW\*(C`abort
jpayne@68	289 ()\*(C'\fR.
jpayne@68	290 .PP
jpayne@68	291 When libev detects a usage error such as a negative timer interval, then
jpayne@68	292 it will print a diagnostic message and abort (via the \f(CW\(C`assert\(C'\fR mechanism,
jpayne@68	293 so \f(CW\(C`NDEBUG\(C'\fR will disable this checking): these are programming errors in
jpayne@68	294 the libev caller and need to be fixed there.
jpayne@68	295 .PP
jpayne@68	296 Via the \f(CW\(C`EV_FREQUENT\(C'\fR macro you can compile in and/or enable extensive
jpayne@68	297 consistency checking code inside libev that can be used to check for
jpayne@68	298 internal inconsistencies, suually caused by application bugs.
jpayne@68	299 .PP
jpayne@68	300 Libev also has a few internal error-checking \f(CW\(C`assert\(C'\fRions. These do not
jpayne@68	301 trigger under normal circumstances, as they indicate either a bug in libev
jpayne@68	302 or worse.
jpayne@68	303 .SH "GLOBAL FUNCTIONS"
jpayne@68	304 .IX Header "GLOBAL FUNCTIONS"
jpayne@68	305 These functions can be called anytime, even before initialising the
jpayne@68	306 library in any way.
jpayne@68	307 .IP "ev_tstamp ev_time ()" 4
jpayne@68	308 .IX Item "ev_tstamp ev_time ()"
jpayne@68	309 Returns the current time as libev would use it. Please note that the
jpayne@68	310 \&\f(CW\(C`ev_now\(C'\fR function is usually faster and also often returns the timestamp
jpayne@68	311 you actually want to know. Also interesting is the combination of
jpayne@68	312 \&\f(CW\(C`ev_now_update\(C'\fR and \f(CW\(C`ev_now\(C'\fR.
jpayne@68	313 .IP "ev_sleep (ev_tstamp interval)" 4
jpayne@68	314 .IX Item "ev_sleep (ev_tstamp interval)"
jpayne@68	315 Sleep for the given interval: The current thread will be blocked
jpayne@68	316 until either it is interrupted or the given time interval has
jpayne@68	317 passed (approximately \- it might return a bit earlier even if not
jpayne@68	318 interrupted). Returns immediately if \f(CW\(C`interval <= 0\(C'\fR.
jpayne@68	319 .Sp
jpayne@68	320 Basically this is a sub-second-resolution \f(CW\(C`sleep ()\(C'\fR.
jpayne@68	321 .Sp
jpayne@68	322 The range of the \f(CW\(C`interval\(C'\fR is limited \- libev only guarantees to work
jpayne@68	323 with sleep times of up to one day (\f(CW\(C`interval <= 86400\(C'\fR).
jpayne@68	324 .IP "int ev_version_major ()" 4
jpayne@68	325 .IX Item "int ev_version_major ()"
jpayne@68	326 .PD 0
jpayne@68	327 .IP "int ev_version_minor ()" 4
jpayne@68	328 .IX Item "int ev_version_minor ()"
jpayne@68	329 .PD
jpayne@68	330 You can find out the major and minor \s-1ABI\s0 version numbers of the library
jpayne@68	331 you linked against by calling the functions \f(CW\(C`ev_version_major\(C'\fR and
jpayne@68	332 \&\f(CW\(C`ev_version_minor\(C'\fR. If you want, you can compare against the global
jpayne@68	333 symbols \f(CW\(C`EV_VERSION_MAJOR\(C'\fR and \f(CW\(C`EV_VERSION_MINOR\(C'\fR, which specify the
jpayne@68	334 version of the library your program was compiled against.
jpayne@68	335 .Sp
jpayne@68	336 These version numbers refer to the \s-1ABI\s0 version of the library, not the
jpayne@68	337 release version.
jpayne@68	338 .Sp
jpayne@68	339 Usually, it's a good idea to terminate if the major versions mismatch,
jpayne@68	340 as this indicates an incompatible change. Minor versions are usually
jpayne@68	341 compatible to older versions, so a larger minor version alone is usually
jpayne@68	342 not a problem.
jpayne@68	343 .Sp
jpayne@68	344 Example: Make sure we haven't accidentally been linked against the wrong
jpayne@68	345 version (note, however, that this will not detect other \s-1ABI\s0 mismatches,
jpayne@68	346 such as \s-1LFS\s0 or reentrancy).
jpayne@68	347 .Sp
jpayne@68	348 .Vb 3
jpayne@68	349 \& assert (("libev version mismatch",
jpayne@68	350 \& ev_version_major () == EV_VERSION_MAJOR
jpayne@68	351 \& && ev_version_minor () >= EV_VERSION_MINOR));
jpayne@68	352 .Ve
jpayne@68	353 .IP "unsigned int ev_supported_backends ()" 4
jpayne@68	354 .IX Item "unsigned int ev_supported_backends ()"
jpayne@68	355 Return the set of all backends (i.e. their corresponding \f(CW\(C`EV_BACKEND_\*(C'\fR
jpayne@68	356 value) compiled into this binary of libev (independent of their
jpayne@68	357 availability on the system you are running on). See \f(CW\(C`ev_default_loop\(C'\fR for
jpayne@68	358 a description of the set values.
jpayne@68	359 .Sp
jpayne@68	360 Example: make sure we have the epoll method, because yeah this is cool and
jpayne@68	361 a must have and can we have a torrent of it please!!!11
jpayne@68	362 .Sp
jpayne@68	363 .Vb 2
jpayne@68	364 \& assert (("sorry, no epoll, no sex",
jpayne@68	365 \& ev_supported_backends () & EVBACKEND_EPOLL));
jpayne@68	366 .Ve
jpayne@68	367 .IP "unsigned int ev_recommended_backends ()" 4
jpayne@68	368 .IX Item "unsigned int ev_recommended_backends ()"
jpayne@68	369 Return the set of all backends compiled into this binary of libev and
jpayne@68	370 also recommended for this platform, meaning it will work for most file
jpayne@68	371 descriptor types. This set is often smaller than the one returned by
jpayne@68	372 \&\f(CW\(C`ev_supported_backends\(C'\fR, as for example kqueue is broken on most BSDs
jpayne@68	373 and will not be auto-detected unless you explicitly request it (assuming
jpayne@68	374 you know what you are doing). This is the set of backends that libev will
jpayne@68	375 probe for if you specify no backends explicitly.
jpayne@68	376 .IP "unsigned int ev_embeddable_backends ()" 4
jpayne@68	377 .IX Item "unsigned int ev_embeddable_backends ()"
jpayne@68	378 Returns the set of backends that are embeddable in other event loops. This
jpayne@68	379 value is platform-specific but can include backends not available on the
jpayne@68	380 current system. To find which embeddable backends might be supported on
jpayne@68	381 the current system, you would need to look at \f(CW\*(C`ev_embeddable_backends ()
jpayne@68	382 & ev_supported_backends ()\*(C'\fR, likewise for recommended ones.
jpayne@68	383 .Sp
jpayne@68	384 See the description of \f(CW\(C`ev_embed\(C'\fR watchers for more info.
jpayne@68	385 .IP "ev_set_allocator (void (cb)(void *ptr, long size) throw ())" 4
jpayne@68	386 .IX Item "ev_set_allocator (void (cb)(void *ptr, long size) throw ())"
jpayne@68	387 Sets the allocation function to use (the prototype is similar \- the
jpayne@68	388 semantics are identical to the \f(CW\(C`realloc\(C'\fR C89/SuS/POSIX function). It is
jpayne@68	389 used to allocate and free memory (no surprises here). If it returns zero
jpayne@68	390 when memory needs to be allocated (\f(CW\(C`size != 0\(C'\fR), the library might abort
jpayne@68	391 or take some potentially destructive action.
jpayne@68	392 .Sp
jpayne@68	393 Since some systems (at least OpenBSD and Darwin) fail to implement
jpayne@68	394 correct \f(CW\(C`realloc\(C'\fR semantics, libev will use a wrapper around the system
jpayne@68	395 \&\f(CW\(C`realloc\(C'\fR and \f(CW\(C`free\(C'\fR functions by default.
jpayne@68	396 .Sp
jpayne@68	397 You could override this function in high-availability programs to, say,
jpayne@68	398 free some memory if it cannot allocate memory, to use a special allocator,
jpayne@68	399 or even to sleep a while and retry until some memory is available.
jpayne@68	400 .Sp
jpayne@68	401 Example: The following is the \f(CW\(C`realloc\(C'\fR function that libev itself uses
jpayne@68	402 which should work with \f(CW\(C`realloc\(C'\fR and \f(CW\(C`free\(C'\fR functions of all kinds and
jpayne@68	403 is probably a good basis for your own implementation.
jpayne@68	404 .Sp
jpayne@68	405 .Vb 5
jpayne@68	406 \& static void *
jpayne@68	407 \& ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
jpayne@68	408 \& {
jpayne@68	409 \& if (size)
jpayne@68	410 \& return realloc (ptr, size);
jpayne@68	411 \&
jpayne@68	412 \& free (ptr);
jpayne@68	413 \& return 0;
jpayne@68	414 \& }
jpayne@68	415 .Ve
jpayne@68	416 .Sp
jpayne@68	417 Example: Replace the libev allocator with one that waits a bit and then
jpayne@68	418 retries.
jpayne@68	419 .Sp
jpayne@68	420 .Vb 8
jpayne@68	421 \& static void *
jpayne@68	422 \& persistent_realloc (void *ptr, size_t size)
jpayne@68	423 \& {
jpayne@68	424 \& if (!size)
jpayne@68	425 \& {
jpayne@68	426 \& free (ptr);
jpayne@68	427 \& return 0;
jpayne@68	428 \& }
jpayne@68	429 \&
jpayne@68	430 \& for (;;)
jpayne@68	431 \& {
jpayne@68	432 \& void *newptr = realloc (ptr, size);
jpayne@68	433 \&
jpayne@68	434 \& if (newptr)
jpayne@68	435 \& return newptr;
jpayne@68	436 \&
jpayne@68	437 \& sleep (60);
jpayne@68	438 \& }
jpayne@68	439 \& }
jpayne@68	440 \&
jpayne@68	441 \& ...
jpayne@68	442 \& ev_set_allocator (persistent_realloc);
jpayne@68	443 .Ve
jpayne@68	444 .IP "ev_set_syserr_cb (void (cb)(const char msg) throw ())" 4
jpayne@68	445 .IX Item "ev_set_syserr_cb (void (cb)(const char msg) throw ())"
jpayne@68	446 Set the callback function to call on a retryable system call error (such
jpayne@68	447 as failed select, poll, epoll_wait). The message is a printable string
jpayne@68	448 indicating the system call or subsystem causing the problem. If this
jpayne@68	449 callback is set, then libev will expect it to remedy the situation, no
jpayne@68	450 matter what, when it returns. That is, libev will generally retry the
jpayne@68	451 requested operation, or, if the condition doesn't go away, do bad stuff
jpayne@68	452 (such as abort).
jpayne@68	453 .Sp
jpayne@68	454 Example: This is basically the same thing that libev does internally, too.
jpayne@68	455 .Sp
jpayne@68	456 .Vb 6
jpayne@68	457 \& static void
jpayne@68	458 \& fatal_error (const char *msg)
jpayne@68	459 \& {
jpayne@68	460 \& perror (msg);
jpayne@68	461 \& abort ();
jpayne@68	462 \& }
jpayne@68	463 \&
jpayne@68	464 \& ...
jpayne@68	465 \& ev_set_syserr_cb (fatal_error);
jpayne@68	466 .Ve
jpayne@68	467 .IP "ev_feed_signal (int signum)" 4
jpayne@68	468 .IX Item "ev_feed_signal (int signum)"
jpayne@68	469 This function can be used to \(L"simulate\(R" a signal receive. It is completely
jpayne@68	470 safe to call this function at any time, from any context, including signal
jpayne@68	471 handlers or random threads.
jpayne@68	472 .Sp
jpayne@68	473 Its main use is to customise signal handling in your process, especially
jpayne@68	474 in the presence of threads. For example, you could block signals
jpayne@68	475 by default in all threads (and specifying \f(CW\(C`EVFLAG_NOSIGMASK\(C'\fR when
jpayne@68	476 creating any loops), and in one thread, use \f(CW\(C`sigwait\(C'\fR or any other
jpayne@68	477 mechanism to wait for signals, then \(L"deliver\(R" them to libev by calling
jpayne@68	478 \&\f(CW\(C`ev_feed_signal\(C'\fR.
jpayne@68	479 .SH "FUNCTIONS CONTROLLING EVENT LOOPS"
jpayne@68	480 .IX Header "FUNCTIONS CONTROLLING EVENT LOOPS"
jpayne@68	481 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	482 \&\fInot\fR optional in this case unless libev 3 compatibility is disabled, as
jpayne@68	483 libev 3 had an \f(CW\(C`ev_loop\(C'\fR function colliding with the struct name).
jpayne@68	484 .PP
jpayne@68	485 The library knows two types of such loops, the \fIdefault\fR loop, which
jpayne@68	486 supports child process events, and dynamically created event loops which
jpayne@68	487 do not.
jpayne@68	488 .IP "struct ev_loop *ev_default_loop (unsigned int flags)" 4
jpayne@68	489 .IX Item "struct ev_loop *ev_default_loop (unsigned int flags)"
jpayne@68	490 This returns the \(L"default\(R" event loop object, which is what you should
jpayne@68	491 normally use when you just need \(L"the event loop\(R". Event loop objects and
jpayne@68	492 the \f(CW\(C`flags\(C'\fR parameter are described in more detail in the entry for
jpayne@68	493 \&\f(CW\(C`ev_loop_new\(C'\fR.
jpayne@68	494 .Sp
jpayne@68	495 If the default loop is already initialised then this function simply
jpayne@68	496 returns it (and ignores the flags. If that is troubling you, check
jpayne@68	497 \&\f(CW\(C`ev_backend ()\(C'\fR afterwards). Otherwise it will create it with the given
jpayne@68	498 flags, which should almost always be \f(CW0\fR, unless the caller is also the
jpayne@68	499 one calling \f(CW\(C`ev_run\(C'\fR or otherwise qualifies as \(L"the main program\(R".
jpayne@68	500 .Sp
jpayne@68	501 If you don't know what event loop to use, use the one returned from this
jpayne@68	502 function (or via the \f(CW\(C`EV_DEFAULT\(C'\fR macro).
jpayne@68	503 .Sp
jpayne@68	504 Note that this function is \fInot\fR thread-safe, so if you want to use it
jpayne@68	505 from multiple threads, you have to employ some kind of mutex (note also
jpayne@68	506 that this case is unlikely, as loops cannot be shared easily between
jpayne@68	507 threads anyway).
jpayne@68	508 .Sp
jpayne@68	509 The default loop is the only loop that can handle \f(CW\(C`ev_child\(C'\fR watchers,
jpayne@68	510 and to do this, it always registers a handler for \f(CW\(C`SIGCHLD\(C'\fR. If this is
jpayne@68	511 a problem for your application you can either create a dynamic loop with
jpayne@68	512 \&\f(CW\(C`ev_loop_new\(C'\fR which doesn't do that, or you can simply overwrite the
jpayne@68	513 \&\f(CW\(C`SIGCHLD\(C'\fR signal handler \fIafter\fR calling \f(CW\(C`ev_default_init\(C'\fR.
jpayne@68	514 .Sp
jpayne@68	515 Example: This is the most typical usage.
jpayne@68	516 .Sp
jpayne@68	517 .Vb 2
jpayne@68	518 \& if (!ev_default_loop (0))
jpayne@68	519 \& fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?");
jpayne@68	520 .Ve
jpayne@68	521 .Sp
jpayne@68	522 Example: Restrict libev to the select and poll backends, and do not allow
jpayne@68	523 environment settings to be taken into account:
jpayne@68	524 .Sp
jpayne@68	525 .Vb 1
jpayne@68	526 \& ev_default_loop (EVBACKEND_POLL \| EVBACKEND_SELECT \| EVFLAG_NOENV);
jpayne@68	527 .Ve
jpayne@68	528 .IP "struct ev_loop *ev_loop_new (unsigned int flags)" 4
jpayne@68	529 .IX Item "struct ev_loop *ev_loop_new (unsigned int flags)"
jpayne@68	530 This will create and initialise a new event loop object. If the loop
jpayne@68	531 could not be initialised, returns false.
jpayne@68	532 .Sp
jpayne@68	533 This function is thread-safe, and one common way to use libev with
jpayne@68	534 threads is indeed to create one loop per thread, and using the default
jpayne@68	535 loop in the \(L"main\(R" or \(L"initial\(R" thread.
jpayne@68	536 .Sp
jpayne@68	537 The flags argument can be used to specify special behaviour or specific
jpayne@68	538 backends to use, and is usually specified as \f(CW0\fR (or \f(CW\(C`EVFLAG_AUTO\(C'\fR).
jpayne@68	539 .Sp
jpayne@68	540 The following flags are supported:
jpayne@68	541 .RS 4
jpayne@68	542 .ie n .IP """EVFLAG_AUTO""" 4
jpayne@68	543 .el .IP "\f(CWEVFLAG_AUTO\fR" 4
jpayne@68	544 .IX Item "EVFLAG_AUTO"
jpayne@68	545 The default flags value. Use this if you have no clue (it's the right
jpayne@68	546 thing, believe me).
jpayne@68	547 .ie n .IP """EVFLAG_NOENV""" 4
jpayne@68	548 .el .IP "\f(CWEVFLAG_NOENV\fR" 4
jpayne@68	549 .IX Item "EVFLAG_NOENV"
jpayne@68	550 If this flag bit is or'ed into the flag value (or the program runs setuid
jpayne@68	551 or setgid) then libev will \fInot\fR look at the environment variable
jpayne@68	552 \&\f(CW\(C`LIBEV_FLAGS\(C'\fR. Otherwise (the default), this environment variable will
jpayne@68	553 override the flags completely if it is found in the environment. This is
jpayne@68	554 useful to try out specific backends to test their performance, to work
jpayne@68	555 around bugs, or to make libev threadsafe (accessing environment variables
jpayne@68	556 cannot be done in a threadsafe way, but usually it works if no other
jpayne@68	557 thread modifies them).
jpayne@68	558 .ie n .IP """EVFLAG_FORKCHECK""" 4
jpayne@68	559 .el .IP "\f(CWEVFLAG_FORKCHECK\fR" 4
jpayne@68	560 .IX Item "EVFLAG_FORKCHECK"
jpayne@68	561 Instead of calling \f(CW\(C`ev_loop_fork\(C'\fR manually after a fork, you can also
jpayne@68	562 make libev check for a fork in each iteration by enabling this flag.
jpayne@68	563 .Sp
jpayne@68	564 This works by calling \f(CW\(C`getpid ()\(C'\fR on every iteration of the loop,
jpayne@68	565 and thus this might slow down your event loop if you do a lot of loop
jpayne@68	566 iterations and little real work, but is usually not noticeable (on my
jpayne@68	567 GNU/Linux system for example, \f(CW\(C`getpid\(C'\fR is actually a simple 5\-insn
jpayne@68	568 sequence without a system call and thus \fIvery\fR fast, but my GNU/Linux
jpayne@68	569 system also has \f(CW\(C`pthread_atfork\(C'\fR which is even faster). (Update: glibc
jpayne@68	570 versions 2.25 apparently removed the \f(CW\(C`getpid\(C'\fR optimisation again).
jpayne@68	571 .Sp
jpayne@68	572 The big advantage of this flag is that you can forget about fork (and
jpayne@68	573 forget about forgetting to tell libev about forking, although you still
jpayne@68	574 have to ignore \f(CW\(C`SIGPIPE\(C'\fR) when you use this flag.
jpayne@68	575 .Sp
jpayne@68	576 This flag setting cannot be overridden or specified in the \f(CW\(C`LIBEV_FLAGS\(C'\fR
jpayne@68	577 environment variable.
jpayne@68	578 .ie n .IP """EVFLAG_NOINOTIFY""" 4
jpayne@68	579 .el .IP "\f(CWEVFLAG_NOINOTIFY\fR" 4
jpayne@68	580 .IX Item "EVFLAG_NOINOTIFY"
jpayne@68	581 When this flag is specified, then libev will not attempt to use the
jpayne@68	582 \&\fIinotify\fR \s-1API\s0 for its \f(CW\(C`ev_stat\(C'\fR watchers. Apart from debugging and
jpayne@68	583 testing, this flag can be useful to conserve inotify file descriptors, as
jpayne@68	584 otherwise each loop using \f(CW\(C`ev_stat\(C'\fR watchers consumes one inotify handle.
jpayne@68	585 .ie n .IP """EVFLAG_SIGNALFD""" 4
jpayne@68	586 .el .IP "\f(CWEVFLAG_SIGNALFD\fR" 4
jpayne@68	587 .IX Item "EVFLAG_SIGNALFD"
jpayne@68	588 When this flag is specified, then libev will attempt to use the
jpayne@68	589 \&\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	590 delivers signals synchronously, which makes it both faster and might make
jpayne@68	591 it possible to get the queued signal data. It can also simplify signal
jpayne@68	592 handling with threads, as long as you properly block signals in your
jpayne@68	593 threads that are not interested in handling them.
jpayne@68	594 .Sp
jpayne@68	595 Signalfd will not be used by default as this changes your signal mask, and
jpayne@68	596 there are a lot of shoddy libraries and programs (glib's threadpool for
jpayne@68	597 example) that can't properly initialise their signal masks.
jpayne@68	598 .ie n .IP """EVFLAG_NOSIGMASK""" 4
jpayne@68	599 .el .IP "\f(CWEVFLAG_NOSIGMASK\fR" 4
jpayne@68	600 .IX Item "EVFLAG_NOSIGMASK"
jpayne@68	601 When this flag is specified, then libev will avoid to modify the signal
jpayne@68	602 mask. Specifically, this means you have to make sure signals are unblocked
jpayne@68	603 when you want to receive them.
jpayne@68	604 .Sp
jpayne@68	605 This behaviour is useful when you want to do your own signal handling, or
jpayne@68	606 want to handle signals only in specific threads and want to avoid libev
jpayne@68	607 unblocking the signals.
jpayne@68	608 .Sp
jpayne@68	609 It's also required by \s-1POSIX\s0 in a threaded program, as libev calls
jpayne@68	610 \&\f(CW\(C`sigprocmask\(C'\fR, whose behaviour is officially unspecified.
jpayne@68	611 .ie n .IP """EVFLAG_NOTIMERFD""" 4
jpayne@68	612 .el .IP "\f(CWEVFLAG_NOTIMERFD\fR" 4
jpayne@68	613 .IX Item "EVFLAG_NOTIMERFD"
jpayne@68	614 When this flag is specified, the libev will avoid using a \f(CW\(C`timerfd\(C'\fR to
jpayne@68	615 detect time jumps. It will still be able to detect time jumps, but takes
jpayne@68	616 longer and has a lower accuracy in doing so, but saves a file descriptor
jpayne@68	617 per loop.
jpayne@68	618 .Sp
jpayne@68	619 The current implementation only tries to use a \f(CW\(C`timerfd\(C'\fR when the first
jpayne@68	620 \&\f(CW\(C`ev_periodic\(C'\fR watcher is started and falls back on other methods if it
jpayne@68	621 cannot be created, but this behaviour might change in the future.
jpayne@68	622 .ie n .IP """EVBACKEND_SELECT"" (value 1, portable select backend)" 4
jpayne@68	623 .el .IP "\f(CWEVBACKEND_SELECT\fR (value 1, portable select backend)" 4
jpayne@68	624 .IX Item "EVBACKEND_SELECT (value 1, portable select backend)"
jpayne@68	625 This is your standard \fBselect\fR\\|(2) backend. Not \fIcompletely\fR standard, as
jpayne@68	626 libev tries to roll its own fd_set with no limits on the number of fds,
jpayne@68	627 but if that fails, expect a fairly low limit on the number of fds when
jpayne@68	628 using this backend. It doesn't scale too well (O(highest_fd)), but its
jpayne@68	629 usually the fastest backend for a low number of (low-numbered :) fds.
jpayne@68	630 .Sp
jpayne@68	631 To get good performance out of this backend you need a high amount of
jpayne@68	632 parallelism (most of the file descriptors should be busy). If you are
jpayne@68	633 writing a server, you should \f(CW\(C`accept ()\(C'\fR in a loop to accept as many
jpayne@68	634 connections as possible during one iteration. You might also want to have
jpayne@68	635 a look at \f(CW\(C`ev_set_io_collect_interval ()\(C'\fR to increase the amount of
jpayne@68	636 readiness notifications you get per iteration.
jpayne@68	637 .Sp
jpayne@68	638 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	639 \&\f(CW\(C`writefds\(C'\fR set (and to work around Microsoft Windows bugs, also onto the
jpayne@68	640 \&\f(CW\(C`exceptfds\(C'\fR set on that platform).
jpayne@68	641 .ie n .IP """EVBACKEND_POLL"" (value 2, poll backend, available everywhere except on windows)" 4
jpayne@68	642 .el .IP "\f(CWEVBACKEND_POLL\fR (value 2, poll backend, available everywhere except on windows)" 4
jpayne@68	643 .IX Item "EVBACKEND_POLL (value 2, poll backend, available everywhere except on windows)"
jpayne@68	644 And this is your standard \fBpoll\fR\\|(2) backend. It's more complicated
jpayne@68	645 than select, but handles sparse fds better and has no artificial
jpayne@68	646 limit on the number of fds you can use (except it will slow down
jpayne@68	647 considerably with a lot of inactive fds). It scales similarly to select,
jpayne@68	648 i.e. O(total_fds). See the entry for \f(CW\(C`EVBACKEND_SELECT\(C'\fR, above, for
jpayne@68	649 performance tips.
jpayne@68	650 .Sp
jpayne@68	651 This backend maps \f(CW\(C`EV_READ\(C'\fR to \f(CW\(C`POLLIN \| POLLERR \| POLLHUP\(C'\fR, and
jpayne@68	652 \&\f(CW\(C`EV_WRITE\(C'\fR to \f(CW\(C`POLLOUT \| POLLERR \| POLLHUP\(C'\fR.
jpayne@68	653 .ie n .IP """EVBACKEND_EPOLL"" (value 4, Linux)" 4
jpayne@68	654 .el .IP "\f(CWEVBACKEND_EPOLL\fR (value 4, Linux)" 4
jpayne@68	655 .IX Item "EVBACKEND_EPOLL (value 4, Linux)"
jpayne@68	656 Use the Linux-specific \fBepoll\fR\\|(7) interface (for both pre\- and post\-2.6.9
jpayne@68	657 kernels).
jpayne@68	658 .Sp
jpayne@68	659 For few fds, this backend is a bit little slower than poll and select, but
jpayne@68	660 it scales phenomenally better. While poll and select usually scale like
jpayne@68	661 O(total_fds) where total_fds is the total number of fds (or the highest
jpayne@68	662 fd), epoll scales either O(1) or O(active_fds).
jpayne@68	663 .Sp
jpayne@68	664 The epoll mechanism deserves honorable mention as the most misdesigned
jpayne@68	665 of the more advanced event mechanisms: mere annoyances include silently
jpayne@68	666 dropping file descriptors, requiring a system call per change per file
jpayne@68	667 descriptor (and unnecessary guessing of parameters), problems with dup,
jpayne@68	668 returning before the timeout value, resulting in additional iterations
jpayne@68	669 (and only giving 5ms accuracy while select on the same platform gives
jpayne@68	670 0.1ms) and so on. The biggest issue is fork races, however \- if a program
jpayne@68	671 forks then \fIboth\fR parent and child process have to recreate the epoll
jpayne@68	672 set, which can take considerable time (one syscall per file descriptor)
jpayne@68	673 and is of course hard to detect.
jpayne@68	674 .Sp
jpayne@68	675 Epoll is also notoriously buggy \- embedding epoll fds \fIshould\fR work,
jpayne@68	676 but of course \fIdoesn't\fR, and epoll just loves to report events for
jpayne@68	677 totally \fIdifferent\fR file descriptors (even already closed ones, so
jpayne@68	678 one cannot even remove them from the set) than registered in the set
jpayne@68	679 (especially on \s-1SMP\s0 systems). Libev tries to counter these spurious
jpayne@68	680 notifications by employing an additional generation counter and comparing
jpayne@68	681 that against the events to filter out spurious ones, recreating the set
jpayne@68	682 when required. Epoll also erroneously rounds down timeouts, but gives you
jpayne@68	683 no way to know when and by how much, so sometimes you have to busy-wait
jpayne@68	684 because epoll returns immediately despite a nonzero timeout. And last
jpayne@68	685 not least, it also refuses to work with some file descriptors which work
jpayne@68	686 perfectly fine with \f(CW\(C`select\(C'\fR (files, many character devices...).
jpayne@68	687 .Sp
jpayne@68	688 Epoll is truly the train wreck among event poll mechanisms, a frankenpoll,
jpayne@68	689 cobbled together in a hurry, no thought to design or interaction with
jpayne@68	690 others. Oh, the pain, will it ever stop...
jpayne@68	691 .Sp
jpayne@68	692 While stopping, setting and starting an I/O watcher in the same iteration
jpayne@68	693 will result in some caching, there is still a system call per such
jpayne@68	694 incident (because the same \fIfile descriptor\fR could point to a different
jpayne@68	695 \&\fIfile description\fR now), so its best to avoid that. Also, \f(CW\(C`dup ()\(C'\fR'ed
jpayne@68	696 file descriptors might not work very well if you register events for both
jpayne@68	697 file descriptors.
jpayne@68	698 .Sp
jpayne@68	699 Best performance from this backend is achieved by not unregistering all
jpayne@68	700 watchers for a file descriptor until it has been closed, if possible,
jpayne@68	701 i.e. keep at least one watcher active per fd at all times. Stopping and
jpayne@68	702 starting a watcher (without re-setting it) also usually doesn't cause
jpayne@68	703 extra overhead. A fork can both result in spurious notifications as well
jpayne@68	704 as in libev having to destroy and recreate the epoll object, which can
jpayne@68	705 take considerable time and thus should be avoided.
jpayne@68	706 .Sp
jpayne@68	707 All this means that, in practice, \f(CW\(C`EVBACKEND_SELECT\(C'\fR can be as fast or
jpayne@68	708 faster than epoll for maybe up to a hundred file descriptors, depending on
jpayne@68	709 the usage. So sad.
jpayne@68	710 .Sp
jpayne@68	711 While nominally embeddable in other event loops, this feature is broken in
jpayne@68	712 a lot of kernel revisions, but probably(!) works in current versions.
jpayne@68	713 .Sp
jpayne@68	714 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	715 \&\f(CW\(C`EVBACKEND_POLL\(C'\fR.
jpayne@68	716 .ie n .IP """EVBACKEND_LINUXAIO"" (value 64, Linux)" 4
jpayne@68	717 .el .IP "\f(CWEVBACKEND_LINUXAIO\fR (value 64, Linux)" 4
jpayne@68	718 .IX Item "EVBACKEND_LINUXAIO (value 64, Linux)"
jpayne@68	719 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	720 only tries to use it in 4.19+).
jpayne@68	721 .Sp
jpayne@68	722 This is another Linux train wreck of an event interface.
jpayne@68	723 .Sp
jpayne@68	724 If this backend works for you (as of this writing, it was very
jpayne@68	725 experimental), it is the best event interface available on Linux and might
jpayne@68	726 be well worth enabling it \- if it isn't available in your kernel this will
jpayne@68	727 be detected and this backend will be skipped.
jpayne@68	728 .Sp
jpayne@68	729 This backend can batch oneshot requests and supports a user-space ring
jpayne@68	730 buffer to receive events. It also doesn't suffer from most of the design
jpayne@68	731 problems of epoll (such as not being able to remove event sources from
jpayne@68	732 the epoll set), and generally sounds too good to be true. Because, this
jpayne@68	733 being the Linux kernel, of course it suffers from a whole new set of
jpayne@68	734 limitations, forcing you to fall back to epoll, inheriting all its design
jpayne@68	735 issues.
jpayne@68	736 .Sp
jpayne@68	737 For one, it is not easily embeddable (but probably could be done using
jpayne@68	738 an event fd at some extra overhead). It also is subject to a system wide
jpayne@68	739 limit that can be configured in \fI/proc/sys/fs/aio\-max\-nr\fR. If no \s-1AIO\s0
jpayne@68	740 requests are left, this backend will be skipped during initialisation, and
jpayne@68	741 will switch to epoll when the loop is active.
jpayne@68	742 .Sp
jpayne@68	743 Most problematic in practice, however, is that not all file descriptors
jpayne@68	744 work with it. For example, in Linux 5.1, \s-1TCP\s0 sockets, pipes, event fds,
jpayne@68	745 files, \fI/dev/null\fR and many others are supported, but ttys do not work
jpayne@68	746 properly (a known bug that the kernel developers don't care about, see
jpayne@68	747 <https://lore.kernel.org/patchwork/patch/1047453/>), so this is not
jpayne@68	748 (yet?) a generic event polling interface.
jpayne@68	749 .Sp
jpayne@68	750 Overall, it seems the Linux developers just don't want it to have a
jpayne@68	751 generic event handling mechanism other than \f(CW\(C`select\(C'\fR or \f(CW\(C`poll\(C'\fR.
jpayne@68	752 .Sp
jpayne@68	753 To work around all these problem, the current version of libev uses its
jpayne@68	754 epoll backend as a fallback for file descriptor types that do not work. Or
jpayne@68	755 falls back completely to epoll if the kernel acts up.
jpayne@68	756 .Sp
jpayne@68	757 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	758 \&\f(CW\(C`EVBACKEND_POLL\(C'\fR.
jpayne@68	759 .ie n .IP """EVBACKEND_KQUEUE"" (value 8, most \s-1BSD\s0 clones)" 4
jpayne@68	760 .el .IP "\f(CWEVBACKEND_KQUEUE\fR (value 8, most \s-1BSD\s0 clones)" 4
jpayne@68	761 .IX Item "EVBACKEND_KQUEUE (value 8, most BSD clones)"
jpayne@68	762 Kqueue deserves special mention, as at the time this backend was
jpayne@68	763 implemented, it was broken on all BSDs except NetBSD (usually it doesn't
jpayne@68	764 work reliably with anything but sockets and pipes, except on Darwin,
jpayne@68	765 where of course it's completely useless). Unlike epoll, however, whose
jpayne@68	766 brokenness is by design, these kqueue bugs can be (and mostly have been)
jpayne@68	767 fixed without \s-1API\s0 changes to existing programs. For this reason it's not
jpayne@68	768 being \(L"auto-detected\(R" on all platforms unless you explicitly specify it
jpayne@68	769 in the flags (i.e. using \f(CW\(C`EVBACKEND_KQUEUE\(C'\fR) or libev was compiled on a
jpayne@68	770 known-to-be-good (\-enough) system like NetBSD.
jpayne@68	771 .Sp
jpayne@68	772 You still can embed kqueue into a normal poll or select backend and use it
jpayne@68	773 only for sockets (after having made sure that sockets work with kqueue on
jpayne@68	774 the target platform). See \f(CW\(C`ev_embed\(C'\fR watchers for more info.
jpayne@68	775 .Sp
jpayne@68	776 It scales in the same way as the epoll backend, but the interface to the
jpayne@68	777 kernel is more efficient (which says nothing about its actual speed, of
jpayne@68	778 course). While stopping, setting and starting an I/O watcher does never
jpayne@68	779 cause an extra system call as with \f(CW\(C`EVBACKEND_EPOLL\(C'\fR, it still adds up to
jpayne@68	780 two event changes per incident. Support for \f(CW\(C`fork ()\(C'\fR is very bad (you
jpayne@68	781 might have to leak fds on fork, but it's more sane than epoll) and it
jpayne@68	782 drops fds silently in similarly hard-to-detect cases.
jpayne@68	783 .Sp
jpayne@68	784 This backend usually performs well under most conditions.
jpayne@68	785 .Sp
jpayne@68	786 While nominally embeddable in other event loops, this doesn't work
jpayne@68	787 everywhere, so you might need to test for this. And since it is broken
jpayne@68	788 almost everywhere, you should only use it when you have a lot of sockets
jpayne@68	789 (for which it usually works), by embedding it into another event loop
jpayne@68	790 (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	791 also broken on \s-1OS X\s0)) and, did I mention it, using it only for sockets.
jpayne@68	792 .Sp
jpayne@68	793 This backend maps \f(CW\(C`EV_READ\(C'\fR into an \f(CW\(C`EVFILT_READ\(C'\fR kevent with
jpayne@68	794 \&\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	795 \&\f(CW\(C`NOTE_EOF\(C'\fR.
jpayne@68	796 .ie n .IP """EVBACKEND_DEVPOLL"" (value 16, Solaris 8)" 4
jpayne@68	797 .el .IP "\f(CWEVBACKEND_DEVPOLL\fR (value 16, Solaris 8)" 4
jpayne@68	798 .IX Item "EVBACKEND_DEVPOLL (value 16, Solaris 8)"
jpayne@68	799 This is not implemented yet (and might never be, unless you send me an
jpayne@68	800 implementation). According to reports, \f(CW\(C`/dev/poll\(C'\fR only supports sockets
jpayne@68	801 and is not embeddable, which would limit the usefulness of this backend
jpayne@68	802 immensely.
jpayne@68	803 .ie n .IP """EVBACKEND_PORT"" (value 32, Solaris 10)" 4
jpayne@68	804 .el .IP "\f(CWEVBACKEND_PORT\fR (value 32, Solaris 10)" 4
jpayne@68	805 .IX Item "EVBACKEND_PORT (value 32, Solaris 10)"
jpayne@68	806 This uses the Solaris 10 event port mechanism. As with everything on Solaris,
jpayne@68	807 it's really slow, but it still scales very well (O(active_fds)).
jpayne@68	808 .Sp
jpayne@68	809 While this backend scales well, it requires one system call per active
jpayne@68	810 file descriptor per loop iteration. For small and medium numbers of file
jpayne@68	811 descriptors a \(L"slow\(R" \f(CW\(C`EVBACKEND_SELECT\(C'\fR or \f(CW\(C`EVBACKEND_POLL\(C'\fR backend
jpayne@68	812 might perform better.
jpayne@68	813 .Sp
jpayne@68	814 On the positive side, this backend actually performed fully to
jpayne@68	815 specification in all tests and is fully embeddable, which is a rare feat
jpayne@68	816 among the OS-specific backends (I vastly prefer correctness over speed
jpayne@68	817 hacks).
jpayne@68	818 .Sp
jpayne@68	819 On the negative side, the interface is \fIbizarre\fR \- so bizarre that
jpayne@68	820 even sun itself gets it wrong in their code examples: The event polling
jpayne@68	821 function sometimes returns events to the caller even though an error
jpayne@68	822 occurred, but with no indication whether it has done so or not (yes, it's
jpayne@68	823 even documented that way) \- deadly for edge-triggered interfaces where you
jpayne@68	824 absolutely have to know whether an event occurred or not because you have
jpayne@68	825 to re-arm the watcher.
jpayne@68	826 .Sp
jpayne@68	827 Fortunately libev seems to be able to work around these idiocies.
jpayne@68	828 .Sp
jpayne@68	829 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	830 \&\f(CW\(C`EVBACKEND_POLL\(C'\fR.
jpayne@68	831 .ie n .IP """EVBACKEND_ALL""" 4
jpayne@68	832 .el .IP "\f(CWEVBACKEND_ALL\fR" 4
jpayne@68	833 .IX Item "EVBACKEND_ALL"
jpayne@68	834 Try all backends (even potentially broken ones that wouldn't be tried
jpayne@68	835 with \f(CW\(C`EVFLAG_AUTO\(C'\fR). Since this is a mask, you can do stuff such as
jpayne@68	836 \&\f(CW\(C`EVBACKEND_ALL & ~EVBACKEND_KQUEUE\(C'\fR.
jpayne@68	837 .Sp
jpayne@68	838 It is definitely not recommended to use this flag, use whatever
jpayne@68	839 \&\f(CW\(C`ev_recommended_backends ()\(C'\fR returns, or simply do not specify a backend
jpayne@68	840 at all.
jpayne@68	841 .ie n .IP """EVBACKEND_MASK""" 4
jpayne@68	842 .el .IP "\f(CWEVBACKEND_MASK\fR" 4
jpayne@68	843 .IX Item "EVBACKEND_MASK"
jpayne@68	844 Not a backend at all, but a mask to select all backend bits from a
jpayne@68	845 \&\f(CW\(C`flags\(C'\fR value, in case you want to mask out any backends from a flags
jpayne@68	846 value (e.g. when modifying the \f(CW\(C`LIBEV_FLAGS\(C'\fR environment variable).
jpayne@68	847 .RE
jpayne@68	848 .RS 4
jpayne@68	849 .Sp
jpayne@68	850 If one or more of the backend flags are or'ed into the flags value,
jpayne@68	851 then only these backends will be tried (in the reverse order as listed
jpayne@68	852 here). If none are specified, all backends in \f(CW\*(C`ev_recommended_backends
jpayne@68	853 ()\*(C'\fR will be tried.
jpayne@68	854 .Sp
jpayne@68	855 Example: Try to create a event loop that uses epoll and nothing else.
jpayne@68	856 .Sp
jpayne@68	857 .Vb 3
jpayne@68	858 \& struct ev_loop *epoller = ev_loop_new (EVBACKEND_EPOLL \| EVFLAG_NOENV);
jpayne@68	859 \& if (!epoller)
jpayne@68	860 \& fatal ("no epoll found here, maybe it hides under your chair");
jpayne@68	861 .Ve
jpayne@68	862 .Sp
jpayne@68	863 Example: Use whatever libev has to offer, but make sure that kqueue is
jpayne@68	864 used if available.
jpayne@68	865 .Sp
jpayne@68	866 .Vb 1
jpayne@68	867 \& struct ev_loop *loop = ev_loop_new (ev_recommended_backends () \| EVBACKEND_KQUEUE);
jpayne@68	868 .Ve
jpayne@68	869 .Sp
jpayne@68	870 Example: Similarly, on linux, you mgiht want to take advantage of the
jpayne@68	871 linux aio backend if possible, but fall back to something else if that
jpayne@68	872 isn't available.
jpayne@68	873 .Sp
jpayne@68	874 .Vb 1
jpayne@68	875 \& struct ev_loop *loop = ev_loop_new (ev_recommended_backends () \| EVBACKEND_LINUXAIO);
jpayne@68	876 .Ve
jpayne@68	877 .RE
jpayne@68	878 .IP "ev_loop_destroy (loop)" 4
jpayne@68	879 .IX Item "ev_loop_destroy (loop)"
jpayne@68	880 Destroys an event loop object (frees all memory and kernel state
jpayne@68	881 etc.). None of the active event watchers will be stopped in the normal
jpayne@68	882 sense, so e.g. \f(CW\(C`ev_is_active\(C'\fR might still return true. It is your
jpayne@68	883 responsibility to either stop all watchers cleanly yourself \fIbefore\fR
jpayne@68	884 calling this function, or cope with the fact afterwards (which is usually
jpayne@68	885 the easiest thing, you can just ignore the watchers and/or \f(CW\(C`free ()\(C'\fR them
jpayne@68	886 for example).
jpayne@68	887 .Sp
jpayne@68	888 Note that certain global state, such as signal state (and installed signal
jpayne@68	889 handlers), will not be freed by this function, and related watchers (such
jpayne@68	890 as signal and child watchers) would need to be stopped manually.
jpayne@68	891 .Sp
jpayne@68	892 This function is normally used on loop objects allocated by
jpayne@68	893 \&\f(CW\(C`ev_loop_new\(C'\fR, but it can also be used on the default loop returned by
jpayne@68	894 \&\f(CW\(C`ev_default_loop\(C'\fR, in which case it is not thread-safe.
jpayne@68	895 .Sp
jpayne@68	896 Note that it is not advisable to call this function on the default loop
jpayne@68	897 except in the rare occasion where you really need to free its resources.
jpayne@68	898 If you need dynamically allocated loops it is better to use \f(CW\(C`ev_loop_new\(C'\fR
jpayne@68	899 and \f(CW\(C`ev_loop_destroy\(C'\fR.
jpayne@68	900 .IP "ev_loop_fork (loop)" 4
jpayne@68	901 .IX Item "ev_loop_fork (loop)"
jpayne@68	902 This function sets a flag that causes subsequent \f(CW\(C`ev_run\(C'\fR iterations
jpayne@68	903 to reinitialise the kernel state for backends that have one. Despite
jpayne@68	904 the name, you can call it anytime you are allowed to start or stop
jpayne@68	905 watchers (except inside an \f(CW\(C`ev_prepare\(C'\fR callback), but it makes most
jpayne@68	906 sense after forking, in the child process. You \fImust\fR call it (or use
jpayne@68	907 \&\f(CW\(C`EVFLAG_FORKCHECK\(C'\fR) in the child before resuming or calling \f(CW\(C`ev_run\(C'\fR.
jpayne@68	908 .Sp
jpayne@68	909 In addition, if you want to reuse a loop (via this function or
jpayne@68	910 \&\f(CW\(C`EVFLAG_FORKCHECK\(C'\fR), you \fIalso\fR have to ignore \f(CW\(C`SIGPIPE\(C'\fR.
jpayne@68	911 .Sp
jpayne@68	912 Again, you \fIhave\fR to call it on \fIany\fR loop that you want to re-use after
jpayne@68	913 a fork, \fIeven if you do not plan to use the loop in the parent\fR. This is
jpayne@68	914 because some kernel interfaces cough \fIkqueue\fR cough do funny things
jpayne@68	915 during fork.
jpayne@68	916 .Sp
jpayne@68	917 On the other hand, you only need to call this function in the child
jpayne@68	918 process if and only if you want to use the event loop in the child. If
jpayne@68	919 you just fork+exec or create a new loop in the child, you don't have to
jpayne@68	920 call it at all (in fact, \f(CW\(C`epoll\(C'\fR is so badly broken that it makes a
jpayne@68	921 difference, but libev will usually detect this case on its own and do a
jpayne@68	922 costly reset of the backend).
jpayne@68	923 .Sp
jpayne@68	924 The function itself is quite fast and it's usually not a problem to call
jpayne@68	925 it just in case after a fork.
jpayne@68	926 .Sp
jpayne@68	927 Example: Automate calling \f(CW\(C`ev_loop_fork\(C'\fR on the default loop when
jpayne@68	928 using pthreads.
jpayne@68	929 .Sp
jpayne@68	930 .Vb 5
jpayne@68	931 \& static void
jpayne@68	932 \& post_fork_child (void)
jpayne@68	933 \& {
jpayne@68	934 \& ev_loop_fork (EV_DEFAULT);
jpayne@68	935 \& }
jpayne@68	936 \&
jpayne@68	937 \& ...
jpayne@68	938 \& pthread_atfork (0, 0, post_fork_child);
jpayne@68	939 .Ve
jpayne@68	940 .IP "int ev_is_default_loop (loop)" 4
jpayne@68	941 .IX Item "int ev_is_default_loop (loop)"
jpayne@68	942 Returns true when the given loop is, in fact, the default loop, and false
jpayne@68	943 otherwise.
jpayne@68	944 .IP "unsigned int ev_iteration (loop)" 4
jpayne@68	945 .IX Item "unsigned int ev_iteration (loop)"
jpayne@68	946 Returns the current iteration count for the event loop, which is identical
jpayne@68	947 to the number of times libev did poll for new events. It starts at \f(CW0\fR
jpayne@68	948 and happily wraps around with enough iterations.
jpayne@68	949 .Sp
jpayne@68	950 This value can sometimes be useful as a generation counter of sorts (it
jpayne@68	951 \&\(L"ticks\(R" the number of loop iterations), as it roughly corresponds with
jpayne@68	952 \&\f(CW\(C`ev_prepare\(C'\fR and \f(CW\(C`ev_check\(C'\fR calls \- and is incremented between the
jpayne@68	953 prepare and check phases.
jpayne@68	954 .IP "unsigned int ev_depth (loop)" 4
jpayne@68	955 .IX Item "unsigned int ev_depth (loop)"
jpayne@68	956 Returns the number of times \f(CW\(C`ev_run\(C'\fR was entered minus the number of
jpayne@68	957 times \f(CW\(C`ev_run\(C'\fR was exited normally, in other words, the recursion depth.
jpayne@68	958 .Sp
jpayne@68	959 Outside \f(CW\(C`ev_run\(C'\fR, this number is zero. In a callback, this number is
jpayne@68	960 \&\f(CW1\fR, unless \f(CW\(C`ev_run\(C'\fR was invoked recursively (or from another thread),
jpayne@68	961 in which case it is higher.
jpayne@68	962 .Sp
jpayne@68	963 Leaving \f(CW\(C`ev_run\(C'\fR abnormally (setjmp/longjmp, cancelling the thread,
jpayne@68	964 throwing an exception etc.), doesn't count as \(L"exit\(R" \- consider this
jpayne@68	965 as a hint to avoid such ungentleman-like behaviour unless it's really
jpayne@68	966 convenient, in which case it is fully supported.
jpayne@68	967 .IP "unsigned int ev_backend (loop)" 4
jpayne@68	968 .IX Item "unsigned int ev_backend (loop)"
jpayne@68	969 Returns one of the \f(CW\(C`EVBACKEND_\*(C'\fR flags indicating the event backend in
jpayne@68	970 use.
jpayne@68	971 .IP "ev_tstamp ev_now (loop)" 4
jpayne@68	972 .IX Item "ev_tstamp ev_now (loop)"
jpayne@68	973 Returns the current \(L"event loop time\(R", which is the time the event loop
jpayne@68	974 received events and started processing them. This timestamp does not
jpayne@68	975 change as long as callbacks are being processed, and this is also the base
jpayne@68	976 time used for relative timers. You can treat it as the timestamp of the
jpayne@68	977 event occurring (or more correctly, libev finding out about it).
jpayne@68	978 .IP "ev_now_update (loop)" 4
jpayne@68	979 .IX Item "ev_now_update (loop)"
jpayne@68	980 Establishes the current time by querying the kernel, updating the time
jpayne@68	981 returned by \f(CW\(C`ev_now ()\(C'\fR in the progress. This is a costly operation and
jpayne@68	982 is usually done automatically within \f(CW\(C`ev_run ()\(C'\fR.
jpayne@68	983 .Sp
jpayne@68	984 This function is rarely useful, but when some event callback runs for a
jpayne@68	985 very long time without entering the event loop, updating libev's idea of
jpayne@68	986 the current time is a good idea.
jpayne@68	987 .Sp
jpayne@68	988 See also \(L"The special problem of time updates\(R" in the \f(CW\(C`ev_timer\(C'\fR section.
jpayne@68	989 .IP "ev_suspend (loop)" 4
jpayne@68	990 .IX Item "ev_suspend (loop)"
jpayne@68	991 .PD 0
jpayne@68	992 .IP "ev_resume (loop)" 4
jpayne@68	993 .IX Item "ev_resume (loop)"
jpayne@68	994 .PD
jpayne@68	995 These two functions suspend and resume an event loop, for use when the
jpayne@68	996 loop is not used for a while and timeouts should not be processed.
jpayne@68	997 .Sp
jpayne@68	998 A typical use case would be an interactive program such as a game: When
jpayne@68	999 the user presses \f(CW\(C`^Z\(C'\fR to suspend the game and resumes it an hour later it
jpayne@68	1000 would be best to handle timeouts as if no time had actually passed while
jpayne@68	1001 the program was suspended. This can be achieved by calling \f(CW\(C`ev_suspend\(C'\fR
jpayne@68	1002 in your \f(CW\(C`SIGTSTP\(C'\fR handler, sending yourself a \f(CW\(C`SIGSTOP\(C'\fR and calling
jpayne@68	1003 \&\f(CW\(C`ev_resume\(C'\fR directly afterwards to resume timer processing.
jpayne@68	1004 .Sp
jpayne@68	1005 Effectively, all \f(CW\(C`ev_timer\(C'\fR watchers will be delayed by the time spend
jpayne@68	1006 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	1007 will be rescheduled (that is, they will lose any events that would have
jpayne@68	1008 occurred while suspended).
jpayne@68	1009 .Sp
jpayne@68	1010 After calling \f(CW\(C`ev_suspend\(C'\fR you \fBmust not\fR call \fIany\fR function on the
jpayne@68	1011 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	1012 without a previous call to \f(CW\(C`ev_suspend\(C'\fR.
jpayne@68	1013 .Sp
jpayne@68	1014 Calling \f(CW\(C`ev_suspend\(C'\fR/\f(CW\(C`ev_resume\(C'\fR has the side effect of updating the
jpayne@68	1015 event loop time (see \f(CW\(C`ev_now_update\(C'\fR).
jpayne@68	1016 .IP "bool ev_run (loop, int flags)" 4
jpayne@68	1017 .IX Item "bool ev_run (loop, int flags)"
jpayne@68	1018 Finally, this is it, the event handler. This function usually is called
jpayne@68	1019 after you have initialised all your watchers and you want to start
jpayne@68	1020 handling events. It will ask the operating system for any new events, call
jpayne@68	1021 the watcher callbacks, and then repeat the whole process indefinitely: This
jpayne@68	1022 is why event loops are called \fIloops\fR.
jpayne@68	1023 .Sp
jpayne@68	1024 If the flags argument is specified as \f(CW0\fR, it will keep handling events
jpayne@68	1025 until either no event watchers are active anymore or \f(CW\(C`ev_break\(C'\fR was
jpayne@68	1026 called.
jpayne@68	1027 .Sp
jpayne@68	1028 The return value is false if there are no more active watchers (which
jpayne@68	1029 usually means \(L"all jobs done\(R" or \(L"deadlock\(R"), and true in all other cases
jpayne@68	1030 (which usually means " you should call \f(CW\(C`ev_run\(C'\fR again").
jpayne@68	1031 .Sp
jpayne@68	1032 Please note that an explicit \f(CW\(C`ev_break\(C'\fR is usually better than
jpayne@68	1033 relying on all watchers to be stopped when deciding when a program has
jpayne@68	1034 finished (especially in interactive programs), but having a program
jpayne@68	1035 that automatically loops as long as it has to and no longer by virtue
jpayne@68	1036 of relying on its watchers stopping correctly, that is truly a thing of
jpayne@68	1037 beauty.
jpayne@68	1038 .Sp
jpayne@68	1039 This function is \fImostly\fR exception-safe \- you can break out of a
jpayne@68	1040 \&\f(CW\(C`ev_run\(C'\fR call by calling \f(CW\(C`longjmp\(C'\fR in a callback, throwing a \*(C+
jpayne@68	1041 exception and so on. This does not decrement the \f(CW\(C`ev_depth\(C'\fR value, nor
jpayne@68	1042 will it clear any outstanding \f(CW\(C`EVBREAK_ONE\(C'\fR breaks.
jpayne@68	1043 .Sp
jpayne@68	1044 A flags value of \f(CW\(C`EVRUN_NOWAIT\(C'\fR will look for new events, will handle
jpayne@68	1045 those events and any already outstanding ones, but will not wait and
jpayne@68	1046 block your process in case there are no events and will return after one
jpayne@68	1047 iteration of the loop. This is sometimes useful to poll and handle new
jpayne@68	1048 events while doing lengthy calculations, to keep the program responsive.
jpayne@68	1049 .Sp
jpayne@68	1050 A flags value of \f(CW\(C`EVRUN_ONCE\(C'\fR will look for new events (waiting if
jpayne@68	1051 necessary) and will handle those and any already outstanding ones. It
jpayne@68	1052 will block your process until at least one new event arrives (which could
jpayne@68	1053 be an event internal to libev itself, so there is no guarantee that a
jpayne@68	1054 user-registered callback will be called), and will return after one
jpayne@68	1055 iteration of the loop.
jpayne@68	1056 .Sp
jpayne@68	1057 This is useful if you are waiting for some external event in conjunction
jpayne@68	1058 with something not expressible using other libev watchers (i.e. "roll your
jpayne@68	1059 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	1060 usually a better approach for this kind of thing.
jpayne@68	1061 .Sp
jpayne@68	1062 Here are the gory details of what \f(CW\(C`ev_run\(C'\fR does (this is for your
jpayne@68	1063 understanding, not a guarantee that things will work exactly like this in
jpayne@68	1064 future versions):
jpayne@68	1065 .Sp
jpayne@68	1066 .Vb 10
jpayne@68	1067 \& \- Increment loop depth.
jpayne@68	1068 \& \- Reset the ev_break status.
jpayne@68	1069 \& \- Before the first iteration, call any pending watchers.
jpayne@68	1070 \& LOOP:
jpayne@68	1071 \& \- If EVFLAG_FORKCHECK was used, check for a fork.
jpayne@68	1072 \& \- If a fork was detected (by any means), queue and call all fork watchers.
jpayne@68	1073 \& \- Queue and call all prepare watchers.
jpayne@68	1074 \& \- If ev_break was called, goto FINISH.
jpayne@68	1075 \& \- If we have been forked, detach and recreate the kernel state
jpayne@68	1076 \& as to not disturb the other process.
jpayne@68	1077 \& \- Update the kernel state with all outstanding changes.
jpayne@68	1078 \& \- Update the "event loop time" (ev_now ()).
jpayne@68	1079 \& \- Calculate for how long to sleep or block, if at all
jpayne@68	1080 \& (active idle watchers, EVRUN_NOWAIT or not having
jpayne@68	1081 \& any active watchers at all will result in not sleeping).
jpayne@68	1082 \& \- Sleep if the I/O and timer collect interval say so.
jpayne@68	1083 \& \- Increment loop iteration counter.
jpayne@68	1084 \& \- Block the process, waiting for any events.
jpayne@68	1085 \& \- Queue all outstanding I/O (fd) events.
jpayne@68	1086 \& \- Update the "event loop time" (ev_now ()), and do time jump adjustments.
jpayne@68	1087 \& \- Queue all expired timers.
jpayne@68	1088 \& \- Queue all expired periodics.
jpayne@68	1089 \& \- Queue all idle watchers with priority higher than that of pending events.
jpayne@68	1090 \& \- Queue all check watchers.
jpayne@68	1091 \& \- Call all queued watchers in reverse order (i.e. check watchers first).
jpayne@68	1092 \& Signals and child watchers are implemented as I/O watchers, and will
jpayne@68	1093 \& be handled here by queueing them when their watcher gets executed.
jpayne@68	1094 \& \- If ev_break has been called, or EVRUN_ONCE or EVRUN_NOWAIT
jpayne@68	1095 \& were used, or there are no active watchers, goto FINISH, otherwise
jpayne@68	1096 \& continue with step LOOP.
jpayne@68	1097 \& FINISH:
jpayne@68	1098 \& \- Reset the ev_break status iff it was EVBREAK_ONE.
jpayne@68	1099 \& \- Decrement the loop depth.
jpayne@68	1100 \& \- Return.
jpayne@68	1101 .Ve
jpayne@68	1102 .Sp
jpayne@68	1103 Example: Queue some jobs and then loop until no events are outstanding
jpayne@68	1104 anymore.
jpayne@68	1105 .Sp
jpayne@68	1106 .Vb 4
jpayne@68	1107 \& ... queue jobs here, make sure they register event watchers as long
jpayne@68	1108 \& ... as they still have work to do (even an idle watcher will do..)
jpayne@68	1109 \& ev_run (my_loop, 0);
jpayne@68	1110 \& ... jobs done or somebody called break. yeah!
jpayne@68	1111 .Ve
jpayne@68	1112 .IP "ev_break (loop, how)" 4
jpayne@68	1113 .IX Item "ev_break (loop, how)"
jpayne@68	1114 Can be used to make a call to \f(CW\(C`ev_run\(C'\fR return early (but only after it
jpayne@68	1115 has processed all outstanding events). The \f(CW\(C`how\(C'\fR argument must be either
jpayne@68	1116 \&\f(CW\(C`EVBREAK_ONE\(C'\fR, which will make the innermost \f(CW\(C`ev_run\(C'\fR call return, or
jpayne@68	1117 \&\f(CW\(C`EVBREAK_ALL\(C'\fR, which will make all nested \f(CW\(C`ev_run\(C'\fR calls return.
jpayne@68	1118 .Sp
jpayne@68	1119 This \(L"break state\(R" will be cleared on the next call to \f(CW\(C`ev_run\(C'\fR.
jpayne@68	1120 .Sp
jpayne@68	1121 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	1122 which case it will have no effect.
jpayne@68	1123 .IP "ev_ref (loop)" 4
jpayne@68	1124 .IX Item "ev_ref (loop)"
jpayne@68	1125 .PD 0
jpayne@68	1126 .IP "ev_unref (loop)" 4
jpayne@68	1127 .IX Item "ev_unref (loop)"
jpayne@68	1128 .PD
jpayne@68	1129 Ref/unref can be used to add or remove a reference count on the event
jpayne@68	1130 loop: Every watcher keeps one reference, and as long as the reference
jpayne@68	1131 count is nonzero, \f(CW\(C`ev_run\(C'\fR will not return on its own.
jpayne@68	1132 .Sp
jpayne@68	1133 This is useful when you have a watcher that you never intend to
jpayne@68	1134 unregister, but that nevertheless should not keep \f(CW\(C`ev_run\(C'\fR from
jpayne@68	1135 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	1136 before stopping it.
jpayne@68	1137 .Sp
jpayne@68	1138 As an example, libev itself uses this for its internal signal pipe: It
jpayne@68	1139 is not visible to the libev user and should not keep \f(CW\(C`ev_run\(C'\fR from
jpayne@68	1140 exiting if no event watchers registered by it are active. It is also an
jpayne@68	1141 excellent way to do this for generic recurring timers or from within
jpayne@68	1142 third-party libraries. Just remember to \fIunref after start\fR and \fIref
jpayne@68	1143 before stop\fR (but only if the watcher wasn't active before, or was active
jpayne@68	1144 before, respectively. Note also that libev might stop watchers itself
jpayne@68	1145 (e.g. non-repeating timers) in which case you have to \f(CW\(C`ev_ref\(C'\fR
jpayne@68	1146 in the callback).
jpayne@68	1147 .Sp
jpayne@68	1148 Example: Create a signal watcher, but keep it from keeping \f(CW\(C`ev_run\(C'\fR
jpayne@68	1149 running when nothing else is active.
jpayne@68	1150 .Sp
jpayne@68	1151 .Vb 4
jpayne@68	1152 \& ev_signal exitsig;
jpayne@68	1153 \& ev_signal_init (&exitsig, sig_cb, SIGINT);
jpayne@68	1154 \& ev_signal_start (loop, &exitsig);
jpayne@68	1155 \& ev_unref (loop);
jpayne@68	1156 .Ve
jpayne@68	1157 .Sp
jpayne@68	1158 Example: For some weird reason, unregister the above signal handler again.
jpayne@68	1159 .Sp
jpayne@68	1160 .Vb 2
jpayne@68	1161 \& ev_ref (loop);
jpayne@68	1162 \& ev_signal_stop (loop, &exitsig);
jpayne@68	1163 .Ve
jpayne@68	1164 .IP "ev_set_io_collect_interval (loop, ev_tstamp interval)" 4
jpayne@68	1165 .IX Item "ev_set_io_collect_interval (loop, ev_tstamp interval)"
jpayne@68	1166 .PD 0
jpayne@68	1167 .IP "ev_set_timeout_collect_interval (loop, ev_tstamp interval)" 4
jpayne@68	1168 .IX Item "ev_set_timeout_collect_interval (loop, ev_tstamp interval)"
jpayne@68	1169 .PD
jpayne@68	1170 These advanced functions influence the time that libev will spend waiting
jpayne@68	1171 for events. Both time intervals are by default \f(CW0\fR, meaning that libev
jpayne@68	1172 will try to invoke timer/periodic callbacks and I/O callbacks with minimum
jpayne@68	1173 latency.
jpayne@68	1174 .Sp
jpayne@68	1175 Setting these to a higher value (the \f(CW\(C`interval\(C'\fR \fImust\fR be >= \f(CW0\fR)
jpayne@68	1176 allows libev to delay invocation of I/O and timer/periodic callbacks
jpayne@68	1177 to increase efficiency of loop iterations (or to increase power-saving
jpayne@68	1178 opportunities).
jpayne@68	1179 .Sp
jpayne@68	1180 The idea is that sometimes your program runs just fast enough to handle
jpayne@68	1181 one (or very few) event(s) per loop iteration. While this makes the
jpayne@68	1182 program responsive, it also wastes a lot of \s-1CPU\s0 time to poll for new
jpayne@68	1183 events, especially with backends like \f(CW\(C`select ()\(C'\fR which have a high
jpayne@68	1184 overhead for the actual polling but can deliver many events at once.
jpayne@68	1185 .Sp
jpayne@68	1186 By setting a higher \fIio collect interval\fR you allow libev to spend more
jpayne@68	1187 time collecting I/O events, so you can handle more events per iteration,
jpayne@68	1188 at the cost of increasing latency. Timeouts (both \f(CW\(C`ev_periodic\(C'\fR and
jpayne@68	1189 \&\f(CW\(C`ev_timer\(C'\fR) will not be affected. Setting this to a non-null value will
jpayne@68	1190 introduce an additional \f(CW\(C`ev_sleep ()\(C'\fR call into most loop iterations. The
jpayne@68	1191 sleep time ensures that libev will not poll for I/O events more often then
jpayne@68	1192 once per this interval, on average (as long as the host time resolution is
jpayne@68	1193 good enough).
jpayne@68	1194 .Sp
jpayne@68	1195 Likewise, by setting a higher \fItimeout collect interval\fR you allow libev
jpayne@68	1196 to spend more time collecting timeouts, at the expense of increased
jpayne@68	1197 latency/jitter/inexactness (the watcher callback will be called
jpayne@68	1198 later). \f(CW\(C`ev_io\(C'\fR watchers will not be affected. Setting this to a non-null
jpayne@68	1199 value will not introduce any overhead in libev.
jpayne@68	1200 .Sp
jpayne@68	1201 Many (busy) programs can usually benefit by setting the I/O collect
jpayne@68	1202 interval to a value near \f(CW0.1\fR or so, which is often enough for
jpayne@68	1203 interactive servers (of course not for games), likewise for timeouts. It
jpayne@68	1204 usually doesn't make much sense to set it to a lower value than \f(CW0.01\fR,
jpayne@68	1205 as this approaches the timing granularity of most systems. Note that if
jpayne@68	1206 you do transactions with the outside world and you can't increase the
jpayne@68	1207 parallelity, then this setting will limit your transaction rate (if you
jpayne@68	1208 need to poll once per transaction and the I/O collect interval is 0.01,
jpayne@68	1209 then you can't do more than 100 transactions per second).
jpayne@68	1210 .Sp
jpayne@68	1211 Setting the \fItimeout collect interval\fR can improve the opportunity for
jpayne@68	1212 saving power, as the program will \(L"bundle\(R" timer callback invocations that
jpayne@68	1213 are \(L"near\(R" in time together, by delaying some, thus reducing the number of
jpayne@68	1214 times the process sleeps and wakes up again. Another useful technique to
jpayne@68	1215 reduce iterations/wake\-ups is to use \f(CW\(C`ev_periodic\(C'\fR watchers and make sure
jpayne@68	1216 they fire on, say, one-second boundaries only.
jpayne@68	1217 .Sp
jpayne@68	1218 Example: we only need 0.1s timeout granularity, and we wish not to poll
jpayne@68	1219 more often than 100 times per second:
jpayne@68	1220 .Sp
jpayne@68	1221 .Vb 2
jpayne@68	1222 \& ev_set_timeout_collect_interval (EV_DEFAULT_UC_ 0.1);
jpayne@68	1223 \& ev_set_io_collect_interval (EV_DEFAULT_UC_ 0.01);
jpayne@68	1224 .Ve
jpayne@68	1225 .IP "ev_invoke_pending (loop)" 4
jpayne@68	1226 .IX Item "ev_invoke_pending (loop)"
jpayne@68	1227 This call will simply invoke all pending watchers while resetting their
jpayne@68	1228 pending state. Normally, \f(CW\(C`ev_run\(C'\fR does this automatically when required,
jpayne@68	1229 but when overriding the invoke callback this call comes handy. This
jpayne@68	1230 function can be invoked from a watcher \- this can be useful for example
jpayne@68	1231 when you want to do some lengthy calculation and want to pass further
jpayne@68	1232 event handling to another thread (you still have to make sure only one
jpayne@68	1233 thread executes within \f(CW\(C`ev_invoke_pending\(C'\fR or \f(CW\(C`ev_run\(C'\fR of course).
jpayne@68	1234 .IP "int ev_pending_count (loop)" 4
jpayne@68	1235 .IX Item "int ev_pending_count (loop)"
jpayne@68	1236 Returns the number of pending watchers \- zero indicates that no watchers
jpayne@68	1237 are pending.
jpayne@68	1238 .IP "ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(\s-1EV_P\s0))" 4
jpayne@68	1239 .IX Item "ev_set_invoke_pending_cb (loop, void (*invoke_pending_cb)(EV_P))"
jpayne@68	1240 This overrides the invoke pending functionality of the loop: Instead of
jpayne@68	1241 invoking all pending watchers when there are any, \f(CW\(C`ev_run\(C'\fR will call
jpayne@68	1242 this callback instead. This is useful, for example, when you want to
jpayne@68	1243 invoke the actual watchers inside another context (another thread etc.).
jpayne@68	1244 .Sp
jpayne@68	1245 If you want to reset the callback, use \f(CW\(C`ev_invoke_pending\(C'\fR as new
jpayne@68	1246 callback.
jpayne@68	1247 .IP "ev_set_loop_release_cb (loop, void (release)(\s-1EV_P\s0) throw (), void (acquire)(\s-1EV_P\s0) throw ())" 4
jpayne@68	1248 .IX Item "ev_set_loop_release_cb (loop, void (release)(EV_P) throw (), void (acquire)(EV_P) throw ())"
jpayne@68	1249 Sometimes you want to share the same loop between multiple threads. This
jpayne@68	1250 can be done relatively simply by putting mutex_lock/unlock calls around
jpayne@68	1251 each call to a libev function.
jpayne@68	1252 .Sp
jpayne@68	1253 However, \f(CW\(C`ev_run\(C'\fR can run an indefinite time, so it is not feasible
jpayne@68	1254 to wait for it to return. One way around this is to wake up the event
jpayne@68	1255 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	1256 \&\fIrelease\fR and \fIacquire\fR callbacks on the loop.
jpayne@68	1257 .Sp
jpayne@68	1258 When set, then \f(CW\(C`release\(C'\fR will be called just before the thread is
jpayne@68	1259 suspended waiting for new events, and \f(CW\(C`acquire\(C'\fR is called just
jpayne@68	1260 afterwards.
jpayne@68	1261 .Sp
jpayne@68	1262 Ideally, \f(CW\(C`release\(C'\fR will just call your mutex_unlock function, and
jpayne@68	1263 \&\f(CW\(C`acquire\(C'\fR will just call the mutex_lock function again.
jpayne@68	1264 .Sp
jpayne@68	1265 While event loop modifications are allowed between invocations of
jpayne@68	1266 \&\f(CW\(C`release\(C'\fR and \f(CW\(C`acquire\(C'\fR (that's their only purpose after all), no
jpayne@68	1267 modifications done will affect the event loop, i.e. adding watchers will
jpayne@68	1268 have no effect on the set of file descriptors being watched, or the time
jpayne@68	1269 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	1270 to take note of any changes you made.
jpayne@68	1271 .Sp
jpayne@68	1272 In theory, threads executing \f(CW\(C`ev_run\(C'\fR will be async-cancel safe between
jpayne@68	1273 invocations of \f(CW\(C`release\(C'\fR and \f(CW\(C`acquire\(C'\fR.
jpayne@68	1274 .Sp
jpayne@68	1275 See also the locking example in the \f(CW\(C`THREADS\(C'\fR section later in this
jpayne@68	1276 document.
jpayne@68	1277 .IP "ev_set_userdata (loop, void *data)" 4
jpayne@68	1278 .IX Item "ev_set_userdata (loop, void *data)"
jpayne@68	1279 .PD 0
jpayne@68	1280 .IP "void *ev_userdata (loop)" 4
jpayne@68	1281 .IX Item "void *ev_userdata (loop)"
jpayne@68	1282 .PD
jpayne@68	1283 Set and retrieve a single \f(CW\(C`void \*(C'\fR associated with a loop. When
jpayne@68	1284 \&\f(CW\(C`ev_set_userdata\(C'\fR has never been called, then \f(CW\(C`ev_userdata\(C'\fR returns
jpayne@68	1285 \&\f(CW0\fR.
jpayne@68	1286 .Sp
jpayne@68	1287 These two functions can be used to associate arbitrary data with a loop,
jpayne@68	1288 and are intended solely for the \f(CW\(C`invoke_pending_cb\(C'\fR, \f(CW\(C`release\(C'\fR and
jpayne@68	1289 \&\f(CW\(C`acquire\(C'\fR callbacks described above, but of course can be (ab\-)used for
jpayne@68	1290 any other purpose as well.
jpayne@68	1291 .IP "ev_verify (loop)" 4
jpayne@68	1292 .IX Item "ev_verify (loop)"
jpayne@68	1293 This function only does something when \f(CW\(C`EV_VERIFY\(C'\fR support has been
jpayne@68	1294 compiled in, which is the default for non-minimal builds. It tries to go
jpayne@68	1295 through all internal structures and checks them for validity. If anything
jpayne@68	1296 is found to be inconsistent, it will print an error message to standard
jpayne@68	1297 error and call \f(CW\(C`abort ()\(C'\fR.
jpayne@68	1298 .Sp
jpayne@68	1299 This can be used to catch bugs inside libev itself: under normal
jpayne@68	1300 circumstances, this function will never abort as of course libev keeps its
jpayne@68	1301 data structures consistent.
jpayne@68	1302 .SH "ANATOMY OF A WATCHER"
jpayne@68	1303 .IX Header "ANATOMY OF A WATCHER"
jpayne@68	1304 In the following description, uppercase \f(CW\(C`TYPE\(C'\fR in names stands for the
jpayne@68	1305 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	1306 watchers and \f(CW\(C`ev_io_start\(C'\fR for I/O watchers.
jpayne@68	1307 .PP
jpayne@68	1308 A watcher is an opaque structure that you allocate and register to record
jpayne@68	1309 your interest in some event. To make a concrete example, imagine you want
jpayne@68	1310 to wait for \s-1STDIN\s0 to become readable, you would create an \f(CW\(C`ev_io\(C'\fR watcher
jpayne@68	1311 for that:
jpayne@68	1312 .PP
jpayne@68	1313 .Vb 5
jpayne@68	1314 \& static void my_cb (struct ev_loop loop, ev_io w, int revents)
jpayne@68	1315 \& {
jpayne@68	1316 \& ev_io_stop (w);
jpayne@68	1317 \& ev_break (loop, EVBREAK_ALL);
jpayne@68	1318 \& }
jpayne@68	1319 \&
jpayne@68	1320 \& struct ev_loop *loop = ev_default_loop (0);
jpayne@68	1321 \&
jpayne@68	1322 \& ev_io stdin_watcher;
jpayne@68	1323 \&
jpayne@68	1324 \& ev_init (&stdin_watcher, my_cb);
jpayne@68	1325 \& ev_io_set (&stdin_watcher, STDIN_FILENO, EV_READ);
jpayne@68	1326 \& ev_io_start (loop, &stdin_watcher);
jpayne@68	1327 \&
jpayne@68	1328 \& ev_run (loop, 0);
jpayne@68	1329 .Ve
jpayne@68	1330 .PP
jpayne@68	1331 As you can see, you are responsible for allocating the memory for your
jpayne@68	1332 watcher structures (and it is \fIusually\fR a bad idea to do this on the
jpayne@68	1333 stack).
jpayne@68	1334 .PP
jpayne@68	1335 Each watcher has an associated watcher structure (called \f(CW\(C`struct ev_TYPE\(C'\fR
jpayne@68	1336 or simply \f(CW\(C`ev_TYPE\(C'\fR, as typedefs are provided for all watcher structs).
jpayne@68	1337 .PP
jpayne@68	1338 Each watcher structure must be initialised by a call to \f(CW\*(C`ev_init (watcher
jpayne@68	1339 , callback)\(C'\fR, which expects a callback to be provided. This callback is
jpayne@68	1340 invoked each time the event occurs (or, in the case of I/O watchers, each
jpayne@68	1341 time the event loop detects that the file descriptor given is readable
jpayne@68	1342 and/or writable).
jpayne@68	1343 .PP
jpayne@68	1344 Each watcher type further has its own \f(CW\(C`ev_TYPE_set (watcher , ...)\*(C'\fR
jpayne@68	1345 macro to configure it, with arguments specific to the watcher type. There
jpayne@68	1346 is also a macro to combine initialisation and setting in one call: \f(CW\(C`ev_TYPE_init (watcher , callback, ...)\*(C'\fR.
jpayne@68	1347 .PP
jpayne@68	1348 To make the watcher actually watch out for events, you have to start it
jpayne@68	1349 with a watcher-specific start function (\f(CW\*(C`ev_TYPE_start (loop, watcher
jpayne@68	1350 )\(C'\fR), and you can stop watching for events at any time by calling the
jpayne@68	1351 corresponding stop function (\f(CW\(C`ev_TYPE_stop (loop, watcher )\*(C'\fR.
jpayne@68	1352 .PP
jpayne@68	1353 As long as your watcher is active (has been started but not stopped) you
jpayne@68	1354 must not touch the values stored in it except when explicitly documented
jpayne@68	1355 otherwise. Most specifically you must never reinitialise it or call its
jpayne@68	1356 \&\f(CW\(C`ev_TYPE_set\(C'\fR macro.
jpayne@68	1357 .PP
jpayne@68	1358 Each and every callback receives the event loop pointer as first, the
jpayne@68	1359 registered watcher structure as second, and a bitset of received events as
jpayne@68	1360 third argument.
jpayne@68	1361 .PP
jpayne@68	1362 The received events usually include a single bit per event type received
jpayne@68	1363 (you can receive multiple events at the same time). The possible bit masks
jpayne@68	1364 are:
jpayne@68	1365 .ie n .IP """EV_READ""" 4
jpayne@68	1366 .el .IP "\f(CWEV_READ\fR" 4
jpayne@68	1367 .IX Item "EV_READ"
jpayne@68	1368 .PD 0
jpayne@68	1369 .ie n .IP """EV_WRITE""" 4
jpayne@68	1370 .el .IP "\f(CWEV_WRITE\fR" 4
jpayne@68	1371 .IX Item "EV_WRITE"
jpayne@68	1372 .PD
jpayne@68	1373 The file descriptor in the \f(CW\(C`ev_io\(C'\fR watcher has become readable and/or
jpayne@68	1374 writable.
jpayne@68	1375 .ie n .IP """EV_TIMER""" 4
jpayne@68	1376 .el .IP "\f(CWEV_TIMER\fR" 4
jpayne@68	1377 .IX Item "EV_TIMER"
jpayne@68	1378 The \f(CW\(C`ev_timer\(C'\fR watcher has timed out.
jpayne@68	1379 .ie n .IP """EV_PERIODIC""" 4
jpayne@68	1380 .el .IP "\f(CWEV_PERIODIC\fR" 4
jpayne@68	1381 .IX Item "EV_PERIODIC"
jpayne@68	1382 The \f(CW\(C`ev_periodic\(C'\fR watcher has timed out.
jpayne@68	1383 .ie n .IP """EV_SIGNAL""" 4
jpayne@68	1384 .el .IP "\f(CWEV_SIGNAL\fR" 4
jpayne@68	1385 .IX Item "EV_SIGNAL"
jpayne@68	1386 The signal specified in the \f(CW\(C`ev_signal\(C'\fR watcher has been received by a thread.
jpayne@68	1387 .ie n .IP """EV_CHILD""" 4
jpayne@68	1388 .el .IP "\f(CWEV_CHILD\fR" 4
jpayne@68	1389 .IX Item "EV_CHILD"
jpayne@68	1390 The pid specified in the \f(CW\(C`ev_child\(C'\fR watcher has received a status change.
jpayne@68	1391 .ie n .IP """EV_STAT""" 4
jpayne@68	1392 .el .IP "\f(CWEV_STAT\fR" 4
jpayne@68	1393 .IX Item "EV_STAT"
jpayne@68	1394 The path specified in the \f(CW\(C`ev_stat\(C'\fR watcher changed its attributes somehow.
jpayne@68	1395 .ie n .IP """EV_IDLE""" 4
jpayne@68	1396 .el .IP "\f(CWEV_IDLE\fR" 4
jpayne@68	1397 .IX Item "EV_IDLE"
jpayne@68	1398 The \f(CW\(C`ev_idle\(C'\fR watcher has determined that you have nothing better to do.
jpayne@68	1399 .ie n .IP """EV_PREPARE""" 4
jpayne@68	1400 .el .IP "\f(CWEV_PREPARE\fR" 4
jpayne@68	1401 .IX Item "EV_PREPARE"
jpayne@68	1402 .PD 0
jpayne@68	1403 .ie n .IP """EV_CHECK""" 4
jpayne@68	1404 .el .IP "\f(CWEV_CHECK\fR" 4
jpayne@68	1405 .IX Item "EV_CHECK"
jpayne@68	1406 .PD
jpayne@68	1407 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	1408 gather new events, and all \f(CW\(C`ev_check\(C'\fR watchers are queued (not invoked)
jpayne@68	1409 just after \f(CW\(C`ev_run\(C'\fR has gathered them, but before it queues any callbacks
jpayne@68	1410 for any received events. That means \f(CW\(C`ev_prepare\(C'\fR watchers are the last
jpayne@68	1411 watchers invoked before the event loop sleeps or polls for new events, and
jpayne@68	1412 \&\f(CW\(C`ev_check\(C'\fR watchers will be invoked before any other watchers of the same
jpayne@68	1413 or lower priority within an event loop iteration.
jpayne@68	1414 .Sp
jpayne@68	1415 Callbacks of both watcher types can start and stop as many watchers as
jpayne@68	1416 they want, and all of them will be taken into account (for example, a
jpayne@68	1417 \&\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	1418 blocking).
jpayne@68	1419 .ie n .IP """EV_EMBED""" 4
jpayne@68	1420 .el .IP "\f(CWEV_EMBED\fR" 4
jpayne@68	1421 .IX Item "EV_EMBED"
jpayne@68	1422 The embedded event loop specified in the \f(CW\(C`ev_embed\(C'\fR watcher needs attention.
jpayne@68	1423 .ie n .IP """EV_FORK""" 4
jpayne@68	1424 .el .IP "\f(CWEV_FORK\fR" 4
jpayne@68	1425 .IX Item "EV_FORK"
jpayne@68	1426 The event loop has been resumed in the child process after fork (see
jpayne@68	1427 \&\f(CW\(C`ev_fork\(C'\fR).
jpayne@68	1428 .ie n .IP """EV_CLEANUP""" 4
jpayne@68	1429 .el .IP "\f(CWEV_CLEANUP\fR" 4
jpayne@68	1430 .IX Item "EV_CLEANUP"
jpayne@68	1431 The event loop is about to be destroyed (see \f(CW\(C`ev_cleanup\(C'\fR).
jpayne@68	1432 .ie n .IP """EV_ASYNC""" 4
jpayne@68	1433 .el .IP "\f(CWEV_ASYNC\fR" 4
jpayne@68	1434 .IX Item "EV_ASYNC"
jpayne@68	1435 The given async watcher has been asynchronously notified (see \f(CW\(C`ev_async\(C'\fR).
jpayne@68	1436 .ie n .IP """EV_CUSTOM""" 4
jpayne@68	1437 .el .IP "\f(CWEV_CUSTOM\fR" 4
jpayne@68	1438 .IX Item "EV_CUSTOM"
jpayne@68	1439 Not ever sent (or otherwise used) by libev itself, but can be freely used
jpayne@68	1440 by libev users to signal watchers (e.g. via \f(CW\(C`ev_feed_event\(C'\fR).
jpayne@68	1441 .ie n .IP """EV_ERROR""" 4
jpayne@68	1442 .el .IP "\f(CWEV_ERROR\fR" 4
jpayne@68	1443 .IX Item "EV_ERROR"
jpayne@68	1444 An unspecified error has occurred, the watcher has been stopped. This might
jpayne@68	1445 happen because the watcher could not be properly started because libev
jpayne@68	1446 ran out of memory, a file descriptor was found to be closed or any other
jpayne@68	1447 problem. Libev considers these application bugs.
jpayne@68	1448 .Sp
jpayne@68	1449 You best act on it by reporting the problem and somehow coping with the
jpayne@68	1450 watcher being stopped. Note that well-written programs should not receive
jpayne@68	1451 an error ever, so when your watcher receives it, this usually indicates a
jpayne@68	1452 bug in your program.
jpayne@68	1453 .Sp
jpayne@68	1454 Libev will usually signal a few \(L"dummy\(R" events together with an error, for
jpayne@68	1455 example it might indicate that a fd is readable or writable, and if your
jpayne@68	1456 callbacks is well-written it can just attempt the operation and cope with
jpayne@68	1457 the error from \fBread()\fR or \fBwrite()\fR. This will not work in multi-threaded
jpayne@68	1458 programs, though, as the fd could already be closed and reused for another
jpayne@68	1459 thing, so beware.
jpayne@68	1460 .SS "\s-1GENERIC WATCHER FUNCTIONS\s0"
jpayne@68	1461 .IX Subsection "GENERIC WATCHER FUNCTIONS"
jpayne@68	1462 .ie n .IP """ev_init"" (ev_TYPE *watcher, callback)" 4
jpayne@68	1463 .el .IP "\f(CWev_init\fR (ev_TYPE *watcher, callback)" 4
jpayne@68	1464 .IX Item "ev_init (ev_TYPE *watcher, callback)"
jpayne@68	1465 This macro initialises the generic portion of a watcher. The contents
jpayne@68	1466 of the watcher object can be arbitrary (so \f(CW\(C`malloc\(C'\fR will do). Only
jpayne@68	1467 the generic parts of the watcher are initialised, you \fIneed\fR to call
jpayne@68	1468 the type-specific \f(CW\(C`ev_TYPE_set\(C'\fR macro afterwards to initialise the
jpayne@68	1469 type-specific parts. For each type there is also a \f(CW\(C`ev_TYPE_init\(C'\fR macro
jpayne@68	1470 which rolls both calls into one.
jpayne@68	1471 .Sp
jpayne@68	1472 You can reinitialise a watcher at any time as long as it has been stopped
jpayne@68	1473 (or never started) and there are no pending events outstanding.
jpayne@68	1474 .Sp
jpayne@68	1475 The callback is always of type \f(CW\(C`void ()(struct ev_loop loop, ev_TYPE watcher,
jpayne@68	1476 int revents)\*(C'\fR.
jpayne@68	1477 .Sp
jpayne@68	1478 Example: Initialise an \f(CW\(C`ev_io\(C'\fR watcher in two steps.
jpayne@68	1479 .Sp
jpayne@68	1480 .Vb 3
jpayne@68	1481 \& ev_io w;
jpayne@68	1482 \& ev_init (&w, my_cb);
jpayne@68	1483 \& ev_io_set (&w, STDIN_FILENO, EV_READ);
jpayne@68	1484 .Ve
jpayne@68	1485 .ie n .IP """ev_TYPE_set"" (ev_TYPE *watcher, [args])" 4
jpayne@68	1486 .el .IP "\f(CWev_TYPE_set\fR (ev_TYPE *watcher, [args])" 4
jpayne@68	1487 .IX Item "ev_TYPE_set (ev_TYPE *watcher, [args])"
jpayne@68	1488 This macro initialises the type-specific parts of a watcher. You need to
jpayne@68	1489 call \f(CW\(C`ev_init\(C'\fR at least once before you call this macro, but you can
jpayne@68	1490 call \f(CW\(C`ev_TYPE_set\(C'\fR any number of times. You must not, however, call this
jpayne@68	1491 macro on a watcher that is active (it can be pending, however, which is a
jpayne@68	1492 difference to the \f(CW\(C`ev_init\(C'\fR macro).
jpayne@68	1493 .Sp
jpayne@68	1494 Although some watcher types do not have type-specific arguments
jpayne@68	1495 (e.g. \f(CW\(C`ev_prepare\(C'\fR) you still need to call its \f(CW\(C`set\(C'\fR macro.
jpayne@68	1496 .Sp
jpayne@68	1497 See \f(CW\(C`ev_init\(C'\fR, above, for an example.
jpayne@68	1498 .ie n .IP """ev_TYPE_init"" (ev_TYPE *watcher, callback, [args])" 4
jpayne@68	1499 .el .IP "\f(CWev_TYPE_init\fR (ev_TYPE *watcher, callback, [args])" 4
jpayne@68	1500 .IX Item "ev_TYPE_init (ev_TYPE *watcher, callback, [args])"
jpayne@68	1501 This convenience macro rolls both \f(CW\(C`ev_init\(C'\fR and \f(CW\(C`ev_TYPE_set\(C'\fR macro
jpayne@68	1502 calls into a single call. This is the most convenient method to initialise
jpayne@68	1503 a watcher. The same limitations apply, of course.
jpayne@68	1504 .Sp
jpayne@68	1505 Example: Initialise and set an \f(CW\(C`ev_io\(C'\fR watcher in one step.
jpayne@68	1506 .Sp
jpayne@68	1507 .Vb 1
jpayne@68	1508 \& ev_io_init (&w, my_cb, STDIN_FILENO, EV_READ);
jpayne@68	1509 .Ve
jpayne@68	1510 .ie n .IP """ev_TYPE_start"" (loop, ev_TYPE *watcher)" 4
jpayne@68	1511 .el .IP "\f(CWev_TYPE_start\fR (loop, ev_TYPE *watcher)" 4
jpayne@68	1512 .IX Item "ev_TYPE_start (loop, ev_TYPE *watcher)"
jpayne@68	1513 Starts (activates) the given watcher. Only active watchers will receive
jpayne@68	1514 events. If the watcher is already active nothing will happen.
jpayne@68	1515 .Sp
jpayne@68	1516 Example: Start the \f(CW\(C`ev_io\(C'\fR watcher that is being abused as example in this
jpayne@68	1517 whole section.
jpayne@68	1518 .Sp
jpayne@68	1519 .Vb 1
jpayne@68	1520 \& ev_io_start (EV_DEFAULT_UC, &w);
jpayne@68	1521 .Ve
jpayne@68	1522 .ie n .IP """ev_TYPE_stop"" (loop, ev_TYPE *watcher)" 4
jpayne@68	1523 .el .IP "\f(CWev_TYPE_stop\fR (loop, ev_TYPE *watcher)" 4
jpayne@68	1524 .IX Item "ev_TYPE_stop (loop, ev_TYPE *watcher)"
jpayne@68	1525 Stops the given watcher if active, and clears the pending status (whether
jpayne@68	1526 the watcher was active or not).
jpayne@68	1527 .Sp
jpayne@68	1528 It is possible that stopped watchers are pending \- for example,
jpayne@68	1529 non-repeating timers are being stopped when they become pending \- but
jpayne@68	1530 calling \f(CW\(C`ev_TYPE_stop\(C'\fR ensures that the watcher is neither active nor
jpayne@68	1531 pending. If you want to free or reuse the memory used by the watcher it is
jpayne@68	1532 therefore a good idea to always call its \f(CW\(C`ev_TYPE_stop\(C'\fR function.
jpayne@68	1533 .IP "bool ev_is_active (ev_TYPE *watcher)" 4
jpayne@68	1534 .IX Item "bool ev_is_active (ev_TYPE *watcher)"
jpayne@68	1535 Returns a true value iff the watcher is active (i.e. it has been started
jpayne@68	1536 and not yet been stopped). As long as a watcher is active you must not modify
jpayne@68	1537 it.
jpayne@68	1538 .IP "bool ev_is_pending (ev_TYPE *watcher)" 4
jpayne@68	1539 .IX Item "bool ev_is_pending (ev_TYPE *watcher)"
jpayne@68	1540 Returns a true value iff the watcher is pending, (i.e. it has outstanding
jpayne@68	1541 events but its callback has not yet been invoked). As long as a watcher
jpayne@68	1542 is pending (but not active) you must not call an init function on it (but
jpayne@68	1543 \&\f(CW\(C`ev_TYPE_set\(C'\fR is safe), you must not change its priority, and you must
jpayne@68	1544 make sure the watcher is available to libev (e.g. you cannot \f(CW\(C`free ()\(C'\fR
jpayne@68	1545 it).
jpayne@68	1546 .IP "callback ev_cb (ev_TYPE *watcher)" 4
jpayne@68	1547 .IX Item "callback ev_cb (ev_TYPE *watcher)"
jpayne@68	1548 Returns the callback currently set on the watcher.
jpayne@68	1549 .IP "ev_set_cb (ev_TYPE *watcher, callback)" 4
jpayne@68	1550 .IX Item "ev_set_cb (ev_TYPE *watcher, callback)"
jpayne@68	1551 Change the callback. You can change the callback at virtually any time
jpayne@68	1552 (modulo threads).
jpayne@68	1553 .IP "ev_set_priority (ev_TYPE *watcher, int priority)" 4
jpayne@68	1554 .IX Item "ev_set_priority (ev_TYPE *watcher, int priority)"
jpayne@68	1555 .PD 0
jpayne@68	1556 .IP "int ev_priority (ev_TYPE *watcher)" 4
jpayne@68	1557 .IX Item "int ev_priority (ev_TYPE *watcher)"
jpayne@68	1558 .PD
jpayne@68	1559 Set and query the priority of the watcher. The priority is a small
jpayne@68	1560 integer between \f(CW\(C`EV_MAXPRI\(C'\fR (default: \f(CW2\fR) and \f(CW\(C`EV_MINPRI\(C'\fR
jpayne@68	1561 (default: \f(CW\(C`\-2\(C'\fR). Pending watchers with higher priority will be invoked
jpayne@68	1562 before watchers with lower priority, but priority will not keep watchers
jpayne@68	1563 from being executed (except for \f(CW\(C`ev_idle\(C'\fR watchers).
jpayne@68	1564 .Sp
jpayne@68	1565 If you need to suppress invocation when higher priority events are pending
jpayne@68	1566 you need to look at \f(CW\(C`ev_idle\(C'\fR watchers, which provide this functionality.
jpayne@68	1567 .Sp
jpayne@68	1568 You \fImust not\fR change the priority of a watcher as long as it is active or
jpayne@68	1569 pending.
jpayne@68	1570 .Sp
jpayne@68	1571 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	1572 fine, as long as you do not mind that the priority value you query might
jpayne@68	1573 or might not have been clamped to the valid range.
jpayne@68	1574 .Sp
jpayne@68	1575 The default priority used by watchers when no priority has been set is
jpayne@68	1576 always \f(CW0\fR, which is supposed to not be too high and not be too low :).
jpayne@68	1577 .Sp
jpayne@68	1578 See \(L"\s-1WATCHER PRIORITY MODELS\(R"\s0, below, for a more thorough treatment of
jpayne@68	1579 priorities.
jpayne@68	1580 .IP "ev_invoke (loop, ev_TYPE *watcher, int revents)" 4
jpayne@68	1581 .IX Item "ev_invoke (loop, ev_TYPE *watcher, int revents)"
jpayne@68	1582 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	1583 \&\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	1584 can deal with that fact, as both are simply passed through to the
jpayne@68	1585 callback.
jpayne@68	1586 .IP "int ev_clear_pending (loop, ev_TYPE *watcher)" 4
jpayne@68	1587 .IX Item "int ev_clear_pending (loop, ev_TYPE *watcher)"
jpayne@68	1588 If the watcher is pending, this function clears its pending status and
jpayne@68	1589 returns its \f(CW\(C`revents\(C'\fR bitset (as if its callback was invoked). If the
jpayne@68	1590 watcher isn't pending it does nothing and returns \f(CW0\fR.
jpayne@68	1591 .Sp
jpayne@68	1592 Sometimes it can be useful to \(L"poll\(R" a watcher instead of waiting for its
jpayne@68	1593 callback to be invoked, which can be accomplished with this function.
jpayne@68	1594 .IP "ev_feed_event (loop, ev_TYPE *watcher, int revents)" 4
jpayne@68	1595 .IX Item "ev_feed_event (loop, ev_TYPE *watcher, int revents)"
jpayne@68	1596 Feeds the given event set into the event loop, as if the specified event
jpayne@68	1597 had happened for the specified watcher (which must be a pointer to an
jpayne@68	1598 initialised but not necessarily started event watcher). Obviously you must
jpayne@68	1599 not free the watcher as long as it has pending events.
jpayne@68	1600 .Sp
jpayne@68	1601 Stopping the watcher, letting libev invoke it, or calling
jpayne@68	1602 \&\f(CW\(C`ev_clear_pending\(C'\fR will clear the pending event, even if the watcher was
jpayne@68	1603 not started in the first place.
jpayne@68	1604 .Sp
jpayne@68	1605 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	1606 functions that do not need a watcher.
jpayne@68	1607 .PP
jpayne@68	1608 See also the \(L"\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\(R"\s0 and \*(L"\s-1BUILDING YOUR
jpayne@68	1609 OWN COMPOSITE WATCHERS\*(R"\s0 idioms.
jpayne@68	1610 .SS "\s-1WATCHER STATES\s0"
jpayne@68	1611 .IX Subsection "WATCHER STATES"
jpayne@68	1612 There are various watcher states mentioned throughout this manual \-
jpayne@68	1613 active, pending and so on. In this section these states and the rules to
jpayne@68	1614 transition between them will be described in more detail \- and while these
jpayne@68	1615 rules might look complicated, they usually do \(L"the right thing\(R".
jpayne@68	1616 .IP "initialised" 4
jpayne@68	1617 .IX Item "initialised"
jpayne@68	1618 Before a watcher can be registered with the event loop it has to be
jpayne@68	1619 initialised. This can be done with a call to \f(CW\(C`ev_TYPE_init\(C'\fR, or calls to
jpayne@68	1620 \&\f(CW\(C`ev_init\(C'\fR followed by the watcher-specific \f(CW\(C`ev_TYPE_set\(C'\fR function.
jpayne@68	1621 .Sp
jpayne@68	1622 In this state it is simply some block of memory that is suitable for
jpayne@68	1623 use in an event loop. It can be moved around, freed, reused etc. at
jpayne@68	1624 will \- as long as you either keep the memory contents intact, or call
jpayne@68	1625 \&\f(CW\(C`ev_TYPE_init\(C'\fR again.
jpayne@68	1626 .IP "started/running/active" 4
jpayne@68	1627 .IX Item "started/running/active"
jpayne@68	1628 Once a watcher has been started with a call to \f(CW\(C`ev_TYPE_start\(C'\fR it becomes
jpayne@68	1629 property of the event loop, and is actively waiting for events. While in
jpayne@68	1630 this state it cannot be accessed (except in a few documented ways), moved,
jpayne@68	1631 freed or anything else \- the only legal thing is to keep a pointer to it,
jpayne@68	1632 and call libev functions on it that are documented to work on active watchers.
jpayne@68	1633 .IP "pending" 4
jpayne@68	1634 .IX Item "pending"
jpayne@68	1635 If a watcher is active and libev determines that an event it is interested
jpayne@68	1636 in has occurred (such as a timer expiring), it will become pending. It will
jpayne@68	1637 stay in this pending state until either it is stopped or its callback is
jpayne@68	1638 about to be invoked, so it is not normally pending inside the watcher
jpayne@68	1639 callback.
jpayne@68	1640 .Sp
jpayne@68	1641 The watcher might or might not be active while it is pending (for example,
jpayne@68	1642 an expired non-repeating timer can be pending but no longer active). If it
jpayne@68	1643 is stopped, it can be freely accessed (e.g. by calling \f(CW\(C`ev_TYPE_set\(C'\fR),
jpayne@68	1644 but it is still property of the event loop at this time, so cannot be
jpayne@68	1645 moved, freed or reused. And if it is active the rules described in the
jpayne@68	1646 previous item still apply.
jpayne@68	1647 .Sp
jpayne@68	1648 It is also possible to feed an event on a watcher that is not active (e.g.
jpayne@68	1649 via \f(CW\(C`ev_feed_event\(C'\fR), in which case it becomes pending without being
jpayne@68	1650 active.
jpayne@68	1651 .IP "stopped" 4
jpayne@68	1652 .IX Item "stopped"
jpayne@68	1653 A watcher can be stopped implicitly by libev (in which case it might still
jpayne@68	1654 be pending), or explicitly by calling its \f(CW\(C`ev_TYPE_stop\(C'\fR function. The
jpayne@68	1655 latter will clear any pending state the watcher might be in, regardless
jpayne@68	1656 of whether it was active or not, so stopping a watcher explicitly before
jpayne@68	1657 freeing it is often a good idea.
jpayne@68	1658 .Sp
jpayne@68	1659 While stopped (and not pending) the watcher is essentially in the
jpayne@68	1660 initialised state, that is, it can be reused, moved, modified in any way
jpayne@68	1661 you wish (but when you trash the memory block, you need to \f(CW\(C`ev_TYPE_init\(C'\fR
jpayne@68	1662 it again).
jpayne@68	1663 .SS "\s-1WATCHER PRIORITY MODELS\s0"
jpayne@68	1664 .IX Subsection "WATCHER PRIORITY MODELS"
jpayne@68	1665 Many event loops support \fIwatcher priorities\fR, which are usually small
jpayne@68	1666 integers that influence the ordering of event callback invocation
jpayne@68	1667 between watchers in some way, all else being equal.
jpayne@68	1668 .PP
jpayne@68	1669 In libev, watcher priorities can be set using \f(CW\(C`ev_set_priority\(C'\fR. See its
jpayne@68	1670 description for the more technical details such as the actual priority
jpayne@68	1671 range.
jpayne@68	1672 .PP
jpayne@68	1673 There are two common ways how these these priorities are being interpreted
jpayne@68	1674 by event loops:
jpayne@68	1675 .PP
jpayne@68	1676 In the more common lock-out model, higher priorities \(L"lock out\(R" invocation
jpayne@68	1677 of lower priority watchers, which means as long as higher priority
jpayne@68	1678 watchers receive events, lower priority watchers are not being invoked.
jpayne@68	1679 .PP
jpayne@68	1680 The less common only-for-ordering model uses priorities solely to order
jpayne@68	1681 callback invocation within a single event loop iteration: Higher priority
jpayne@68	1682 watchers are invoked before lower priority ones, but they all get invoked
jpayne@68	1683 before polling for new events.
jpayne@68	1684 .PP
jpayne@68	1685 Libev uses the second (only-for-ordering) model for all its watchers
jpayne@68	1686 except for idle watchers (which use the lock-out model).
jpayne@68	1687 .PP
jpayne@68	1688 The rationale behind this is that implementing the lock-out model for
jpayne@68	1689 watchers is not well supported by most kernel interfaces, and most event
jpayne@68	1690 libraries will just poll for the same events again and again as long as
jpayne@68	1691 their callbacks have not been executed, which is very inefficient in the
jpayne@68	1692 common case of one high-priority watcher locking out a mass of lower
jpayne@68	1693 priority ones.
jpayne@68	1694 .PP
jpayne@68	1695 Static (ordering) priorities are most useful when you have two or more
jpayne@68	1696 watchers handling the same resource: a typical usage example is having an
jpayne@68	1697 \&\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	1698 timeouts. Under load, data might be received while the program handles
jpayne@68	1699 other jobs, but since timers normally get invoked first, the timeout
jpayne@68	1700 handler will be executed before checking for data. In that case, giving
jpayne@68	1701 the timer a lower priority than the I/O watcher ensures that I/O will be
jpayne@68	1702 handled first even under adverse conditions (which is usually, but not
jpayne@68	1703 always, what you want).
jpayne@68	1704 .PP
jpayne@68	1705 Since idle watchers use the \(L"lock-out\(R" model, meaning that idle watchers
jpayne@68	1706 will only be executed when no same or higher priority watchers have
jpayne@68	1707 received events, they can be used to implement the \(L"lock-out\(R" model when
jpayne@68	1708 required.
jpayne@68	1709 .PP
jpayne@68	1710 For example, to emulate how many other event libraries handle priorities,
jpayne@68	1711 you can associate an \f(CW\(C`ev_idle\(C'\fR watcher to each such watcher, and in
jpayne@68	1712 the normal watcher callback, you just start the idle watcher. The real
jpayne@68	1713 processing is done in the idle watcher callback. This causes libev to
jpayne@68	1714 continuously poll and process kernel event data for the watcher, but when
jpayne@68	1715 the lock-out case is known to be rare (which in turn is rare :), this is
jpayne@68	1716 workable.
jpayne@68	1717 .PP
jpayne@68	1718 Usually, however, the lock-out model implemented that way will perform
jpayne@68	1719 miserably under the type of load it was designed to handle. In that case,
jpayne@68	1720 it might be preferable to stop the real watcher before starting the
jpayne@68	1721 idle watcher, so the kernel will not have to process the event in case
jpayne@68	1722 the actual processing will be delayed for considerable time.
jpayne@68	1723 .PP
jpayne@68	1724 Here is an example of an I/O watcher that should run at a strictly lower
jpayne@68	1725 priority than the default, and which should only process data when no
jpayne@68	1726 other events are pending:
jpayne@68	1727 .PP
jpayne@68	1728 .Vb 2
jpayne@68	1729 \& ev_idle idle; // actual processing watcher
jpayne@68	1730 \& ev_io io; // actual event watcher
jpayne@68	1731 \&
jpayne@68	1732 \& static void
jpayne@68	1733 \& io_cb (EV_P_ ev_io *w, int revents)
jpayne@68	1734 \& {
jpayne@68	1735 \& // stop the I/O watcher, we received the event, but
jpayne@68	1736 \& // are not yet ready to handle it.
jpayne@68	1737 \& ev_io_stop (EV_A_ w);
jpayne@68	1738 \&
jpayne@68	1739 \& // start the idle watcher to handle the actual event.
jpayne@68	1740 \& // it will not be executed as long as other watchers
jpayne@68	1741 \& // with the default priority are receiving events.
jpayne@68	1742 \& ev_idle_start (EV_A_ &idle);
jpayne@68	1743 \& }
jpayne@68	1744 \&
jpayne@68	1745 \& static void
jpayne@68	1746 \& idle_cb (EV_P_ ev_idle *w, int revents)
jpayne@68	1747 \& {
jpayne@68	1748 \& // actual processing
jpayne@68	1749 \& read (STDIN_FILENO, ...);
jpayne@68	1750 \&
jpayne@68	1751 \& // have to start the I/O watcher again, as
jpayne@68	1752 \& // we have handled the event
jpayne@68	1753 \& ev_io_start (EV_P_ &io);
jpayne@68	1754 \& }
jpayne@68	1755 \&
jpayne@68	1756 \& // initialisation
jpayne@68	1757 \& ev_idle_init (&idle, idle_cb);
jpayne@68	1758 \& ev_io_init (&io, io_cb, STDIN_FILENO, EV_READ);
jpayne@68	1759 \& ev_io_start (EV_DEFAULT_ &io);
jpayne@68	1760 .Ve
jpayne@68	1761 .PP
jpayne@68	1762 In the \(L"real\(R" world, it might also be beneficial to start a timer, so that
jpayne@68	1763 low-priority connections can not be locked out forever under load. This
jpayne@68	1764 enables your program to keep a lower latency for important connections
jpayne@68	1765 during short periods of high load, while not completely locking out less
jpayne@68	1766 important ones.
jpayne@68	1767 .SH "WATCHER TYPES"
jpayne@68	1768 .IX Header "WATCHER TYPES"
jpayne@68	1769 This section describes each watcher in detail, but will not repeat
jpayne@68	1770 information given in the last section. Any initialisation/set macros,
jpayne@68	1771 functions and members specific to the watcher type are explained.
jpayne@68	1772 .PP
jpayne@68	1773 Most members are additionally marked with either \fI[read\-only]\fR, meaning
jpayne@68	1774 that, while the watcher is active, you can look at the member and expect
jpayne@68	1775 some sensible content, but you must not modify it (you can modify it while
jpayne@68	1776 the watcher is stopped to your hearts content), or \fI[read\-write]\fR, which
jpayne@68	1777 means you can expect it to have some sensible content while the watcher is
jpayne@68	1778 active, but you can also modify it (within the same thread as the event
jpayne@68	1779 loop, i.e. without creating data races). Modifying it may not do something
jpayne@68	1780 sensible or take immediate effect (or do anything at all), but libev will
jpayne@68	1781 not crash or malfunction in any way.
jpayne@68	1782 .PP
jpayne@68	1783 In any case, the documentation for each member will explain what the
jpayne@68	1784 effects are, and if there are any additional access restrictions.
jpayne@68	1785 .ie n .SS """ev_io"" \- is this file descriptor readable or writable?"
jpayne@68	1786 .el .SS "\f(CWev_io\fP \- is this file descriptor readable or writable?"
jpayne@68	1787 .IX Subsection "ev_io - is this file descriptor readable or writable?"
jpayne@68	1788 I/O watchers check whether a file descriptor is readable or writable
jpayne@68	1789 in each iteration of the event loop, or, more precisely, when reading
jpayne@68	1790 would not block the process and writing would at least be able to write
jpayne@68	1791 some data. This behaviour is called level-triggering because you keep
jpayne@68	1792 receiving events as long as the condition persists. Remember you can stop
jpayne@68	1793 the watcher if you don't want to act on the event and neither want to
jpayne@68	1794 receive future events.
jpayne@68	1795 .PP
jpayne@68	1796 In general you can register as many read and/or write event watchers per
jpayne@68	1797 fd as you want (as long as you don't confuse yourself). Setting all file
jpayne@68	1798 descriptors to non-blocking mode is also usually a good idea (but not
jpayne@68	1799 required if you know what you are doing).
jpayne@68	1800 .PP
jpayne@68	1801 Another thing you have to watch out for is that it is quite easy to
jpayne@68	1802 receive \(L"spurious\(R" readiness notifications, that is, your callback might
jpayne@68	1803 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	1804 because there is no data. It is very easy to get into this situation even
jpayne@68	1805 with a relatively standard program structure. Thus it is best to always
jpayne@68	1806 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	1807 preferable to a program hanging until some data arrives.
jpayne@68	1808 .PP
jpayne@68	1809 If you cannot run the fd in non-blocking mode (for example you should
jpayne@68	1810 not play around with an Xlib connection), then you have to separately
jpayne@68	1811 re-test whether a file descriptor is really ready with a known-to-be good
jpayne@68	1812 interface such as poll (fortunately in the case of Xlib, it already does
jpayne@68	1813 this on its own, so its quite safe to use). Some people additionally
jpayne@68	1814 use \f(CW\(C`SIGALRM\(C'\fR and an interval timer, just to be sure you won't block
jpayne@68	1815 indefinitely.
jpayne@68	1816 .PP
jpayne@68	1817 But really, best use non-blocking mode.
jpayne@68	1818 .PP
jpayne@68	1819 \fIThe special problem of disappearing file descriptors\fR
jpayne@68	1820 .IX Subsection "The special problem of disappearing file descriptors"
jpayne@68	1821 .PP
jpayne@68	1822 Some backends (e.g. kqueue, epoll, linuxaio) need to be told about closing
jpayne@68	1823 a file descriptor (either due to calling \f(CW\(C`close\(C'\fR explicitly or any other
jpayne@68	1824 means, such as \f(CW\(C`dup2\(C'\fR). The reason is that you register interest in some
jpayne@68	1825 file descriptor, but when it goes away, the operating system will silently
jpayne@68	1826 drop this interest. If another file descriptor with the same number then
jpayne@68	1827 is registered with libev, there is no efficient way to see that this is,
jpayne@68	1828 in fact, a different file descriptor.
jpayne@68	1829 .PP
jpayne@68	1830 To avoid having to explicitly tell libev about such cases, libev follows
jpayne@68	1831 the following policy: Each time \f(CW\(C`ev_io_set\(C'\fR is being called, libev
jpayne@68	1832 will assume that this is potentially a new file descriptor, otherwise
jpayne@68	1833 it is assumed that the file descriptor stays the same. That means that
jpayne@68	1834 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	1835 descriptor even if the file descriptor number itself did not change.
jpayne@68	1836 .PP
jpayne@68	1837 This is how one would do it normally anyway, the important point is that
jpayne@68	1838 the libev application should not optimise around libev but should leave
jpayne@68	1839 optimisations to libev.
jpayne@68	1840 .PP
jpayne@68	1841 \fIThe special problem of dup'ed file descriptors\fR
jpayne@68	1842 .IX Subsection "The special problem of dup'ed file descriptors"
jpayne@68	1843 .PP
jpayne@68	1844 Some backends (e.g. epoll), cannot register events for file descriptors,
jpayne@68	1845 but only events for the underlying file descriptions. That means when you
jpayne@68	1846 have \f(CW\(C`dup ()\(C'\fR'ed file descriptors or weirder constellations, and register
jpayne@68	1847 events for them, only one file descriptor might actually receive events.
jpayne@68	1848 .PP
jpayne@68	1849 There is no workaround possible except not registering events
jpayne@68	1850 for potentially \f(CW\(C`dup ()\(C'\fR'ed file descriptors, or to resort to
jpayne@68	1851 \&\f(CW\(C`EVBACKEND_SELECT\(C'\fR or \f(CW\(C`EVBACKEND_POLL\(C'\fR.
jpayne@68	1852 .PP
jpayne@68	1853 \fIThe special problem of files\fR
jpayne@68	1854 .IX Subsection "The special problem of files"
jpayne@68	1855 .PP
jpayne@68	1856 Many people try to use \f(CW\(C`select\(C'\fR (or libev) on file descriptors
jpayne@68	1857 representing files, and expect it to become ready when their program
jpayne@68	1858 doesn't block on disk accesses (which can take a long time on their own).
jpayne@68	1859 .PP
jpayne@68	1860 However, this cannot ever work in the \(L"expected\(R" way \- you get a readiness
jpayne@68	1861 notification as soon as the kernel knows whether and how much data is
jpayne@68	1862 there, and in the case of open files, that's always the case, so you
jpayne@68	1863 always get a readiness notification instantly, and your read (or possibly
jpayne@68	1864 write) will still block on the disk I/O.
jpayne@68	1865 .PP
jpayne@68	1866 Another way to view it is that in the case of sockets, pipes, character
jpayne@68	1867 devices and so on, there is another party (the sender) that delivers data
jpayne@68	1868 on its own, but in the case of files, there is no such thing: the disk
jpayne@68	1869 will not send data on its own, simply because it doesn't know what you
jpayne@68	1870 wish to read \- you would first have to request some data.
jpayne@68	1871 .PP
jpayne@68	1872 Since files are typically not-so-well supported by advanced notification
jpayne@68	1873 mechanism, libev tries hard to emulate \s-1POSIX\s0 behaviour with respect
jpayne@68	1874 to files, even though you should not use it. The reason for this is
jpayne@68	1875 convenience: sometimes you want to watch \s-1STDIN\s0 or \s-1STDOUT,\s0 which is
jpayne@68	1876 usually a tty, often a pipe, but also sometimes files or special devices
jpayne@68	1877 (for example, \f(CW\(C`epoll\(C'\fR on Linux works with \fI/dev/random\fR but not with
jpayne@68	1878 \&\fI/dev/urandom\fR), and even though the file might better be served with
jpayne@68	1879 asynchronous I/O instead of with non-blocking I/O, it is still useful when
jpayne@68	1880 it \(L"just works\(R" instead of freezing.
jpayne@68	1881 .PP
jpayne@68	1882 So avoid file descriptors pointing to files when you know it (e.g. use
jpayne@68	1883 libeio), but use them when it is convenient, e.g. for \s-1STDIN/STDOUT,\s0 or
jpayne@68	1884 when you rarely read from a file instead of from a socket, and want to
jpayne@68	1885 reuse the same code path.
jpayne@68	1886 .PP
jpayne@68	1887 \fIThe special problem of fork\fR
jpayne@68	1888 .IX Subsection "The special problem of fork"
jpayne@68	1889 .PP
jpayne@68	1890 Some backends (epoll, kqueue, linuxaio, iouring) do not support \f(CW\(C`fork ()\(C'\fR
jpayne@68	1891 at all or exhibit useless behaviour. Libev fully supports fork, but needs
jpayne@68	1892 to be told about it in the child if you want to continue to use it in the
jpayne@68	1893 child.
jpayne@68	1894 .PP
jpayne@68	1895 To support fork in your child processes, you have to call \f(CW\*(C`ev_loop_fork
jpayne@68	1896 ()\(C'\fR after a fork in the child, enable \f(CW\(C`EVFLAG_FORKCHECK\*(C'\fR, or resort to
jpayne@68	1897 \&\f(CW\(C`EVBACKEND_SELECT\(C'\fR or \f(CW\(C`EVBACKEND_POLL\(C'\fR.
jpayne@68	1898 .PP
jpayne@68	1899 \fIThe special problem of \s-1SIGPIPE\s0\fR
jpayne@68	1900 .IX Subsection "The special problem of SIGPIPE"
jpayne@68	1901 .PP
jpayne@68	1902 While not really specific to libev, it is easy to forget about \f(CW\(C`SIGPIPE\(C'\fR:
jpayne@68	1903 when writing to a pipe whose other end has been closed, your program gets
jpayne@68	1904 sent a \s-1SIGPIPE,\s0 which, by default, aborts your program. For most programs
jpayne@68	1905 this is sensible behaviour, for daemons, this is usually undesirable.
jpayne@68	1906 .PP
jpayne@68	1907 So when you encounter spurious, unexplained daemon exits, make sure you
jpayne@68	1908 ignore \s-1SIGPIPE\s0 (and maybe make sure you log the exit status of your daemon
jpayne@68	1909 somewhere, as that would have given you a big clue).
jpayne@68	1910 .PP
jpayne@68	1911 \fIThe special problem of \f(BIaccept()\fIing when you can't\fR
jpayne@68	1912 .IX Subsection "The special problem of accept()ing when you can't"
jpayne@68	1913 .PP
jpayne@68	1914 Many implementations of the \s-1POSIX\s0 \f(CW\(C`accept\(C'\fR function (for example,
jpayne@68	1915 found in post\-2004 Linux) have the peculiar behaviour of not removing a
jpayne@68	1916 connection from the pending queue in all error cases.
jpayne@68	1917 .PP
jpayne@68	1918 For example, larger servers often run out of file descriptors (because
jpayne@68	1919 of resource limits), causing \f(CW\(C`accept\(C'\fR to fail with \f(CW\(C`ENFILE\(C'\fR but not
jpayne@68	1920 rejecting the connection, leading to libev signalling readiness on
jpayne@68	1921 the next iteration again (the connection still exists after all), and
jpayne@68	1922 typically causing the program to loop at 100% \s-1CPU\s0 usage.
jpayne@68	1923 .PP
jpayne@68	1924 Unfortunately, the set of errors that cause this issue differs between
jpayne@68	1925 operating systems, there is usually little the app can do to remedy the
jpayne@68	1926 situation, and no known thread-safe method of removing the connection to
jpayne@68	1927 cope with overload is known (to me).
jpayne@68	1928 .PP
jpayne@68	1929 One of the easiest ways to handle this situation is to just ignore it
jpayne@68	1930 \&\- when the program encounters an overload, it will just loop until the
jpayne@68	1931 situation is over. While this is a form of busy waiting, no \s-1OS\s0 offers an
jpayne@68	1932 event-based way to handle this situation, so it's the best one can do.
jpayne@68	1933 .PP
jpayne@68	1934 A better way to handle the situation is to log any errors other than
jpayne@68	1935 \&\f(CW\(C`EAGAIN\(C'\fR and \f(CW\(C`EWOULDBLOCK\(C'\fR, making sure not to flood the log with such
jpayne@68	1936 messages, and continue as usual, which at least gives the user an idea of
jpayne@68	1937 what could be wrong (\(L"raise the ulimit!\(R"). For extra points one could stop
jpayne@68	1938 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	1939 usage.
jpayne@68	1940 .PP
jpayne@68	1941 If your program is single-threaded, then you could also keep a dummy file
jpayne@68	1942 descriptor for overload situations (e.g. by opening \fI/dev/null\fR), and
jpayne@68	1943 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	1944 close that fd, and create a new dummy fd. This will gracefully refuse
jpayne@68	1945 clients under typical overload conditions.
jpayne@68	1946 .PP
jpayne@68	1947 The last way to handle it is to simply log the error and \f(CW\(C`exit\(C'\fR, as
jpayne@68	1948 is often done with \f(CW\(C`malloc\(C'\fR failures, but this results in an easy
jpayne@68	1949 opportunity for a DoS attack.
jpayne@68	1950 .PP
jpayne@68	1951 \fIWatcher-Specific Functions\fR
jpayne@68	1952 .IX Subsection "Watcher-Specific Functions"
jpayne@68	1953 .IP "ev_io_init (ev_io *, callback, int fd, int events)" 4
jpayne@68	1954 .IX Item "ev_io_init (ev_io *, callback, int fd, int events)"
jpayne@68	1955 .PD 0
jpayne@68	1956 .IP "ev_io_set (ev_io *, int fd, int events)" 4
jpayne@68	1957 .IX Item "ev_io_set (ev_io *, int fd, int events)"
jpayne@68	1958 .PD
jpayne@68	1959 Configures an \f(CW\(C`ev_io\(C'\fR watcher. The \f(CW\(C`fd\(C'\fR is the file descriptor to
jpayne@68	1960 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	1961 \&\f(CW\(C`EV_READ \| EV_WRITE\(C'\fR or \f(CW0\fR, to express the desire to receive the given
jpayne@68	1962 events.
jpayne@68	1963 .Sp
jpayne@68	1964 Note that setting the \f(CW\(C`events\(C'\fR to \f(CW0\fR and starting the watcher is
jpayne@68	1965 supported, but not specially optimized \- if your program sometimes happens
jpayne@68	1966 to generate this combination this is fine, but if it is easy to avoid
jpayne@68	1967 starting an io watcher watching for no events you should do so.
jpayne@68	1968 .IP "ev_io_modify (ev_io *, int events)" 4
jpayne@68	1969 .IX Item "ev_io_modify (ev_io *, int events)"
jpayne@68	1970 Similar to \f(CW\(C`ev_io_set\(C'\fR, but only changes the requested events. Using this
jpayne@68	1971 might be faster with some backends, as libev can assume that the \f(CW\(C`fd\(C'\fR
jpayne@68	1972 still refers to the same underlying file description, something it cannot
jpayne@68	1973 do when using \f(CW\(C`ev_io_set\(C'\fR.
jpayne@68	1974 .IP "int fd [no\-modify]" 4
jpayne@68	1975 .IX Item "int fd [no-modify]"
jpayne@68	1976 The file descriptor being watched. While it can be read at any time, you
jpayne@68	1977 must not modify this member even when the watcher is stopped \- always use
jpayne@68	1978 \&\f(CW\(C`ev_io_set\(C'\fR for that.
jpayne@68	1979 .IP "int events [no\-modify]" 4
jpayne@68	1980 .IX Item "int events [no-modify]"
jpayne@68	1981 The set of events the fd is being watched for, among other flags. Remember
jpayne@68	1982 that this is a bit set \- to test for \f(CW\(C`EV_READ\(C'\fR, use \f(CW\*(C`w\->events &
jpayne@68	1983 EV_READ\(C'\fR, and similarly for \f(CW\(C`EV_WRITE\*(C'\fR.
jpayne@68	1984 .Sp
jpayne@68	1985 As with \f(CW\(C`fd\(C'\fR, you must not modify this member even when the watcher is
jpayne@68	1986 stopped, always use \f(CW\(C`ev_io_set\(C'\fR or \f(CW\(C`ev_io_modify\(C'\fR for that.
jpayne@68	1987 .PP
jpayne@68	1988 \fIExamples\fR
jpayne@68	1989 .IX Subsection "Examples"
jpayne@68	1990 .PP
jpayne@68	1991 Example: Call \f(CW\(C`stdin_readable_cb\(C'\fR when \s-1STDIN_FILENO\s0 has become, well
jpayne@68	1992 readable, but only once. Since it is likely line-buffered, you could
jpayne@68	1993 attempt to read a whole line in the callback.
jpayne@68	1994 .PP
jpayne@68	1995 .Vb 6
jpayne@68	1996 \& static void
jpayne@68	1997 \& stdin_readable_cb (struct ev_loop loop, ev_io w, int revents)
jpayne@68	1998 \& {
jpayne@68	1999 \& ev_io_stop (loop, w);
jpayne@68	2000 \& .. read from stdin here (or from w\->fd) and handle any I/O errors
jpayne@68	2001 \& }
jpayne@68	2002 \&
jpayne@68	2003 \& ...
jpayne@68	2004 \& struct ev_loop *loop = ev_default_init (0);
jpayne@68	2005 \& ev_io stdin_readable;
jpayne@68	2006 \& ev_io_init (&stdin_readable, stdin_readable_cb, STDIN_FILENO, EV_READ);
jpayne@68	2007 \& ev_io_start (loop, &stdin_readable);
jpayne@68	2008 \& ev_run (loop, 0);
jpayne@68	2009 .Ve
jpayne@68	2010 .ie n .SS """ev_timer"" \- relative and optionally repeating timeouts"
jpayne@68	2011 .el .SS "\f(CWev_timer\fP \- relative and optionally repeating timeouts"
jpayne@68	2012 .IX Subsection "ev_timer - relative and optionally repeating timeouts"
jpayne@68	2013 Timer watchers are simple relative timers that generate an event after a
jpayne@68	2014 given time, and optionally repeating in regular intervals after that.
jpayne@68	2015 .PP
jpayne@68	2016 The timers are based on real time, that is, if you register an event that
jpayne@68	2017 times out after an hour and you reset your system clock to January last
jpayne@68	2018 year, it will still time out after (roughly) one hour. \(L"Roughly\(R" because
jpayne@68	2019 detecting time jumps is hard, and some inaccuracies are unavoidable (the
jpayne@68	2020 monotonic clock option helps a lot here).
jpayne@68	2021 .PP
jpayne@68	2022 The callback is guaranteed to be invoked only \fIafter\fR its timeout has
jpayne@68	2023 passed (not \fIat\fR, so on systems with very low-resolution clocks this
jpayne@68	2024 might introduce a small delay, see \*(L"the special problem of being too
jpayne@68	2025 early\*(R", below). If multiple timers become ready during the same loop
jpayne@68	2026 iteration then the ones with earlier time-out values are invoked before
jpayne@68	2027 ones of the same priority with later time-out values (but this is no
jpayne@68	2028 longer true when a callback calls \f(CW\(C`ev_run\(C'\fR recursively).
jpayne@68	2029 .PP
jpayne@68	2030 \fIBe smart about timeouts\fR
jpayne@68	2031 .IX Subsection "Be smart about timeouts"
jpayne@68	2032 .PP
jpayne@68	2033 Many real-world problems involve some kind of timeout, usually for error
jpayne@68	2034 recovery. A typical example is an \s-1HTTP\s0 request \- if the other side hangs,
jpayne@68	2035 you want to raise some error after a while.
jpayne@68	2036 .PP
jpayne@68	2037 What follows are some ways to handle this problem, from obvious and
jpayne@68	2038 inefficient to smart and efficient.
jpayne@68	2039 .PP
jpayne@68	2040 In the following, a 60 second activity timeout is assumed \- a timeout that
jpayne@68	2041 gets reset to 60 seconds each time there is activity (e.g. each time some
jpayne@68	2042 data or other life sign was received).
jpayne@68	2043 .IP "1. Use a timer and stop, reinitialise and start it on activity." 4
jpayne@68	2044 .IX Item "1. Use a timer and stop, reinitialise and start it on activity."
jpayne@68	2045 This is the most obvious, but not the most simple way: In the beginning,
jpayne@68	2046 start the watcher:
jpayne@68	2047 .Sp
jpayne@68	2048 .Vb 2
jpayne@68	2049 \& ev_timer_init (timer, callback, 60., 0.);
jpayne@68	2050 \& ev_timer_start (loop, timer);
jpayne@68	2051 .Ve
jpayne@68	2052 .Sp
jpayne@68	2053 Then, each time there is some activity, \f(CW\(C`ev_timer_stop\(C'\fR it, initialise it
jpayne@68	2054 and start it again:
jpayne@68	2055 .Sp
jpayne@68	2056 .Vb 3
jpayne@68	2057 \& ev_timer_stop (loop, timer);
jpayne@68	2058 \& ev_timer_set (timer, 60., 0.);
jpayne@68	2059 \& ev_timer_start (loop, timer);
jpayne@68	2060 .Ve
jpayne@68	2061 .Sp
jpayne@68	2062 This is relatively simple to implement, but means that each time there is
jpayne@68	2063 some activity, libev will first have to remove the timer from its internal
jpayne@68	2064 data structure and then add it again. Libev tries to be fast, but it's
jpayne@68	2065 still not a constant-time operation.
jpayne@68	2066 .ie n .IP "2. Use a timer and re-start it with ""ev_timer_again"" inactivity." 4
jpayne@68	2067 .el .IP "2. Use a timer and re-start it with \f(CWev_timer_again\fR inactivity." 4
jpayne@68	2068 .IX Item "2. Use a timer and re-start it with ev_timer_again inactivity."
jpayne@68	2069 This is the easiest way, and involves using \f(CW\(C`ev_timer_again\(C'\fR instead of
jpayne@68	2070 \&\f(CW\(C`ev_timer_start\(C'\fR.
jpayne@68	2071 .Sp
jpayne@68	2072 To implement this, configure an \f(CW\(C`ev_timer\(C'\fR with a \f(CW\(C`repeat\(C'\fR value
jpayne@68	2073 of \f(CW60\fR and then call \f(CW\(C`ev_timer_again\(C'\fR at start and each time you
jpayne@68	2074 successfully read or write some data. If you go into an idle state where
jpayne@68	2075 you do not expect data to travel on the socket, you can \f(CW\(C`ev_timer_stop\(C'\fR
jpayne@68	2076 the timer, and \f(CW\(C`ev_timer_again\(C'\fR will automatically restart it if need be.
jpayne@68	2077 .Sp
jpayne@68	2078 That means you can ignore both the \f(CW\(C`ev_timer_start\(C'\fR function and the
jpayne@68	2079 \&\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	2080 member and \f(CW\(C`ev_timer_again\(C'\fR.
jpayne@68	2081 .Sp
jpayne@68	2082 At start:
jpayne@68	2083 .Sp
jpayne@68	2084 .Vb 3
jpayne@68	2085 \& ev_init (timer, callback);
jpayne@68	2086 \& timer\->repeat = 60.;
jpayne@68	2087 \& ev_timer_again (loop, timer);
jpayne@68	2088 .Ve
jpayne@68	2089 .Sp
jpayne@68	2090 Each time there is some activity:
jpayne@68	2091 .Sp
jpayne@68	2092 .Vb 1
jpayne@68	2093 \& ev_timer_again (loop, timer);
jpayne@68	2094 .Ve
jpayne@68	2095 .Sp
jpayne@68	2096 It is even possible to change the time-out on the fly, regardless of
jpayne@68	2097 whether the watcher is active or not:
jpayne@68	2098 .Sp
jpayne@68	2099 .Vb 2
jpayne@68	2100 \& timer\->repeat = 30.;
jpayne@68	2101 \& ev_timer_again (loop, timer);
jpayne@68	2102 .Ve
jpayne@68	2103 .Sp
jpayne@68	2104 This is slightly more efficient then stopping/starting the timer each time
jpayne@68	2105 you want to modify its timeout value, as libev does not have to completely
jpayne@68	2106 remove and re-insert the timer from/into its internal data structure.
jpayne@68	2107 .Sp
jpayne@68	2108 It is, however, even simpler than the \(L"obvious\(R" way to do it.
jpayne@68	2109 .IP "3. Let the timer time out, but then re-arm it as required." 4
jpayne@68	2110 .IX Item "3. Let the timer time out, but then re-arm it as required."
jpayne@68	2111 This method is more tricky, but usually most efficient: Most timeouts are
jpayne@68	2112 relatively long compared to the intervals between other activity \- in
jpayne@68	2113 our example, within 60 seconds, there are usually many I/O events with
jpayne@68	2114 associated activity resets.
jpayne@68	2115 .Sp
jpayne@68	2116 In this case, it would be more efficient to leave the \f(CW\(C`ev_timer\(C'\fR alone,
jpayne@68	2117 but remember the time of last activity, and check for a real timeout only
jpayne@68	2118 within the callback:
jpayne@68	2119 .Sp
jpayne@68	2120 .Vb 3
jpayne@68	2121 \& ev_tstamp timeout = 60.;
jpayne@68	2122 \& ev_tstamp last_activity; // time of last activity
jpayne@68	2123 \& ev_timer timer;
jpayne@68	2124 \&
jpayne@68	2125 \& static void
jpayne@68	2126 \& callback (EV_P_ ev_timer *w, int revents)
jpayne@68	2127 \& {
jpayne@68	2128 \& // calculate when the timeout would happen
jpayne@68	2129 \& ev_tstamp after = last_activity \- ev_now (EV_A) + timeout;
jpayne@68	2130 \&
jpayne@68	2131 \& // if negative, it means we the timeout already occurred
jpayne@68	2132 \& if (after < 0.)
jpayne@68	2133 \& {
jpayne@68	2134 \& // timeout occurred, take action
jpayne@68	2135 \& }
jpayne@68	2136 \& else
jpayne@68	2137 \& {
jpayne@68	2138 \& // callback was invoked, but there was some recent
jpayne@68	2139 \& // activity. simply restart the timer to time out
jpayne@68	2140 \& // after "after" seconds, which is the earliest time
jpayne@68	2141 \& // the timeout can occur.
jpayne@68	2142 \& ev_timer_set (w, after, 0.);
jpayne@68	2143 \& ev_timer_start (EV_A_ w);
jpayne@68	2144 \& }
jpayne@68	2145 \& }
jpayne@68	2146 .Ve
jpayne@68	2147 .Sp
jpayne@68	2148 To summarise the callback: first calculate in how many seconds the
jpayne@68	2149 timeout will occur (by calculating the absolute time when it would occur,
jpayne@68	2150 \&\f(CW\(C`last_activity + timeout\(C'\fR, and subtracting the current time, \f(CW\*(C`ev_now
jpayne@68	2151 (EV_A)\*(C'\fR from that).
jpayne@68	2152 .Sp
jpayne@68	2153 If this value is negative, then we are already past the timeout, i.e. we
jpayne@68	2154 timed out, and need to do whatever is needed in this case.
jpayne@68	2155 .Sp
jpayne@68	2156 Otherwise, we now the earliest time at which the timeout would trigger,
jpayne@68	2157 and simply start the timer with this timeout value.
jpayne@68	2158 .Sp
jpayne@68	2159 In other words, each time the callback is invoked it will check whether
jpayne@68	2160 the timeout occurred. If not, it will simply reschedule itself to check
jpayne@68	2161 again at the earliest time it could time out. Rinse. Repeat.
jpayne@68	2162 .Sp
jpayne@68	2163 This scheme causes more callback invocations (about one every 60 seconds
jpayne@68	2164 minus half the average time between activity), but virtually no calls to
jpayne@68	2165 libev to change the timeout.
jpayne@68	2166 .Sp
jpayne@68	2167 To start the machinery, simply initialise the watcher and set
jpayne@68	2168 \&\f(CW\(C`last_activity\(C'\fR to the current time (meaning there was some activity just
jpayne@68	2169 now), then call the callback, which will \(L"do the right thing\(R" and start
jpayne@68	2170 the timer:
jpayne@68	2171 .Sp
jpayne@68	2172 .Vb 3
jpayne@68	2173 \& last_activity = ev_now (EV_A);
jpayne@68	2174 \& ev_init (&timer, callback);
jpayne@68	2175 \& callback (EV_A_ &timer, 0);
jpayne@68	2176 .Ve
jpayne@68	2177 .Sp
jpayne@68	2178 When there is some activity, simply store the current time in
jpayne@68	2179 \&\f(CW\(C`last_activity\(C'\fR, no libev calls at all:
jpayne@68	2180 .Sp
jpayne@68	2181 .Vb 2
jpayne@68	2182 \& if (activity detected)
jpayne@68	2183 \& last_activity = ev_now (EV_A);
jpayne@68	2184 .Ve
jpayne@68	2185 .Sp
jpayne@68	2186 When your timeout value changes, then the timeout can be changed by simply
jpayne@68	2187 providing a new value, stopping the timer and calling the callback, which
jpayne@68	2188 will again do the right thing (for example, time out immediately :).
jpayne@68	2189 .Sp
jpayne@68	2190 .Vb 3
jpayne@68	2191 \& timeout = new_value;
jpayne@68	2192 \& ev_timer_stop (EV_A_ &timer);
jpayne@68	2193 \& callback (EV_A_ &timer, 0);
jpayne@68	2194 .Ve
jpayne@68	2195 .Sp
jpayne@68	2196 This technique is slightly more complex, but in most cases where the
jpayne@68	2197 time-out is unlikely to be triggered, much more efficient.
jpayne@68	2198 .IP "4. Wee, just use a double-linked list for your timeouts." 4
jpayne@68	2199 .IX Item "4. Wee, just use a double-linked list for your timeouts."
jpayne@68	2200 If there is not one request, but many thousands (millions...), all
jpayne@68	2201 employing some kind of timeout with the same timeout value, then one can
jpayne@68	2202 do even better:
jpayne@68	2203 .Sp
jpayne@68	2204 When starting the timeout, calculate the timeout value and put the timeout
jpayne@68	2205 at the \fIend\fR of the list.
jpayne@68	2206 .Sp
jpayne@68	2207 Then use an \f(CW\(C`ev_timer\(C'\fR to fire when the timeout at the \fIbeginning\fR of
jpayne@68	2208 the list is expected to fire (for example, using the technique #3).
jpayne@68	2209 .Sp
jpayne@68	2210 When there is some activity, remove the timer from the list, recalculate
jpayne@68	2211 the timeout, append it to the end of the list again, and make sure to
jpayne@68	2212 update the \f(CW\(C`ev_timer\(C'\fR if it was taken from the beginning of the list.
jpayne@68	2213 .Sp
jpayne@68	2214 This way, one can manage an unlimited number of timeouts in O(1) time for
jpayne@68	2215 starting, stopping and updating the timers, at the expense of a major
jpayne@68	2216 complication, and having to use a constant timeout. The constant timeout
jpayne@68	2217 ensures that the list stays sorted.
jpayne@68	2218 .PP
jpayne@68	2219 So which method the best?
jpayne@68	2220 .PP
jpayne@68	2221 Method #2 is a simple no-brain-required solution that is adequate in most
jpayne@68	2222 situations. Method #3 requires a bit more thinking, but handles many cases
jpayne@68	2223 better, and isn't very complicated either. In most case, choosing either
jpayne@68	2224 one is fine, with #3 being better in typical situations.
jpayne@68	2225 .PP
jpayne@68	2226 Method #1 is almost always a bad idea, and buys you nothing. Method #4 is
jpayne@68	2227 rather complicated, but extremely efficient, something that really pays
jpayne@68	2228 off after the first million or so of active timers, i.e. it's usually
jpayne@68	2229 overkill :)
jpayne@68	2230 .PP
jpayne@68	2231 \fIThe special problem of being too early\fR
jpayne@68	2232 .IX Subsection "The special problem of being too early"
jpayne@68	2233 .PP
jpayne@68	2234 If you ask a timer to call your callback after three seconds, then
jpayne@68	2235 you expect it to be invoked after three seconds \- but of course, this
jpayne@68	2236 cannot be guaranteed to infinite precision. Less obviously, it cannot be
jpayne@68	2237 guaranteed to any precision by libev \- imagine somebody suspending the
jpayne@68	2238 process with a \s-1STOP\s0 signal for a few hours for example.
jpayne@68	2239 .PP
jpayne@68	2240 So, libev tries to invoke your callback as soon as possible \fIafter\fR the
jpayne@68	2241 delay has occurred, but cannot guarantee this.
jpayne@68	2242 .PP
jpayne@68	2243 A less obvious failure mode is calling your callback too early: many event
jpayne@68	2244 loops compare timestamps with a \(L"elapsed delay >= requested delay\(R", but
jpayne@68	2245 this can cause your callback to be invoked much earlier than you would
jpayne@68	2246 expect.
jpayne@68	2247 .PP
jpayne@68	2248 To see why, imagine a system with a clock that only offers full second
jpayne@68	2249 resolution (think windows if you can't come up with a broken enough \s-1OS\s0
jpayne@68	2250 yourself). If you schedule a one-second timer at the time 500.9, then the
jpayne@68	2251 event loop will schedule your timeout to elapse at a system time of 500
jpayne@68	2252 (500.9 truncated to the resolution) + 1, or 501.
jpayne@68	2253 .PP
jpayne@68	2254 If an event library looks at the timeout 0.1s later, it will see \*(L"501 >=
jpayne@68	2255 501\*(R" and invoke the callback 0.1s after it was started, even though a
jpayne@68	2256 one-second delay was requested \- this is being \(L"too early\(R", despite best
jpayne@68	2257 intentions.
jpayne@68	2258 .PP
jpayne@68	2259 This is the reason why libev will never invoke the callback if the elapsed
jpayne@68	2260 delay equals the requested delay, but only when the elapsed delay is
jpayne@68	2261 larger than the requested delay. In the example above, libev would only invoke
jpayne@68	2262 the callback at system time 502, or 1.1s after the timer was started.
jpayne@68	2263 .PP
jpayne@68	2264 So, while libev cannot guarantee that your callback will be invoked
jpayne@68	2265 exactly when requested, it \fIcan\fR and \fIdoes\fR guarantee that the requested
jpayne@68	2266 delay has actually elapsed, or in other words, it always errs on the \*(L"too
jpayne@68	2267 late\*(R" side of things.
jpayne@68	2268 .PP
jpayne@68	2269 \fIThe special problem of time updates\fR
jpayne@68	2270 .IX Subsection "The special problem of time updates"
jpayne@68	2271 .PP
jpayne@68	2272 Establishing the current time is a costly operation (it usually takes
jpayne@68	2273 at least one system call): \s-1EV\s0 therefore updates its idea of the current
jpayne@68	2274 time only before and after \f(CW\(C`ev_run\(C'\fR collects new events, which causes a
jpayne@68	2275 growing difference between \f(CW\(C`ev_now ()\(C'\fR and \f(CW\(C`ev_time ()\(C'\fR when handling
jpayne@68	2276 lots of events in one iteration.
jpayne@68	2277 .PP
jpayne@68	2278 The relative timeouts are calculated relative to the \f(CW\(C`ev_now ()\(C'\fR
jpayne@68	2279 time. This is usually the right thing as this timestamp refers to the time
jpayne@68	2280 of the event triggering whatever timeout you are modifying/starting. If
jpayne@68	2281 you suspect event processing to be delayed and you \fIneed\fR to base the
jpayne@68	2282 timeout on the current time, use something like the following to adjust
jpayne@68	2283 for it:
jpayne@68	2284 .PP
jpayne@68	2285 .Vb 1
jpayne@68	2286 \& ev_timer_set (&timer, after + (ev_time () \- ev_now ()), 0.);
jpayne@68	2287 .Ve
jpayne@68	2288 .PP
jpayne@68	2289 If the event loop is suspended for a long time, you can also force an
jpayne@68	2290 update of the time returned by \f(CW\(C`ev_now ()\(C'\fR by calling \f(CW\*(C`ev_now_update
jpayne@68	2291 ()\*(C'\fR, although that will push the event time of all outstanding events
jpayne@68	2292 further into the future.
jpayne@68	2293 .PP
jpayne@68	2294 \fIThe special problem of unsynchronised clocks\fR
jpayne@68	2295 .IX Subsection "The special problem of unsynchronised clocks"
jpayne@68	2296 .PP
jpayne@68	2297 Modern systems have a variety of clocks \- libev itself uses the normal
jpayne@68	2298 \&\(L"wall clock\(R" clock and, if available, the monotonic clock (to avoid time
jpayne@68	2299 jumps).
jpayne@68	2300 .PP
jpayne@68	2301 Neither of these clocks is synchronised with each other or any other clock
jpayne@68	2302 on the system, so \f(CW\(C`ev_time ()\(C'\fR might return a considerably different time
jpayne@68	2303 than \f(CW\(C`gettimeofday ()\(C'\fR or \f(CW\(C`time ()\(C'\fR. On a GNU/Linux system, for example,
jpayne@68	2304 a call to \f(CW\(C`gettimeofday\(C'\fR might return a second count that is one higher
jpayne@68	2305 than a directly following call to \f(CW\(C`time\(C'\fR.
jpayne@68	2306 .PP
jpayne@68	2307 The moral of this is to only compare libev-related timestamps with
jpayne@68	2308 \&\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	2309 a second or so.
jpayne@68	2310 .PP
jpayne@68	2311 One more problem arises due to this lack of synchronisation: if libev uses
jpayne@68	2312 the system monotonic clock and you compare timestamps from \f(CW\(C`ev_time\(C'\fR
jpayne@68	2313 or \f(CW\(C`ev_now\(C'\fR from when you started your timer and when your callback is
jpayne@68	2314 invoked, you will find that sometimes the callback is a bit \(L"early\(R".
jpayne@68	2315 .PP
jpayne@68	2316 This is because \f(CW\(C`ev_timer\(C'\fRs work in real time, not wall clock time, so
jpayne@68	2317 libev makes sure your callback is not invoked before the delay happened,
jpayne@68	2318 \&\fImeasured according to the real time\fR, not the system clock.
jpayne@68	2319 .PP
jpayne@68	2320 If your timeouts are based on a physical timescale (e.g. \*(L"time out this
jpayne@68	2321 connection after 100 seconds\*(R") then this shouldn't bother you as it is
jpayne@68	2322 exactly the right behaviour.
jpayne@68	2323 .PP
jpayne@68	2324 If you want to compare wall clock/system timestamps to your timers, then
jpayne@68	2325 you need to use \f(CW\(C`ev_periodic\(C'\fRs, as these are based on the wall clock
jpayne@68	2326 time, where your comparisons will always generate correct results.
jpayne@68	2327 .PP
jpayne@68	2328 \fIThe special problems of suspended animation\fR
jpayne@68	2329 .IX Subsection "The special problems of suspended animation"
jpayne@68	2330 .PP
jpayne@68	2331 When you leave the server world it is quite customary to hit machines that
jpayne@68	2332 can suspend/hibernate \- what happens to the clocks during such a suspend?
jpayne@68	2333 .PP
jpayne@68	2334 Some quick tests made with a Linux 2.6.28 indicate that a suspend freezes
jpayne@68	2335 all processes, while the clocks (\f(CW\(C`times\(C'\fR, \f(CW\(C`CLOCK_MONOTONIC\(C'\fR) continue
jpayne@68	2336 to run until the system is suspended, but they will not advance while the
jpayne@68	2337 system is suspended. That means, on resume, it will be as if the program
jpayne@68	2338 was frozen for a few seconds, but the suspend time will not be counted
jpayne@68	2339 towards \f(CW\(C`ev_timer\(C'\fR when a monotonic clock source is used. The real time
jpayne@68	2340 clock advanced as expected, but if it is used as sole clocksource, then a
jpayne@68	2341 long suspend would be detected as a time jump by libev, and timers would
jpayne@68	2342 be adjusted accordingly.
jpayne@68	2343 .PP
jpayne@68	2344 I would not be surprised to see different behaviour in different between
jpayne@68	2345 operating systems, \s-1OS\s0 versions or even different hardware.
jpayne@68	2346 .PP
jpayne@68	2347 The other form of suspend (job control, or sending a \s-1SIGSTOP\s0) will see a
jpayne@68	2348 time jump in the monotonic clocks and the realtime clock. If the program
jpayne@68	2349 is suspended for a very long time, and monotonic clock sources are in use,
jpayne@68	2350 then you can expect \f(CW\(C`ev_timer\(C'\fRs to expire as the full suspension time
jpayne@68	2351 will be counted towards the timers. When no monotonic clock source is in
jpayne@68	2352 use, then libev will again assume a timejump and adjust accordingly.
jpayne@68	2353 .PP
jpayne@68	2354 It might be beneficial for this latter case to call \f(CW\(C`ev_suspend\(C'\fR
jpayne@68	2355 and \f(CW\(C`ev_resume\(C'\fR in code that handles \f(CW\(C`SIGTSTP\(C'\fR, to at least get
jpayne@68	2356 deterministic behaviour in this case (you can do nothing against
jpayne@68	2357 \&\f(CW\(C`SIGSTOP\(C'\fR).
jpayne@68	2358 .PP
jpayne@68	2359 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	2360 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	2361 .IP "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)" 4
jpayne@68	2362 .IX Item "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)"
jpayne@68	2363 .PD 0
jpayne@68	2364 .IP "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)" 4
jpayne@68	2365 .IX Item "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)"
jpayne@68	2366 .PD
jpayne@68	2367 Configure the timer to trigger after \f(CW\(C`after\(C'\fR seconds (fractional and
jpayne@68	2368 negative values are supported). If \f(CW\(C`repeat\(C'\fR is \f(CW0.\fR, then it will
jpayne@68	2369 automatically be stopped once the timeout is reached. If it is positive,
jpayne@68	2370 then the timer will automatically be configured to trigger again \f(CW\(C`repeat\(C'\fR
jpayne@68	2371 seconds later, again, and again, until stopped manually.
jpayne@68	2372 .Sp
jpayne@68	2373 The timer itself will do a best-effort at avoiding drift, that is, if
jpayne@68	2374 you configure a timer to trigger every 10 seconds, then it will normally
jpayne@68	2375 trigger at exactly 10 second intervals. If, however, your program cannot
jpayne@68	2376 keep up with the timer (because it takes longer than those 10 seconds to
jpayne@68	2377 do stuff) the timer will not fire more than once per event loop iteration.
jpayne@68	2378 .IP "ev_timer_again (loop, ev_timer *)" 4
jpayne@68	2379 .IX Item "ev_timer_again (loop, ev_timer *)"
jpayne@68	2380 This will act as if the timer timed out, and restarts it again if it is
jpayne@68	2381 repeating. It basically works like calling \f(CW\(C`ev_timer_stop\(C'\fR, updating the
jpayne@68	2382 timeout to the \f(CW\(C`repeat\(C'\fR value and calling \f(CW\(C`ev_timer_start\(C'\fR.
jpayne@68	2383 .Sp
jpayne@68	2384 The exact semantics are as in the following rules, all of which will be
jpayne@68	2385 applied to the watcher:
jpayne@68	2386 .RS 4
jpayne@68	2387 .IP "If the timer is pending, the pending status is always cleared." 4
jpayne@68	2388 .IX Item "If the timer is pending, the pending status is always cleared."
jpayne@68	2389 .PD 0
jpayne@68	2390 .IP "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)." 4
jpayne@68	2391 .IX Item "If the timer is started but non-repeating, stop it (as if it timed out, without invoking it)."
jpayne@68	2392 .ie n .IP "If the timer is repeating, make the ""repeat"" value the new timeout and start the timer, if necessary." 4
jpayne@68	2393 .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	2394 .IX Item "If the timer is repeating, make the repeat value the new timeout and start the timer, if necessary."
jpayne@68	2395 .RE
jpayne@68	2396 .RS 4
jpayne@68	2397 .PD
jpayne@68	2398 .Sp
jpayne@68	2399 This sounds a bit complicated, see \(L"Be smart about timeouts\(R", above, for a
jpayne@68	2400 usage example.
jpayne@68	2401 .RE
jpayne@68	2402 .IP "ev_tstamp ev_timer_remaining (loop, ev_timer *)" 4
jpayne@68	2403 .IX Item "ev_tstamp ev_timer_remaining (loop, ev_timer *)"
jpayne@68	2404 Returns the remaining time until a timer fires. If the timer is active,
jpayne@68	2405 then this time is relative to the current event loop time, otherwise it's
jpayne@68	2406 the timeout value currently configured.
jpayne@68	2407 .Sp
jpayne@68	2408 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	2409 \&\f(CW5\fR. When the timer is started and one second passes, \f(CW\(C`ev_timer_remaining\(C'\fR
jpayne@68	2410 will return \f(CW4\fR. When the timer expires and is restarted, it will return
jpayne@68	2411 roughly \f(CW7\fR (likely slightly less as callback invocation takes some time,
jpayne@68	2412 too), and so on.
jpayne@68	2413 .IP "ev_tstamp repeat [read\-write]" 4
jpayne@68	2414 .IX Item "ev_tstamp repeat [read-write]"
jpayne@68	2415 The current \f(CW\(C`repeat\(C'\fR value. Will be used each time the watcher times out
jpayne@68	2416 or \f(CW\(C`ev_timer_again\(C'\fR is called, and determines the next timeout (if any),
jpayne@68	2417 which is also when any modifications are taken into account.
jpayne@68	2418 .PP
jpayne@68	2419 \fIExamples\fR
jpayne@68	2420 .IX Subsection "Examples"
jpayne@68	2421 .PP
jpayne@68	2422 Example: Create a timer that fires after 60 seconds.
jpayne@68	2423 .PP
jpayne@68	2424 .Vb 5
jpayne@68	2425 \& static void
jpayne@68	2426 \& one_minute_cb (struct ev_loop loop, ev_timer w, int revents)
jpayne@68	2427 \& {
jpayne@68	2428 \& .. one minute over, w is actually stopped right here
jpayne@68	2429 \& }
jpayne@68	2430 \&
jpayne@68	2431 \& ev_timer mytimer;
jpayne@68	2432 \& ev_timer_init (&mytimer, one_minute_cb, 60., 0.);
jpayne@68	2433 \& ev_timer_start (loop, &mytimer);
jpayne@68	2434 .Ve
jpayne@68	2435 .PP
jpayne@68	2436 Example: Create a timeout timer that times out after 10 seconds of
jpayne@68	2437 inactivity.
jpayne@68	2438 .PP
jpayne@68	2439 .Vb 5
jpayne@68	2440 \& static void
jpayne@68	2441 \& timeout_cb (struct ev_loop loop, ev_timer w, int revents)
jpayne@68	2442 \& {
jpayne@68	2443 \& .. ten seconds without any activity
jpayne@68	2444 \& }
jpayne@68	2445 \&
jpayne@68	2446 \& ev_timer mytimer;
jpayne@68	2447 \& ev_timer_init (&mytimer, timeout_cb, 0., 10.); /* note, only repeat used */
jpayne@68	2448 \& ev_timer_again (&mytimer); /* start timer */
jpayne@68	2449 \& ev_run (loop, 0);
jpayne@68	2450 \&
jpayne@68	2451 \& // and in some piece of code that gets executed on any "activity":
jpayne@68	2452 \& // reset the timeout to start ticking again at 10 seconds
jpayne@68	2453 \& ev_timer_again (&mytimer);
jpayne@68	2454 .Ve
jpayne@68	2455 .ie n .SS """ev_periodic"" \- to cron or not to cron?"
jpayne@68	2456 .el .SS "\f(CWev_periodic\fP \- to cron or not to cron?"
jpayne@68	2457 .IX Subsection "ev_periodic - to cron or not to cron?"
jpayne@68	2458 Periodic watchers are also timers of a kind, but they are very versatile
jpayne@68	2459 (and unfortunately a bit complex).
jpayne@68	2460 .PP
jpayne@68	2461 Unlike \f(CW\(C`ev_timer\(C'\fR, periodic watchers are not based on real time (or
jpayne@68	2462 relative time, the physical time that passes) but on wall clock time
jpayne@68	2463 (absolute time, the thing you can read on your calendar or clock). The
jpayne@68	2464 difference is that wall clock time can run faster or slower than real
jpayne@68	2465 time, and time jumps are not uncommon (e.g. when you adjust your
jpayne@68	2466 wrist-watch).
jpayne@68	2467 .PP
jpayne@68	2468 You can tell a periodic watcher to trigger after some specific point
jpayne@68	2469 in time: for example, if you tell a periodic watcher to trigger \*(L"in 10
jpayne@68	2470 seconds\(R" (by specifying e.g. \f(CW\(C`ev_now () + 10.\*(C'\fR, that is, an absolute time
jpayne@68	2471 not a delay) and then reset your system clock to January of the previous
jpayne@68	2472 year, then it will take a year or more to trigger the event (unlike an
jpayne@68	2473 \&\f(CW\(C`ev_timer\(C'\fR, which would still trigger roughly 10 seconds after starting
jpayne@68	2474 it, as it uses a relative timeout).
jpayne@68	2475 .PP
jpayne@68	2476 \&\f(CW\(C`ev_periodic\(C'\fR watchers can also be used to implement vastly more complex
jpayne@68	2477 timers, such as triggering an event on each \(L"midnight, local time\(R", or
jpayne@68	2478 other complicated rules. This cannot easily be done with \f(CW\(C`ev_timer\(C'\fR
jpayne@68	2479 watchers, as those cannot react to time jumps.
jpayne@68	2480 .PP
jpayne@68	2481 As with timers, the callback is guaranteed to be invoked only when the
jpayne@68	2482 point in time where it is supposed to trigger has passed. If multiple
jpayne@68	2483 timers become ready during the same loop iteration then the ones with
jpayne@68	2484 earlier time-out values are invoked before ones with later time-out values
jpayne@68	2485 (but this is no longer true when a callback calls \f(CW\(C`ev_run\(C'\fR recursively).
jpayne@68	2486 .PP
jpayne@68	2487 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	2488 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	2489 .IP "ev_periodic_init (ev_periodic *, callback, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" 4
jpayne@68	2490 .IX Item "ev_periodic_init (ev_periodic *, callback, ev_tstamp offset, ev_tstamp interval, reschedule_cb)"
jpayne@68	2491 .PD 0
jpayne@68	2492 .IP "ev_periodic_set (ev_periodic *, ev_tstamp offset, ev_tstamp interval, reschedule_cb)" 4
jpayne@68	2493 .IX Item "ev_periodic_set (ev_periodic *, ev_tstamp offset, ev_tstamp interval, reschedule_cb)"
jpayne@68	2494 .PD
jpayne@68	2495 Lots of arguments, let's sort it out... There are basically three modes of
jpayne@68	2496 operation, and we will explain them from simplest to most complex:
jpayne@68	2497 .RS 4
jpayne@68	2498 .IP "\(bu" 4
jpayne@68	2499 absolute timer (offset = absolute time, interval = 0, reschedule_cb = 0)
jpayne@68	2500 .Sp
jpayne@68	2501 In this configuration the watcher triggers an event after the wall clock
jpayne@68	2502 time \f(CW\(C`offset\(C'\fR has passed. It will not repeat and will not adjust when a
jpayne@68	2503 time jump occurs, that is, if it is to be run at January 1st 2011 then it
jpayne@68	2504 will be stopped and invoked when the system clock reaches or surpasses
jpayne@68	2505 this point in time.
jpayne@68	2506 .IP "\(bu" 4
jpayne@68	2507 repeating interval timer (offset = offset within interval, interval > 0, reschedule_cb = 0)
jpayne@68	2508 .Sp
jpayne@68	2509 In this mode the watcher will always be scheduled to time out at the next
jpayne@68	2510 \&\f(CW\(C`offset + N interval\*(C'\fR time (for some integer N, which can also be
jpayne@68	2511 negative) and then repeat, regardless of any time jumps. The \f(CW\(C`offset\(C'\fR
jpayne@68	2512 argument is merely an offset into the \f(CW\(C`interval\(C'\fR periods.
jpayne@68	2513 .Sp
jpayne@68	2514 This can be used to create timers that do not drift with respect to the
jpayne@68	2515 system clock, for example, here is an \f(CW\(C`ev_periodic\(C'\fR that triggers each
jpayne@68	2516 hour, on the hour (with respect to \s-1UTC\s0):
jpayne@68	2517 .Sp
jpayne@68	2518 .Vb 1
jpayne@68	2519 \& ev_periodic_set (&periodic, 0., 3600., 0);
jpayne@68	2520 .Ve
jpayne@68	2521 .Sp
jpayne@68	2522 This doesn't mean there will always be 3600 seconds in between triggers,
jpayne@68	2523 but only that the callback will be called when the system time shows a
jpayne@68	2524 full hour (\s-1UTC\s0), or more correctly, when the system time is evenly divisible
jpayne@68	2525 by 3600.
jpayne@68	2526 .Sp
jpayne@68	2527 Another way to think about it (for the mathematically inclined) is that
jpayne@68	2528 \&\f(CW\(C`ev_periodic\(C'\fR will try to run the callback in this mode at the next possible
jpayne@68	2529 time where \f(CW\(C`time = offset (mod interval)\(C'\fR, regardless of any time jumps.
jpayne@68	2530 .Sp
jpayne@68	2531 The \f(CW\(C`interval\(C'\fR \fI\s-1MUST\s0\fR be positive, and for numerical stability, the
jpayne@68	2532 interval value should be higher than \f(CW\(C`1/8192\(C'\fR (which is around 100
jpayne@68	2533 microseconds) and \f(CW\(C`offset\(C'\fR should be higher than \f(CW0\fR and should have
jpayne@68	2534 at most a similar magnitude as the current time (say, within a factor of
jpayne@68	2535 ten). Typical values for offset are, in fact, \f(CW0\fR or something between
jpayne@68	2536 \&\f(CW0\fR and \f(CW\(C`interval\(C'\fR, which is also the recommended range.
jpayne@68	2537 .Sp
jpayne@68	2538 Note also that there is an upper limit to how often a timer can fire (\s-1CPU\s0
jpayne@68	2539 speed for example), so if \f(CW\(C`interval\(C'\fR is very small then timing stability
jpayne@68	2540 will of course deteriorate. Libev itself tries to be exact to be about one
jpayne@68	2541 millisecond (if the \s-1OS\s0 supports it and the machine is fast enough).
jpayne@68	2542 .IP "\(bu" 4
jpayne@68	2543 manual reschedule mode (offset ignored, interval ignored, reschedule_cb = callback)
jpayne@68	2544 .Sp
jpayne@68	2545 In this mode the values for \f(CW\(C`interval\(C'\fR and \f(CW\(C`offset\(C'\fR are both being
jpayne@68	2546 ignored. Instead, each time the periodic watcher gets scheduled, the
jpayne@68	2547 reschedule callback will be called with the watcher as first, and the
jpayne@68	2548 current time as second argument.
jpayne@68	2549 .Sp
jpayne@68	2550 \&\s-1NOTE:\s0 \fIThis callback \s-1MUST NOT\s0 stop or destroy any periodic watcher, ever,
jpayne@68	2551 or make \s-1ANY\s0 other event loop modifications whatsoever, unless explicitly
jpayne@68	2552 allowed by documentation here\fR.
jpayne@68	2553 .Sp
jpayne@68	2554 If you need to stop it, return \f(CW\(C`now + 1e30\(C'\fR (or so, fudge fudge) and stop
jpayne@68	2555 it afterwards (e.g. by starting an \f(CW\(C`ev_prepare\(C'\fR watcher, which is the
jpayne@68	2556 only event loop modification you are allowed to do).
jpayne@68	2557 .Sp
jpayne@68	2558 The callback prototype is \f(CW\(C`ev_tstamp (reschedule_cb)(ev_periodic
jpayne@68	2559 w, ev_tstamp now)\(C'\fR, e.g.:
jpayne@68	2560 .Sp
jpayne@68	2561 .Vb 5
jpayne@68	2562 \& static ev_tstamp
jpayne@68	2563 \& my_rescheduler (ev_periodic *w, ev_tstamp now)
jpayne@68	2564 \& {
jpayne@68	2565 \& return now + 60.;
jpayne@68	2566 \& }
jpayne@68	2567 .Ve
jpayne@68	2568 .Sp
jpayne@68	2569 It must return the next time to trigger, based on the passed time value
jpayne@68	2570 (that is, the lowest time value larger than to the second argument). It
jpayne@68	2571 will usually be called just before the callback will be triggered, but
jpayne@68	2572 might be called at other times, too.
jpayne@68	2573 .Sp
jpayne@68	2574 \&\s-1NOTE:\s0 \fIThis callback must always return a time that is higher than or
jpayne@68	2575 equal to the passed \f(CI\(C`now\(C'\fI value\fR.
jpayne@68	2576 .Sp
jpayne@68	2577 This can be used to create very complex timers, such as a timer that
jpayne@68	2578 triggers on \(L"next midnight, local time\(R". To do this, you would calculate
jpayne@68	2579 the next midnight after \f(CW\(C`now\(C'\fR and return the timestamp value for
jpayne@68	2580 this. Here is a (completely untested, no error checking) example on how to
jpayne@68	2581 do this:
jpayne@68	2582 .Sp
jpayne@68	2583 .Vb 1
jpayne@68	2584 \& #include <time.h>
jpayne@68	2585 \&
jpayne@68	2586 \& static ev_tstamp
jpayne@68	2587 \& my_rescheduler (ev_periodic *w, ev_tstamp now)
jpayne@68	2588 \& {
jpayne@68	2589 \& time_t tnow = (time_t)now;
jpayne@68	2590 \& struct tm tm;
jpayne@68	2591 \& localtime_r (&tnow, &tm);
jpayne@68	2592 \&
jpayne@68	2593 \& tm.tm_sec = tm.tm_min = tm.tm_hour = 0; // midnight current day
jpayne@68	2594 \& ++tm.tm_mday; // midnight next day
jpayne@68	2595 \&
jpayne@68	2596 \& return mktime (&tm);
jpayne@68	2597 \& }
jpayne@68	2598 .Ve
jpayne@68	2599 .Sp
jpayne@68	2600 Note: this code might run into trouble on days that have more then two
jpayne@68	2601 midnights (beginning and end).
jpayne@68	2602 .RE
jpayne@68	2603 .RS 4
jpayne@68	2604 .RE
jpayne@68	2605 .IP "ev_periodic_again (loop, ev_periodic *)" 4
jpayne@68	2606 .IX Item "ev_periodic_again (loop, ev_periodic *)"
jpayne@68	2607 Simply stops and restarts the periodic watcher again. This is only useful
jpayne@68	2608 when you changed some parameters or the reschedule callback would return
jpayne@68	2609 a different time than the last time it was called (e.g. in a crond like
jpayne@68	2610 program when the crontabs have changed).
jpayne@68	2611 .IP "ev_tstamp ev_periodic_at (ev_periodic *)" 4
jpayne@68	2612 .IX Item "ev_tstamp ev_periodic_at (ev_periodic *)"
jpayne@68	2613 When active, returns the absolute time that the watcher is supposed
jpayne@68	2614 to trigger next. This is not the same as the \f(CW\(C`offset\(C'\fR argument to
jpayne@68	2615 \&\f(CW\(C`ev_periodic_set\(C'\fR, but indeed works even in interval and manual
jpayne@68	2616 rescheduling modes.
jpayne@68	2617 .IP "ev_tstamp offset [read\-write]" 4
jpayne@68	2618 .IX Item "ev_tstamp offset [read-write]"
jpayne@68	2619 When repeating, this contains the offset value, otherwise this is the
jpayne@68	2620 absolute point in time (the \f(CW\(C`offset\(C'\fR value passed to \f(CW\(C`ev_periodic_set\(C'\fR,
jpayne@68	2621 although libev might modify this value for better numerical stability).
jpayne@68	2622 .Sp
jpayne@68	2623 Can be modified any time, but changes only take effect when the periodic
jpayne@68	2624 timer fires or \f(CW\(C`ev_periodic_again\(C'\fR is being called.
jpayne@68	2625 .IP "ev_tstamp interval [read\-write]" 4
jpayne@68	2626 .IX Item "ev_tstamp interval [read-write]"
jpayne@68	2627 The current interval value. Can be modified any time, but changes only
jpayne@68	2628 take effect when the periodic timer fires or \f(CW\(C`ev_periodic_again\(C'\fR is being
jpayne@68	2629 called.
jpayne@68	2630 .IP "ev_tstamp (reschedule_cb)(ev_periodic w, ev_tstamp now) [read\-write]" 4
jpayne@68	2631 .IX Item "ev_tstamp (reschedule_cb)(ev_periodic w, ev_tstamp now) [read-write]"
jpayne@68	2632 The current reschedule callback, or \f(CW0\fR, if this functionality is
jpayne@68	2633 switched off. Can be changed any time, but changes only take effect when
jpayne@68	2634 the periodic timer fires or \f(CW\(C`ev_periodic_again\(C'\fR is being called.
jpayne@68	2635 .PP
jpayne@68	2636 \fIExamples\fR
jpayne@68	2637 .IX Subsection "Examples"
jpayne@68	2638 .PP
jpayne@68	2639 Example: Call a callback every hour, or, more precisely, whenever the
jpayne@68	2640 system time is divisible by 3600. The callback invocation times have
jpayne@68	2641 potentially a lot of jitter, but good long-term stability.
jpayne@68	2642 .PP
jpayne@68	2643 .Vb 5
jpayne@68	2644 \& static void
jpayne@68	2645 \& clock_cb (struct ev_loop loop, ev_periodic w, int revents)
jpayne@68	2646 \& {
jpayne@68	2647 \& ... its now a full hour (UTC, or TAI or whatever your clock follows)
jpayne@68	2648 \& }
jpayne@68	2649 \&
jpayne@68	2650 \& ev_periodic hourly_tick;
jpayne@68	2651 \& ev_periodic_init (&hourly_tick, clock_cb, 0., 3600., 0);
jpayne@68	2652 \& ev_periodic_start (loop, &hourly_tick);
jpayne@68	2653 .Ve
jpayne@68	2654 .PP
jpayne@68	2655 Example: The same as above, but use a reschedule callback to do it:
jpayne@68	2656 .PP
jpayne@68	2657 .Vb 1
jpayne@68	2658 \& #include <math.h>
jpayne@68	2659 \&
jpayne@68	2660 \& static ev_tstamp
jpayne@68	2661 \& my_scheduler_cb (ev_periodic *w, ev_tstamp now)
jpayne@68	2662 \& {
jpayne@68	2663 \& return now + (3600. \- fmod (now, 3600.));
jpayne@68	2664 \& }
jpayne@68	2665 \&
jpayne@68	2666 \& ev_periodic_init (&hourly_tick, clock_cb, 0., 0., my_scheduler_cb);
jpayne@68	2667 .Ve
jpayne@68	2668 .PP
jpayne@68	2669 Example: Call a callback every hour, starting now:
jpayne@68	2670 .PP
jpayne@68	2671 .Vb 4
jpayne@68	2672 \& ev_periodic hourly_tick;
jpayne@68	2673 \& ev_periodic_init (&hourly_tick, clock_cb,
jpayne@68	2674 \& fmod (ev_now (loop), 3600.), 3600., 0);
jpayne@68	2675 \& ev_periodic_start (loop, &hourly_tick);
jpayne@68	2676 .Ve
jpayne@68	2677 .ie n .SS """ev_signal"" \- signal me when a signal gets signalled!"
jpayne@68	2678 .el .SS "\f(CWev_signal\fP \- signal me when a signal gets signalled!"
jpayne@68	2679 .IX Subsection "ev_signal - signal me when a signal gets signalled!"
jpayne@68	2680 Signal watchers will trigger an event when the process receives a specific
jpayne@68	2681 signal one or more times. Even though signals are very asynchronous, libev
jpayne@68	2682 will try its best to deliver signals synchronously, i.e. as part of the
jpayne@68	2683 normal event processing, like any other event.
jpayne@68	2684 .PP
jpayne@68	2685 If you want signals to be delivered truly asynchronously, just use
jpayne@68	2686 \&\f(CW\(C`sigaction\(C'\fR as you would do without libev and forget about sharing
jpayne@68	2687 the signal. You can even use \f(CW\(C`ev_async\(C'\fR from a signal handler to
jpayne@68	2688 synchronously wake up an event loop.
jpayne@68	2689 .PP
jpayne@68	2690 You can configure as many watchers as you like for the same signal, but
jpayne@68	2691 only within the same loop, i.e. you can watch for \f(CW\(C`SIGINT\(C'\fR in your
jpayne@68	2692 default loop and for \f(CW\(C`SIGIO\(C'\fR in another loop, but you cannot watch for
jpayne@68	2693 \&\f(CW\(C`SIGINT\(C'\fR in both the default loop and another loop at the same time. At
jpayne@68	2694 the moment, \f(CW\(C`SIGCHLD\(C'\fR is permanently tied to the default loop.
jpayne@68	2695 .PP
jpayne@68	2696 Only after the first watcher for a signal is started will libev actually
jpayne@68	2697 register something with the kernel. It thus coexists with your own signal
jpayne@68	2698 handlers as long as you don't register any with libev for the same signal.
jpayne@68	2699 .PP
jpayne@68	2700 If possible and supported, libev will install its handlers with
jpayne@68	2701 \&\f(CW\(C`SA_RESTART\(C'\fR (or equivalent) behaviour enabled, so system calls should
jpayne@68	2702 not be unduly interrupted. If you have a problem with system calls getting
jpayne@68	2703 interrupted by signals you can block all signals in an \f(CW\(C`ev_check\(C'\fR watcher
jpayne@68	2704 and unblock them in an \f(CW\(C`ev_prepare\(C'\fR watcher.
jpayne@68	2705 .PP
jpayne@68	2706 \fIThe special problem of inheritance over fork/execve/pthread_create\fR
jpayne@68	2707 .IX Subsection "The special problem of inheritance over fork/execve/pthread_create"
jpayne@68	2708 .PP
jpayne@68	2709 Both the signal mask (\f(CW\(C`sigprocmask\(C'\fR) and the signal disposition
jpayne@68	2710 (\f(CW\(C`sigaction\(C'\fR) are unspecified after starting a signal watcher (and after
jpayne@68	2711 stopping it again), that is, libev might or might not block the signal,
jpayne@68	2712 and might or might not set or restore the installed signal handler (but
jpayne@68	2713 see \f(CW\(C`EVFLAG_NOSIGMASK\(C'\fR).
jpayne@68	2714 .PP
jpayne@68	2715 While this does not matter for the signal disposition (libev never
jpayne@68	2716 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	2717 \&\f(CW\(C`execve\(C'\fR), this matters for the signal mask: many programs do not expect
jpayne@68	2718 certain signals to be blocked.
jpayne@68	2719 .PP
jpayne@68	2720 This means that before calling \f(CW\(C`exec\(C'\fR (from the child) you should reset
jpayne@68	2721 the signal mask to whatever \(L"default\(R" you expect (all clear is a good
jpayne@68	2722 choice usually).
jpayne@68	2723 .PP
jpayne@68	2724 The simplest way to ensure that the signal mask is reset in the child is
jpayne@68	2725 to install a fork handler with \f(CW\(C`pthread_atfork\(C'\fR that resets it. That will
jpayne@68	2726 catch fork calls done by libraries (such as the libc) as well.
jpayne@68	2727 .PP
jpayne@68	2728 In current versions of libev, the signal will not be blocked indefinitely
jpayne@68	2729 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	2730 the window of opportunity for problems, it will not go away, as libev
jpayne@68	2731 \&\fIhas\fR to modify the signal mask, at least temporarily.
jpayne@68	2732 .PP
jpayne@68	2733 So I can't stress this enough: \fIIf you do not reset your signal mask when
jpayne@68	2734 you expect it to be empty, you have a race condition in your code\fR. This
jpayne@68	2735 is not a libev-specific thing, this is true for most event libraries.
jpayne@68	2736 .PP
jpayne@68	2737 \fIThe special problem of threads signal handling\fR
jpayne@68	2738 .IX Subsection "The special problem of threads signal handling"
jpayne@68	2739 .PP
jpayne@68	2740 \&\s-1POSIX\s0 threads has problematic signal handling semantics, specifically,
jpayne@68	2741 a lot of functionality (sigfd, sigwait etc.) only really works if all
jpayne@68	2742 threads in a process block signals, which is hard to achieve.
jpayne@68	2743 .PP
jpayne@68	2744 When you want to use sigwait (or mix libev signal handling with your own
jpayne@68	2745 for the same signals), you can tackle this problem by globally blocking
jpayne@68	2746 all signals before creating any threads (or creating them with a fully set
jpayne@68	2747 sigprocmask) and also specifying the \f(CW\(C`EVFLAG_NOSIGMASK\(C'\fR when creating
jpayne@68	2748 loops. Then designate one thread as \(L"signal receiver thread\(R" which handles
jpayne@68	2749 these signals. You can pass on any signals that libev might be interested
jpayne@68	2750 in by calling \f(CW\(C`ev_feed_signal\(C'\fR.
jpayne@68	2751 .PP
jpayne@68	2752 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	2753 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	2754 .IP "ev_signal_init (ev_signal *, callback, int signum)" 4
jpayne@68	2755 .IX Item "ev_signal_init (ev_signal *, callback, int signum)"
jpayne@68	2756 .PD 0
jpayne@68	2757 .IP "ev_signal_set (ev_signal *, int signum)" 4
jpayne@68	2758 .IX Item "ev_signal_set (ev_signal *, int signum)"
jpayne@68	2759 .PD
jpayne@68	2760 Configures the watcher to trigger on the given signal number (usually one
jpayne@68	2761 of the \f(CW\(C`SIGxxx\(C'\fR constants).
jpayne@68	2762 .IP "int signum [read\-only]" 4
jpayne@68	2763 .IX Item "int signum [read-only]"
jpayne@68	2764 The signal the watcher watches out for.
jpayne@68	2765 .PP
jpayne@68	2766 \fIExamples\fR
jpayne@68	2767 .IX Subsection "Examples"
jpayne@68	2768 .PP
jpayne@68	2769 Example: Try to exit cleanly on \s-1SIGINT.\s0
jpayne@68	2770 .PP
jpayne@68	2771 .Vb 5
jpayne@68	2772 \& static void
jpayne@68	2773 \& sigint_cb (struct ev_loop loop, ev_signal w, int revents)
jpayne@68	2774 \& {
jpayne@68	2775 \& ev_break (loop, EVBREAK_ALL);
jpayne@68	2776 \& }
jpayne@68	2777 \&
jpayne@68	2778 \& ev_signal signal_watcher;
jpayne@68	2779 \& ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
jpayne@68	2780 \& ev_signal_start (loop, &signal_watcher);
jpayne@68	2781 .Ve
jpayne@68	2782 .ie n .SS """ev_child"" \- watch out for process status changes"
jpayne@68	2783 .el .SS "\f(CWev_child\fP \- watch out for process status changes"
jpayne@68	2784 .IX Subsection "ev_child - watch out for process status changes"
jpayne@68	2785 Child watchers trigger when your process receives a \s-1SIGCHLD\s0 in response to
jpayne@68	2786 some child status changes (most typically when a child of yours dies or
jpayne@68	2787 exits). It is permissible to install a child watcher \fIafter\fR the child
jpayne@68	2788 has been forked (which implies it might have already exited), as long
jpayne@68	2789 as the event loop isn't entered (or is continued from a watcher), i.e.,
jpayne@68	2790 forking and then immediately registering a watcher for the child is fine,
jpayne@68	2791 but forking and registering a watcher a few event loop iterations later or
jpayne@68	2792 in the next callback invocation is not.
jpayne@68	2793 .PP
jpayne@68	2794 Only the default event loop is capable of handling signals, and therefore
jpayne@68	2795 you can only register child watchers in the default event loop.
jpayne@68	2796 .PP
jpayne@68	2797 Due to some design glitches inside libev, child watchers will always be
jpayne@68	2798 handled at maximum priority (their priority is set to \f(CW\(C`EV_MAXPRI\(C'\fR by
jpayne@68	2799 libev)
jpayne@68	2800 .PP
jpayne@68	2801 \fIProcess Interaction\fR
jpayne@68	2802 .IX Subsection "Process Interaction"
jpayne@68	2803 .PP
jpayne@68	2804 Libev grabs \f(CW\(C`SIGCHLD\(C'\fR as soon as the default event loop is
jpayne@68	2805 initialised. This is necessary to guarantee proper behaviour even if the
jpayne@68	2806 first child watcher is started after the child exits. The occurrence
jpayne@68	2807 of \f(CW\(C`SIGCHLD\(C'\fR is recorded asynchronously, but child reaping is done
jpayne@68	2808 synchronously as part of the event loop processing. Libev always reaps all
jpayne@68	2809 children, even ones not watched.
jpayne@68	2810 .PP
jpayne@68	2811 \fIOverriding the Built-In Processing\fR
jpayne@68	2812 .IX Subsection "Overriding the Built-In Processing"
jpayne@68	2813 .PP
jpayne@68	2814 Libev offers no special support for overriding the built-in child
jpayne@68	2815 processing, but if your application collides with libev's default child
jpayne@68	2816 handler, you can override it easily by installing your own handler for
jpayne@68	2817 \&\f(CW\(C`SIGCHLD\(C'\fR after initialising the default loop, and making sure the
jpayne@68	2818 default loop never gets destroyed. You are encouraged, however, to use an
jpayne@68	2819 event-based approach to child reaping and thus use libev's support for
jpayne@68	2820 that, so other libev users can use \f(CW\(C`ev_child\(C'\fR watchers freely.
jpayne@68	2821 .PP
jpayne@68	2822 \fIStopping the Child Watcher\fR
jpayne@68	2823 .IX Subsection "Stopping the Child Watcher"
jpayne@68	2824 .PP
jpayne@68	2825 Currently, the child watcher never gets stopped, even when the
jpayne@68	2826 child terminates, so normally one needs to stop the watcher in the
jpayne@68	2827 callback. Future versions of libev might stop the watcher automatically
jpayne@68	2828 when a child exit is detected (calling \f(CW\(C`ev_child_stop\(C'\fR twice is not a
jpayne@68	2829 problem).
jpayne@68	2830 .PP
jpayne@68	2831 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	2832 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	2833 .IP "ev_child_init (ev_child *, callback, int pid, int trace)" 4
jpayne@68	2834 .IX Item "ev_child_init (ev_child *, callback, int pid, int trace)"
jpayne@68	2835 .PD 0
jpayne@68	2836 .IP "ev_child_set (ev_child *, int pid, int trace)" 4
jpayne@68	2837 .IX Item "ev_child_set (ev_child *, int pid, int trace)"
jpayne@68	2838 .PD
jpayne@68	2839 Configures the watcher to wait for status changes of process \f(CW\(C`pid\(C'\fR (or
jpayne@68	2840 \&\fIany\fR process if \f(CW\(C`pid\(C'\fR is specified as \f(CW0\fR). The callback can look
jpayne@68	2841 at the \f(CW\(C`rstatus\(C'\fR member of the \f(CW\(C`ev_child\(C'\fR watcher structure to see
jpayne@68	2842 the status word (use the macros from \f(CW\(C`sys/wait.h\(C'\fR and see your systems
jpayne@68	2843 \&\f(CW\(C`waitpid\(C'\fR documentation). The \f(CW\(C`rpid\(C'\fR member contains the pid of the
jpayne@68	2844 process causing the status change. \f(CW\(C`trace\(C'\fR must be either \f(CW0\fR (only
jpayne@68	2845 activate the watcher when the process terminates) or \f(CW1\fR (additionally
jpayne@68	2846 activate the watcher when the process is stopped or continued).
jpayne@68	2847 .IP "int pid [read\-only]" 4
jpayne@68	2848 .IX Item "int pid [read-only]"
jpayne@68	2849 The process id this watcher watches out for, or \f(CW0\fR, meaning any process id.
jpayne@68	2850 .IP "int rpid [read\-write]" 4
jpayne@68	2851 .IX Item "int rpid [read-write]"
jpayne@68	2852 The process id that detected a status change.
jpayne@68	2853 .IP "int rstatus [read\-write]" 4
jpayne@68	2854 .IX Item "int rstatus [read-write]"
jpayne@68	2855 The process exit/trace status caused by \f(CW\(C`rpid\(C'\fR (see your systems
jpayne@68	2856 \&\f(CW\(C`waitpid\(C'\fR and \f(CW\(C`sys/wait.h\(C'\fR documentation for details).
jpayne@68	2857 .PP
jpayne@68	2858 \fIExamples\fR
jpayne@68	2859 .IX Subsection "Examples"
jpayne@68	2860 .PP
jpayne@68	2861 Example: \f(CW\(C`fork()\(C'\fR a new process and install a child handler to wait for
jpayne@68	2862 its completion.
jpayne@68	2863 .PP
jpayne@68	2864 .Vb 1
jpayne@68	2865 \& ev_child cw;
jpayne@68	2866 \&
jpayne@68	2867 \& static void
jpayne@68	2868 \& child_cb (EV_P_ ev_child *w, int revents)
jpayne@68	2869 \& {
jpayne@68	2870 \& ev_child_stop (EV_A_ w);
jpayne@68	2871 \& printf ("process %d exited with status %x\en", w\->rpid, w\->rstatus);
jpayne@68	2872 \& }
jpayne@68	2873 \&
jpayne@68	2874 \& pid_t pid = fork ();
jpayne@68	2875 \&
jpayne@68	2876 \& if (pid < 0)
jpayne@68	2877 \& // error
jpayne@68	2878 \& else if (pid == 0)
jpayne@68	2879 \& {
jpayne@68	2880 \& // the forked child executes here
jpayne@68	2881 \& exit (1);
jpayne@68	2882 \& }
jpayne@68	2883 \& else
jpayne@68	2884 \& {
jpayne@68	2885 \& ev_child_init (&cw, child_cb, pid, 0);
jpayne@68	2886 \& ev_child_start (EV_DEFAULT_ &cw);
jpayne@68	2887 \& }
jpayne@68	2888 .Ve
jpayne@68	2889 .ie n .SS """ev_stat"" \- did the file attributes just change?"
jpayne@68	2890 .el .SS "\f(CWev_stat\fP \- did the file attributes just change?"
jpayne@68	2891 .IX Subsection "ev_stat - did the file attributes just change?"
jpayne@68	2892 This watches a file system path for attribute changes. That is, it calls
jpayne@68	2893 \&\f(CW\(C`stat\(C'\fR on that path in regular intervals (or when the \s-1OS\s0 says it changed)
jpayne@68	2894 and sees if it changed compared to the last time, invoking the callback
jpayne@68	2895 if it did. Starting the watcher \f(CW\(C`stat\(C'\fR's the file, so only changes that
jpayne@68	2896 happen after the watcher has been started will be reported.
jpayne@68	2897 .PP
jpayne@68	2898 The path does not need to exist: changing from \(L"path exists\(R" to \*(L"path does
jpayne@68	2899 not exist\(R" is a status change like any other. The condition \(L"path does not
jpayne@68	2900 exist\(R" (or more correctly \(L"path cannot be stat'ed\*(R") is signified by the
jpayne@68	2901 \&\f(CW\(C`st_nlink\(C'\fR field being zero (which is otherwise always forced to be at
jpayne@68	2902 least one) and all the other fields of the stat buffer having unspecified
jpayne@68	2903 contents.
jpayne@68	2904 .PP
jpayne@68	2905 The path \fImust not\fR end in a slash or contain special components such as
jpayne@68	2906 \&\f(CW\(C`.\(C'\fR or \f(CW\(C`..\(C'\fR. The path \fIshould\fR be absolute: If it is relative and
jpayne@68	2907 your working directory changes, then the behaviour is undefined.
jpayne@68	2908 .PP
jpayne@68	2909 Since there is no portable change notification interface available, the
jpayne@68	2910 portable implementation simply calls \f(CWstat(2)\fR regularly on the path
jpayne@68	2911 to see if it changed somehow. You can specify a recommended polling
jpayne@68	2912 interval for this case. If you specify a polling interval of \f(CW0\fR (highly
jpayne@68	2913 recommended!) then a \fIsuitable, unspecified default\fR value will be used
jpayne@68	2914 (which you can expect to be around five seconds, although this might
jpayne@68	2915 change dynamically). Libev will also impose a minimum interval which is
jpayne@68	2916 currently around \f(CW0.1\fR, but that's usually overkill.
jpayne@68	2917 .PP
jpayne@68	2918 This watcher type is not meant for massive numbers of stat watchers,
jpayne@68	2919 as even with OS-supported change notifications, this can be
jpayne@68	2920 resource-intensive.
jpayne@68	2921 .PP
jpayne@68	2922 At the time of this writing, the only OS-specific interface implemented
jpayne@68	2923 is the Linux inotify interface (implementing kqueue support is left as an
jpayne@68	2924 exercise for the reader. Note, however, that the author sees no way of
jpayne@68	2925 implementing \f(CW\(C`ev_stat\(C'\fR semantics with kqueue, except as a hint).
jpayne@68	2926 .PP
jpayne@68	2927 \fI\s-1ABI\s0 Issues (Largefile Support)\fR
jpayne@68	2928 .IX Subsection "ABI Issues (Largefile Support)"
jpayne@68	2929 .PP
jpayne@68	2930 Libev by default (unless the user overrides this) uses the default
jpayne@68	2931 compilation environment, which means that on systems with large file
jpayne@68	2932 support disabled by default, you get the 32 bit version of the stat
jpayne@68	2933 structure. When using the library from programs that change the \s-1ABI\s0 to
jpayne@68	2934 use 64 bit file offsets the programs will fail. In that case you have to
jpayne@68	2935 compile libev with the same flags to get binary compatibility. This is
jpayne@68	2936 obviously the case with any flags that change the \s-1ABI,\s0 but the problem is
jpayne@68	2937 most noticeably displayed with ev_stat and large file support.
jpayne@68	2938 .PP
jpayne@68	2939 The solution for this is to lobby your distribution maker to make large
jpayne@68	2940 file interfaces available by default (as e.g. FreeBSD does) and not
jpayne@68	2941 optional. Libev cannot simply switch on large file support because it has
jpayne@68	2942 to exchange stat structures with application programs compiled using the
jpayne@68	2943 default compilation environment.
jpayne@68	2944 .PP
jpayne@68	2945 \fIInotify and Kqueue\fR
jpayne@68	2946 .IX Subsection "Inotify and Kqueue"
jpayne@68	2947 .PP
jpayne@68	2948 When \f(CW\(C`inotify (7)\(C'\fR support has been compiled into libev and present at
jpayne@68	2949 runtime, it will be used to speed up change detection where possible. The
jpayne@68	2950 inotify descriptor will be created lazily when the first \f(CW\(C`ev_stat\(C'\fR
jpayne@68	2951 watcher is being started.
jpayne@68	2952 .PP
jpayne@68	2953 Inotify presence does not change the semantics of \f(CW\(C`ev_stat\(C'\fR watchers
jpayne@68	2954 except that changes might be detected earlier, and in some cases, to avoid
jpayne@68	2955 making regular \f(CW\(C`stat\(C'\fR calls. Even in the presence of inotify support
jpayne@68	2956 there are many cases where libev has to resort to regular \f(CW\(C`stat\(C'\fR polling,
jpayne@68	2957 but as long as kernel 2.6.25 or newer is used (2.6.24 and older have too
jpayne@68	2958 many bugs), the path exists (i.e. stat succeeds), and the path resides on
jpayne@68	2959 a local filesystem (libev currently assumes only ext2/3, jfs, reiserfs and
jpayne@68	2960 xfs are fully working) libev usually gets away without polling.
jpayne@68	2961 .PP
jpayne@68	2962 There is no support for kqueue, as apparently it cannot be used to
jpayne@68	2963 implement this functionality, due to the requirement of having a file
jpayne@68	2964 descriptor open on the object at all times, and detecting renames, unlinks
jpayne@68	2965 etc. is difficult.
jpayne@68	2966 .PP
jpayne@68	2967 \fI\f(CI\(C`stat ()\(C'\fI is a synchronous operation\fR
jpayne@68	2968 .IX Subsection "stat () is a synchronous operation"
jpayne@68	2969 .PP
jpayne@68	2970 Libev doesn't normally do any kind of I/O itself, and so is not blocking
jpayne@68	2971 the process. The exception are \f(CW\(C`ev_stat\(C'\fR watchers \- those call \f(CW\*(C`stat
jpayne@68	2972 ()\*(C'\fR, which is a synchronous operation.
jpayne@68	2973 .PP
jpayne@68	2974 For local paths, this usually doesn't matter: unless the system is very
jpayne@68	2975 busy or the intervals between stat's are large, a stat call will be fast,
jpayne@68	2976 as the path data is usually in memory already (except when starting the
jpayne@68	2977 watcher).
jpayne@68	2978 .PP
jpayne@68	2979 For networked file systems, calling \f(CW\(C`stat ()\(C'\fR can block an indefinite
jpayne@68	2980 time due to network issues, and even under good conditions, a stat call
jpayne@68	2981 often takes multiple milliseconds.
jpayne@68	2982 .PP
jpayne@68	2983 Therefore, it is best to avoid using \f(CW\(C`ev_stat\(C'\fR watchers on networked
jpayne@68	2984 paths, although this is fully supported by libev.
jpayne@68	2985 .PP
jpayne@68	2986 \fIThe special problem of stat time resolution\fR
jpayne@68	2987 .IX Subsection "The special problem of stat time resolution"
jpayne@68	2988 .PP
jpayne@68	2989 The \f(CW\(C`stat ()\(C'\fR system call only supports full-second resolution portably,
jpayne@68	2990 and even on systems where the resolution is higher, most file systems
jpayne@68	2991 still only support whole seconds.
jpayne@68	2992 .PP
jpayne@68	2993 That means that, if the time is the only thing that changes, you can
jpayne@68	2994 easily miss updates: on the first update, \f(CW\(C`ev_stat\(C'\fR detects a change and
jpayne@68	2995 calls your callback, which does something. When there is another update
jpayne@68	2996 within the same second, \f(CW\(C`ev_stat\(C'\fR will be unable to detect unless the
jpayne@68	2997 stat data does change in other ways (e.g. file size).
jpayne@68	2998 .PP
jpayne@68	2999 The solution to this is to delay acting on a change for slightly more
jpayne@68	3000 than a second (or till slightly after the next full second boundary), using
jpayne@68	3001 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	3002 ev_timer_again (loop, w)\*(C'\fR).
jpayne@68	3003 .PP
jpayne@68	3004 The \f(CW.02\fR offset is added to work around small timing inconsistencies
jpayne@68	3005 of some operating systems (where the second counter of the current time
jpayne@68	3006 might be be delayed. One such system is the Linux kernel, where a call to
jpayne@68	3007 \&\f(CW\(C`gettimeofday\(C'\fR might return a timestamp with a full second later than
jpayne@68	3008 a subsequent \f(CW\(C`time\(C'\fR call \- if the equivalent of \f(CW\(C`time ()\(C'\fR is used to
jpayne@68	3009 update file times then there will be a small window where the kernel uses
jpayne@68	3010 the previous second to update file times but libev might already execute
jpayne@68	3011 the timer callback).
jpayne@68	3012 .PP
jpayne@68	3013 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	3014 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	3015 .IP "ev_stat_init (ev_stat , callback, const char path, ev_tstamp interval)" 4
jpayne@68	3016 .IX Item "ev_stat_init (ev_stat , callback, const char path, ev_tstamp interval)"
jpayne@68	3017 .PD 0
jpayne@68	3018 .IP "ev_stat_set (ev_stat , const char path, ev_tstamp interval)" 4
jpayne@68	3019 .IX Item "ev_stat_set (ev_stat , const char path, ev_tstamp interval)"
jpayne@68	3020 .PD
jpayne@68	3021 Configures the watcher to wait for status changes of the given
jpayne@68	3022 \&\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	3023 be detected and should normally be specified as \f(CW0\fR to let libev choose
jpayne@68	3024 a suitable value. The memory pointed to by \f(CW\(C`path\(C'\fR must point to the same
jpayne@68	3025 path for as long as the watcher is active.
jpayne@68	3026 .Sp
jpayne@68	3027 The callback will receive an \f(CW\(C`EV_STAT\(C'\fR event when a change was detected,
jpayne@68	3028 relative to the attributes at the time the watcher was started (or the
jpayne@68	3029 last change was detected).
jpayne@68	3030 .IP "ev_stat_stat (loop, ev_stat *)" 4
jpayne@68	3031 .IX Item "ev_stat_stat (loop, ev_stat *)"
jpayne@68	3032 Updates the stat buffer immediately with new values. If you change the
jpayne@68	3033 watched path in your callback, you could call this function to avoid
jpayne@68	3034 detecting this change (while introducing a race condition if you are not
jpayne@68	3035 the only one changing the path). Can also be useful simply to find out the
jpayne@68	3036 new values.
jpayne@68	3037 .IP "ev_statdata attr [read\-only]" 4
jpayne@68	3038 .IX Item "ev_statdata attr [read-only]"
jpayne@68	3039 The most-recently detected attributes of the file. Although the type is
jpayne@68	3040 \&\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	3041 suitable for your system, but you can only rely on the POSIX-standardised
jpayne@68	3042 members to be present. If the \f(CW\(C`st_nlink\(C'\fR member is \f(CW0\fR, then there was
jpayne@68	3043 some error while \f(CW\(C`stat\(C'\fRing the file.
jpayne@68	3044 .IP "ev_statdata prev [read\-only]" 4
jpayne@68	3045 .IX Item "ev_statdata prev [read-only]"
jpayne@68	3046 The previous attributes of the file. The callback gets invoked whenever
jpayne@68	3047 \&\f(CW\(C`prev\(C'\fR != \f(CW\(C`attr\(C'\fR, or, more precisely, one or more of these members
jpayne@68	3048 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	3049 \&\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	3050 .IP "ev_tstamp interval [read\-only]" 4
jpayne@68	3051 .IX Item "ev_tstamp interval [read-only]"
jpayne@68	3052 The specified interval.
jpayne@68	3053 .IP "const char *path [read\-only]" 4
jpayne@68	3054 .IX Item "const char *path [read-only]"
jpayne@68	3055 The file system path that is being watched.
jpayne@68	3056 .PP
jpayne@68	3057 \fIExamples\fR
jpayne@68	3058 .IX Subsection "Examples"
jpayne@68	3059 .PP
jpayne@68	3060 Example: Watch \f(CW\(C`/etc/passwd\(C'\fR for attribute changes.
jpayne@68	3061 .PP
jpayne@68	3062 .Vb 10
jpayne@68	3063 \& static void
jpayne@68	3064 \& passwd_cb (struct ev_loop loop, ev_stat w, int revents)
jpayne@68	3065 \& {
jpayne@68	3066 \& /* /etc/passwd changed in some way */
jpayne@68	3067 \& if (w\->attr.st_nlink)
jpayne@68	3068 \& {
jpayne@68	3069 \& printf ("passwd current size %ld\en", (long)w\->attr.st_size);
jpayne@68	3070 \& printf ("passwd current atime %ld\en", (long)w\->attr.st_mtime);
jpayne@68	3071 \& printf ("passwd current mtime %ld\en", (long)w\->attr.st_mtime);
jpayne@68	3072 \& }
jpayne@68	3073 \& else
jpayne@68	3074 \& /* you shalt not abuse printf for puts */
jpayne@68	3075 \& puts ("wow, /etc/passwd is not there, expect problems. "
jpayne@68	3076 \& "if this is windows, they already arrived\en");
jpayne@68	3077 \& }
jpayne@68	3078 \&
jpayne@68	3079 \& ...
jpayne@68	3080 \& ev_stat passwd;
jpayne@68	3081 \&
jpayne@68	3082 \& ev_stat_init (&passwd, passwd_cb, "/etc/passwd", 0.);
jpayne@68	3083 \& ev_stat_start (loop, &passwd);
jpayne@68	3084 .Ve
jpayne@68	3085 .PP
jpayne@68	3086 Example: Like above, but additionally use a one-second delay so we do not
jpayne@68	3087 miss updates (however, frequent updates will delay processing, too, so
jpayne@68	3088 one might do the work both on \f(CW\(C`ev_stat\(C'\fR callback invocation \fIand\fR on
jpayne@68	3089 \&\f(CW\(C`ev_timer\(C'\fR callback invocation).
jpayne@68	3090 .PP
jpayne@68	3091 .Vb 2
jpayne@68	3092 \& static ev_stat passwd;
jpayne@68	3093 \& static ev_timer timer;
jpayne@68	3094 \&
jpayne@68	3095 \& static void
jpayne@68	3096 \& timer_cb (EV_P_ ev_timer *w, int revents)
jpayne@68	3097 \& {
jpayne@68	3098 \& ev_timer_stop (EV_A_ w);
jpayne@68	3099 \&
jpayne@68	3100 \& /* now it\(Aqs one second after the most recent passwd change /
jpayne@68	3101 \& }
jpayne@68	3102 \&
jpayne@68	3103 \& static void
jpayne@68	3104 \& stat_cb (EV_P_ ev_stat *w, int revents)
jpayne@68	3105 \& {
jpayne@68	3106 \& /* reset the one\-second timer */
jpayne@68	3107 \& ev_timer_again (EV_A_ &timer);
jpayne@68	3108 \& }
jpayne@68	3109 \&
jpayne@68	3110 \& ...
jpayne@68	3111 \& ev_stat_init (&passwd, stat_cb, "/etc/passwd", 0.);
jpayne@68	3112 \& ev_stat_start (loop, &passwd);
jpayne@68	3113 \& ev_timer_init (&timer, timer_cb, 0., 1.02);
jpayne@68	3114 .Ve
jpayne@68	3115 .ie n .SS """ev_idle"" \- when you've got nothing better to do..."
jpayne@68	3116 .el .SS "\f(CWev_idle\fP \- when you've got nothing better to do..."
jpayne@68	3117 .IX Subsection "ev_idle - when you've got nothing better to do..."
jpayne@68	3118 Idle watchers trigger events when no other events of the same or higher
jpayne@68	3119 priority are pending (prepare, check and other idle watchers do not count
jpayne@68	3120 as receiving \(L"events\(R").
jpayne@68	3121 .PP
jpayne@68	3122 That is, as long as your process is busy handling sockets or timeouts
jpayne@68	3123 (or even signals, imagine) of the same or higher priority it will not be
jpayne@68	3124 triggered. But when your process is idle (or only lower-priority watchers
jpayne@68	3125 are pending), the idle watchers are being called once per event loop
jpayne@68	3126 iteration \- until stopped, that is, or your process receives more events
jpayne@68	3127 and becomes busy again with higher priority stuff.
jpayne@68	3128 .PP
jpayne@68	3129 The most noteworthy effect is that as long as any idle watchers are
jpayne@68	3130 active, the process will not block when waiting for new events.
jpayne@68	3131 .PP
jpayne@68	3132 Apart from keeping your process non-blocking (which is a useful
jpayne@68	3133 effect on its own sometimes), idle watchers are a good place to do
jpayne@68	3134 \&\(L"pseudo-background processing\(R", or delay processing stuff to after the
jpayne@68	3135 event loop has handled all outstanding events.
jpayne@68	3136 .PP
jpayne@68	3137 \fIAbusing an \f(CI\(C`ev_idle\(C'\fI watcher for its side-effect\fR
jpayne@68	3138 .IX Subsection "Abusing an ev_idle watcher for its side-effect"
jpayne@68	3139 .PP
jpayne@68	3140 As long as there is at least one active idle watcher, libev will never
jpayne@68	3141 sleep unnecessarily. Or in other words, it will loop as fast as possible.
jpayne@68	3142 For this to work, the idle watcher doesn't need to be invoked at all \- the
jpayne@68	3143 lowest priority will do.
jpayne@68	3144 .PP
jpayne@68	3145 This mode of operation can be useful together with an \f(CW\(C`ev_check\(C'\fR watcher,
jpayne@68	3146 to do something on each event loop iteration \- for example to balance load
jpayne@68	3147 between different connections.
jpayne@68	3148 .PP
jpayne@68	3149 See \(L"Abusing an ev_check watcher for its side-effect\(R" for a longer
jpayne@68	3150 example.
jpayne@68	3151 .PP
jpayne@68	3152 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	3153 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	3154 .IP "ev_idle_init (ev_idle *, callback)" 4
jpayne@68	3155 .IX Item "ev_idle_init (ev_idle *, callback)"
jpayne@68	3156 Initialises and configures the idle watcher \- it has no parameters of any
jpayne@68	3157 kind. There is a \f(CW\(C`ev_idle_set\(C'\fR macro, but using it is utterly pointless,
jpayne@68	3158 believe me.
jpayne@68	3159 .PP
jpayne@68	3160 \fIExamples\fR
jpayne@68	3161 .IX Subsection "Examples"
jpayne@68	3162 .PP
jpayne@68	3163 Example: Dynamically allocate an \f(CW\(C`ev_idle\(C'\fR watcher, start it, and in the
jpayne@68	3164 callback, free it. Also, use no error checking, as usual.
jpayne@68	3165 .PP
jpayne@68	3166 .Vb 5
jpayne@68	3167 \& static void
jpayne@68	3168 \& idle_cb (struct ev_loop loop, ev_idle w, int revents)
jpayne@68	3169 \& {
jpayne@68	3170 \& // stop the watcher
jpayne@68	3171 \& ev_idle_stop (loop, w);
jpayne@68	3172 \&
jpayne@68	3173 \& // now we can free it
jpayne@68	3174 \& free (w);
jpayne@68	3175 \&
jpayne@68	3176 \& // now do something you wanted to do when the program has
jpayne@68	3177 \& // no longer anything immediate to do.
jpayne@68	3178 \& }
jpayne@68	3179 \&
jpayne@68	3180 \& ev_idle *idle_watcher = malloc (sizeof (ev_idle));
jpayne@68	3181 \& ev_idle_init (idle_watcher, idle_cb);
jpayne@68	3182 \& ev_idle_start (loop, idle_watcher);
jpayne@68	3183 .Ve
jpayne@68	3184 .ie n .SS """ev_prepare"" and ""ev_check"" \- customise your event loop!"
jpayne@68	3185 .el .SS "\f(CWev_prepare\fP and \f(CWev_check\fP \- customise your event loop!"
jpayne@68	3186 .IX Subsection "ev_prepare and ev_check - customise your event loop!"
jpayne@68	3187 Prepare and check watchers are often (but not always) used in pairs:
jpayne@68	3188 prepare watchers get invoked before the process blocks and check watchers
jpayne@68	3189 afterwards.
jpayne@68	3190 .PP
jpayne@68	3191 You \fImust not\fR call \f(CW\(C`ev_run\(C'\fR (or similar functions that enter the
jpayne@68	3192 current event loop) or \f(CW\(C`ev_loop_fork\(C'\fR from either \f(CW\(C`ev_prepare\(C'\fR or
jpayne@68	3193 \&\f(CW\(C`ev_check\(C'\fR watchers. Other loops than the current one are fine,
jpayne@68	3194 however. The rationale behind this is that you do not need to check
jpayne@68	3195 for recursion in those watchers, i.e. the sequence will always be
jpayne@68	3196 \&\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	3197 kind they will always be called in pairs bracketing the blocking call.
jpayne@68	3198 .PP
jpayne@68	3199 Their main purpose is to integrate other event mechanisms into libev and
jpayne@68	3200 their use is somewhat advanced. They could be used, for example, to track
jpayne@68	3201 variable changes, implement your own watchers, integrate net-snmp or a
jpayne@68	3202 coroutine library and lots more. They are also occasionally useful if
jpayne@68	3203 you cache some data and want to flush it before blocking (for example,
jpayne@68	3204 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	3205 watcher).
jpayne@68	3206 .PP
jpayne@68	3207 This is done by examining in each prepare call which file descriptors
jpayne@68	3208 need to be watched by the other library, registering \f(CW\(C`ev_io\(C'\fR watchers
jpayne@68	3209 for them and starting an \f(CW\(C`ev_timer\(C'\fR watcher for any timeouts (many
jpayne@68	3210 libraries provide exactly this functionality). Then, in the check watcher,
jpayne@68	3211 you check for any events that occurred (by checking the pending status
jpayne@68	3212 of all watchers and stopping them) and call back into the library. The
jpayne@68	3213 I/O and timer callbacks will never actually be called (but must be valid
jpayne@68	3214 nevertheless, because you never know, you know?).
jpayne@68	3215 .PP
jpayne@68	3216 As another example, the Perl Coro module uses these hooks to integrate
jpayne@68	3217 coroutines into libev programs, by yielding to other active coroutines
jpayne@68	3218 during each prepare and only letting the process block if no coroutines
jpayne@68	3219 are ready to run (it's actually more complicated: it only runs coroutines
jpayne@68	3220 with priority higher than or equal to the event loop and one coroutine
jpayne@68	3221 of lower priority, but only once, using idle watchers to keep the event
jpayne@68	3222 loop from blocking if lower-priority coroutines are active, thus mapping
jpayne@68	3223 low-priority coroutines to idle/background tasks).
jpayne@68	3224 .PP
jpayne@68	3225 When used for this purpose, it is recommended to give \f(CW\(C`ev_check\(C'\fR watchers
jpayne@68	3226 highest (\f(CW\(C`EV_MAXPRI\(C'\fR) priority, to ensure that they are being run before
jpayne@68	3227 any other watchers after the poll (this doesn't matter for \f(CW\(C`ev_prepare\(C'\fR
jpayne@68	3228 watchers).
jpayne@68	3229 .PP
jpayne@68	3230 Also, \f(CW\(C`ev_check\(C'\fR watchers (and \f(CW\(C`ev_prepare\(C'\fR watchers, too) should not
jpayne@68	3231 activate (\(L"feed\(R") events into libev. While libev fully supports this, they
jpayne@68	3232 might get executed before other \f(CW\(C`ev_check\(C'\fR watchers did their job. As
jpayne@68	3233 \&\f(CW\(C`ev_check\(C'\fR watchers are often used to embed other (non-libev) event
jpayne@68	3234 loops those other event loops might be in an unusable state until their
jpayne@68	3235 \&\f(CW\(C`ev_check\(C'\fR watcher ran (always remind yourself to coexist peacefully with
jpayne@68	3236 others).
jpayne@68	3237 .PP
jpayne@68	3238 \fIAbusing an \f(CI\(C`ev_check\(C'\fI watcher for its side-effect\fR
jpayne@68	3239 .IX Subsection "Abusing an ev_check watcher for its side-effect"
jpayne@68	3240 .PP
jpayne@68	3241 \&\f(CW\(C`ev_check\(C'\fR (and less often also \f(CW\(C`ev_prepare\(C'\fR) watchers can also be
jpayne@68	3242 useful because they are called once per event loop iteration. For
jpayne@68	3243 example, if you want to handle a large number of connections fairly, you
jpayne@68	3244 normally only do a bit of work for each active connection, and if there
jpayne@68	3245 is more work to do, you wait for the next event loop iteration, so other
jpayne@68	3246 connections have a chance of making progress.
jpayne@68	3247 .PP
jpayne@68	3248 Using an \f(CW\(C`ev_check\(C'\fR watcher is almost enough: it will be called on the
jpayne@68	3249 next event loop iteration. However, that isn't as soon as possible \-
jpayne@68	3250 without external events, your \f(CW\(C`ev_check\(C'\fR watcher will not be invoked.
jpayne@68	3251 .PP
jpayne@68	3252 This is where \f(CW\(C`ev_idle\(C'\fR watchers come in handy \- all you need is a
jpayne@68	3253 single global idle watcher that is active as long as you have one active
jpayne@68	3254 \&\f(CW\(C`ev_check\(C'\fR watcher. The \f(CW\(C`ev_idle\(C'\fR watcher makes sure the event loop
jpayne@68	3255 will not sleep, and the \f(CW\(C`ev_check\(C'\fR watcher makes sure a callback gets
jpayne@68	3256 invoked. Neither watcher alone can do that.
jpayne@68	3257 .PP
jpayne@68	3258 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	3259 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	3260 .IP "ev_prepare_init (ev_prepare *, callback)" 4
jpayne@68	3261 .IX Item "ev_prepare_init (ev_prepare *, callback)"
jpayne@68	3262 .PD 0
jpayne@68	3263 .IP "ev_check_init (ev_check *, callback)" 4
jpayne@68	3264 .IX Item "ev_check_init (ev_check *, callback)"
jpayne@68	3265 .PD
jpayne@68	3266 Initialises and configures the prepare or check watcher \- they have no
jpayne@68	3267 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	3268 macros, but using them is utterly, utterly, utterly and completely
jpayne@68	3269 pointless.
jpayne@68	3270 .PP
jpayne@68	3271 \fIExamples\fR
jpayne@68	3272 .IX Subsection "Examples"
jpayne@68	3273 .PP
jpayne@68	3274 There are a number of principal ways to embed other event loops or modules
jpayne@68	3275 into libev. Here are some ideas on how to include libadns into libev
jpayne@68	3276 (there is a Perl module named \f(CW\(C`EV::ADNS\(C'\fR that does this, which you could
jpayne@68	3277 use as a working example. Another Perl module named \f(CW\(C`EV::Glib\(C'\fR embeds a
jpayne@68	3278 Glib main context into libev, and finally, \f(CW\(C`Glib::EV\(C'\fR embeds \s-1EV\s0 into the
jpayne@68	3279 Glib event loop).
jpayne@68	3280 .PP
jpayne@68	3281 Method 1: Add \s-1IO\s0 watchers and a timeout watcher in a prepare handler,
jpayne@68	3282 and in a check watcher, destroy them and call into libadns. What follows
jpayne@68	3283 is pseudo-code only of course. This requires you to either use a low
jpayne@68	3284 priority for the check watcher or use \f(CW\(C`ev_clear_pending\(C'\fR explicitly, as
jpayne@68	3285 the callbacks for the IO/timeout watchers might not have been called yet.
jpayne@68	3286 .PP
jpayne@68	3287 .Vb 2
jpayne@68	3288 \& static ev_io iow [nfd];
jpayne@68	3289 \& static ev_timer tw;
jpayne@68	3290 \&
jpayne@68	3291 \& static void
jpayne@68	3292 \& io_cb (struct ev_loop loop, ev_io w, int revents)
jpayne@68	3293 \& {
jpayne@68	3294 \& }
jpayne@68	3295 \&
jpayne@68	3296 \& // create io watchers for each fd and a timer before blocking
jpayne@68	3297 \& static void
jpayne@68	3298 \& adns_prepare_cb (struct ev_loop loop, ev_prepare w, int revents)
jpayne@68	3299 \& {
jpayne@68	3300 \& int timeout = 3600000;
jpayne@68	3301 \& struct pollfd fds [nfd];
jpayne@68	3302 \& // actual code will need to loop here and realloc etc.
jpayne@68	3303 \& adns_beforepoll (ads, fds, &nfd, &timeout, timeval_from (ev_time ()));
jpayne@68	3304 \&
jpayne@68	3305 \& /* the callback is illegal, but won\(Aqt be called as we stop during check /
jpayne@68	3306 \& ev_timer_init (&tw, 0, timeout * 1e\-3, 0.);
jpayne@68	3307 \& ev_timer_start (loop, &tw);
jpayne@68	3308 \&
jpayne@68	3309 \& // create one ev_io per pollfd
jpayne@68	3310 \& for (int i = 0; i < nfd; ++i)
jpayne@68	3311 \& {
jpayne@68	3312 \& ev_io_init (iow + i, io_cb, fds [i].fd,
jpayne@68	3313 \& ((fds [i].events & POLLIN ? EV_READ : 0)
jpayne@68	3314 \& \| (fds [i].events & POLLOUT ? EV_WRITE : 0)));
jpayne@68	3315 \&
jpayne@68	3316 \& fds [i].revents = 0;
jpayne@68	3317 \& ev_io_start (loop, iow + i);
jpayne@68	3318 \& }
jpayne@68	3319 \& }
jpayne@68	3320 \&
jpayne@68	3321 \& // stop all watchers after blocking
jpayne@68	3322 \& static void
jpayne@68	3323 \& adns_check_cb (struct ev_loop loop, ev_check w, int revents)
jpayne@68	3324 \& {
jpayne@68	3325 \& ev_timer_stop (loop, &tw);
jpayne@68	3326 \&
jpayne@68	3327 \& for (int i = 0; i < nfd; ++i)
jpayne@68	3328 \& {
jpayne@68	3329 \& // set the relevant poll flags
jpayne@68	3330 \& // could also call adns_processreadable etc. here
jpayne@68	3331 \& struct pollfd *fd = fds + i;
jpayne@68	3332 \& int revents = ev_clear_pending (iow + i);
jpayne@68	3333 \& if (revents & EV_READ ) fd\->revents \|= fd\->events & POLLIN;
jpayne@68	3334 \& if (revents & EV_WRITE) fd\->revents \|= fd\->events & POLLOUT;
jpayne@68	3335 \&
jpayne@68	3336 \& // now stop the watcher
jpayne@68	3337 \& ev_io_stop (loop, iow + i);
jpayne@68	3338 \& }
jpayne@68	3339 \&
jpayne@68	3340 \& adns_afterpoll (adns, fds, nfd, timeval_from (ev_now (loop));
jpayne@68	3341 \& }
jpayne@68	3342 .Ve
jpayne@68	3343 .PP
jpayne@68	3344 Method 2: This would be just like method 1, but you run \f(CW\(C`adns_afterpoll\(C'\fR
jpayne@68	3345 in the prepare watcher and would dispose of the check watcher.
jpayne@68	3346 .PP
jpayne@68	3347 Method 3: If the module to be embedded supports explicit event
jpayne@68	3348 notification (libadns does), you can also make use of the actual watcher
jpayne@68	3349 callbacks, and only destroy/create the watchers in the prepare watcher.
jpayne@68	3350 .PP
jpayne@68	3351 .Vb 5
jpayne@68	3352 \& static void
jpayne@68	3353 \& timer_cb (EV_P_ ev_timer *w, int revents)
jpayne@68	3354 \& {
jpayne@68	3355 \& adns_state ads = (adns_state)w\->data;
jpayne@68	3356 \& update_now (EV_A);
jpayne@68	3357 \&
jpayne@68	3358 \& adns_processtimeouts (ads, &tv_now);
jpayne@68	3359 \& }
jpayne@68	3360 \&
jpayne@68	3361 \& static void
jpayne@68	3362 \& io_cb (EV_P_ ev_io *w, int revents)
jpayne@68	3363 \& {
jpayne@68	3364 \& adns_state ads = (adns_state)w\->data;
jpayne@68	3365 \& update_now (EV_A);
jpayne@68	3366 \&
jpayne@68	3367 \& if (revents & EV_READ ) adns_processreadable (ads, w\->fd, &tv_now);
jpayne@68	3368 \& if (revents & EV_WRITE) adns_processwriteable (ads, w\->fd, &tv_now);
jpayne@68	3369 \& }
jpayne@68	3370 \&
jpayne@68	3371 \& // do not ever call adns_afterpoll
jpayne@68	3372 .Ve
jpayne@68	3373 .PP
jpayne@68	3374 Method 4: Do not use a prepare or check watcher because the module you
jpayne@68	3375 want to embed is not flexible enough to support it. Instead, you can
jpayne@68	3376 override their poll function. The drawback with this solution is that the
jpayne@68	3377 main loop is now no longer controllable by \s-1EV.\s0 The \f(CW\(C`Glib::EV\(C'\fR module uses
jpayne@68	3378 this approach, effectively embedding \s-1EV\s0 as a client into the horrible
jpayne@68	3379 libglib event loop.
jpayne@68	3380 .PP
jpayne@68	3381 .Vb 4
jpayne@68	3382 \& static gint
jpayne@68	3383 \& event_poll_func (GPollFD *fds, guint nfds, gint timeout)
jpayne@68	3384 \& {
jpayne@68	3385 \& int got_events = 0;
jpayne@68	3386 \&
jpayne@68	3387 \& for (n = 0; n < nfds; ++n)
jpayne@68	3388 \& // create/start io watcher that sets the relevant bits in fds[n] and increment got_events
jpayne@68	3389 \&
jpayne@68	3390 \& if (timeout >= 0)
jpayne@68	3391 \& // create/start timer
jpayne@68	3392 \&
jpayne@68	3393 \& // poll
jpayne@68	3394 \& ev_run (EV_A_ 0);
jpayne@68	3395 \&
jpayne@68	3396 \& // stop timer again
jpayne@68	3397 \& if (timeout >= 0)
jpayne@68	3398 \& ev_timer_stop (EV_A_ &to);
jpayne@68	3399 \&
jpayne@68	3400 \& // stop io watchers again \- their callbacks should have set
jpayne@68	3401 \& for (n = 0; n < nfds; ++n)
jpayne@68	3402 \& ev_io_stop (EV_A_ iow [n]);
jpayne@68	3403 \&
jpayne@68	3404 \& return got_events;
jpayne@68	3405 \& }
jpayne@68	3406 .Ve
jpayne@68	3407 .ie n .SS """ev_embed"" \- when one backend isn't enough..."
jpayne@68	3408 .el .SS "\f(CWev_embed\fP \- when one backend isn't enough..."
jpayne@68	3409 .IX Subsection "ev_embed - when one backend isn't enough..."
jpayne@68	3410 This is a rather advanced watcher type that lets you embed one event loop
jpayne@68	3411 into another (currently only \f(CW\(C`ev_io\(C'\fR events are supported in the embedded
jpayne@68	3412 loop, other types of watchers might be handled in a delayed or incorrect
jpayne@68	3413 fashion and must not be used).
jpayne@68	3414 .PP
jpayne@68	3415 There are primarily two reasons you would want that: work around bugs and
jpayne@68	3416 prioritise I/O.
jpayne@68	3417 .PP
jpayne@68	3418 As an example for a bug workaround, the kqueue backend might only support
jpayne@68	3419 sockets on some platform, so it is unusable as generic backend, but you
jpayne@68	3420 still want to make use of it because you have many sockets and it scales
jpayne@68	3421 so nicely. In this case, you would create a kqueue-based loop and embed
jpayne@68	3422 it into your default loop (which might use e.g. poll). Overall operation
jpayne@68	3423 will be a bit slower because first libev has to call \f(CW\(C`poll\(C'\fR and then
jpayne@68	3424 \&\f(CW\(C`kevent\(C'\fR, but at least you can use both mechanisms for what they are
jpayne@68	3425 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	3426 .PP
jpayne@68	3427 As for prioritising I/O: under rare circumstances you have the case where
jpayne@68	3428 some fds have to be watched and handled very quickly (with low latency),
jpayne@68	3429 and even priorities and idle watchers might have too much overhead. In
jpayne@68	3430 this case you would put all the high priority stuff in one loop and all
jpayne@68	3431 the rest in a second one, and embed the second one in the first.
jpayne@68	3432 .PP
jpayne@68	3433 As long as the watcher is active, the callback will be invoked every
jpayne@68	3434 time there might be events pending in the embedded loop. The callback
jpayne@68	3435 must then call \f(CW\(C`ev_embed_sweep (mainloop, watcher)\(C'\fR to make a single
jpayne@68	3436 sweep and invoke their callbacks (the callback doesn't need to invoke the
jpayne@68	3437 \&\f(CW\(C`ev_embed_sweep\(C'\fR function directly, it could also start an idle watcher
jpayne@68	3438 to give the embedded loop strictly lower priority for example).
jpayne@68	3439 .PP
jpayne@68	3440 You can also set the callback to \f(CW0\fR, in which case the embed watcher
jpayne@68	3441 will automatically execute the embedded loop sweep whenever necessary.
jpayne@68	3442 .PP
jpayne@68	3443 Fork detection will be handled transparently while the \f(CW\(C`ev_embed\(C'\fR watcher
jpayne@68	3444 is active, i.e., the embedded loop will automatically be forked when the
jpayne@68	3445 embedding loop forks. In other cases, the user is responsible for calling
jpayne@68	3446 \&\f(CW\(C`ev_loop_fork\(C'\fR on the embedded loop.
jpayne@68	3447 .PP
jpayne@68	3448 Unfortunately, not all backends are embeddable: only the ones returned by
jpayne@68	3449 \&\f(CW\(C`ev_embeddable_backends\(C'\fR are, which, unfortunately, does not include any
jpayne@68	3450 portable one.
jpayne@68	3451 .PP
jpayne@68	3452 So when you want to use this feature you will always have to be prepared
jpayne@68	3453 that you cannot get an embeddable loop. The recommended way to get around
jpayne@68	3454 this is to have a separate variables for your embeddable loop, try to
jpayne@68	3455 create it, and if that fails, use the normal loop for everything.
jpayne@68	3456 .PP
jpayne@68	3457 \fI\f(CI\(C`ev_embed\(C'\fI and fork\fR
jpayne@68	3458 .IX Subsection "ev_embed and fork"
jpayne@68	3459 .PP
jpayne@68	3460 While the \f(CW\(C`ev_embed\(C'\fR watcher is running, forks in the embedding loop will
jpayne@68	3461 automatically be applied to the embedded loop as well, so no special
jpayne@68	3462 fork handling is required in that case. When the watcher is not running,
jpayne@68	3463 however, it is still the task of the libev user to call \f(CW\(C`ev_loop_fork ()\(C'\fR
jpayne@68	3464 as applicable.
jpayne@68	3465 .PP
jpayne@68	3466 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	3467 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	3468 .IP "ev_embed_init (ev_embed , callback, struct ev_loop embedded_loop)" 4
jpayne@68	3469 .IX Item "ev_embed_init (ev_embed , callback, struct ev_loop embedded_loop)"
jpayne@68	3470 .PD 0
jpayne@68	3471 .IP "ev_embed_set (ev_embed , struct ev_loop embedded_loop)" 4
jpayne@68	3472 .IX Item "ev_embed_set (ev_embed , struct ev_loop embedded_loop)"
jpayne@68	3473 .PD
jpayne@68	3474 Configures the watcher to embed the given loop, which must be
jpayne@68	3475 embeddable. If the callback is \f(CW0\fR, then \f(CW\(C`ev_embed_sweep\(C'\fR will be
jpayne@68	3476 invoked automatically, otherwise it is the responsibility of the callback
jpayne@68	3477 to invoke it (it will continue to be called until the sweep has been done,
jpayne@68	3478 if you do not want that, you need to temporarily stop the embed watcher).
jpayne@68	3479 .IP "ev_embed_sweep (loop, ev_embed *)" 4
jpayne@68	3480 .IX Item "ev_embed_sweep (loop, ev_embed *)"
jpayne@68	3481 Make a single, non-blocking sweep over the embedded loop. This works
jpayne@68	3482 similarly to \f(CW\(C`ev_run (embedded_loop, EVRUN_NOWAIT)\(C'\fR, but in the most
jpayne@68	3483 appropriate way for embedded loops.
jpayne@68	3484 .IP "struct ev_loop *other [read\-only]" 4
jpayne@68	3485 .IX Item "struct ev_loop *other [read-only]"
jpayne@68	3486 The embedded event loop.
jpayne@68	3487 .PP
jpayne@68	3488 \fIExamples\fR
jpayne@68	3489 .IX Subsection "Examples"
jpayne@68	3490 .PP
jpayne@68	3491 Example: Try to get an embeddable event loop and embed it into the default
jpayne@68	3492 event loop. If that is not possible, use the default loop. The default
jpayne@68	3493 loop is stored in \f(CW\(C`loop_hi\(C'\fR, while the embeddable loop is stored in
jpayne@68	3494 \&\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	3495 used).
jpayne@68	3496 .PP
jpayne@68	3497 .Vb 3
jpayne@68	3498 \& struct ev_loop *loop_hi = ev_default_init (0);
jpayne@68	3499 \& struct ev_loop *loop_lo = 0;
jpayne@68	3500 \& ev_embed embed;
jpayne@68	3501 \&
jpayne@68	3502 \& // see if there is a chance of getting one that works
jpayne@68	3503 \& // (remember that a flags value of 0 means autodetection)
jpayne@68	3504 \& loop_lo = ev_embeddable_backends () & ev_recommended_backends ()
jpayne@68	3505 \& ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ())
jpayne@68	3506 \& : 0;
jpayne@68	3507 \&
jpayne@68	3508 \& // if we got one, then embed it, otherwise default to loop_hi
jpayne@68	3509 \& if (loop_lo)
jpayne@68	3510 \& {
jpayne@68	3511 \& ev_embed_init (&embed, 0, loop_lo);
jpayne@68	3512 \& ev_embed_start (loop_hi, &embed);
jpayne@68	3513 \& }
jpayne@68	3514 \& else
jpayne@68	3515 \& loop_lo = loop_hi;
jpayne@68	3516 .Ve
jpayne@68	3517 .PP
jpayne@68	3518 Example: Check if kqueue is available but not recommended and create
jpayne@68	3519 a kqueue backend for use with sockets (which usually work with any
jpayne@68	3520 kqueue implementation). Store the kqueue/socket\-only event loop in
jpayne@68	3521 \&\f(CW\(C`loop_socket\(C'\fR. (One might optionally use \f(CW\(C`EVFLAG_NOENV\(C'\fR, too).
jpayne@68	3522 .PP
jpayne@68	3523 .Vb 3
jpayne@68	3524 \& struct ev_loop *loop = ev_default_init (0);
jpayne@68	3525 \& struct ev_loop *loop_socket = 0;
jpayne@68	3526 \& ev_embed embed;
jpayne@68	3527 \&
jpayne@68	3528 \& if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE)
jpayne@68	3529 \& if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE))
jpayne@68	3530 \& {
jpayne@68	3531 \& ev_embed_init (&embed, 0, loop_socket);
jpayne@68	3532 \& ev_embed_start (loop, &embed);
jpayne@68	3533 \& }
jpayne@68	3534 \&
jpayne@68	3535 \& if (!loop_socket)
jpayne@68	3536 \& loop_socket = loop;
jpayne@68	3537 \&
jpayne@68	3538 \& // now use loop_socket for all sockets, and loop for everything else
jpayne@68	3539 .Ve
jpayne@68	3540 .ie n .SS """ev_fork"" \- the audacity to resume the event loop after a fork"
jpayne@68	3541 .el .SS "\f(CWev_fork\fP \- the audacity to resume the event loop after a fork"
jpayne@68	3542 .IX Subsection "ev_fork - the audacity to resume the event loop after a fork"
jpayne@68	3543 Fork watchers are called when a \f(CW\(C`fork ()\(C'\fR was detected (usually because
jpayne@68	3544 whoever is a good citizen cared to tell libev about it by calling
jpayne@68	3545 \&\f(CW\(C`ev_loop_fork\(C'\fR). The invocation is done before the event loop blocks next
jpayne@68	3546 and before \f(CW\(C`ev_check\(C'\fR watchers are being called, and only in the child
jpayne@68	3547 after the fork. If whoever good citizen calling \f(CW\(C`ev_default_fork\(C'\fR cheats
jpayne@68	3548 and calls it in the wrong process, the fork handlers will be invoked, too,
jpayne@68	3549 of course.
jpayne@68	3550 .PP
jpayne@68	3551 \fIThe special problem of life after fork \- how is it possible?\fR
jpayne@68	3552 .IX Subsection "The special problem of life after fork - how is it possible?"
jpayne@68	3553 .PP
jpayne@68	3554 Most uses of \f(CW\(C`fork ()\(C'\fR consist of forking, then some simple calls to set
jpayne@68	3555 up/change the process environment, followed by a call to \f(CW\(C`exec()\(C'\fR. This
jpayne@68	3556 sequence should be handled by libev without any problems.
jpayne@68	3557 .PP
jpayne@68	3558 This changes when the application actually wants to do event handling
jpayne@68	3559 in the child, or both parent in child, in effect \(L"continuing\(R" after the
jpayne@68	3560 fork.
jpayne@68	3561 .PP
jpayne@68	3562 The default mode of operation (for libev, with application help to detect
jpayne@68	3563 forks) is to duplicate all the state in the child, as would be expected
jpayne@68	3564 when \fIeither\fR the parent \fIor\fR the child process continues.
jpayne@68	3565 .PP
jpayne@68	3566 When both processes want to continue using libev, then this is usually the
jpayne@68	3567 wrong result. In that case, usually one process (typically the parent) is
jpayne@68	3568 supposed to continue with all watchers in place as before, while the other
jpayne@68	3569 process typically wants to start fresh, i.e. without any active watchers.
jpayne@68	3570 .PP
jpayne@68	3571 The cleanest and most efficient way to achieve that with libev is to
jpayne@68	3572 simply create a new event loop, which of course will be \(L"empty\(R", and
jpayne@68	3573 use that for new watchers. This has the advantage of not touching more
jpayne@68	3574 memory than necessary, and thus avoiding the copy-on-write, and the
jpayne@68	3575 disadvantage of having to use multiple event loops (which do not support
jpayne@68	3576 signal watchers).
jpayne@68	3577 .PP
jpayne@68	3578 When this is not possible, or you want to use the default loop for
jpayne@68	3579 other reasons, then in the process that wants to start \(L"fresh\(R", call
jpayne@68	3580 \&\f(CW\(C`ev_loop_destroy (EV_DEFAULT)\(C'\fR followed by \f(CW\(C`ev_default_loop (...)\(C'\fR.
jpayne@68	3581 Destroying the default loop will \(L"orphan\(R" (not stop) all registered
jpayne@68	3582 watchers, so you have to be careful not to execute code that modifies
jpayne@68	3583 those watchers. Note also that in that case, you have to re-register any
jpayne@68	3584 signal watchers.
jpayne@68	3585 .PP
jpayne@68	3586 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	3587 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	3588 .IP "ev_fork_init (ev_fork *, callback)" 4
jpayne@68	3589 .IX Item "ev_fork_init (ev_fork *, callback)"
jpayne@68	3590 Initialises and configures the fork watcher \- it has no parameters of any
jpayne@68	3591 kind. There is a \f(CW\(C`ev_fork_set\(C'\fR macro, but using it is utterly pointless,
jpayne@68	3592 really.
jpayne@68	3593 .ie n .SS """ev_cleanup"" \- even the best things end"
jpayne@68	3594 .el .SS "\f(CWev_cleanup\fP \- even the best things end"
jpayne@68	3595 .IX Subsection "ev_cleanup - even the best things end"
jpayne@68	3596 Cleanup watchers are called just before the event loop is being destroyed
jpayne@68	3597 by a call to \f(CW\(C`ev_loop_destroy\(C'\fR.
jpayne@68	3598 .PP
jpayne@68	3599 While there is no guarantee that the event loop gets destroyed, cleanup
jpayne@68	3600 watchers provide a convenient method to install cleanup hooks for your
jpayne@68	3601 program, worker threads and so on \- you just to make sure to destroy the
jpayne@68	3602 loop when you want them to be invoked.
jpayne@68	3603 .PP
jpayne@68	3604 Cleanup watchers are invoked in the same way as any other watcher. Unlike
jpayne@68	3605 all other watchers, they do not keep a reference to the event loop (which
jpayne@68	3606 makes a lot of sense if you think about it). Like all other watchers, you
jpayne@68	3607 can call libev functions in the callback, except \f(CW\(C`ev_cleanup_start\(C'\fR.
jpayne@68	3608 .PP
jpayne@68	3609 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	3610 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	3611 .IP "ev_cleanup_init (ev_cleanup *, callback)" 4
jpayne@68	3612 .IX Item "ev_cleanup_init (ev_cleanup *, callback)"
jpayne@68	3613 Initialises and configures the cleanup watcher \- it has no parameters of
jpayne@68	3614 any kind. There is a \f(CW\(C`ev_cleanup_set\(C'\fR macro, but using it is utterly
jpayne@68	3615 pointless, I assure you.
jpayne@68	3616 .PP
jpayne@68	3617 Example: Register an atexit handler to destroy the default loop, so any
jpayne@68	3618 cleanup functions are called.
jpayne@68	3619 .PP
jpayne@68	3620 .Vb 5
jpayne@68	3621 \& static void
jpayne@68	3622 \& program_exits (void)
jpayne@68	3623 \& {
jpayne@68	3624 \& ev_loop_destroy (EV_DEFAULT_UC);
jpayne@68	3625 \& }
jpayne@68	3626 \&
jpayne@68	3627 \& ...
jpayne@68	3628 \& atexit (program_exits);
jpayne@68	3629 .Ve
jpayne@68	3630 .ie n .SS """ev_async"" \- how to wake up an event loop"
jpayne@68	3631 .el .SS "\f(CWev_async\fP \- how to wake up an event loop"
jpayne@68	3632 .IX Subsection "ev_async - how to wake up an event loop"
jpayne@68	3633 In general, you cannot use an \f(CW\(C`ev_loop\(C'\fR from multiple threads or other
jpayne@68	3634 asynchronous sources such as signal handlers (as opposed to multiple event
jpayne@68	3635 loops \- those are of course safe to use in different threads).
jpayne@68	3636 .PP
jpayne@68	3637 Sometimes, however, you need to wake up an event loop you do not control,
jpayne@68	3638 for example because it belongs to another thread. This is what \f(CW\(C`ev_async\(C'\fR
jpayne@68	3639 watchers do: as long as the \f(CW\(C`ev_async\(C'\fR watcher is active, you can signal
jpayne@68	3640 it by calling \f(CW\(C`ev_async_send\(C'\fR, which is thread\- and signal safe.
jpayne@68	3641 .PP
jpayne@68	3642 This functionality is very similar to \f(CW\(C`ev_signal\(C'\fR watchers, as signals,
jpayne@68	3643 too, are asynchronous in nature, and signals, too, will be compressed
jpayne@68	3644 (i.e. the number of callback invocations may be less than the number of
jpayne@68	3645 \&\f(CW\(C`ev_async_send\(C'\fR calls). In fact, you could use signal watchers as a kind
jpayne@68	3646 of \(L"global async watchers\(R" by using a watcher on an otherwise unused
jpayne@68	3647 signal, and \f(CW\(C`ev_feed_signal\(C'\fR to signal this watcher from another thread,
jpayne@68	3648 even without knowing which loop owns the signal.
jpayne@68	3649 .PP
jpayne@68	3650 \fIQueueing\fR
jpayne@68	3651 .IX Subsection "Queueing"
jpayne@68	3652 .PP
jpayne@68	3653 \&\f(CW\(C`ev_async\(C'\fR does not support queueing of data in any way. The reason
jpayne@68	3654 is that the author does not know of a simple (or any) algorithm for a
jpayne@68	3655 multiple-writer-single-reader queue that works in all cases and doesn't
jpayne@68	3656 need elaborate support such as pthreads or unportable memory access
jpayne@68	3657 semantics.
jpayne@68	3658 .PP
jpayne@68	3659 That means that if you want to queue data, you have to provide your own
jpayne@68	3660 queue. But at least I can tell you how to implement locking around your
jpayne@68	3661 queue:
jpayne@68	3662 .IP "queueing from a signal handler context" 4
jpayne@68	3663 .IX Item "queueing from a signal handler context"
jpayne@68	3664 To implement race-free queueing, you simply add to the queue in the signal
jpayne@68	3665 handler but you block the signal handler in the watcher callback. Here is
jpayne@68	3666 an example that does that for some fictitious \s-1SIGUSR1\s0 handler:
jpayne@68	3667 .Sp
jpayne@68	3668 .Vb 1
jpayne@68	3669 \& static ev_async mysig;
jpayne@68	3670 \&
jpayne@68	3671 \& static void
jpayne@68	3672 \& sigusr1_handler (void)
jpayne@68	3673 \& {
jpayne@68	3674 \& sometype data;
jpayne@68	3675 \&
jpayne@68	3676 \& // no locking etc.
jpayne@68	3677 \& queue_put (data);
jpayne@68	3678 \& ev_async_send (EV_DEFAULT_ &mysig);
jpayne@68	3679 \& }
jpayne@68	3680 \&
jpayne@68	3681 \& static void
jpayne@68	3682 \& mysig_cb (EV_P_ ev_async *w, int revents)
jpayne@68	3683 \& {
jpayne@68	3684 \& sometype data;
jpayne@68	3685 \& sigset_t block, prev;
jpayne@68	3686 \&
jpayne@68	3687 \& sigemptyset (&block);
jpayne@68	3688 \& sigaddset (&block, SIGUSR1);
jpayne@68	3689 \& sigprocmask (SIG_BLOCK, &block, &prev);
jpayne@68	3690 \&
jpayne@68	3691 \& while (queue_get (&data))
jpayne@68	3692 \& process (data);
jpayne@68	3693 \&
jpayne@68	3694 \& if (sigismember (&prev, SIGUSR1)
jpayne@68	3695 \& sigprocmask (SIG_UNBLOCK, &block, 0);
jpayne@68	3696 \& }
jpayne@68	3697 .Ve
jpayne@68	3698 .Sp
jpayne@68	3699 (Note: pthreads in theory requires you to use \f(CW\(C`pthread_setmask\(C'\fR
jpayne@68	3700 instead of \f(CW\(C`sigprocmask\(C'\fR when you use threads, but libev doesn't do it
jpayne@68	3701 either...).
jpayne@68	3702 .IP "queueing from a thread context" 4
jpayne@68	3703 .IX Item "queueing from a thread context"
jpayne@68	3704 The strategy for threads is different, as you cannot (easily) block
jpayne@68	3705 threads but you can easily preempt them, so to queue safely you need to
jpayne@68	3706 employ a traditional mutex lock, such as in this pthread example:
jpayne@68	3707 .Sp
jpayne@68	3708 .Vb 2
jpayne@68	3709 \& static ev_async mysig;
jpayne@68	3710 \& static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
jpayne@68	3711 \&
jpayne@68	3712 \& static void
jpayne@68	3713 \& otherthread (void)
jpayne@68	3714 \& {
jpayne@68	3715 \& // only need to lock the actual queueing operation
jpayne@68	3716 \& pthread_mutex_lock (&mymutex);
jpayne@68	3717 \& queue_put (data);
jpayne@68	3718 \& pthread_mutex_unlock (&mymutex);
jpayne@68	3719 \&
jpayne@68	3720 \& ev_async_send (EV_DEFAULT_ &mysig);
jpayne@68	3721 \& }
jpayne@68	3722 \&
jpayne@68	3723 \& static void
jpayne@68	3724 \& mysig_cb (EV_P_ ev_async *w, int revents)
jpayne@68	3725 \& {
jpayne@68	3726 \& pthread_mutex_lock (&mymutex);
jpayne@68	3727 \&
jpayne@68	3728 \& while (queue_get (&data))
jpayne@68	3729 \& process (data);
jpayne@68	3730 \&
jpayne@68	3731 \& pthread_mutex_unlock (&mymutex);
jpayne@68	3732 \& }
jpayne@68	3733 .Ve
jpayne@68	3734 .PP
jpayne@68	3735 \fIWatcher-Specific Functions and Data Members\fR
jpayne@68	3736 .IX Subsection "Watcher-Specific Functions and Data Members"
jpayne@68	3737 .IP "ev_async_init (ev_async *, callback)" 4
jpayne@68	3738 .IX Item "ev_async_init (ev_async *, callback)"
jpayne@68	3739 Initialises and configures the async watcher \- it has no parameters of any
jpayne@68	3740 kind. There is a \f(CW\(C`ev_async_set\(C'\fR macro, but using it is utterly pointless,
jpayne@68	3741 trust me.
jpayne@68	3742 .IP "ev_async_send (loop, ev_async *)" 4
jpayne@68	3743 .IX Item "ev_async_send (loop, ev_async *)"
jpayne@68	3744 Sends/signals/activates the given \f(CW\(C`ev_async\(C'\fR watcher, that is, feeds
jpayne@68	3745 an \f(CW\(C`EV_ASYNC\(C'\fR event on the watcher into the event loop, and instantly
jpayne@68	3746 returns.
jpayne@68	3747 .Sp
jpayne@68	3748 Unlike \f(CW\(C`ev_feed_event\(C'\fR, this call is safe to do from other threads,
jpayne@68	3749 signal or similar contexts (see the discussion of \f(CW\(C`EV_ATOMIC_T\(C'\fR in the
jpayne@68	3750 embedding section below on what exactly this means).
jpayne@68	3751 .Sp
jpayne@68	3752 Note that, as with other watchers in libev, multiple events might get
jpayne@68	3753 compressed into a single callback invocation (another way to look at
jpayne@68	3754 this is that \f(CW\(C`ev_async\(C'\fR watchers are level-triggered: they are set on
jpayne@68	3755 \&\f(CW\(C`ev_async_send\(C'\fR, reset when the event loop detects that).
jpayne@68	3756 .Sp
jpayne@68	3757 This call incurs the overhead of at most one extra system call per event
jpayne@68	3758 loop iteration, if the event loop is blocked, and no syscall at all if
jpayne@68	3759 the event loop (or your program) is processing events. That means that
jpayne@68	3760 repeated calls are basically free (there is no need to avoid calls for
jpayne@68	3761 performance reasons) and that the overhead becomes smaller (typically
jpayne@68	3762 zero) under load.
jpayne@68	3763 .IP "bool = ev_async_pending (ev_async *)" 4
jpayne@68	3764 .IX Item "bool = ev_async_pending (ev_async *)"
jpayne@68	3765 Returns a non-zero value when \f(CW\(C`ev_async_send\(C'\fR has been called on the
jpayne@68	3766 watcher but the event has not yet been processed (or even noted) by the
jpayne@68	3767 event loop.
jpayne@68	3768 .Sp
jpayne@68	3769 \&\f(CW\(C`ev_async_send\(C'\fR sets a flag in the watcher and wakes up the loop. When
jpayne@68	3770 the loop iterates next and checks for the watcher to have become active,
jpayne@68	3771 it will reset the flag again. \f(CW\(C`ev_async_pending\(C'\fR can be used to very
jpayne@68	3772 quickly check whether invoking the loop might be a good idea.
jpayne@68	3773 .Sp
jpayne@68	3774 Not that this does \fInot\fR check whether the watcher itself is pending,
jpayne@68	3775 only whether it has been requested to make this watcher pending: there
jpayne@68	3776 is a time window between the event loop checking and resetting the async
jpayne@68	3777 notification, and the callback being invoked.
jpayne@68	3778 .SH "OTHER FUNCTIONS"
jpayne@68	3779 .IX Header "OTHER FUNCTIONS"
jpayne@68	3780 There are some other functions of possible interest. Described. Here. Now.
jpayne@68	3781 .IP "ev_once (loop, int fd, int events, ev_tstamp timeout, callback, arg)" 4
jpayne@68	3782 .IX Item "ev_once (loop, int fd, int events, ev_tstamp timeout, callback, arg)"
jpayne@68	3783 This function combines a simple timer and an I/O watcher, calls your
jpayne@68	3784 callback on whichever event happens first and automatically stops both
jpayne@68	3785 watchers. This is useful if you want to wait for a single event on an fd
jpayne@68	3786 or timeout without having to allocate/configure/start/stop/free one or
jpayne@68	3787 more watchers yourself.
jpayne@68	3788 .Sp
jpayne@68	3789 If \f(CW\(C`fd\(C'\fR is less than 0, then no I/O watcher will be started and the
jpayne@68	3790 \&\f(CW\(C`events\(C'\fR argument is being ignored. Otherwise, an \f(CW\(C`ev_io\(C'\fR watcher for
jpayne@68	3791 the given \f(CW\(C`fd\(C'\fR and \f(CW\(C`events\(C'\fR set will be created and started.
jpayne@68	3792 .Sp
jpayne@68	3793 If \f(CW\(C`timeout\(C'\fR is less than 0, then no timeout watcher will be
jpayne@68	3794 started. Otherwise an \f(CW\(C`ev_timer\(C'\fR watcher with after = \f(CW\(C`timeout\(C'\fR (and
jpayne@68	3795 repeat = 0) will be started. \f(CW0\fR is a valid timeout.
jpayne@68	3796 .Sp
jpayne@68	3797 The callback has the type \f(CW\(C`void (cb)(int revents, void arg)\(C'\fR and is
jpayne@68	3798 passed an \f(CW\(C`revents\(C'\fR set like normal event callbacks (a combination of
jpayne@68	3799 \&\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	3800 value passed to \f(CW\(C`ev_once\(C'\fR. Note that it is possible to receive \fIboth\fR
jpayne@68	3801 a timeout and an io event at the same time \- you probably should give io
jpayne@68	3802 events precedence.
jpayne@68	3803 .Sp
jpayne@68	3804 Example: wait up to ten seconds for data to appear on \s-1STDIN_FILENO.\s0
jpayne@68	3805 .Sp
jpayne@68	3806 .Vb 7
jpayne@68	3807 \& static void stdin_ready (int revents, void *arg)
jpayne@68	3808 \& {
jpayne@68	3809 \& if (revents & EV_READ)
jpayne@68	3810 \& /* stdin might have data for us, joy! */;
jpayne@68	3811 \& else if (revents & EV_TIMER)
jpayne@68	3812 \& /* doh, nothing entered */;
jpayne@68	3813 \& }
jpayne@68	3814 \&
jpayne@68	3815 \& ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);
jpayne@68	3816 .Ve
jpayne@68	3817 .IP "ev_feed_fd_event (loop, int fd, int revents)" 4
jpayne@68	3818 .IX Item "ev_feed_fd_event (loop, int fd, int revents)"
jpayne@68	3819 Feed an event on the given fd, as if a file descriptor backend detected
jpayne@68	3820 the given events.
jpayne@68	3821 .IP "ev_feed_signal_event (loop, int signum)" 4
jpayne@68	3822 .IX Item "ev_feed_signal_event (loop, int signum)"
jpayne@68	3823 Feed an event as if the given signal occurred. See also \f(CW\(C`ev_feed_signal\(C'\fR,
jpayne@68	3824 which is async-safe.
jpayne@68	3825 .SH "COMMON OR USEFUL IDIOMS (OR BOTH)"
jpayne@68	3826 .IX Header "COMMON OR USEFUL IDIOMS (OR BOTH)"
jpayne@68	3827 This section explains some common idioms that are not immediately
jpayne@68	3828 obvious. Note that examples are sprinkled over the whole manual, and this
jpayne@68	3829 section only contains stuff that wouldn't fit anywhere else.
jpayne@68	3830 .SS "\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\s0"
jpayne@68	3831 .IX Subsection "ASSOCIATING CUSTOM DATA WITH A WATCHER"
jpayne@68	3832 Each watcher has, by default, a \f(CW\(C`void data\*(C'\fR member that you can read
jpayne@68	3833 or modify at any time: libev will completely ignore it. This can be used
jpayne@68	3834 to associate arbitrary data with your watcher. If you need more data and
jpayne@68	3835 don't want to allocate memory separately and store a pointer to it in that
jpayne@68	3836 data member, you can also \(L"subclass\(R" the watcher type and provide your own
jpayne@68	3837 data:
jpayne@68	3838 .PP
jpayne@68	3839 .Vb 7
jpayne@68	3840 \& struct my_io
jpayne@68	3841 \& {
jpayne@68	3842 \& ev_io io;
jpayne@68	3843 \& int otherfd;
jpayne@68	3844 \& void *somedata;
jpayne@68	3845 \& struct whatever *mostinteresting;
jpayne@68	3846 \& };
jpayne@68	3847 \&
jpayne@68	3848 \& ...
jpayne@68	3849 \& struct my_io w;
jpayne@68	3850 \& ev_io_init (&w.io, my_cb, fd, EV_READ);
jpayne@68	3851 .Ve
jpayne@68	3852 .PP
jpayne@68	3853 And since your callback will be called with a pointer to the watcher, you
jpayne@68	3854 can cast it back to your own type:
jpayne@68	3855 .PP
jpayne@68	3856 .Vb 5
jpayne@68	3857 \& static void my_cb (struct ev_loop loop, ev_io w_, int revents)
jpayne@68	3858 \& {
jpayne@68	3859 \& struct my_io w = (struct my_io )w_;
jpayne@68	3860 \& ...
jpayne@68	3861 \& }
jpayne@68	3862 .Ve
jpayne@68	3863 .PP
jpayne@68	3864 More interesting and less C\-conformant ways of casting your callback
jpayne@68	3865 function type instead have been omitted.
jpayne@68	3866 .SS "\s-1BUILDING YOUR OWN COMPOSITE WATCHERS\s0"
jpayne@68	3867 .IX Subsection "BUILDING YOUR OWN COMPOSITE WATCHERS"
jpayne@68	3868 Another common scenario is to use some data structure with multiple
jpayne@68	3869 embedded watchers, in effect creating your own watcher that combines
jpayne@68	3870 multiple libev event sources into one \(L"super-watcher\(R":
jpayne@68	3871 .PP
jpayne@68	3872 .Vb 6
jpayne@68	3873 \& struct my_biggy
jpayne@68	3874 \& {
jpayne@68	3875 \& int some_data;
jpayne@68	3876 \& ev_timer t1;
jpayne@68	3877 \& ev_timer t2;
jpayne@68	3878 \& }
jpayne@68	3879 .Ve
jpayne@68	3880 .PP
jpayne@68	3881 In this case getting the pointer to \f(CW\(C`my_biggy\(C'\fR is a bit more
jpayne@68	3882 complicated: Either you store the address of your \f(CW\(C`my_biggy\(C'\fR struct in
jpayne@68	3883 the \f(CW\(C`data\(C'\fR member of the watcher (for woozies or \*(C+ coders), or you need
jpayne@68	3884 to use some pointer arithmetic using \f(CW\(C`offsetof\(C'\fR inside your watchers (for
jpayne@68	3885 real programmers):
jpayne@68	3886 .PP
jpayne@68	3887 .Vb 1
jpayne@68	3888 \& #include <stddef.h>
jpayne@68	3889 \&
jpayne@68	3890 \& static void
jpayne@68	3891 \& t1_cb (EV_P_ ev_timer *w, int revents)
jpayne@68	3892 \& {
jpayne@68	3893 \& struct my_biggy big = (struct my_biggy *)
jpayne@68	3894 \& (((char *)w) \- offsetof (struct my_biggy, t1));
jpayne@68	3895 \& }
jpayne@68	3896 \&
jpayne@68	3897 \& static void
jpayne@68	3898 \& t2_cb (EV_P_ ev_timer *w, int revents)
jpayne@68	3899 \& {
jpayne@68	3900 \& struct my_biggy big = (struct my_biggy *)
jpayne@68	3901 \& (((char *)w) \- offsetof (struct my_biggy, t2));
jpayne@68	3902 \& }
jpayne@68	3903 .Ve
jpayne@68	3904 .SS "\s-1AVOIDING FINISHING BEFORE RETURNING\s0"
jpayne@68	3905 .IX Subsection "AVOIDING FINISHING BEFORE RETURNING"
jpayne@68	3906 Often you have structures like this in event-based programs:
jpayne@68	3907 .PP
jpayne@68	3908 .Vb 4
jpayne@68	3909 \& callback ()
jpayne@68	3910 \& {
jpayne@68	3911 \& free (request);
jpayne@68	3912 \& }
jpayne@68	3913 \&
jpayne@68	3914 \& request = start_new_request (..., callback);
jpayne@68	3915 .Ve
jpayne@68	3916 .PP
jpayne@68	3917 The intent is to start some \(L"lengthy\(R" operation. The \f(CW\(C`request\(C'\fR could be
jpayne@68	3918 used to cancel the operation, or do other things with it.
jpayne@68	3919 .PP
jpayne@68	3920 It's not uncommon to have code paths in \f(CW\(C`start_new_request\(C'\fR that
jpayne@68	3921 immediately invoke the callback, for example, to report errors. Or you add
jpayne@68	3922 some caching layer that finds that it can skip the lengthy aspects of the
jpayne@68	3923 operation and simply invoke the callback with the result.
jpayne@68	3924 .PP
jpayne@68	3925 The problem here is that this will happen \fIbefore\fR \f(CW\(C`start_new_request\(C'\fR
jpayne@68	3926 has returned, so \f(CW\(C`request\(C'\fR is not set.
jpayne@68	3927 .PP
jpayne@68	3928 Even if you pass the request by some safer means to the callback, you
jpayne@68	3929 might want to do something to the request after starting it, such as
jpayne@68	3930 canceling it, which probably isn't working so well when the callback has
jpayne@68	3931 already been invoked.
jpayne@68	3932 .PP
jpayne@68	3933 A common way around all these issues is to make sure that
jpayne@68	3934 \&\f(CW\(C`start_new_request\(C'\fR \fIalways\fR returns before the callback is invoked. If
jpayne@68	3935 \&\f(CW\(C`start_new_request\(C'\fR immediately knows the result, it can artificially
jpayne@68	3936 delay invoking the callback by using a \f(CW\(C`prepare\(C'\fR or \f(CW\(C`idle\(C'\fR watcher for
jpayne@68	3937 example, or more sneakily, by reusing an existing (stopped) watcher and
jpayne@68	3938 pushing it into the pending queue:
jpayne@68	3939 .PP
jpayne@68	3940 .Vb 2
jpayne@68	3941 \& ev_set_cb (watcher, callback);
jpayne@68	3942 \& ev_feed_event (EV_A_ watcher, 0);
jpayne@68	3943 .Ve
jpayne@68	3944 .PP
jpayne@68	3945 This way, \f(CW\(C`start_new_request\(C'\fR can safely return before the callback is
jpayne@68	3946 invoked, while not delaying callback invocation too much.
jpayne@68	3947 .SS "\s-1MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS\s0"
jpayne@68	3948 .IX Subsection "MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS"
jpayne@68	3949 Often (especially in \s-1GUI\s0 toolkits) there are places where you have
jpayne@68	3950 \&\fImodal\fR interaction, which is most easily implemented by recursively
jpayne@68	3951 invoking \f(CW\(C`ev_run\(C'\fR.
jpayne@68	3952 .PP
jpayne@68	3953 This brings the problem of exiting \- a callback might want to finish the
jpayne@68	3954 main \f(CW\(C`ev_run\(C'\fR call, but not the nested one (e.g. user clicked \(L"Quit\(R", but
jpayne@68	3955 a modal \(L"Are you sure?\(R" dialog is still waiting), or just the nested one
jpayne@68	3956 and not the main one (e.g. user clocked \(L"Ok\(R" in a modal dialog), or some
jpayne@68	3957 other combination: In these cases, a simple \f(CW\(C`ev_break\(C'\fR will not work.
jpayne@68	3958 .PP
jpayne@68	3959 The solution is to maintain \(L"break this loop\(R" variable for each \f(CW\(C`ev_run\(C'\fR
jpayne@68	3960 invocation, and use a loop around \f(CW\(C`ev_run\(C'\fR until the condition is
jpayne@68	3961 triggered, using \f(CW\(C`EVRUN_ONCE\(C'\fR:
jpayne@68	3962 .PP
jpayne@68	3963 .Vb 2
jpayne@68	3964 \& // main loop
jpayne@68	3965 \& int exit_main_loop = 0;
jpayne@68	3966 \&
jpayne@68	3967 \& while (!exit_main_loop)
jpayne@68	3968 \& ev_run (EV_DEFAULT_ EVRUN_ONCE);
jpayne@68	3969 \&
jpayne@68	3970 \& // in a modal watcher
jpayne@68	3971 \& int exit_nested_loop = 0;
jpayne@68	3972 \&
jpayne@68	3973 \& while (!exit_nested_loop)
jpayne@68	3974 \& ev_run (EV_A_ EVRUN_ONCE);
jpayne@68	3975 .Ve
jpayne@68	3976 .PP
jpayne@68	3977 To exit from any of these loops, just set the corresponding exit variable:
jpayne@68	3978 .PP
jpayne@68	3979 .Vb 2
jpayne@68	3980 \& // exit modal loop
jpayne@68	3981 \& exit_nested_loop = 1;
jpayne@68	3982 \&
jpayne@68	3983 \& // exit main program, after modal loop is finished
jpayne@68	3984 \& exit_main_loop = 1;
jpayne@68	3985 \&
jpayne@68	3986 \& // exit both
jpayne@68	3987 \& exit_main_loop = exit_nested_loop = 1;
jpayne@68	3988 .Ve
jpayne@68	3989 .SS "\s-1THREAD LOCKING EXAMPLE\s0"
jpayne@68	3990 .IX Subsection "THREAD LOCKING EXAMPLE"
jpayne@68	3991 Here is a fictitious example of how to run an event loop in a different
jpayne@68	3992 thread from where callbacks are being invoked and watchers are
jpayne@68	3993 created/added/removed.
jpayne@68	3994 .PP
jpayne@68	3995 For a real-world example, see the \f(CW\(C`EV::Loop::Async\(C'\fR perl module,
jpayne@68	3996 which uses exactly this technique (which is suited for many high-level
jpayne@68	3997 languages).
jpayne@68	3998 .PP
jpayne@68	3999 The example uses a pthread mutex to protect the loop data, a condition
jpayne@68	4000 variable to wait for callback invocations, an async watcher to notify the
jpayne@68	4001 event loop thread and an unspecified mechanism to wake up the main thread.
jpayne@68	4002 .PP
jpayne@68	4003 First, you need to associate some data with the event loop:
jpayne@68	4004 .PP
jpayne@68	4005 .Vb 6
jpayne@68	4006 \& typedef struct {
jpayne@68	4007 \& mutex_t lock; /* global loop lock */
jpayne@68	4008 \& ev_async async_w;
jpayne@68	4009 \& thread_t tid;
jpayne@68	4010 \& cond_t invoke_cv;
jpayne@68	4011 \& } userdata;
jpayne@68	4012 \&
jpayne@68	4013 \& void prepare_loop (EV_P)
jpayne@68	4014 \& {
jpayne@68	4015 \& // for simplicity, we use a static userdata struct.
jpayne@68	4016 \& static userdata u;
jpayne@68	4017 \&
jpayne@68	4018 \& ev_async_init (&u\->async_w, async_cb);
jpayne@68	4019 \& ev_async_start (EV_A_ &u\->async_w);
jpayne@68	4020 \&
jpayne@68	4021 \& pthread_mutex_init (&u\->lock, 0);
jpayne@68	4022 \& pthread_cond_init (&u\->invoke_cv, 0);
jpayne@68	4023 \&
jpayne@68	4024 \& // now associate this with the loop
jpayne@68	4025 \& ev_set_userdata (EV_A_ u);
jpayne@68	4026 \& ev_set_invoke_pending_cb (EV_A_ l_invoke);
jpayne@68	4027 \& ev_set_loop_release_cb (EV_A_ l_release, l_acquire);
jpayne@68	4028 \&
jpayne@68	4029 \& // then create the thread running ev_run
jpayne@68	4030 \& pthread_create (&u\->tid, 0, l_run, EV_A);
jpayne@68	4031 \& }
jpayne@68	4032 .Ve
jpayne@68	4033 .PP
jpayne@68	4034 The callback for the \f(CW\(C`ev_async\(C'\fR watcher does nothing: the watcher is used
jpayne@68	4035 solely to wake up the event loop so it takes notice of any new watchers
jpayne@68	4036 that might have been added:
jpayne@68	4037 .PP
jpayne@68	4038 .Vb 5
jpayne@68	4039 \& static void
jpayne@68	4040 \& async_cb (EV_P_ ev_async *w, int revents)
jpayne@68	4041 \& {
jpayne@68	4042 \& // just used for the side effects
jpayne@68	4043 \& }
jpayne@68	4044 .Ve
jpayne@68	4045 .PP
jpayne@68	4046 The \f(CW\(C`l_release\(C'\fR and \f(CW\(C`l_acquire\(C'\fR callbacks simply unlock/lock the mutex
jpayne@68	4047 protecting the loop data, respectively.
jpayne@68	4048 .PP
jpayne@68	4049 .Vb 6
jpayne@68	4050 \& static void
jpayne@68	4051 \& l_release (EV_P)
jpayne@68	4052 \& {
jpayne@68	4053 \& userdata *u = ev_userdata (EV_A);
jpayne@68	4054 \& pthread_mutex_unlock (&u\->lock);
jpayne@68	4055 \& }
jpayne@68	4056 \&
jpayne@68	4057 \& static void
jpayne@68	4058 \& l_acquire (EV_P)
jpayne@68	4059 \& {
jpayne@68	4060 \& userdata *u = ev_userdata (EV_A);
jpayne@68	4061 \& pthread_mutex_lock (&u\->lock);
jpayne@68	4062 \& }
jpayne@68	4063 .Ve
jpayne@68	4064 .PP
jpayne@68	4065 The event loop thread first acquires the mutex, and then jumps straight
jpayne@68	4066 into \f(CW\(C`ev_run\(C'\fR:
jpayne@68	4067 .PP
jpayne@68	4068 .Vb 4
jpayne@68	4069 \& void *
jpayne@68	4070 \& l_run (void *thr_arg)
jpayne@68	4071 \& {
jpayne@68	4072 \& struct ev_loop loop = (struct ev_loop )thr_arg;
jpayne@68	4073 \&
jpayne@68	4074 \& l_acquire (EV_A);
jpayne@68	4075 \& pthread_setcanceltype (PTHREAD_CANCEL_ASYNCHRONOUS, 0);
jpayne@68	4076 \& ev_run (EV_A_ 0);
jpayne@68	4077 \& l_release (EV_A);
jpayne@68	4078 \&
jpayne@68	4079 \& return 0;
jpayne@68	4080 \& }
jpayne@68	4081 .Ve
jpayne@68	4082 .PP
jpayne@68	4083 Instead of invoking all pending watchers, the \f(CW\(C`l_invoke\(C'\fR callback will
jpayne@68	4084 signal the main thread via some unspecified mechanism (signals? pipe
jpayne@68	4085 writes? \f(CW\(C`Async::Interrupt\(C'\fR?) and then waits until all pending watchers
jpayne@68	4086 have been called (in a while loop because a) spurious wakeups are possible
jpayne@68	4087 and b) skipping inter-thread-communication when there are no pending
jpayne@68	4088 watchers is very beneficial):
jpayne@68	4089 .PP
jpayne@68	4090 .Vb 4
jpayne@68	4091 \& static void
jpayne@68	4092 \& l_invoke (EV_P)
jpayne@68	4093 \& {
jpayne@68	4094 \& userdata *u = ev_userdata (EV_A);
jpayne@68	4095 \&
jpayne@68	4096 \& while (ev_pending_count (EV_A))
jpayne@68	4097 \& {
jpayne@68	4098 \& wake_up_other_thread_in_some_magic_or_not_so_magic_way ();
jpayne@68	4099 \& pthread_cond_wait (&u\->invoke_cv, &u\->lock);
jpayne@68	4100 \& }
jpayne@68	4101 \& }
jpayne@68	4102 .Ve
jpayne@68	4103 .PP
jpayne@68	4104 Now, whenever the main thread gets told to invoke pending watchers, it
jpayne@68	4105 will grab the lock, call \f(CW\(C`ev_invoke_pending\(C'\fR and then signal the loop
jpayne@68	4106 thread to continue:
jpayne@68	4107 .PP
jpayne@68	4108 .Vb 4
jpayne@68	4109 \& static void
jpayne@68	4110 \& real_invoke_pending (EV_P)
jpayne@68	4111 \& {
jpayne@68	4112 \& userdata *u = ev_userdata (EV_A);
jpayne@68	4113 \&
jpayne@68	4114 \& pthread_mutex_lock (&u\->lock);
jpayne@68	4115 \& ev_invoke_pending (EV_A);
jpayne@68	4116 \& pthread_cond_signal (&u\->invoke_cv);
jpayne@68	4117 \& pthread_mutex_unlock (&u\->lock);
jpayne@68	4118 \& }
jpayne@68	4119 .Ve
jpayne@68	4120 .PP
jpayne@68	4121 Whenever you want to start/stop a watcher or do other modifications to an
jpayne@68	4122 event loop, you will now have to lock:
jpayne@68	4123 .PP
jpayne@68	4124 .Vb 2
jpayne@68	4125 \& ev_timer timeout_watcher;
jpayne@68	4126 \& userdata *u = ev_userdata (EV_A);
jpayne@68	4127 \&
jpayne@68	4128 \& ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.);
jpayne@68	4129 \&
jpayne@68	4130 \& pthread_mutex_lock (&u\->lock);
jpayne@68	4131 \& ev_timer_start (EV_A_ &timeout_watcher);
jpayne@68	4132 \& ev_async_send (EV_A_ &u\->async_w);
jpayne@68	4133 \& pthread_mutex_unlock (&u\->lock);
jpayne@68	4134 .Ve
jpayne@68	4135 .PP
jpayne@68	4136 Note that sending the \f(CW\(C`ev_async\(C'\fR watcher is required because otherwise
jpayne@68	4137 an event loop currently blocking in the kernel will have no knowledge
jpayne@68	4138 about the newly added timer. By waking up the loop it will pick up any new
jpayne@68	4139 watchers in the next event loop iteration.
jpayne@68	4140 .SS "\s-1THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS\s0"
jpayne@68	4141 .IX Subsection "THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS"
jpayne@68	4142 While the overhead of a callback that e.g. schedules a thread is small, it
jpayne@68	4143 is still an overhead. If you embed libev, and your main usage is with some
jpayne@68	4144 kind of threads or coroutines, you might want to customise libev so that
jpayne@68	4145 doesn't need callbacks anymore.
jpayne@68	4146 .PP
jpayne@68	4147 Imagine you have coroutines that you can switch to using a function
jpayne@68	4148 \&\f(CW\(C`switch_to (coro)\(C'\fR, that libev runs in a coroutine called \f(CW\(C`libev_coro\(C'\fR
jpayne@68	4149 and that due to some magic, the currently active coroutine is stored in a
jpayne@68	4150 global called \f(CW\(C`current_coro\(C'\fR. Then you can build your own \*(L"wait for libev
jpayne@68	4151 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	4152 the differing \f(CW\(C`;\(C'\fR conventions):
jpayne@68	4153 .PP
jpayne@68	4154 .Vb 2
jpayne@68	4155 \& #define EV_CB_DECLARE(type) struct my_coro *cb;
jpayne@68	4156 \& #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb)
jpayne@68	4157 .Ve
jpayne@68	4158 .PP
jpayne@68	4159 That means instead of having a C callback function, you store the
jpayne@68	4160 coroutine to switch to in each watcher, and instead of having libev call
jpayne@68	4161 your callback, you instead have it switch to that coroutine.
jpayne@68	4162 .PP
jpayne@68	4163 A coroutine might now wait for an event with a function called
jpayne@68	4164 \&\f(CW\(C`wait_for_event\(C'\fR. (the watcher needs to be started, as always, but it doesn't
jpayne@68	4165 matter when, or whether the watcher is active or not when this function is
jpayne@68	4166 called):
jpayne@68	4167 .PP
jpayne@68	4168 .Vb 6
jpayne@68	4169 \& void
jpayne@68	4170 \& wait_for_event (ev_watcher *w)
jpayne@68	4171 \& {
jpayne@68	4172 \& ev_set_cb (w, current_coro);
jpayne@68	4173 \& switch_to (libev_coro);
jpayne@68	4174 \& }
jpayne@68	4175 .Ve
jpayne@68	4176 .PP
jpayne@68	4177 That basically suspends the coroutine inside \f(CW\(C`wait_for_event\(C'\fR and
jpayne@68	4178 continues the libev coroutine, which, when appropriate, switches back to
jpayne@68	4179 this or any other coroutine.
jpayne@68	4180 .PP
jpayne@68	4181 You can do similar tricks if you have, say, threads with an event queue \-
jpayne@68	4182 instead of storing a coroutine, you store the queue object and instead of
jpayne@68	4183 switching to a coroutine, you push the watcher onto the queue and notify
jpayne@68	4184 any waiters.
jpayne@68	4185 .PP
jpayne@68	4186 To embed libev, see \(L"\s-1EMBEDDING\(R"\s0, but in short, it's easiest to create two
jpayne@68	4187 files, \fImy_ev.h\fR and \fImy_ev.c\fR that include the respective libev files:
jpayne@68	4188 .PP
jpayne@68	4189 .Vb 4
jpayne@68	4190 \& // my_ev.h
jpayne@68	4191 \& #define EV_CB_DECLARE(type) struct my_coro *cb;
jpayne@68	4192 \& #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb)
jpayne@68	4193 \& #include "../libev/ev.h"
jpayne@68	4194 \&
jpayne@68	4195 \& // my_ev.c
jpayne@68	4196 \& #define EV_H "my_ev.h"
jpayne@68	4197 \& #include "../libev/ev.c"
jpayne@68	4198 .Ve
jpayne@68	4199 .PP
jpayne@68	4200 And then use \fImy_ev.h\fR when you would normally use \fIev.h\fR, and compile
jpayne@68	4201 \&\fImy_ev.c\fR into your project. When properly specifying include paths, you
jpayne@68	4202 can even use \fIev.h\fR as header file name directly.
jpayne@68	4203 .SH "LIBEVENT EMULATION"
jpayne@68	4204 .IX Header "LIBEVENT EMULATION"
jpayne@68	4205 Libev offers a compatibility emulation layer for libevent. It cannot
jpayne@68	4206 emulate the internals of libevent, so here are some usage hints:
jpayne@68	4207 .IP "\(bu" 4
jpayne@68	4208 Only the libevent\-1.4.1\-beta \s-1API\s0 is being emulated.
jpayne@68	4209 .Sp
jpayne@68	4210 This was the newest libevent version available when libev was implemented,
jpayne@68	4211 and is still mostly unchanged in 2010.
jpayne@68	4212 .IP "\(bu" 4
jpayne@68	4213 Use it by including <event.h>, as usual.
jpayne@68	4214 .IP "\(bu" 4
jpayne@68	4215 The following members are fully supported: ev_base, ev_callback,
jpayne@68	4216 ev_arg, ev_fd, ev_res, ev_events.
jpayne@68	4217 .IP "\(bu" 4
jpayne@68	4218 Avoid using ev_flags and the EVLIST_*\-macros, while it is
jpayne@68	4219 maintained by libev, it does not work exactly the same way as in libevent (consider
jpayne@68	4220 it a private \s-1API\s0).
jpayne@68	4221 .IP "\(bu" 4
jpayne@68	4222 Priorities are not currently supported. Initialising priorities
jpayne@68	4223 will fail and all watchers will have the same priority, even though there
jpayne@68	4224 is an ev_pri field.
jpayne@68	4225 .IP "\(bu" 4
jpayne@68	4226 In libevent, the last base created gets the signals, in libev, the
jpayne@68	4227 base that registered the signal gets the signals.
jpayne@68	4228 .IP "\(bu" 4
jpayne@68	4229 Other members are not supported.
jpayne@68	4230 .IP "\(bu" 4
jpayne@68	4231 The libev emulation is \fInot\fR \s-1ABI\s0 compatible to libevent, you need
jpayne@68	4232 to use the libev header file and library.
jpayne@68	4233 .SH "\*(C+ SUPPORT"
jpayne@68	4234 .IX Header " SUPPORT"
jpayne@68	4235 .SS "C \s-1API\s0"
jpayne@68	4236 .IX Subsection "C API"
jpayne@68	4237 The normal C \s-1API\s0 should work fine when used from \*(C+: both ev.h and the
jpayne@68	4238 libev sources can be compiled as \*(C+. Therefore, code that uses the C \s-1API\s0
jpayne@68	4239 will work fine.
jpayne@68	4240 .PP
jpayne@68	4241 Proper exception specifications might have to be added to callbacks passed
jpayne@68	4242 to libev: exceptions may be thrown only from watcher callbacks, all other
jpayne@68	4243 callbacks (allocator, syserr, loop acquire/release and periodic reschedule
jpayne@68	4244 callbacks) must not throw exceptions, and might need a \f(CW\(C`noexcept\(C'\fR
jpayne@68	4245 specification. If you have code that needs to be compiled as both C and
jpayne@68	4246 \&\(C+ you can use the \f(CW\(C`EV_NOEXCEPT\*(C'\fR macro for this:
jpayne@68	4247 .PP
jpayne@68	4248 .Vb 6
jpayne@68	4249 \& static void
jpayne@68	4250 \& fatal_error (const char *msg) EV_NOEXCEPT
jpayne@68	4251 \& {
jpayne@68	4252 \& perror (msg);
jpayne@68	4253 \& abort ();
jpayne@68	4254 \& }
jpayne@68	4255 \&
jpayne@68	4256 \& ...
jpayne@68	4257 \& ev_set_syserr_cb (fatal_error);
jpayne@68	4258 .Ve
jpayne@68	4259 .PP
jpayne@68	4260 The only \s-1API\s0 functions that can currently throw exceptions are \f(CW\(C`ev_run\(C'\fR,
jpayne@68	4261 \&\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	4262 because it runs cleanup watchers).
jpayne@68	4263 .PP
jpayne@68	4264 Throwing exceptions in watcher callbacks is only supported if libev itself
jpayne@68	4265 is compiled with a \(C+ compiler or your C and \(C+ environments allow
jpayne@68	4266 throwing exceptions through C libraries (most do).
jpayne@68	4267 .SS "\*(C+ \s-1API\s0"
jpayne@68	4268 .IX Subsection " API"
jpayne@68	4269 Libev comes with some simplistic wrapper classes for \*(C+ that mainly allow
jpayne@68	4270 you to use some convenience methods to start/stop watchers and also change
jpayne@68	4271 the callback model to a model using method callbacks on objects.
jpayne@68	4272 .PP
jpayne@68	4273 To use it,
jpayne@68	4274 .PP
jpayne@68	4275 .Vb 1
jpayne@68	4276 \& #include <ev++.h>
jpayne@68	4277 .Ve
jpayne@68	4278 .PP
jpayne@68	4279 This automatically includes \fIev.h\fR and puts all of its definitions (many
jpayne@68	4280 of them macros) into the global namespace. All \*(C+ specific things are
jpayne@68	4281 put into the \f(CW\(C`ev\(C'\fR namespace. It should support all the same embedding
jpayne@68	4282 options as \fIev.h\fR, most notably \f(CW\(C`EV_MULTIPLICITY\(C'\fR.
jpayne@68	4283 .PP
jpayne@68	4284 Care has been taken to keep the overhead low. The only data member the \*(C+
jpayne@68	4285 classes add (compared to plain C\-style watchers) is the event loop pointer
jpayne@68	4286 that the watcher is associated with (or no additional members at all if
jpayne@68	4287 you disable \f(CW\(C`EV_MULTIPLICITY\(C'\fR when embedding libev).
jpayne@68	4288 .PP
jpayne@68	4289 Currently, functions, static and non-static member functions and classes
jpayne@68	4290 with \f(CW\(C`operator ()\(C'\fR can be used as callbacks. Other types should be easy
jpayne@68	4291 to add as long as they only need one additional pointer for context. If
jpayne@68	4292 you need support for other types of functors please contact the author
jpayne@68	4293 (preferably after implementing it).
jpayne@68	4294 .PP
jpayne@68	4295 For all this to work, your \*(C+ compiler either has to use the same calling
jpayne@68	4296 conventions as your C compiler (for static member functions), or you have
jpayne@68	4297 to embed libev and compile libev itself as \*(C+.
jpayne@68	4298 .PP
jpayne@68	4299 Here is a list of things available in the \f(CW\(C`ev\(C'\fR namespace:
jpayne@68	4300 .ie n .IP """ev::READ"", ""ev::WRITE"" etc." 4
jpayne@68	4301 .el .IP "\f(CWev::READ\fR, \f(CWev::WRITE\fR etc." 4
jpayne@68	4302 .IX Item "ev::READ, ev::WRITE etc."
jpayne@68	4303 These are just enum values with the same values as the \f(CW\(C`EV_READ\(C'\fR etc.
jpayne@68	4304 macros from \fIev.h\fR.
jpayne@68	4305 .ie n .IP """ev::tstamp"", ""ev::now""" 4
jpayne@68	4306 .el .IP "\f(CWev::tstamp\fR, \f(CWev::now\fR" 4
jpayne@68	4307 .IX Item "ev::tstamp, ev::now"
jpayne@68	4308 Aliases to the same types/functions as with the \f(CW\(C`ev_\(C'\fR prefix.
jpayne@68	4309 .ie n .IP """ev::io"", ""ev::timer"", ""ev::periodic"", ""ev::idle"", ""ev::sig"" etc." 4
jpayne@68	4310 .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	4311 .IX Item "ev::io, ev::timer, ev::periodic, ev::idle, ev::sig etc."
jpayne@68	4312 For each \f(CW\(C`ev_TYPE\(C'\fR watcher in \fIev.h\fR there is a corresponding class of
jpayne@68	4313 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	4314 which is called \f(CW\(C`ev::sig\(C'\fR to avoid clashes with the \f(CW\(C`signal\(C'\fR macro
jpayne@68	4315 defined by many implementations.
jpayne@68	4316 .Sp
jpayne@68	4317 All of those classes have these methods:
jpayne@68	4318 .RS 4
jpayne@68	4319 .IP "ev::TYPE::TYPE ()" 4
jpayne@68	4320 .IX Item "ev::TYPE::TYPE ()"
jpayne@68	4321 .PD 0
jpayne@68	4322 .IP "ev::TYPE::TYPE (loop)" 4
jpayne@68	4323 .IX Item "ev::TYPE::TYPE (loop)"
jpayne@68	4324 .IP "ev::TYPE::~TYPE" 4
jpayne@68	4325 .IX Item "ev::TYPE::~TYPE"
jpayne@68	4326 .PD
jpayne@68	4327 The constructor (optionally) takes an event loop to associate the watcher
jpayne@68	4328 with. If it is omitted, it will use \f(CW\(C`EV_DEFAULT\(C'\fR.
jpayne@68	4329 .Sp
jpayne@68	4330 The constructor calls \f(CW\(C`ev_init\(C'\fR for you, which means you have to call the
jpayne@68	4331 \&\f(CW\(C`set\(C'\fR method before starting it.
jpayne@68	4332 .Sp
jpayne@68	4333 It will not set a callback, however: You have to call the templated \f(CW\(C`set\(C'\fR
jpayne@68	4334 method to set a callback before you can start the watcher.
jpayne@68	4335 .Sp
jpayne@68	4336 (The reason why you have to use a method is a limitation in \*(C+ which does
jpayne@68	4337 not allow explicit template arguments for constructors).
jpayne@68	4338 .Sp
jpayne@68	4339 The destructor automatically stops the watcher if it is active.
jpayne@68	4340 .IP "w\->set<class, &class::method> (object *)" 4
jpayne@68	4341 .IX Item "w->set<class, &class::method> (object *)"
jpayne@68	4342 This method sets the callback method to call. The method has to have a
jpayne@68	4343 signature of \f(CW\(C`void ()(ev_TYPE &, int)\*(C'\fR, it receives the watcher as
jpayne@68	4344 first argument and the \f(CW\(C`revents\(C'\fR as second. The object must be given as
jpayne@68	4345 parameter and is stored in the \f(CW\(C`data\(C'\fR member of the watcher.
jpayne@68	4346 .Sp
jpayne@68	4347 This method synthesizes efficient thunking code to call your method from
jpayne@68	4348 the C callback that libev requires. If your compiler can inline your
jpayne@68	4349 callback (i.e. it is visible to it at the place of the \f(CW\(C`set\(C'\fR call and
jpayne@68	4350 your compiler is good :), then the method will be fully inlined into the
jpayne@68	4351 thunking function, making it as fast as a direct C callback.
jpayne@68	4352 .Sp
jpayne@68	4353 Example: simple class declaration and watcher initialisation
jpayne@68	4354 .Sp
jpayne@68	4355 .Vb 4
jpayne@68	4356 \& struct myclass
jpayne@68	4357 \& {
jpayne@68	4358 \& void io_cb (ev::io &w, int revents) { }
jpayne@68	4359 \& }
jpayne@68	4360 \&
jpayne@68	4361 \& myclass obj;
jpayne@68	4362 \& ev::io iow;
jpayne@68	4363 \& iow.set <myclass, &myclass::io_cb> (&obj);
jpayne@68	4364 .Ve
jpayne@68	4365 .IP "w\->set (object *)" 4
jpayne@68	4366 .IX Item "w->set (object *)"
jpayne@68	4367 This is a variation of a method callback \- leaving out the method to call
jpayne@68	4368 will default the method to \f(CW\(C`operator ()\(C'\fR, which makes it possible to use
jpayne@68	4369 functor objects without having to manually specify the \f(CW\(C`operator ()\(C'\fR all
jpayne@68	4370 the time. Incidentally, you can then also leave out the template argument
jpayne@68	4371 list.
jpayne@68	4372 .Sp
jpayne@68	4373 The \f(CW\(C`operator ()\(C'\fR method prototype must be \f(CW\*(C`void operator ()(watcher &w,
jpayne@68	4374 int revents)\*(C'\fR.
jpayne@68	4375 .Sp
jpayne@68	4376 See the method\-\f(CW\(C`set\(C'\fR above for more details.
jpayne@68	4377 .Sp
jpayne@68	4378 Example: use a functor object as callback.
jpayne@68	4379 .Sp
jpayne@68	4380 .Vb 7
jpayne@68	4381 \& struct myfunctor
jpayne@68	4382 \& {
jpayne@68	4383 \& void operator() (ev::io &w, int revents)
jpayne@68	4384 \& {
jpayne@68	4385 \& ...
jpayne@68	4386 \& }
jpayne@68	4387 \& }
jpayne@68	4388 \&
jpayne@68	4389 \& myfunctor f;
jpayne@68	4390 \&
jpayne@68	4391 \& ev::io w;
jpayne@68	4392 \& w.set (&f);
jpayne@68	4393 .Ve
jpayne@68	4394 .IP "w\->set<function> (void *data = 0)" 4
jpayne@68	4395 .IX Item "w->set<function> (void *data = 0)"
jpayne@68	4396 Also sets a callback, but uses a static method or plain function as
jpayne@68	4397 callback. The optional \f(CW\(C`data\(C'\fR argument will be stored in the watcher's
jpayne@68	4398 \&\f(CW\(C`data\(C'\fR member and is free for you to use.
jpayne@68	4399 .Sp
jpayne@68	4400 The prototype of the \f(CW\(C`function\(C'\fR must be \f(CW\(C`void ()(ev::TYPE &w, int)\*(C'\fR.
jpayne@68	4401 .Sp
jpayne@68	4402 See the method\-\f(CW\(C`set\(C'\fR above for more details.
jpayne@68	4403 .Sp
jpayne@68	4404 Example: Use a plain function as callback.
jpayne@68	4405 .Sp
jpayne@68	4406 .Vb 2
jpayne@68	4407 \& static void io_cb (ev::io &w, int revents) { }
jpayne@68	4408 \& iow.set <io_cb> ();
jpayne@68	4409 .Ve
jpayne@68	4410 .IP "w\->set (loop)" 4
jpayne@68	4411 .IX Item "w->set (loop)"
jpayne@68	4412 Associates a different \f(CW\(C`struct ev_loop\(C'\fR with this watcher. You can only
jpayne@68	4413 do this when the watcher is inactive (and not pending either).
jpayne@68	4414 .IP "w\->set ([arguments])" 4
jpayne@68	4415 .IX Item "w->set ([arguments])"
jpayne@68	4416 Basically the same as \f(CW\(C`ev_TYPE_set\(C'\fR (except for \f(CW\(C`ev::embed\(C'\fR watchers>),
jpayne@68	4417 with the same arguments. Either this method or a suitable start method
jpayne@68	4418 must be called at least once. Unlike the C counterpart, an active watcher
jpayne@68	4419 gets automatically stopped and restarted when reconfiguring it with this
jpayne@68	4420 method.
jpayne@68	4421 .Sp
jpayne@68	4422 For \f(CW\(C`ev::embed\(C'\fR watchers this method is called \f(CW\(C`set_embed\(C'\fR, to avoid
jpayne@68	4423 clashing with the \f(CW\(C`set (loop)\(C'\fR method.
jpayne@68	4424 .Sp
jpayne@68	4425 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	4426 new event mask only, and internally calls \f(CW\(C`ev_io_modfify\(C'\fR.
jpayne@68	4427 .IP "w\->start ()" 4
jpayne@68	4428 .IX Item "w->start ()"
jpayne@68	4429 Starts the watcher. Note that there is no \f(CW\(C`loop\(C'\fR argument, as the
jpayne@68	4430 constructor already stores the event loop.
jpayne@68	4431 .IP "w\->start ([arguments])" 4
jpayne@68	4432 .IX Item "w->start ([arguments])"
jpayne@68	4433 Instead of calling \f(CW\(C`set\(C'\fR and \f(CW\(C`start\(C'\fR methods separately, it is often
jpayne@68	4434 convenient to wrap them in one call. Uses the same type of arguments as
jpayne@68	4435 the configure \f(CW\(C`set\(C'\fR method of the watcher.
jpayne@68	4436 .IP "w\->stop ()" 4
jpayne@68	4437 .IX Item "w->stop ()"
jpayne@68	4438 Stops the watcher if it is active. Again, no \f(CW\(C`loop\(C'\fR argument.
jpayne@68	4439 .ie n .IP "w\->again () (""ev::timer"", ""ev::periodic"" only)" 4
jpayne@68	4440 .el .IP "w\->again () (\f(CWev::timer\fR, \f(CWev::periodic\fR only)" 4
jpayne@68	4441 .IX Item "w->again () (ev::timer, ev::periodic only)"
jpayne@68	4442 For \f(CW\(C`ev::timer\(C'\fR and \f(CW\(C`ev::periodic\(C'\fR, this invokes the corresponding
jpayne@68	4443 \&\f(CW\(C`ev_TYPE_again\(C'\fR function.
jpayne@68	4444 .ie n .IP "w\->sweep () (""ev::embed"" only)" 4
jpayne@68	4445 .el .IP "w\->sweep () (\f(CWev::embed\fR only)" 4
jpayne@68	4446 .IX Item "w->sweep () (ev::embed only)"
jpayne@68	4447 Invokes \f(CW\(C`ev_embed_sweep\(C'\fR.
jpayne@68	4448 .ie n .IP "w\->update () (""ev::stat"" only)" 4
jpayne@68	4449 .el .IP "w\->update () (\f(CWev::stat\fR only)" 4
jpayne@68	4450 .IX Item "w->update () (ev::stat only)"
jpayne@68	4451 Invokes \f(CW\(C`ev_stat_stat\(C'\fR.
jpayne@68	4452 .RE
jpayne@68	4453 .RS 4
jpayne@68	4454 .RE
jpayne@68	4455 .PP
jpayne@68	4456 Example: Define a class with two I/O and idle watchers, start the I/O
jpayne@68	4457 watchers in the constructor.
jpayne@68	4458 .PP
jpayne@68	4459 .Vb 5
jpayne@68	4460 \& class myclass
jpayne@68	4461 \& {
jpayne@68	4462 \& ev::io io ; void io_cb (ev::io &w, int revents);
jpayne@68	4463 \& ev::io io2 ; void io2_cb (ev::io &w, int revents);
jpayne@68	4464 \& ev::idle idle; void idle_cb (ev::idle &w, int revents);
jpayne@68	4465 \&
jpayne@68	4466 \& myclass (int fd)
jpayne@68	4467 \& {
jpayne@68	4468 \& io .set <myclass, &myclass::io_cb > (this);
jpayne@68	4469 \& io2 .set <myclass, &myclass::io2_cb > (this);
jpayne@68	4470 \& idle.set <myclass, &myclass::idle_cb> (this);
jpayne@68	4471 \&
jpayne@68	4472 \& io.set (fd, ev::WRITE); // configure the watcher
jpayne@68	4473 \& io.start (); // start it whenever convenient
jpayne@68	4474 \&
jpayne@68	4475 \& io2.start (fd, ev::READ); // set + start in one call
jpayne@68	4476 \& }
jpayne@68	4477 \& };
jpayne@68	4478 .Ve
jpayne@68	4479 .SH "OTHER LANGUAGE BINDINGS"
jpayne@68	4480 .IX Header "OTHER LANGUAGE BINDINGS"
jpayne@68	4481 Libev does not offer other language bindings itself, but bindings for a
jpayne@68	4482 number of languages exist in the form of third-party packages. If you know
jpayne@68	4483 any interesting language binding in addition to the ones listed here, drop
jpayne@68	4484 me a note.
jpayne@68	4485 .IP "Perl" 4
jpayne@68	4486 .IX Item "Perl"
jpayne@68	4487 The \s-1EV\s0 module implements the full libev \s-1API\s0 and is actually used to test
jpayne@68	4488 libev. \s-1EV\s0 is developed together with libev. Apart from the \s-1EV\s0 core module,
jpayne@68	4489 there are additional modules that implement libev-compatible interfaces
jpayne@68	4490 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	4491 \&\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	4492 and \f(CW\(C`EV::Glib\(C'\fR).
jpayne@68	4493 .Sp
jpayne@68	4494 It can be found and installed via \s-1CPAN,\s0 its homepage is at
jpayne@68	4495 <http://software.schmorp.de/pkg/EV>.
jpayne@68	4496 .IP "Python" 4
jpayne@68	4497 .IX Item "Python"
jpayne@68	4498 Python bindings can be found at <http://code.google.com/p/pyev/>. It
jpayne@68	4499 seems to be quite complete and well-documented.
jpayne@68	4500 .IP "Ruby" 4
jpayne@68	4501 .IX Item "Ruby"
jpayne@68	4502 Tony Arcieri has written a ruby extension that offers access to a subset
jpayne@68	4503 of the libev \s-1API\s0 and adds file handle abstractions, asynchronous \s-1DNS\s0 and
jpayne@68	4504 more on top of it. It can be found via gem servers. Its homepage is at
jpayne@68	4505 <http://rev.rubyforge.org/>.
jpayne@68	4506 .Sp
jpayne@68	4507 Roger Pack reports that using the link order \f(CW\(C`\-lws2_32 \-lmsvcrt\-ruby\-190\(C'\fR
jpayne@68	4508 makes rev work even on mingw.
jpayne@68	4509 .IP "Haskell" 4
jpayne@68	4510 .IX Item "Haskell"
jpayne@68	4511 A haskell binding to libev is available at
jpayne@68	4512 <http://hackage.haskell.org/cgi\-bin/hackage\-scripts/package/hlibev>.
jpayne@68	4513 .IP "D" 4
jpayne@68	4514 .IX Item "D"
jpayne@68	4515 Leandro Lucarella has written a D language binding (\fIev.d\fR) for libev, to
jpayne@68	4516 be found at <http://www.llucax.com.ar/proj/ev.d/index.html>.
jpayne@68	4517 .IP "Ocaml" 4
jpayne@68	4518 .IX Item "Ocaml"
jpayne@68	4519 Erkki Seppala has written Ocaml bindings for libev, to be found at
jpayne@68	4520 <http://modeemi.cs.tut.fi/~flux/software/ocaml\-ev/>.
jpayne@68	4521 .IP "Lua" 4
jpayne@68	4522 .IX Item "Lua"
jpayne@68	4523 Brian Maher has written a partial interface to libev for lua (at the
jpayne@68	4524 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	4525 <http://github.com/brimworks/lua\-ev>.
jpayne@68	4526 .IP "Javascript" 4
jpayne@68	4527 .IX Item "Javascript"
jpayne@68	4528 Node.js (<http://nodejs.org>) uses libev as the underlying event library.
jpayne@68	4529 .IP "Others" 4
jpayne@68	4530 .IX Item "Others"
jpayne@68	4531 There are others, and I stopped counting.
jpayne@68	4532 .SH "MACRO MAGIC"
jpayne@68	4533 .IX Header "MACRO MAGIC"
jpayne@68	4534 Libev can be compiled with a variety of options, the most fundamental
jpayne@68	4535 of which is \f(CW\(C`EV_MULTIPLICITY\(C'\fR. This option determines whether (most)
jpayne@68	4536 functions and callbacks have an initial \f(CW\(C`struct ev_loop \*(C'\fR argument.
jpayne@68	4537 .PP
jpayne@68	4538 To make it easier to write programs that cope with either variant, the
jpayne@68	4539 following macros are defined:
jpayne@68	4540 .ie n .IP """EV_A"", ""EV_A_""" 4
jpayne@68	4541 .el .IP "\f(CWEV_A\fR, \f(CWEV_A_\fR" 4
jpayne@68	4542 .IX Item "EV_A, EV_A_"
jpayne@68	4543 This provides the loop \fIargument\fR for functions, if one is required (\*(L"ev
jpayne@68	4544 loop argument\(R"). The \f(CW\(C`EV_A\*(C'\fR form is used when this is the sole argument,
jpayne@68	4545 \&\f(CW\(C`EV_A_\(C'\fR is used when other arguments are following. Example:
jpayne@68	4546 .Sp
jpayne@68	4547 .Vb 3
jpayne@68	4548 \& ev_unref (EV_A);
jpayne@68	4549 \& ev_timer_add (EV_A_ watcher);
jpayne@68	4550 \& ev_run (EV_A_ 0);
jpayne@68	4551 .Ve
jpayne@68	4552 .Sp
jpayne@68	4553 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	4554 which is often provided by the following macro.
jpayne@68	4555 .ie n .IP """EV_P"", ""EV_P_""" 4
jpayne@68	4556 .el .IP "\f(CWEV_P\fR, \f(CWEV_P_\fR" 4
jpayne@68	4557 .IX Item "EV_P, EV_P_"
jpayne@68	4558 This provides the loop \fIparameter\fR for functions, if one is required (\*(L"ev
jpayne@68	4559 loop parameter\(R"). The \f(CW\(C`EV_P\*(C'\fR form is used when this is the sole parameter,
jpayne@68	4560 \&\f(CW\(C`EV_P_\(C'\fR is used when other parameters are following. Example:
jpayne@68	4561 .Sp
jpayne@68	4562 .Vb 2
jpayne@68	4563 \& // this is how ev_unref is being declared
jpayne@68	4564 \& static void ev_unref (EV_P);
jpayne@68	4565 \&
jpayne@68	4566 \& // this is how you can declare your typical callback
jpayne@68	4567 \& static void cb (EV_P_ ev_timer *w, int revents)
jpayne@68	4568 .Ve
jpayne@68	4569 .Sp
jpayne@68	4570 It declares a parameter \f(CW\(C`loop\(C'\fR of type \f(CW\(C`struct ev_loop \*(C'\fR, quite
jpayne@68	4571 suitable for use with \f(CW\(C`EV_A\(C'\fR.
jpayne@68	4572 .ie n .IP """EV_DEFAULT"", ""EV_DEFAULT_""" 4
jpayne@68	4573 .el .IP "\f(CWEV_DEFAULT\fR, \f(CWEV_DEFAULT_\fR" 4
jpayne@68	4574 .IX Item "EV_DEFAULT, EV_DEFAULT_"
jpayne@68	4575 Similar to the other two macros, this gives you the value of the default
jpayne@68	4576 loop, if multiple loops are supported (\(L"ev loop default\(R"). The default loop
jpayne@68	4577 will be initialised if it isn't already initialised.
jpayne@68	4578 .Sp
jpayne@68	4579 For non-multiplicity builds, these macros do nothing, so you always have
jpayne@68	4580 to initialise the loop somewhere.
jpayne@68	4581 .ie n .IP """EV_DEFAULT_UC"", ""EV_DEFAULT_UC_""" 4
jpayne@68	4582 .el .IP "\f(CWEV_DEFAULT_UC\fR, \f(CWEV_DEFAULT_UC_\fR" 4
jpayne@68	4583 .IX Item "EV_DEFAULT_UC, EV_DEFAULT_UC_"
jpayne@68	4584 Usage identical to \f(CW\(C`EV_DEFAULT\(C'\fR and \f(CW\(C`EV_DEFAULT_\(C'\fR, but requires that the
jpayne@68	4585 default loop has been initialised (\f(CW\(C`UC\(C'\fR == unchecked). Their behaviour
jpayne@68	4586 is undefined when the default loop has not been initialised by a previous
jpayne@68	4587 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	4588 .Sp
jpayne@68	4589 It is often prudent to use \f(CW\(C`EV_DEFAULT\(C'\fR when initialising the first
jpayne@68	4590 watcher in a function but use \f(CW\(C`EV_DEFAULT_UC\(C'\fR afterwards.
jpayne@68	4591 .PP
jpayne@68	4592 Example: Declare and initialise a check watcher, utilising the above
jpayne@68	4593 macros so it will work regardless of whether multiple loops are supported
jpayne@68	4594 or not.
jpayne@68	4595 .PP
jpayne@68	4596 .Vb 5
jpayne@68	4597 \& static void
jpayne@68	4598 \& check_cb (EV_P_ ev_timer *w, int revents)
jpayne@68	4599 \& {
jpayne@68	4600 \& ev_check_stop (EV_A_ w);
jpayne@68	4601 \& }
jpayne@68	4602 \&
jpayne@68	4603 \& ev_check check;
jpayne@68	4604 \& ev_check_init (&check, check_cb);
jpayne@68	4605 \& ev_check_start (EV_DEFAULT_ &check);
jpayne@68	4606 \& ev_run (EV_DEFAULT_ 0);
jpayne@68	4607 .Ve
jpayne@68	4608 .SH "EMBEDDING"
jpayne@68	4609 .IX Header "EMBEDDING"
jpayne@68	4610 Libev can (and often is) directly embedded into host
jpayne@68	4611 applications. Examples of applications that embed it include the Deliantra
jpayne@68	4612 Game Server, the \s-1EV\s0 perl module, the \s-1GNU\s0 Virtual Private Ethernet (gvpe)
jpayne@68	4613 and rxvt-unicode.
jpayne@68	4614 .PP
jpayne@68	4615 The goal is to enable you to just copy the necessary files into your
jpayne@68	4616 source directory without having to change even a single line in them, so
jpayne@68	4617 you can easily upgrade by simply copying (or having a checked-out copy of
jpayne@68	4618 libev somewhere in your source tree).
jpayne@68	4619 .SS "\s-1FILESETS\s0"
jpayne@68	4620 .IX Subsection "FILESETS"
jpayne@68	4621 Depending on what features you need you need to include one or more sets of files
jpayne@68	4622 in your application.
jpayne@68	4623 .PP
jpayne@68	4624 \fI\s-1CORE EVENT LOOP\s0\fR
jpayne@68	4625 .IX Subsection "CORE EVENT LOOP"
jpayne@68	4626 .PP
jpayne@68	4627 To include only the libev core (all the \f(CW\(C`ev_\*(C'\fR functions), with manual
jpayne@68	4628 configuration (no autoconf):
jpayne@68	4629 .PP
jpayne@68	4630 .Vb 2
jpayne@68	4631 \& #define EV_STANDALONE 1
jpayne@68	4632 \& #include "ev.c"
jpayne@68	4633 .Ve
jpayne@68	4634 .PP
jpayne@68	4635 This will automatically include \fIev.h\fR, too, and should be done in a
jpayne@68	4636 single C source file only to provide the function implementations. To use
jpayne@68	4637 it, do the same for \fIev.h\fR in all files wishing to use this \s-1API\s0 (best
jpayne@68	4638 done by writing a wrapper around \fIev.h\fR that you can include instead and
jpayne@68	4639 where you can put other configuration options):
jpayne@68	4640 .PP
jpayne@68	4641 .Vb 2
jpayne@68	4642 \& #define EV_STANDALONE 1
jpayne@68	4643 \& #include "ev.h"
jpayne@68	4644 .Ve
jpayne@68	4645 .PP
jpayne@68	4646 Both header files and implementation files can be compiled with a \*(C+
jpayne@68	4647 compiler (at least, that's a stated goal, and breakage will be treated
jpayne@68	4648 as a bug).
jpayne@68	4649 .PP
jpayne@68	4650 You need the following files in your source tree, or in a directory
jpayne@68	4651 in your include path (e.g. in libev/ when using \-Ilibev):
jpayne@68	4652 .PP
jpayne@68	4653 .Vb 4
jpayne@68	4654 \& ev.h
jpayne@68	4655 \& ev.c
jpayne@68	4656 \& ev_vars.h
jpayne@68	4657 \& ev_wrap.h
jpayne@68	4658 \&
jpayne@68	4659 \& ev_win32.c required on win32 platforms only
jpayne@68	4660 \&
jpayne@68	4661 \& ev_select.c only when select backend is enabled
jpayne@68	4662 \& ev_poll.c only when poll backend is enabled
jpayne@68	4663 \& ev_epoll.c only when the epoll backend is enabled
jpayne@68	4664 \& ev_linuxaio.c only when the linux aio backend is enabled
jpayne@68	4665 \& ev_iouring.c only when the linux io_uring backend is enabled
jpayne@68	4666 \& ev_kqueue.c only when the kqueue backend is enabled
jpayne@68	4667 \& ev_port.c only when the solaris port backend is enabled
jpayne@68	4668 .Ve
jpayne@68	4669 .PP
jpayne@68	4670 \&\fIev.c\fR includes the backend files directly when enabled, so you only need
jpayne@68	4671 to compile this single file.
jpayne@68	4672 .PP
jpayne@68	4673 \fI\s-1LIBEVENT COMPATIBILITY API\s0\fR
jpayne@68	4674 .IX Subsection "LIBEVENT COMPATIBILITY API"
jpayne@68	4675 .PP
jpayne@68	4676 To include the libevent compatibility \s-1API,\s0 also include:
jpayne@68	4677 .PP
jpayne@68	4678 .Vb 1
jpayne@68	4679 \& #include "event.c"
jpayne@68	4680 .Ve
jpayne@68	4681 .PP
jpayne@68	4682 in the file including \fIev.c\fR, and:
jpayne@68	4683 .PP
jpayne@68	4684 .Vb 1
jpayne@68	4685 \& #include "event.h"
jpayne@68	4686 .Ve
jpayne@68	4687 .PP
jpayne@68	4688 in the files that want to use the libevent \s-1API.\s0 This also includes \fIev.h\fR.
jpayne@68	4689 .PP
jpayne@68	4690 You need the following additional files for this:
jpayne@68	4691 .PP
jpayne@68	4692 .Vb 2
jpayne@68	4693 \& event.h
jpayne@68	4694 \& event.c
jpayne@68	4695 .Ve
jpayne@68	4696 .PP
jpayne@68	4697 \fI\s-1AUTOCONF SUPPORT\s0\fR
jpayne@68	4698 .IX Subsection "AUTOCONF SUPPORT"
jpayne@68	4699 .PP
jpayne@68	4700 Instead of using \f(CW\(C`EV_STANDALONE=1\(C'\fR and providing your configuration in
jpayne@68	4701 whatever way you want, you can also \f(CW\(C`m4_include([libev.m4])\(C'\fR in your
jpayne@68	4702 \&\fIconfigure.ac\fR and leave \f(CW\(C`EV_STANDALONE\(C'\fR undefined. \fIev.c\fR will then
jpayne@68	4703 include \fIconfig.h\fR and configure itself accordingly.
jpayne@68	4704 .PP
jpayne@68	4705 For this of course you need the m4 file:
jpayne@68	4706 .PP
jpayne@68	4707 .Vb 1
jpayne@68	4708 \& libev.m4
jpayne@68	4709 .Ve
jpayne@68	4710 .SS "\s-1PREPROCESSOR SYMBOLS/MACROS\s0"
jpayne@68	4711 .IX Subsection "PREPROCESSOR SYMBOLS/MACROS"
jpayne@68	4712 Libev can be configured via a variety of preprocessor symbols you have to
jpayne@68	4713 define before including (or compiling) any of its files. The default in
jpayne@68	4714 the absence of autoconf is documented for every option.
jpayne@68	4715 .PP
jpayne@68	4716 Symbols marked with \(L"(h)\(R" do not change the \s-1ABI,\s0 and can have different
jpayne@68	4717 values when compiling libev vs. including \fIev.h\fR, so it is permissible
jpayne@68	4718 to redefine them before including \fIev.h\fR without breaking compatibility
jpayne@68	4719 to a compiled library. All other symbols change the \s-1ABI,\s0 which means all
jpayne@68	4720 users of libev and the libev code itself must be compiled with compatible
jpayne@68	4721 settings.
jpayne@68	4722 .IP "\s-1EV_COMPAT3\s0 (h)" 4
jpayne@68	4723 .IX Item "EV_COMPAT3 (h)"
jpayne@68	4724 Backwards compatibility is a major concern for libev. This is why this
jpayne@68	4725 release of libev comes with wrappers for the functions and symbols that
jpayne@68	4726 have been renamed between libev version 3 and 4.
jpayne@68	4727 .Sp
jpayne@68	4728 You can disable these wrappers (to test compatibility with future
jpayne@68	4729 versions) by defining \f(CW\(C`EV_COMPAT3\(C'\fR to \f(CW0\fR when compiling your
jpayne@68	4730 sources. This has the additional advantage that you can drop the \f(CW\(C`struct\(C'\fR
jpayne@68	4731 from \f(CW\(C`struct ev_loop\(C'\fR declarations, as libev will provide an \f(CW\(C`ev_loop\(C'\fR
jpayne@68	4732 typedef in that case.
jpayne@68	4733 .Sp
jpayne@68	4734 In some future version, the default for \f(CW\(C`EV_COMPAT3\(C'\fR will become \f(CW0\fR,
jpayne@68	4735 and in some even more future version the compatibility code will be
jpayne@68	4736 removed completely.
jpayne@68	4737 .IP "\s-1EV_STANDALONE\s0 (h)" 4
jpayne@68	4738 .IX Item "EV_STANDALONE (h)"
jpayne@68	4739 Must always be \f(CW1\fR if you do not use autoconf configuration, which
jpayne@68	4740 keeps libev from including \fIconfig.h\fR, and it also defines dummy
jpayne@68	4741 implementations for some libevent functions (such as logging, which is not
jpayne@68	4742 supported). It will also not define any of the structs usually found in
jpayne@68	4743 \&\fIevent.h\fR that are not directly supported by the libev core alone.
jpayne@68	4744 .Sp
jpayne@68	4745 In standalone mode, libev will still try to automatically deduce the
jpayne@68	4746 configuration, but has to be more conservative.
jpayne@68	4747 .IP "\s-1EV_USE_FLOOR\s0" 4
jpayne@68	4748 .IX Item "EV_USE_FLOOR"
jpayne@68	4749 If defined to be \f(CW1\fR, libev will use the \f(CW\(C`floor ()\(C'\fR function for its
jpayne@68	4750 periodic reschedule calculations, otherwise libev will fall back on a
jpayne@68	4751 portable (slower) implementation. If you enable this, you usually have to
jpayne@68	4752 link against libm or something equivalent. Enabling this when the \f(CW\(C`floor\(C'\fR
jpayne@68	4753 function is not available will fail, so the safe default is to not enable
jpayne@68	4754 this.
jpayne@68	4755 .IP "\s-1EV_USE_MONOTONIC\s0" 4
jpayne@68	4756 .IX Item "EV_USE_MONOTONIC"
jpayne@68	4757 If defined to be \f(CW1\fR, libev will try to detect the availability of the
jpayne@68	4758 monotonic clock option at both compile time and runtime. Otherwise no
jpayne@68	4759 use of the monotonic clock option will be attempted. If you enable this,
jpayne@68	4760 you usually have to link against librt or something similar. Enabling it
jpayne@68	4761 when the functionality isn't available is safe, though, although you have
jpayne@68	4762 to make sure you link against any libraries where the \f(CW\(C`clock_gettime\(C'\fR
jpayne@68	4763 function is hiding in (often \fI\-lrt\fR). See also \f(CW\(C`EV_USE_CLOCK_SYSCALL\(C'\fR.
jpayne@68	4764 .IP "\s-1EV_USE_REALTIME\s0" 4
jpayne@68	4765 .IX Item "EV_USE_REALTIME"
jpayne@68	4766 If defined to be \f(CW1\fR, libev will try to detect the availability of the
jpayne@68	4767 real-time clock option at compile time (and assume its availability
jpayne@68	4768 at runtime if successful). Otherwise no use of the real-time clock
jpayne@68	4769 option will be attempted. This effectively replaces \f(CW\(C`gettimeofday\(C'\fR
jpayne@68	4770 by \f(CW\(C`clock_get (CLOCK_REALTIME, ...)\(C'\fR and will not normally affect
jpayne@68	4771 correctness. See the note about libraries in the description of
jpayne@68	4772 \&\f(CW\(C`EV_USE_MONOTONIC\(C'\fR, though. Defaults to the opposite value of
jpayne@68	4773 \&\f(CW\(C`EV_USE_CLOCK_SYSCALL\(C'\fR.
jpayne@68	4774 .IP "\s-1EV_USE_CLOCK_SYSCALL\s0" 4
jpayne@68	4775 .IX Item "EV_USE_CLOCK_SYSCALL"
jpayne@68	4776 If defined to be \f(CW1\fR, libev will try to use a direct syscall instead
jpayne@68	4777 of calling the system-provided \f(CW\(C`clock_gettime\(C'\fR function. This option
jpayne@68	4778 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	4779 unconditionally pulls in \f(CW\(C`libpthread\(C'\fR, slowing down single-threaded
jpayne@68	4780 programs needlessly. Using a direct syscall is slightly slower (in
jpayne@68	4781 theory), because no optimised vdso implementation can be used, but avoids
jpayne@68	4782 the pthread dependency. Defaults to \f(CW1\fR on GNU/Linux with glibc 2.x or
jpayne@68	4783 higher, as it simplifies linking (no need for \f(CW\(C`\-lrt\(C'\fR).
jpayne@68	4784 .IP "\s-1EV_USE_NANOSLEEP\s0" 4
jpayne@68	4785 .IX Item "EV_USE_NANOSLEEP"
jpayne@68	4786 If defined to be \f(CW1\fR, libev will assume that \f(CW\(C`nanosleep ()\(C'\fR is available
jpayne@68	4787 and will use it for delays. Otherwise it will use \f(CW\(C`select ()\(C'\fR.
jpayne@68	4788 .IP "\s-1EV_USE_EVENTFD\s0" 4
jpayne@68	4789 .IX Item "EV_USE_EVENTFD"
jpayne@68	4790 If defined to be \f(CW1\fR, then libev will assume that \f(CW\(C`eventfd ()\(C'\fR is
jpayne@68	4791 available and will probe for kernel support at runtime. This will improve
jpayne@68	4792 \&\f(CW\(C`ev_signal\(C'\fR and \f(CW\(C`ev_async\(C'\fR performance and reduce resource consumption.
jpayne@68	4793 If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
jpayne@68	4794 2.7 or newer, otherwise disabled.
jpayne@68	4795 .IP "\s-1EV_USE_SIGNALFD\s0" 4
jpayne@68	4796 .IX Item "EV_USE_SIGNALFD"
jpayne@68	4797 If defined to be \f(CW1\fR, then libev will assume that \f(CW\(C`signalfd ()\(C'\fR is
jpayne@68	4798 available and will probe for kernel support at runtime. This enables
jpayne@68	4799 the use of \s-1EVFLAG_SIGNALFD\s0 for faster and simpler signal handling. If
jpayne@68	4800 undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
jpayne@68	4801 2.7 or newer, otherwise disabled.
jpayne@68	4802 .IP "\s-1EV_USE_TIMERFD\s0" 4
jpayne@68	4803 .IX Item "EV_USE_TIMERFD"
jpayne@68	4804 If defined to be \f(CW1\fR, then libev will assume that \f(CW\(C`timerfd ()\(C'\fR is
jpayne@68	4805 available and will probe for kernel support at runtime. This allows
jpayne@68	4806 libev to detect time jumps accurately. If undefined, it will be enabled
jpayne@68	4807 if the headers indicate GNU/Linux + Glibc 2.8 or newer and define
jpayne@68	4808 \&\f(CW\(C`TFD_TIMER_CANCEL_ON_SET\(C'\fR, otherwise disabled.
jpayne@68	4809 .IP "\s-1EV_USE_EVENTFD\s0" 4
jpayne@68	4810 .IX Item "EV_USE_EVENTFD"
jpayne@68	4811 If defined to be \f(CW1\fR, then libev will assume that \f(CW\(C`eventfd ()\(C'\fR is
jpayne@68	4812 available and will probe for kernel support at runtime. This will improve
jpayne@68	4813 \&\f(CW\(C`ev_signal\(C'\fR and \f(CW\(C`ev_async\(C'\fR performance and reduce resource consumption.
jpayne@68	4814 If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
jpayne@68	4815 2.7 or newer, otherwise disabled.
jpayne@68	4816 .IP "\s-1EV_USE_SELECT\s0" 4
jpayne@68	4817 .IX Item "EV_USE_SELECT"
jpayne@68	4818 If undefined or defined to be \f(CW1\fR, libev will compile in support for the
jpayne@68	4819 \&\f(CW\(C`select\(C'\fR(2) backend. No attempt at auto-detection will be done: if no
jpayne@68	4820 other method takes over, select will be it. Otherwise the select backend
jpayne@68	4821 will not be compiled in.
jpayne@68	4822 .IP "\s-1EV_SELECT_USE_FD_SET\s0" 4
jpayne@68	4823 .IX Item "EV_SELECT_USE_FD_SET"
jpayne@68	4824 If defined to \f(CW1\fR, then the select backend will use the system \f(CW\(C`fd_set\(C'\fR
jpayne@68	4825 structure. This is useful if libev doesn't compile due to a missing
jpayne@68	4826 \&\f(CW\(C`NFDBITS\(C'\fR or \f(CW\(C`fd_mask\(C'\fR definition or it mis-guesses the bitset layout
jpayne@68	4827 on exotic systems. This usually limits the range of file descriptors to
jpayne@68	4828 some low limit such as 1024 or might have other limitations (winsocket
jpayne@68	4829 only allows 64 sockets). The \f(CW\(C`FD_SETSIZE\(C'\fR macro, set before compilation,
jpayne@68	4830 configures the maximum size of the \f(CW\(C`fd_set\(C'\fR.
jpayne@68	4831 .IP "\s-1EV_SELECT_IS_WINSOCKET\s0" 4
jpayne@68	4832 .IX Item "EV_SELECT_IS_WINSOCKET"
jpayne@68	4833 When defined to \f(CW1\fR, the select backend will assume that
jpayne@68	4834 select/socket/connect etc. don't understand file descriptors but
jpayne@68	4835 wants osf handles on win32 (this is the case when the select to
jpayne@68	4836 be used is the winsock select). This means that it will call
jpayne@68	4837 \&\f(CW\(C`_get_osfhandle\(C'\fR on the fd to convert it to an \s-1OS\s0 handle. Otherwise,
jpayne@68	4838 it is assumed that all these functions actually work on fds, even
jpayne@68	4839 on win32. Should not be defined on non\-win32 platforms.
jpayne@68	4840 .IP "\s-1EV_FD_TO_WIN32_HANDLE\s0(fd)" 4
jpayne@68	4841 .IX Item "EV_FD_TO_WIN32_HANDLE(fd)"
jpayne@68	4842 If \f(CW\(C`EV_SELECT_IS_WINSOCKET\(C'\fR is enabled, then libev needs a way to map
jpayne@68	4843 file descriptors to socket handles. When not defining this symbol (the
jpayne@68	4844 default), then libev will call \f(CW\(C`_get_osfhandle\(C'\fR, which is usually
jpayne@68	4845 correct. In some cases, programs use their own file descriptor management,
jpayne@68	4846 in which case they can provide this function to map fds to socket handles.
jpayne@68	4847 .IP "\s-1EV_WIN32_HANDLE_TO_FD\s0(handle)" 4
jpayne@68	4848 .IX Item "EV_WIN32_HANDLE_TO_FD(handle)"
jpayne@68	4849 If \f(CW\(C`EV_SELECT_IS_WINSOCKET\(C'\fR then libev maps handles to file descriptors
jpayne@68	4850 using the standard \f(CW\(C`_open_osfhandle\(C'\fR function. For programs implementing
jpayne@68	4851 their own fd to handle mapping, overwriting this function makes it easier
jpayne@68	4852 to do so. This can be done by defining this macro to an appropriate value.
jpayne@68	4853 .IP "\s-1EV_WIN32_CLOSE_FD\s0(fd)" 4
jpayne@68	4854 .IX Item "EV_WIN32_CLOSE_FD(fd)"
jpayne@68	4855 If programs implement their own fd to handle mapping on win32, then this
jpayne@68	4856 macro can be used to override the \f(CW\(C`close\(C'\fR function, useful to unregister
jpayne@68	4857 file descriptors again. Note that the replacement function has to close
jpayne@68	4858 the underlying \s-1OS\s0 handle.
jpayne@68	4859 .IP "\s-1EV_USE_WSASOCKET\s0" 4
jpayne@68	4860 .IX Item "EV_USE_WSASOCKET"
jpayne@68	4861 If defined to be \f(CW1\fR, libev will use \f(CW\(C`WSASocket\(C'\fR to create its internal
jpayne@68	4862 communication socket, which works better in some environments. Otherwise,
jpayne@68	4863 the normal \f(CW\(C`socket\(C'\fR function will be used, which works better in other
jpayne@68	4864 environments.
jpayne@68	4865 .IP "\s-1EV_USE_POLL\s0" 4
jpayne@68	4866 .IX Item "EV_USE_POLL"
jpayne@68	4867 If defined to be \f(CW1\fR, libev will compile in support for the \f(CW\(C`poll\(C'\fR(2)
jpayne@68	4868 backend. Otherwise it will be enabled on non\-win32 platforms. It
jpayne@68	4869 takes precedence over select.
jpayne@68	4870 .IP "\s-1EV_USE_EPOLL\s0" 4
jpayne@68	4871 .IX Item "EV_USE_EPOLL"
jpayne@68	4872 If defined to be \f(CW1\fR, libev will compile in support for the Linux
jpayne@68	4873 \&\f(CW\(C`epoll\(C'\fR(7) backend. Its availability will be detected at runtime,
jpayne@68	4874 otherwise another method will be used as fallback. This is the preferred
jpayne@68	4875 backend for GNU/Linux systems. If undefined, it will be enabled if the
jpayne@68	4876 headers indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
jpayne@68	4877 .IP "\s-1EV_USE_LINUXAIO\s0" 4
jpayne@68	4878 .IX Item "EV_USE_LINUXAIO"
jpayne@68	4879 If defined to be \f(CW1\fR, libev will compile in support for the Linux aio
jpayne@68	4880 backend (\f(CW\(C`EV_USE_EPOLL\(C'\fR must also be enabled). If undefined, it will be
jpayne@68	4881 enabled on linux, otherwise disabled.
jpayne@68	4882 .IP "\s-1EV_USE_IOURING\s0" 4
jpayne@68	4883 .IX Item "EV_USE_IOURING"
jpayne@68	4884 If defined to be \f(CW1\fR, libev will compile in support for the Linux
jpayne@68	4885 io_uring backend (\f(CW\(C`EV_USE_EPOLL\(C'\fR must also be enabled). Due to it's
jpayne@68	4886 current limitations it has to be requested explicitly. If undefined, it
jpayne@68	4887 will be enabled on linux, otherwise disabled.
jpayne@68	4888 .IP "\s-1EV_USE_KQUEUE\s0" 4
jpayne@68	4889 .IX Item "EV_USE_KQUEUE"
jpayne@68	4890 If defined to be \f(CW1\fR, libev will compile in support for the \s-1BSD\s0 style
jpayne@68	4891 \&\f(CW\(C`kqueue\(C'\fR(2) backend. Its actual availability will be detected at runtime,
jpayne@68	4892 otherwise another method will be used as fallback. This is the preferred
jpayne@68	4893 backend for \s-1BSD\s0 and BSD-like systems, although on most BSDs kqueue only
jpayne@68	4894 supports some types of fds correctly (the only platform we found that
jpayne@68	4895 supports ptys for example was NetBSD), so kqueue might be compiled in, but
jpayne@68	4896 not be used unless explicitly requested. The best way to use it is to find
jpayne@68	4897 out whether kqueue supports your type of fd properly and use an embedded
jpayne@68	4898 kqueue loop.
jpayne@68	4899 .IP "\s-1EV_USE_PORT\s0" 4
jpayne@68	4900 .IX Item "EV_USE_PORT"
jpayne@68	4901 If defined to be \f(CW1\fR, libev will compile in support for the Solaris
jpayne@68	4902 10 port style backend. Its availability will be detected at runtime,
jpayne@68	4903 otherwise another method will be used as fallback. This is the preferred
jpayne@68	4904 backend for Solaris 10 systems.
jpayne@68	4905 .IP "\s-1EV_USE_DEVPOLL\s0" 4
jpayne@68	4906 .IX Item "EV_USE_DEVPOLL"
jpayne@68	4907 Reserved for future expansion, works like the \s-1USE\s0 symbols above.
jpayne@68	4908 .IP "\s-1EV_USE_INOTIFY\s0" 4
jpayne@68	4909 .IX Item "EV_USE_INOTIFY"
jpayne@68	4910 If defined to be \f(CW1\fR, libev will compile in support for the Linux inotify
jpayne@68	4911 interface to speed up \f(CW\(C`ev_stat\(C'\fR watchers. Its actual availability will
jpayne@68	4912 be detected at runtime. If undefined, it will be enabled if the headers
jpayne@68	4913 indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
jpayne@68	4914 .IP "\s-1EV_NO_SMP\s0" 4
jpayne@68	4915 .IX Item "EV_NO_SMP"
jpayne@68	4916 If defined to be \f(CW1\fR, libev will assume that memory is always coherent
jpayne@68	4917 between threads, that is, threads can be used, but threads never run on
jpayne@68	4918 different cpus (or different cpu cores). This reduces dependencies
jpayne@68	4919 and makes libev faster.
jpayne@68	4920 .IP "\s-1EV_NO_THREADS\s0" 4
jpayne@68	4921 .IX Item "EV_NO_THREADS"
jpayne@68	4922 If defined to be \f(CW1\fR, libev will assume that it will never be called from
jpayne@68	4923 different threads (that includes signal handlers), which is a stronger
jpayne@68	4924 assumption than \f(CW\(C`EV_NO_SMP\(C'\fR, above. This reduces dependencies and makes
jpayne@68	4925 libev faster.
jpayne@68	4926 .IP "\s-1EV_ATOMIC_T\s0" 4
jpayne@68	4927 .IX Item "EV_ATOMIC_T"
jpayne@68	4928 Libev requires an integer type (suitable for storing \f(CW0\fR or \f(CW1\fR) whose
jpayne@68	4929 access is atomic with respect to other threads or signal contexts. No
jpayne@68	4930 such type is easily found in the C language, so you can provide your own
jpayne@68	4931 type that you know is safe for your purposes. It is used both for signal
jpayne@68	4932 handler \(L"locking\(R" as well as for signal and thread safety in \f(CW\(C`ev_async\(C'\fR
jpayne@68	4933 watchers.
jpayne@68	4934 .Sp
jpayne@68	4935 In the absence of this define, libev will use \f(CW\(C`sig_atomic_t volatile\(C'\fR
jpayne@68	4936 (from \fIsignal.h\fR), which is usually good enough on most platforms.
jpayne@68	4937 .IP "\s-1EV_H\s0 (h)" 4
jpayne@68	4938 .IX Item "EV_H (h)"
jpayne@68	4939 The name of the \fIev.h\fR header file used to include it. The default if
jpayne@68	4940 undefined is \f(CW"ev.h"\fR in \fIevent.h\fR, \fIev.c\fR and \fIev++.h\fR. This can be
jpayne@68	4941 used to virtually rename the \fIev.h\fR header file in case of conflicts.
jpayne@68	4942 .IP "\s-1EV_CONFIG_H\s0 (h)" 4
jpayne@68	4943 .IX Item "EV_CONFIG_H (h)"
jpayne@68	4944 If \f(CW\(C`EV_STANDALONE\(C'\fR isn't \f(CW1\fR, this variable can be used to override
jpayne@68	4945 \&\fIev.c\fR's idea of where to find the \fIconfig.h\fR file, similarly to
jpayne@68	4946 \&\f(CW\(C`EV_H\(C'\fR, above.
jpayne@68	4947 .IP "\s-1EV_EVENT_H\s0 (h)" 4
jpayne@68	4948 .IX Item "EV_EVENT_H (h)"
jpayne@68	4949 Similarly to \f(CW\(C`EV_H\(C'\fR, this macro can be used to override \fIevent.c\fR's idea
jpayne@68	4950 of how the \fIevent.h\fR header can be found, the default is \f(CW"event.h"\fR.
jpayne@68	4951 .IP "\s-1EV_PROTOTYPES\s0 (h)" 4
jpayne@68	4952 .IX Item "EV_PROTOTYPES (h)"
jpayne@68	4953 If defined to be \f(CW0\fR, then \fIev.h\fR will not define any function
jpayne@68	4954 prototypes, but still define all the structs and other symbols. This is
jpayne@68	4955 occasionally useful if you want to provide your own wrapper functions
jpayne@68	4956 around libev functions.
jpayne@68	4957 .IP "\s-1EV_MULTIPLICITY\s0" 4
jpayne@68	4958 .IX Item "EV_MULTIPLICITY"
jpayne@68	4959 If undefined or defined to \f(CW1\fR, then all event-loop-specific functions
jpayne@68	4960 will have the \f(CW\(C`struct ev_loop \*(C'\fR as first argument, and you can create
jpayne@68	4961 additional independent event loops. Otherwise there will be no support
jpayne@68	4962 for multiple event loops and there is no first event loop pointer
jpayne@68	4963 argument. Instead, all functions act on the single default loop.
jpayne@68	4964 .Sp
jpayne@68	4965 Note that \f(CW\(C`EV_DEFAULT\(C'\fR and \f(CW\(C`EV_DEFAULT_\(C'\fR will no longer provide a
jpayne@68	4966 default loop when multiplicity is switched off \- you always have to
jpayne@68	4967 initialise the loop manually in this case.
jpayne@68	4968 .IP "\s-1EV_MINPRI\s0" 4
jpayne@68	4969 .IX Item "EV_MINPRI"
jpayne@68	4970 .PD 0
jpayne@68	4971 .IP "\s-1EV_MAXPRI\s0" 4
jpayne@68	4972 .IX Item "EV_MAXPRI"
jpayne@68	4973 .PD
jpayne@68	4974 The range of allowed priorities. \f(CW\(C`EV_MINPRI\(C'\fR must be smaller or equal to
jpayne@68	4975 \&\f(CW\(C`EV_MAXPRI\(C'\fR, but otherwise there are no non-obvious limitations. You can
jpayne@68	4976 provide for more priorities by overriding those symbols (usually defined
jpayne@68	4977 to be \f(CW\(C`\-2\(C'\fR and \f(CW2\fR, respectively).
jpayne@68	4978 .Sp
jpayne@68	4979 When doing priority-based operations, libev usually has to linearly search
jpayne@68	4980 all the priorities, so having many of them (hundreds) uses a lot of space
jpayne@68	4981 and time, so using the defaults of five priorities (\-2 .. +2) is usually
jpayne@68	4982 fine.
jpayne@68	4983 .Sp
jpayne@68	4984 If your embedding application does not need any priorities, defining these
jpayne@68	4985 both to \f(CW0\fR will save some memory and \s-1CPU.\s0
jpayne@68	4986 .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	4987 .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	4988 If undefined or defined to be \f(CW1\fR (and the platform supports it), then
jpayne@68	4989 the respective watcher type is supported. If defined to be \f(CW0\fR, then it
jpayne@68	4990 is not. Disabling watcher types mainly saves code size.
jpayne@68	4991 .IP "\s-1EV_FEATURES\s0" 4
jpayne@68	4992 .IX Item "EV_FEATURES"
jpayne@68	4993 If you need to shave off some kilobytes of code at the expense of some
jpayne@68	4994 speed (but with the full \s-1API\s0), you can define this symbol to request
jpayne@68	4995 certain subsets of functionality. The default is to enable all features
jpayne@68	4996 that can be enabled on the platform.
jpayne@68	4997 .Sp
jpayne@68	4998 A typical way to use this symbol is to define it to \f(CW0\fR (or to a bitset
jpayne@68	4999 with some broad features you want) and then selectively re-enable
jpayne@68	5000 additional parts you want, for example if you want everything minimal,
jpayne@68	5001 but multiple event loop support, async and child watchers and the poll
jpayne@68	5002 backend, use this:
jpayne@68	5003 .Sp
jpayne@68	5004 .Vb 5
jpayne@68	5005 \& #define EV_FEATURES 0
jpayne@68	5006 \& #define EV_MULTIPLICITY 1
jpayne@68	5007 \& #define EV_USE_POLL 1
jpayne@68	5008 \& #define EV_CHILD_ENABLE 1
jpayne@68	5009 \& #define EV_ASYNC_ENABLE 1
jpayne@68	5010 .Ve
jpayne@68	5011 .Sp
jpayne@68	5012 The actual value is a bitset, it can be a combination of the following
jpayne@68	5013 values (by default, all of these are enabled):
jpayne@68	5014 .RS 4
jpayne@68	5015 .ie n .IP "1 \- faster/larger code" 4
jpayne@68	5016 .el .IP "\f(CW1\fR \- faster/larger code" 4
jpayne@68	5017 .IX Item "1 - faster/larger code"
jpayne@68	5018 Use larger code to speed up some operations.
jpayne@68	5019 .Sp
jpayne@68	5020 Currently this is used to override some inlining decisions (enlarging the
jpayne@68	5021 code size by roughly 30% on amd64).
jpayne@68	5022 .Sp
jpayne@68	5023 When optimising for size, use of compiler flags such as \f(CW\(C`\-Os\(C'\fR with
jpayne@68	5024 gcc is recommended, as well as \f(CW\(C`\-DNDEBUG\(C'\fR, as libev contains a number of
jpayne@68	5025 assertions.
jpayne@68	5026 .Sp
jpayne@68	5027 The default is off when \f(CW\(C`_\\|_OPTIMIZE_SIZE_\\|_\(C'\fR is defined by your compiler
jpayne@68	5028 (e.g. gcc with \f(CW\(C`\-Os\(C'\fR).
jpayne@68	5029 .ie n .IP "2 \- faster/larger data structures" 4
jpayne@68	5030 .el .IP "\f(CW2\fR \- faster/larger data structures" 4
jpayne@68	5031 .IX Item "2 - faster/larger data structures"
jpayne@68	5032 Replaces the small 2\-heap for timer management by a faster 4\-heap, larger
jpayne@68	5033 hash table sizes and so on. This will usually further increase code size
jpayne@68	5034 and can additionally have an effect on the size of data structures at
jpayne@68	5035 runtime.
jpayne@68	5036 .Sp
jpayne@68	5037 The default is off when \f(CW\(C`_\\|_OPTIMIZE_SIZE_\\|_\(C'\fR is defined by your compiler
jpayne@68	5038 (e.g. gcc with \f(CW\(C`\-Os\(C'\fR).
jpayne@68	5039 .ie n .IP "4 \- full \s-1API\s0 configuration" 4
jpayne@68	5040 .el .IP "\f(CW4\fR \- full \s-1API\s0 configuration" 4
jpayne@68	5041 .IX Item "4 - full API configuration"
jpayne@68	5042 This enables priorities (sets \f(CW\(C`EV_MAXPRI\(C'\fR=2 and \f(CW\(C`EV_MINPRI\(C'\fR=\-2), and
jpayne@68	5043 enables multiplicity (\f(CW\(C`EV_MULTIPLICITY\(C'\fR=1).
jpayne@68	5044 .ie n .IP "8 \- full \s-1API\s0" 4
jpayne@68	5045 .el .IP "\f(CW8\fR \- full \s-1API\s0" 4
jpayne@68	5046 .IX Item "8 - full API"
jpayne@68	5047 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	5048 details on which parts of the \s-1API\s0 are still available without this
jpayne@68	5049 feature, and do not complain if this subset changes over time.
jpayne@68	5050 .ie n .IP "16 \- enable all optional watcher types" 4
jpayne@68	5051 .el .IP "\f(CW16\fR \- enable all optional watcher types" 4
jpayne@68	5052 .IX Item "16 - enable all optional watcher types"
jpayne@68	5053 Enables all optional watcher types. If you want to selectively enable
jpayne@68	5054 only some watcher types other than I/O and timers (e.g. prepare,
jpayne@68	5055 embed, async, child...) you can enable them manually by defining
jpayne@68	5056 \&\f(CW\(C`EV_watchertype_ENABLE\(C'\fR to \f(CW1\fR instead.
jpayne@68	5057 .ie n .IP "32 \- enable all backends" 4
jpayne@68	5058 .el .IP "\f(CW32\fR \- enable all backends" 4
jpayne@68	5059 .IX Item "32 - enable all backends"
jpayne@68	5060 This enables all backends \- without this feature, you need to enable at
jpayne@68	5061 least one backend manually (\f(CW\(C`EV_USE_SELECT\(C'\fR is a good choice).
jpayne@68	5062 .ie n .IP "64 \- enable OS-specific ""helper"" APIs" 4
jpayne@68	5063 .el .IP "\f(CW64\fR \- enable OS-specific ``helper'' APIs" 4
jpayne@68	5064 .IX Item "64 - enable OS-specific helper APIs"
jpayne@68	5065 Enable inotify, eventfd, signalfd and similar OS-specific helper APIs by
jpayne@68	5066 default.
jpayne@68	5067 .RE
jpayne@68	5068 .RS 4
jpayne@68	5069 .Sp
jpayne@68	5070 Compiling with \f(CW\(C`gcc \-Os \-DEV_STANDALONE \-DEV_USE_EPOLL=1 \-DEV_FEATURES=0\(C'\fR
jpayne@68	5071 reduces the compiled size of libev from 24.7Kb code/2.8Kb data to 6.5Kb
jpayne@68	5072 code/0.3Kb data on my GNU/Linux amd64 system, while still giving you I/O
jpayne@68	5073 watchers, timers and monotonic clock support.
jpayne@68	5074 .Sp
jpayne@68	5075 With an intelligent-enough linker (gcc+binutils are intelligent enough
jpayne@68	5076 when you use \f(CW\(C`\-Wl,\-\-gc\-sections \-ffunction\-sections\(C'\fR) functions unused by
jpayne@68	5077 your program might be left out as well \- a binary starting a timer and an
jpayne@68	5078 I/O watcher then might come out at only 5Kb.
jpayne@68	5079 .RE
jpayne@68	5080 .IP "\s-1EV_API_STATIC\s0" 4
jpayne@68	5081 .IX Item "EV_API_STATIC"
jpayne@68	5082 If this symbol is defined (by default it is not), then all identifiers
jpayne@68	5083 will have static linkage. This means that libev will not export any
jpayne@68	5084 identifiers, and you cannot link against libev anymore. This can be useful
jpayne@68	5085 when you embed libev, only want to use libev functions in a single file,
jpayne@68	5086 and do not want its identifiers to be visible.
jpayne@68	5087 .Sp
jpayne@68	5088 To use this, define \f(CW\(C`EV_API_STATIC\(C'\fR and include \fIev.c\fR in the file that
jpayne@68	5089 wants to use libev.
jpayne@68	5090 .Sp
jpayne@68	5091 This option only works when libev is compiled with a C compiler, as \*(C+
jpayne@68	5092 doesn't support the required declaration syntax.
jpayne@68	5093 .IP "\s-1EV_AVOID_STDIO\s0" 4
jpayne@68	5094 .IX Item "EV_AVOID_STDIO"
jpayne@68	5095 If this is set to \f(CW1\fR at compiletime, then libev will avoid using stdio
jpayne@68	5096 functions (printf, scanf, perror etc.). This will increase the code size
jpayne@68	5097 somewhat, but if your program doesn't otherwise depend on stdio and your
jpayne@68	5098 libc allows it, this avoids linking in the stdio library which is quite
jpayne@68	5099 big.
jpayne@68	5100 .Sp
jpayne@68	5101 Note that error messages might become less precise when this option is
jpayne@68	5102 enabled.
jpayne@68	5103 .IP "\s-1EV_NSIG\s0" 4
jpayne@68	5104 .IX Item "EV_NSIG"
jpayne@68	5105 The highest supported signal number, +1 (or, the number of
jpayne@68	5106 signals): Normally, libev tries to deduce the maximum number of signals
jpayne@68	5107 automatically, but sometimes this fails, in which case it can be
jpayne@68	5108 specified. Also, using a lower number than detected (\f(CW32\fR should be
jpayne@68	5109 good for about any system in existence) can save some memory, as libev
jpayne@68	5110 statically allocates some 12\-24 bytes per signal number.
jpayne@68	5111 .IP "\s-1EV_PID_HASHSIZE\s0" 4
jpayne@68	5112 .IX Item "EV_PID_HASHSIZE"
jpayne@68	5113 \&\f(CW\(C`ev_child\(C'\fR watchers use a small hash table to distribute workload by
jpayne@68	5114 pid. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\(C`EV_FEATURES\(C'\fR disabled),
jpayne@68	5115 usually more than enough. If you need to manage thousands of children you
jpayne@68	5116 might want to increase this value (\fImust\fR be a power of two).
jpayne@68	5117 .IP "\s-1EV_INOTIFY_HASHSIZE\s0" 4
jpayne@68	5118 .IX Item "EV_INOTIFY_HASHSIZE"
jpayne@68	5119 \&\f(CW\(C`ev_stat\(C'\fR watchers use a small hash table to distribute workload by
jpayne@68	5120 inotify watch id. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\(C`EV_FEATURES\(C'\fR
jpayne@68	5121 disabled), usually more than enough. If you need to manage thousands of
jpayne@68	5122 \&\f(CW\(C`ev_stat\(C'\fR watchers you might want to increase this value (\fImust\fR be a
jpayne@68	5123 power of two).
jpayne@68	5124 .IP "\s-1EV_USE_4HEAP\s0" 4
jpayne@68	5125 .IX Item "EV_USE_4HEAP"
jpayne@68	5126 Heaps are not very cache-efficient. To improve the cache-efficiency of the
jpayne@68	5127 timer and periodics heaps, libev uses a 4\-heap when this symbol is defined
jpayne@68	5128 to \f(CW1\fR. The 4\-heap uses more complicated (longer) code but has noticeably
jpayne@68	5129 faster performance with many (thousands) of watchers.
jpayne@68	5130 .Sp
jpayne@68	5131 The default is \f(CW1\fR, unless \f(CW\(C`EV_FEATURES\(C'\fR overrides it, in which case it
jpayne@68	5132 will be \f(CW0\fR.
jpayne@68	5133 .IP "\s-1EV_HEAP_CACHE_AT\s0" 4
jpayne@68	5134 .IX Item "EV_HEAP_CACHE_AT"
jpayne@68	5135 Heaps are not very cache-efficient. To improve the cache-efficiency of the
jpayne@68	5136 timer and periodics heaps, libev can cache the timestamp (\fIat\fR) within
jpayne@68	5137 the heap structure (selected by defining \f(CW\(C`EV_HEAP_CACHE_AT\(C'\fR to \f(CW1\fR),
jpayne@68	5138 which uses 8\-12 bytes more per watcher and a few hundred bytes more code,
jpayne@68	5139 but avoids random read accesses on heap changes. This improves performance
jpayne@68	5140 noticeably with many (hundreds) of watchers.
jpayne@68	5141 .Sp
jpayne@68	5142 The default is \f(CW1\fR, unless \f(CW\(C`EV_FEATURES\(C'\fR overrides it, in which case it
jpayne@68	5143 will be \f(CW0\fR.
jpayne@68	5144 .IP "\s-1EV_VERIFY\s0" 4
jpayne@68	5145 .IX Item "EV_VERIFY"
jpayne@68	5146 Controls how much internal verification (see \f(CW\(C`ev_verify ()\(C'\fR) will
jpayne@68	5147 be done: If set to \f(CW0\fR, no internal verification code will be compiled
jpayne@68	5148 in. If set to \f(CW1\fR, then verification code will be compiled in, but not
jpayne@68	5149 called. If set to \f(CW2\fR, then the internal verification code will be
jpayne@68	5150 called once per loop, which can slow down libev. If set to \f(CW3\fR, then the
jpayne@68	5151 verification code will be called very frequently, which will slow down
jpayne@68	5152 libev considerably.
jpayne@68	5153 .Sp
jpayne@68	5154 Verification errors are reported via C's \f(CW\(C`assert\(C'\fR mechanism, so if you
jpayne@68	5155 disable that (e.g. by defining \f(CW\(C`NDEBUG\(C'\fR) then no errors will be reported.
jpayne@68	5156 .Sp
jpayne@68	5157 The default is \f(CW1\fR, unless \f(CW\(C`EV_FEATURES\(C'\fR overrides it, in which case it
jpayne@68	5158 will be \f(CW0\fR.
jpayne@68	5159 .IP "\s-1EV_COMMON\s0" 4
jpayne@68	5160 .IX Item "EV_COMMON"
jpayne@68	5161 By default, all watchers have a \f(CW\(C`void data\*(C'\fR member. By redefining
jpayne@68	5162 this macro to something else you can include more and other types of
jpayne@68	5163 members. You have to define it each time you include one of the files,
jpayne@68	5164 though, and it must be identical each time.
jpayne@68	5165 .Sp
jpayne@68	5166 For example, the perl \s-1EV\s0 module uses something like this:
jpayne@68	5167 .Sp
jpayne@68	5168 .Vb 3
jpayne@68	5169 \& #define EV_COMMON \e
jpayne@68	5170 \& SV self; / contains this struct */ \e
jpayne@68	5171 \& SV cb_sv, fh /* note no trailing ";" */
jpayne@68	5172 .Ve
jpayne@68	5173 .IP "\s-1EV_CB_DECLARE\s0 (type)" 4
jpayne@68	5174 .IX Item "EV_CB_DECLARE (type)"
jpayne@68	5175 .PD 0
jpayne@68	5176 .IP "\s-1EV_CB_INVOKE\s0 (watcher, revents)" 4
jpayne@68	5177 .IX Item "EV_CB_INVOKE (watcher, revents)"
jpayne@68	5178 .IP "ev_set_cb (ev, cb)" 4
jpayne@68	5179 .IX Item "ev_set_cb (ev, cb)"
jpayne@68	5180 .PD
jpayne@68	5181 Can be used to change the callback member declaration in each watcher,
jpayne@68	5182 and the way callbacks are invoked and set. Must expand to a struct member
jpayne@68	5183 definition and a statement, respectively. See the \fIev.h\fR header file for
jpayne@68	5184 their default definitions. One possible use for overriding these is to
jpayne@68	5185 avoid the \f(CW\(C`struct ev_loop \*(C'\fR as first argument in all cases, or to use
jpayne@68	5186 method calls instead of plain function calls in \*(C+.
jpayne@68	5187 .SS "\s-1EXPORTED API SYMBOLS\s0"
jpayne@68	5188 .IX Subsection "EXPORTED API SYMBOLS"
jpayne@68	5189 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	5190 exported symbols, you can use the provided \fISymbol.*\fR files which list
jpayne@68	5191 all public symbols, one per line:
jpayne@68	5192 .PP
jpayne@68	5193 .Vb 2
jpayne@68	5194 \& Symbols.ev for libev proper
jpayne@68	5195 \& Symbols.event for the libevent emulation
jpayne@68	5196 .Ve
jpayne@68	5197 .PP
jpayne@68	5198 This can also be used to rename all public symbols to avoid clashes with
jpayne@68	5199 multiple versions of libev linked together (which is obviously bad in
jpayne@68	5200 itself, but sometimes it is inconvenient to avoid this).
jpayne@68	5201 .PP
jpayne@68	5202 A sed command like this will create wrapper \f(CW\(C`#define\(C'\fR's that you need to
jpayne@68	5203 include before including \fIev.h\fR:
jpayne@68	5204 .PP
jpayne@68	5205 .Vb 1
jpayne@68	5206 \& <Symbols.ev sed \-e "s/.*/#define & myprefix_&/" >wrap.h
jpayne@68	5207 .Ve
jpayne@68	5208 .PP
jpayne@68	5209 This would create a file \fIwrap.h\fR which essentially looks like this:
jpayne@68	5210 .PP
jpayne@68	5211 .Vb 4
jpayne@68	5212 \& #define ev_backend myprefix_ev_backend
jpayne@68	5213 \& #define ev_check_start myprefix_ev_check_start
jpayne@68	5214 \& #define ev_check_stop myprefix_ev_check_stop
jpayne@68	5215 \& ...
jpayne@68	5216 .Ve
jpayne@68	5217 .SS "\s-1EXAMPLES\s0"
jpayne@68	5218 .IX Subsection "EXAMPLES"
jpayne@68	5219 For a real-world example of a program the includes libev
jpayne@68	5220 verbatim, you can have a look at the \s-1EV\s0 perl module
jpayne@68	5221 (<http://software.schmorp.de/pkg/EV.html>). It has the libev files in
jpayne@68	5222 the \fIlibev/\fR subdirectory and includes them in the \fI\s-1EV/EVAPI\s0.h\fR (public
jpayne@68	5223 interface) and \fI\s-1EV\s0.xs\fR (implementation) files. Only the \fI\s-1EV\s0.xs\fR file
jpayne@68	5224 will be compiled. It is pretty complex because it provides its own header
jpayne@68	5225 file.
jpayne@68	5226 .PP
jpayne@68	5227 The usage in rxvt-unicode is simpler. It has a \fIev_cpp.h\fR header file
jpayne@68	5228 that everybody includes and which overrides some configure choices:
jpayne@68	5229 .PP
jpayne@68	5230 .Vb 8
jpayne@68	5231 \& #define EV_FEATURES 8
jpayne@68	5232 \& #define EV_USE_SELECT 1
jpayne@68	5233 \& #define EV_PREPARE_ENABLE 1
jpayne@68	5234 \& #define EV_IDLE_ENABLE 1
jpayne@68	5235 \& #define EV_SIGNAL_ENABLE 1
jpayne@68	5236 \& #define EV_CHILD_ENABLE 1
jpayne@68	5237 \& #define EV_USE_STDEXCEPT 0
jpayne@68	5238 \& #define EV_CONFIG_H <config.h>
jpayne@68	5239 \&
jpayne@68	5240 \& #include "ev++.h"
jpayne@68	5241 .Ve
jpayne@68	5242 .PP
jpayne@68	5243 And a \fIev_cpp.C\fR implementation file that contains libev proper and is compiled:
jpayne@68	5244 .PP
jpayne@68	5245 .Vb 2
jpayne@68	5246 \& #include "ev_cpp.h"
jpayne@68	5247 \& #include "ev.c"
jpayne@68	5248 .Ve
jpayne@68	5249 .SH "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT"
jpayne@68	5250 .IX Header "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT"
jpayne@68	5251 .SS "\s-1THREADS AND COROUTINES\s0"
jpayne@68	5252 .IX Subsection "THREADS AND COROUTINES"
jpayne@68	5253 \fI\s-1THREADS\s0\fR
jpayne@68	5254 .IX Subsection "THREADS"
jpayne@68	5255 .PP
jpayne@68	5256 All libev functions are reentrant and thread-safe unless explicitly
jpayne@68	5257 documented otherwise, but libev implements no locking itself. This means
jpayne@68	5258 that you can use as many loops as you want in parallel, as long as there
jpayne@68	5259 are no concurrent calls into any libev function with the same loop
jpayne@68	5260 parameter (\f(CW\(C`ev_default_\*(C'\fR calls have an implicit default loop parameter,
jpayne@68	5261 of course): libev guarantees that different event loops share no data
jpayne@68	5262 structures that need any locking.
jpayne@68	5263 .PP
jpayne@68	5264 Or to put it differently: calls with different loop parameters can be done
jpayne@68	5265 concurrently from multiple threads, calls with the same loop parameter
jpayne@68	5266 must be done serially (but can be done from different threads, as long as
jpayne@68	5267 only one thread ever is inside a call at any point in time, e.g. by using
jpayne@68	5268 a mutex per loop).
jpayne@68	5269 .PP
jpayne@68	5270 Specifically to support threads (and signal handlers), libev implements
jpayne@68	5271 so-called \f(CW\(C`ev_async\(C'\fR watchers, which allow some limited form of
jpayne@68	5272 concurrency on the same event loop, namely waking it up \*(L"from the
jpayne@68	5273 outside\*(R".
jpayne@68	5274 .PP
jpayne@68	5275 If you want to know which design (one loop, locking, or multiple loops
jpayne@68	5276 without or something else still) is best for your problem, then I cannot
jpayne@68	5277 help you, but here is some generic advice:
jpayne@68	5278 .IP "\(bu" 4
jpayne@68	5279 most applications have a main thread: use the default libev loop
jpayne@68	5280 in that thread, or create a separate thread running only the default loop.
jpayne@68	5281 .Sp
jpayne@68	5282 This helps integrating other libraries or software modules that use libev
jpayne@68	5283 themselves and don't care/know about threading.
jpayne@68	5284 .IP "\(bu" 4
jpayne@68	5285 one loop per thread is usually a good model.
jpayne@68	5286 .Sp
jpayne@68	5287 Doing this is almost never wrong, sometimes a better-performance model
jpayne@68	5288 exists, but it is always a good start.
jpayne@68	5289 .IP "\(bu" 4
jpayne@68	5290 other models exist, such as the leader/follower pattern, where one
jpayne@68	5291 loop is handed through multiple threads in a kind of round-robin fashion.
jpayne@68	5292 .Sp
jpayne@68	5293 Choosing a model is hard \- look around, learn, know that usually you can do
jpayne@68	5294 better than you currently do :\-)
jpayne@68	5295 .IP "\(bu" 4
jpayne@68	5296 often you need to talk to some other thread which blocks in the
jpayne@68	5297 event loop.
jpayne@68	5298 .Sp
jpayne@68	5299 \&\f(CW\(C`ev_async\(C'\fR watchers can be used to wake them up from other threads safely
jpayne@68	5300 (or from signal contexts...).
jpayne@68	5301 .Sp
jpayne@68	5302 An example use would be to communicate signals or other events that only
jpayne@68	5303 work in the default loop by registering the signal watcher with the
jpayne@68	5304 default loop and triggering an \f(CW\(C`ev_async\(C'\fR watcher from the default loop
jpayne@68	5305 watcher callback into the event loop interested in the signal.
jpayne@68	5306 .PP
jpayne@68	5307 See also \(L"\s-1THREAD LOCKING EXAMPLE\(R"\s0.
jpayne@68	5308 .PP
jpayne@68	5309 \fI\s-1COROUTINES\s0\fR
jpayne@68	5310 .IX Subsection "COROUTINES"
jpayne@68	5311 .PP
jpayne@68	5312 Libev is very accommodating to coroutines (\(L"cooperative threads\(R"):
jpayne@68	5313 libev fully supports nesting calls to its functions from different
jpayne@68	5314 coroutines (e.g. you can call \f(CW\(C`ev_run\(C'\fR on the same loop from two
jpayne@68	5315 different coroutines, and switch freely between both coroutines running
jpayne@68	5316 the loop, as long as you don't confuse yourself). The only exception is
jpayne@68	5317 that you must not do this from \f(CW\(C`ev_periodic\(C'\fR reschedule callbacks.
jpayne@68	5318 .PP
jpayne@68	5319 Care has been taken to ensure that libev does not keep local state inside
jpayne@68	5320 \&\f(CW\(C`ev_run\(C'\fR, and other calls do not usually allow for coroutine switches as
jpayne@68	5321 they do not call any callbacks.
jpayne@68	5322 .SS "\s-1COMPILER WARNINGS\s0"
jpayne@68	5323 .IX Subsection "COMPILER WARNINGS"
jpayne@68	5324 Depending on your compiler and compiler settings, you might get no or a
jpayne@68	5325 lot of warnings when compiling libev code. Some people are apparently
jpayne@68	5326 scared by this.
jpayne@68	5327 .PP
jpayne@68	5328 However, these are unavoidable for many reasons. For one, each compiler
jpayne@68	5329 has different warnings, and each user has different tastes regarding
jpayne@68	5330 warning options. \(L"Warn-free\(R" code therefore cannot be a goal except when
jpayne@68	5331 targeting a specific compiler and compiler-version.
jpayne@68	5332 .PP
jpayne@68	5333 Another reason is that some compiler warnings require elaborate
jpayne@68	5334 workarounds, or other changes to the code that make it less clear and less
jpayne@68	5335 maintainable.
jpayne@68	5336 .PP
jpayne@68	5337 And of course, some compiler warnings are just plain stupid, or simply
jpayne@68	5338 wrong (because they don't actually warn about the condition their message
jpayne@68	5339 seems to warn about). For example, certain older gcc versions had some
jpayne@68	5340 warnings that resulted in an extreme number of false positives. These have
jpayne@68	5341 been fixed, but some people still insist on making code warn-free with
jpayne@68	5342 such buggy versions.
jpayne@68	5343 .PP
jpayne@68	5344 While libev is written to generate as few warnings as possible,
jpayne@68	5345 \&\(L"warn-free\(R" code is not a goal, and it is recommended not to build libev
jpayne@68	5346 with any compiler warnings enabled unless you are prepared to cope with
jpayne@68	5347 them (e.g. by ignoring them). Remember that warnings are just that:
jpayne@68	5348 warnings, not errors, or proof of bugs.
jpayne@68	5349 .SS "\s-1VALGRIND\s0"
jpayne@68	5350 .IX Subsection "VALGRIND"
jpayne@68	5351 Valgrind has a special section here because it is a popular tool that is
jpayne@68	5352 highly useful. Unfortunately, valgrind reports are very hard to interpret.
jpayne@68	5353 .PP
jpayne@68	5354 If you think you found a bug (memory leak, uninitialised data access etc.)
jpayne@68	5355 in libev, then check twice: If valgrind reports something like:
jpayne@68	5356 .PP
jpayne@68	5357 .Vb 3
jpayne@68	5358 \& ==2274== definitely lost: 0 bytes in 0 blocks.
jpayne@68	5359 \& ==2274== possibly lost: 0 bytes in 0 blocks.
jpayne@68	5360 \& ==2274== still reachable: 256 bytes in 1 blocks.
jpayne@68	5361 .Ve
jpayne@68	5362 .PP
jpayne@68	5363 Then there is no memory leak, just as memory accounted to global variables
jpayne@68	5364 is not a memleak \- the memory is still being referenced, and didn't leak.
jpayne@68	5365 .PP
jpayne@68	5366 Similarly, under some circumstances, valgrind might report kernel bugs
jpayne@68	5367 as if it were a bug in libev (e.g. in realloc or in the poll backend,
jpayne@68	5368 although an acceptable workaround has been found here), or it might be
jpayne@68	5369 confused.
jpayne@68	5370 .PP
jpayne@68	5371 Keep in mind that valgrind is a very good tool, but only a tool. Don't
jpayne@68	5372 make it into some kind of religion.
jpayne@68	5373 .PP
jpayne@68	5374 If you are unsure about something, feel free to contact the mailing list
jpayne@68	5375 with the full valgrind report and an explanation on why you think this
jpayne@68	5376 is a bug in libev (best check the archives, too :). However, don't be
jpayne@68	5377 annoyed when you get a brisk \(L"this is no bug\(R" answer and take the chance
jpayne@68	5378 of learning how to interpret valgrind properly.
jpayne@68	5379 .PP
jpayne@68	5380 If you need, for some reason, empty reports from valgrind for your project
jpayne@68	5381 I suggest using suppression lists.
jpayne@68	5382 .SH "PORTABILITY NOTES"
jpayne@68	5383 .IX Header "PORTABILITY NOTES"
jpayne@68	5384 .SS "\s-1GNU/LINUX 32 BIT LIMITATIONS\s0"
jpayne@68	5385 .IX Subsection "GNU/LINUX 32 BIT LIMITATIONS"
jpayne@68	5386 GNU/Linux is the only common platform that supports 64 bit file/large file
jpayne@68	5387 interfaces but \fIdisables\fR them by default.
jpayne@68	5388 .PP
jpayne@68	5389 That means that libev compiled in the default environment doesn't support
jpayne@68	5390 files larger than 2GiB or so, which mainly affects \f(CW\(C`ev_stat\(C'\fR watchers.
jpayne@68	5391 .PP
jpayne@68	5392 Unfortunately, many programs try to work around this GNU/Linux issue
jpayne@68	5393 by enabling the large file \s-1API,\s0 which makes them incompatible with the
jpayne@68	5394 standard libev compiled for their system.
jpayne@68	5395 .PP
jpayne@68	5396 Likewise, libev cannot enable the large file \s-1API\s0 itself as this would
jpayne@68	5397 suddenly make it incompatible to the default compile time environment,
jpayne@68	5398 i.e. all programs not using special compile switches.
jpayne@68	5399 .SS "\s-1OS/X AND DARWIN BUGS\s0"
jpayne@68	5400 .IX Subsection "OS/X AND DARWIN BUGS"
jpayne@68	5401 The whole thing is a bug if you ask me \- basically any system interface
jpayne@68	5402 you touch is broken, whether it is locales, poll, kqueue or even the
jpayne@68	5403 OpenGL drivers.
jpayne@68	5404 .PP
jpayne@68	5405 \fI\f(CI\(C`kqueue\(C'\fI is buggy\fR
jpayne@68	5406 .IX Subsection "kqueue is buggy"
jpayne@68	5407 .PP
jpayne@68	5408 The kqueue syscall is broken in all known versions \- most versions support
jpayne@68	5409 only sockets, many support pipes.
jpayne@68	5410 .PP
jpayne@68	5411 Libev tries to work around this by not using \f(CW\(C`kqueue\(C'\fR by default on this
jpayne@68	5412 rotten platform, but of course you can still ask for it when creating a
jpayne@68	5413 loop \- embedding a socket-only kqueue loop into a select-based one is
jpayne@68	5414 probably going to work well.
jpayne@68	5415 .PP
jpayne@68	5416 \fI\f(CI\(C`poll\(C'\fI is buggy\fR
jpayne@68	5417 .IX Subsection "poll is buggy"
jpayne@68	5418 .PP
jpayne@68	5419 Instead of fixing \f(CW\(C`kqueue\(C'\fR, Apple replaced their (working) \f(CW\(C`poll\(C'\fR
jpayne@68	5420 implementation by something calling \f(CW\(C`kqueue\(C'\fR internally around the 10.5.6
jpayne@68	5421 release, so now \f(CW\(C`kqueue\(C'\fR \fIand\fR \f(CW\(C`poll\(C'\fR are broken.
jpayne@68	5422 .PP
jpayne@68	5423 Libev tries to work around this by not using \f(CW\(C`poll\(C'\fR by default on
jpayne@68	5424 this rotten platform, but of course you can still ask for it when creating
jpayne@68	5425 a loop.
jpayne@68	5426 .PP
jpayne@68	5427 \fI\f(CI\(C`select\(C'\fI is buggy\fR
jpayne@68	5428 .IX Subsection "select is buggy"
jpayne@68	5429 .PP
jpayne@68	5430 All that's left is \f(CW\(C`select\(C'\fR, and of course Apple found a way to fuck this
jpayne@68	5431 one up as well: On \s-1OS/X,\s0 \f(CW\(C`select\(C'\fR actively limits the number of file
jpayne@68	5432 descriptors you can pass in to 1024 \- your program suddenly crashes when
jpayne@68	5433 you use more.
jpayne@68	5434 .PP
jpayne@68	5435 There is an undocumented \(L"workaround\(R" for this \- defining
jpayne@68	5436 \&\f(CW\(C`_DARWIN_UNLIMITED_SELECT\(C'\fR, which libev tries to use, so select \fIshould\fR
jpayne@68	5437 work on \s-1OS/X.\s0
jpayne@68	5438 .SS "\s-1SOLARIS PROBLEMS AND WORKAROUNDS\s0"
jpayne@68	5439 .IX Subsection "SOLARIS PROBLEMS AND WORKAROUNDS"
jpayne@68	5440 \fI\f(CI\(C`errno\(C'\fI reentrancy\fR
jpayne@68	5441 .IX Subsection "errno reentrancy"
jpayne@68	5442 .PP
jpayne@68	5443 The default compile environment on Solaris is unfortunately so
jpayne@68	5444 thread-unsafe that you can't even use components/libraries compiled
jpayne@68	5445 without \f(CW\(C`\-D_REENTRANT\(C'\fR in a threaded program, which, of course, isn't
jpayne@68	5446 defined by default. A valid, if stupid, implementation choice.
jpayne@68	5447 .PP
jpayne@68	5448 If you want to use libev in threaded environments you have to make sure
jpayne@68	5449 it's compiled with \f(CW\(C`_REENTRANT\(C'\fR defined.
jpayne@68	5450 .PP
jpayne@68	5451 \fIEvent port backend\fR
jpayne@68	5452 .IX Subsection "Event port backend"
jpayne@68	5453 .PP
jpayne@68	5454 The scalable event interface for Solaris is called \*(L"event
jpayne@68	5455 ports\*(R". Unfortunately, this mechanism is very buggy in all major
jpayne@68	5456 releases. If you run into high \s-1CPU\s0 usage, your program freezes or you get
jpayne@68	5457 a large number of spurious wakeups, make sure you have all the relevant
jpayne@68	5458 and latest kernel patches applied. No, I don't know which ones, but there
jpayne@68	5459 are multiple ones to apply, and afterwards, event ports actually work
jpayne@68	5460 great.
jpayne@68	5461 .PP
jpayne@68	5462 If you can't get it to work, you can try running the program by setting
jpayne@68	5463 the environment variable \f(CW\(C`LIBEV_FLAGS=3\(C'\fR to only allow \f(CW\(C`poll\(C'\fR and
jpayne@68	5464 \&\f(CW\(C`select\(C'\fR backends.
jpayne@68	5465 .SS "\s-1AIX POLL BUG\s0"
jpayne@68	5466 .IX Subsection "AIX POLL BUG"
jpayne@68	5467 \&\s-1AIX\s0 unfortunately has a broken \f(CW\(C`poll.h\(C'\fR header. Libev works around
jpayne@68	5468 this by trying to avoid the poll backend altogether (i.e. it's not even
jpayne@68	5469 compiled in), which normally isn't a big problem as \f(CW\(C`select\(C'\fR works fine
jpayne@68	5470 with large bitsets on \s-1AIX,\s0 and \s-1AIX\s0 is dead anyway.
jpayne@68	5471 .SS "\s-1WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS\s0"
jpayne@68	5472 .IX Subsection "WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS"
jpayne@68	5473 \fIGeneral issues\fR
jpayne@68	5474 .IX Subsection "General issues"
jpayne@68	5475 .PP
jpayne@68	5476 Win32 doesn't support any of the standards (e.g. \s-1POSIX\s0) that libev
jpayne@68	5477 requires, and its I/O model is fundamentally incompatible with the \s-1POSIX\s0
jpayne@68	5478 model. Libev still offers limited functionality on this platform in
jpayne@68	5479 the form of the \f(CW\(C`EVBACKEND_SELECT\(C'\fR backend, and only supports socket
jpayne@68	5480 descriptors. This only applies when using Win32 natively, not when using
jpayne@68	5481 e.g. cygwin. Actually, it only applies to the microsofts own compilers,
jpayne@68	5482 as every compiler comes with a slightly differently broken/incompatible
jpayne@68	5483 environment.
jpayne@68	5484 .PP
jpayne@68	5485 Lifting these limitations would basically require the full
jpayne@68	5486 re-implementation of the I/O system. If you are into this kind of thing,
jpayne@68	5487 then note that glib does exactly that for you in a very portable way (note
jpayne@68	5488 also that glib is the slowest event library known to man).
jpayne@68	5489 .PP
jpayne@68	5490 There is no supported compilation method available on windows except
jpayne@68	5491 embedding it into other applications.
jpayne@68	5492 .PP
jpayne@68	5493 Sensible signal handling is officially unsupported by Microsoft \- libev
jpayne@68	5494 tries its best, but under most conditions, signals will simply not work.
jpayne@68	5495 .PP
jpayne@68	5496 Not a libev limitation but worth mentioning: windows apparently doesn't
jpayne@68	5497 accept large writes: instead of resulting in a partial write, windows will
jpayne@68	5498 either accept everything or return \f(CW\(C`ENOBUFS\(C'\fR if the buffer is too large,
jpayne@68	5499 so make sure you only write small amounts into your sockets (less than a
jpayne@68	5500 megabyte seems safe, but this apparently depends on the amount of memory
jpayne@68	5501 available).
jpayne@68	5502 .PP
jpayne@68	5503 Due to the many, low, and arbitrary limits on the win32 platform and
jpayne@68	5504 the abysmal performance of winsockets, using a large number of sockets
jpayne@68	5505 is not recommended (and not reasonable). If your program needs to use
jpayne@68	5506 more than a hundred or so sockets, then likely it needs to use a totally
jpayne@68	5507 different implementation for windows, as libev offers the \s-1POSIX\s0 readiness
jpayne@68	5508 notification model, which cannot be implemented efficiently on windows
jpayne@68	5509 (due to Microsoft monopoly games).
jpayne@68	5510 .PP
jpayne@68	5511 A typical way to use libev under windows is to embed it (see the embedding
jpayne@68	5512 section for details) and use the following \fIevwrap.h\fR header file instead
jpayne@68	5513 of \fIev.h\fR:
jpayne@68	5514 .PP
jpayne@68	5515 .Vb 2
jpayne@68	5516 \& #define EV_STANDALONE /* keeps ev from requiring config.h */
jpayne@68	5517 \& #define EV_SELECT_IS_WINSOCKET 1 /* configure libev for windows select */
jpayne@68	5518 \&
jpayne@68	5519 \& #include "ev.h"
jpayne@68	5520 .Ve
jpayne@68	5521 .PP
jpayne@68	5522 And compile the following \fIevwrap.c\fR file into your project (make sure
jpayne@68	5523 you do \fInot\fR compile the \fIev.c\fR or any other embedded source files!):
jpayne@68	5524 .PP
jpayne@68	5525 .Vb 2
jpayne@68	5526 \& #include "evwrap.h"
jpayne@68	5527 \& #include "ev.c"
jpayne@68	5528 .Ve
jpayne@68	5529 .PP
jpayne@68	5530 \fIThe winsocket \f(CI\(C`select\(C'\fI function\fR
jpayne@68	5531 .IX Subsection "The winsocket select function"
jpayne@68	5532 .PP
jpayne@68	5533 The winsocket \f(CW\(C`select\(C'\fR function doesn't follow \s-1POSIX\s0 in that it
jpayne@68	5534 requires socket \fIhandles\fR and not socket \fIfile descriptors\fR (it is
jpayne@68	5535 also extremely buggy). This makes select very inefficient, and also
jpayne@68	5536 requires a mapping from file descriptors to socket handles (the Microsoft
jpayne@68	5537 C runtime provides the function \f(CW\(C`_open_osfhandle\(C'\fR for this). See the
jpayne@68	5538 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	5539 \&\f(CW\(C`EV_FD_TO_WIN32_HANDLE\(C'\fR preprocessor symbols for more info.
jpayne@68	5540 .PP
jpayne@68	5541 The configuration for a \(L"naked\(R" win32 using the Microsoft runtime
jpayne@68	5542 libraries and raw winsocket select is:
jpayne@68	5543 .PP
jpayne@68	5544 .Vb 2
jpayne@68	5545 \& #define EV_USE_SELECT 1
jpayne@68	5546 \& #define EV_SELECT_IS_WINSOCKET 1 /* forces EV_SELECT_USE_FD_SET, too */
jpayne@68	5547 .Ve
jpayne@68	5548 .PP
jpayne@68	5549 Note that winsockets handling of fd sets is O(n), so you can easily get a
jpayne@68	5550 complexity in the O(nX) range when using win32.
jpayne@68	5551 .PP
jpayne@68	5552 \fILimited number of file descriptors\fR
jpayne@68	5553 .IX Subsection "Limited number of file descriptors"
jpayne@68	5554 .PP
jpayne@68	5555 Windows has numerous arbitrary (and low) limits on things.
jpayne@68	5556 .PP
jpayne@68	5557 Early versions of winsocket's select only supported waiting for a maximum
jpayne@68	5558 of \f(CW64\fR handles (probably owning to the fact that all windows kernels
jpayne@68	5559 can only wait for \f(CW64\fR things at the same time internally; Microsoft
jpayne@68	5560 recommends spawning a chain of threads and wait for 63 handles and the
jpayne@68	5561 previous thread in each. Sounds great!).
jpayne@68	5562 .PP
jpayne@68	5563 Newer versions support more handles, but you need to define \f(CW\(C`FD_SETSIZE\(C'\fR
jpayne@68	5564 to some high number (e.g. \f(CW2048\fR) before compiling the winsocket select
jpayne@68	5565 call (which might be in libev or elsewhere, for example, perl and many
jpayne@68	5566 other interpreters do their own select emulation on windows).
jpayne@68	5567 .PP
jpayne@68	5568 Another limit is the number of file descriptors in the Microsoft runtime
jpayne@68	5569 libraries, which by default is \f(CW64\fR (there must be a hidden \fI64\fR
jpayne@68	5570 fetish or something like this inside Microsoft). You can increase this
jpayne@68	5571 by calling \f(CW\(C`_setmaxstdio\(C'\fR, which can increase this limit to \f(CW2048\fR
jpayne@68	5572 (another arbitrary limit), but is broken in many versions of the Microsoft
jpayne@68	5573 runtime libraries. This might get you to about \f(CW512\fR or \f(CW2048\fR sockets
jpayne@68	5574 (depending on windows version and/or the phase of the moon). To get more,
jpayne@68	5575 you need to wrap all I/O functions and provide your own fd management, but
jpayne@68	5576 the cost of calling select (O(nX)) will likely make this unworkable.
jpayne@68	5577 .SS "\s-1PORTABILITY REQUIREMENTS\s0"
jpayne@68	5578 .IX Subsection "PORTABILITY REQUIREMENTS"
jpayne@68	5579 In addition to a working ISO-C implementation and of course the
jpayne@68	5580 backend-specific APIs, libev relies on a few additional extensions:
jpayne@68	5581 .ie n .IP """void ()(ev_watcher_type , int revents)"" must have compatible calling conventions regardless of ""ev_watcher_type *""." 4
jpayne@68	5582 .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	5583 .IX Item "void ()(ev_watcher_type , int revents) must have compatible calling conventions regardless of ev_watcher_type *."
jpayne@68	5584 Libev assumes not only that all watcher pointers have the same internal
jpayne@68	5585 structure (guaranteed by \s-1POSIX\s0 but not by \s-1ISO C\s0 for example), but it also
jpayne@68	5586 assumes that the same (machine) code can be used to call any watcher
jpayne@68	5587 callback: The watcher callbacks have different type signatures, but libev
jpayne@68	5588 calls them using an \f(CW\(C`ev_watcher \*(C'\fR internally.
jpayne@68	5589 .IP "null pointers and integer zero are represented by 0 bytes" 4
jpayne@68	5590 .IX Item "null pointers and integer zero are represented by 0 bytes"
jpayne@68	5591 Libev uses \f(CW\(C`memset\(C'\fR to initialise structs and arrays to \f(CW0\fR bytes, and
jpayne@68	5592 relies on this setting pointers and integers to null.
jpayne@68	5593 .IP "pointer accesses must be thread-atomic" 4
jpayne@68	5594 .IX Item "pointer accesses must be thread-atomic"
jpayne@68	5595 Accessing a pointer value must be atomic, it must both be readable and
jpayne@68	5596 writable in one piece \- this is the case on all current architectures.
jpayne@68	5597 .ie n .IP """sig_atomic_t volatile"" must be thread-atomic as well" 4
jpayne@68	5598 .el .IP "\f(CWsig_atomic_t volatile\fR must be thread-atomic as well" 4
jpayne@68	5599 .IX Item "sig_atomic_t volatile must be thread-atomic as well"
jpayne@68	5600 The type \f(CW\(C`sig_atomic_t volatile\(C'\fR (or whatever is defined as
jpayne@68	5601 \&\f(CW\(C`EV_ATOMIC_T\(C'\fR) must be atomic with respect to accesses from different
jpayne@68	5602 threads. This is not part of the specification for \f(CW\(C`sig_atomic_t\(C'\fR, but is
jpayne@68	5603 believed to be sufficiently portable.
jpayne@68	5604 .ie n .IP """sigprocmask"" must work in a threaded environment" 4
jpayne@68	5605 .el .IP "\f(CWsigprocmask\fR must work in a threaded environment" 4
jpayne@68	5606 .IX Item "sigprocmask must work in a threaded environment"
jpayne@68	5607 Libev uses \f(CW\(C`sigprocmask\(C'\fR to temporarily block signals. This is not
jpayne@68	5608 allowed in a threaded program (\f(CW\(C`pthread_sigmask\(C'\fR has to be used). Typical
jpayne@68	5609 pthread implementations will either allow \f(CW\(C`sigprocmask\(C'\fR in the \*(L"main
jpayne@68	5610 thread\*(R" or will block signals process-wide, both behaviours would
jpayne@68	5611 be compatible with libev. Interaction between \f(CW\(C`sigprocmask\(C'\fR and
jpayne@68	5612 \&\f(CW\(C`pthread_sigmask\(C'\fR could complicate things, however.
jpayne@68	5613 .Sp
jpayne@68	5614 The most portable way to handle signals is to block signals in all threads
jpayne@68	5615 except the initial one, and run the signal handling loop in the initial
jpayne@68	5616 thread as well.
jpayne@68	5617 .ie n .IP """long"" must be large enough for common memory allocation sizes" 4
jpayne@68	5618 .el .IP "\f(CWlong\fR must be large enough for common memory allocation sizes" 4
jpayne@68	5619 .IX Item "long must be large enough for common memory allocation sizes"
jpayne@68	5620 To improve portability and simplify its \s-1API,\s0 libev uses \f(CW\(C`long\(C'\fR internally
jpayne@68	5621 instead of \f(CW\(C`size_t\(C'\fR when allocating its data structures. On non-POSIX
jpayne@68	5622 systems (Microsoft...) this might be unexpectedly low, but is still at
jpayne@68	5623 least 31 bits everywhere, which is enough for hundreds of millions of
jpayne@68	5624 watchers.
jpayne@68	5625 .ie n .IP """double"" must hold a time value in seconds with enough accuracy" 4
jpayne@68	5626 .el .IP "\f(CWdouble\fR must hold a time value in seconds with enough accuracy" 4
jpayne@68	5627 .IX Item "double must hold a time value in seconds with enough accuracy"
jpayne@68	5628 The type \f(CW\(C`double\(C'\fR is used to represent timestamps. It is required to
jpayne@68	5629 have at least 51 bits of mantissa (and 9 bits of exponent), which is
jpayne@68	5630 good enough for at least into the year 4000 with millisecond accuracy
jpayne@68	5631 (the design goal for libev). This requirement is overfulfilled by
jpayne@68	5632 implementations using \s-1IEEE 754,\s0 which is basically all existing ones.
jpayne@68	5633 .Sp
jpayne@68	5634 With \s-1IEEE 754\s0 doubles, you get microsecond accuracy until at least the
jpayne@68	5635 year 2255 (and millisecond accuracy till the year 287396 \- by then, libev
jpayne@68	5636 is either obsolete or somebody patched it to use \f(CW\(C`long double\(C'\fR or
jpayne@68	5637 something like that, just kidding).
jpayne@68	5638 .PP
jpayne@68	5639 If you know of other additional requirements drop me a note.
jpayne@68	5640 .SH "ALGORITHMIC COMPLEXITIES"
jpayne@68	5641 .IX Header "ALGORITHMIC COMPLEXITIES"
jpayne@68	5642 In this section the complexities of (many of) the algorithms used inside
jpayne@68	5643 libev will be documented. For complexity discussions about backends see
jpayne@68	5644 the documentation for \f(CW\(C`ev_default_init\(C'\fR.
jpayne@68	5645 .PP
jpayne@68	5646 All of the following are about amortised time: If an array needs to be
jpayne@68	5647 extended, libev needs to realloc and move the whole array, but this
jpayne@68	5648 happens asymptotically rarer with higher number of elements, so O(1) might
jpayne@68	5649 mean that libev does a lengthy realloc operation in rare cases, but on
jpayne@68	5650 average it is much faster and asymptotically approaches constant time.
jpayne@68	5651 .IP "Starting and stopping timer/periodic watchers: O(log skipped_other_timers)" 4
jpayne@68	5652 .IX Item "Starting and stopping timer/periodic watchers: O(log skipped_other_timers)"
jpayne@68	5653 This means that, when you have a watcher that triggers in one hour and
jpayne@68	5654 there are 100 watchers that would trigger before that, then inserting will
jpayne@68	5655 have to skip roughly seven (\f(CW\(C`ld 100\(C'\fR) of these watchers.
jpayne@68	5656 .IP "Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers)" 4
jpayne@68	5657 .IX Item "Changing timer/periodic watchers (by autorepeat or calling again): O(log skipped_other_timers)"
jpayne@68	5658 That means that changing a timer costs less than removing/adding them,
jpayne@68	5659 as only the relative motion in the event queue has to be paid for.
jpayne@68	5660 .IP "Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1)" 4
jpayne@68	5661 .IX Item "Starting io/check/prepare/idle/signal/child/fork/async watchers: O(1)"
jpayne@68	5662 These just add the watcher into an array or at the head of a list.
jpayne@68	5663 .IP "Stopping check/prepare/idle/fork/async watchers: O(1)" 4
jpayne@68	5664 .IX Item "Stopping check/prepare/idle/fork/async watchers: O(1)"
jpayne@68	5665 .PD 0
jpayne@68	5666 .IP "Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % \s-1EV_PID_HASHSIZE\s0))" 4
jpayne@68	5667 .IX Item "Stopping an io/signal/child watcher: O(number_of_watchers_for_this_(fd/signal/pid % EV_PID_HASHSIZE))"
jpayne@68	5668 .PD
jpayne@68	5669 These watchers are stored in lists, so they need to be walked to find the
jpayne@68	5670 correct watcher to remove. The lists are usually short (you don't usually
jpayne@68	5671 have many watchers waiting for the same fd or signal: one is typical, two
jpayne@68	5672 is rare).
jpayne@68	5673 .IP "Finding the next timer in each loop iteration: O(1)" 4
jpayne@68	5674 .IX Item "Finding the next timer in each loop iteration: O(1)"
jpayne@68	5675 By virtue of using a binary or 4\-heap, the next timer is always found at a
jpayne@68	5676 fixed position in the storage array.
jpayne@68	5677 .IP "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)" 4
jpayne@68	5678 .IX Item "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)"
jpayne@68	5679 A change means an I/O watcher gets started or stopped, which requires
jpayne@68	5680 libev to recalculate its status (and possibly tell the kernel, depending
jpayne@68	5681 on backend and whether \f(CW\(C`ev_io_set\(C'\fR was used).
jpayne@68	5682 .IP "Activating one watcher (putting it into the pending state): O(1)" 4
jpayne@68	5683 .IX Item "Activating one watcher (putting it into the pending state): O(1)"
jpayne@68	5684 .PD 0
jpayne@68	5685 .IP "Priority handling: O(number_of_priorities)" 4
jpayne@68	5686 .IX Item "Priority handling: O(number_of_priorities)"
jpayne@68	5687 .PD
jpayne@68	5688 Priorities are implemented by allocating some space for each
jpayne@68	5689 priority. When doing priority-based operations, libev usually has to
jpayne@68	5690 linearly search all the priorities, but starting/stopping and activating
jpayne@68	5691 watchers becomes O(1) with respect to priority handling.
jpayne@68	5692 .IP "Sending an ev_async: O(1)" 4
jpayne@68	5693 .IX Item "Sending an ev_async: O(1)"
jpayne@68	5694 .PD 0
jpayne@68	5695 .IP "Processing ev_async_send: O(number_of_async_watchers)" 4
jpayne@68	5696 .IX Item "Processing ev_async_send: O(number_of_async_watchers)"
jpayne@68	5697 .IP "Processing signals: O(max_signal_number)" 4
jpayne@68	5698 .IX Item "Processing signals: O(max_signal_number)"
jpayne@68	5699 .PD
jpayne@68	5700 Sending involves a system call \fIiff\fR there were no other \f(CW\(C`ev_async_send\(C'\fR
jpayne@68	5701 calls in the current loop iteration and the loop is currently
jpayne@68	5702 blocked. Checking for async and signal events involves iterating over all
jpayne@68	5703 running async watchers or all signal numbers.
jpayne@68	5704 .SH "PORTING FROM LIBEV 3.X TO 4.X"
jpayne@68	5705 .IX Header "PORTING FROM LIBEV 3.X TO 4.X"
jpayne@68	5706 The major version 4 introduced some incompatible changes to the \s-1API.\s0
jpayne@68	5707 .PP
jpayne@68	5708 At the moment, the \f(CW\(C`ev.h\(C'\fR header file provides compatibility definitions
jpayne@68	5709 for all changes, so most programs should still compile. The compatibility
jpayne@68	5710 layer might be removed in later versions of libev, so better update to the
jpayne@68	5711 new \s-1API\s0 early than late.
jpayne@68	5712 .ie n .IP """EV_COMPAT3"" backwards compatibility mechanism" 4
jpayne@68	5713 .el .IP "\f(CWEV_COMPAT3\fR backwards compatibility mechanism" 4
jpayne@68	5714 .IX Item "EV_COMPAT3 backwards compatibility mechanism"
jpayne@68	5715 The backward compatibility mechanism can be controlled by
jpayne@68	5716 \&\f(CW\(C`EV_COMPAT3\(C'\fR. See \(L"\s-1PREPROCESSOR SYMBOLS/MACROS\(R"\s0 in the \(L"\s-1EMBEDDING\(R"\s0
jpayne@68	5717 section.
jpayne@68	5718 .ie n .IP """ev_default_destroy"" and ""ev_default_fork"" have been removed" 4
jpayne@68	5719 .el .IP "\f(CWev_default_destroy\fR and \f(CWev_default_fork\fR have been removed" 4
jpayne@68	5720 .IX Item "ev_default_destroy and ev_default_fork have been removed"
jpayne@68	5721 These calls can be replaced easily by their \f(CW\(C`ev_loop_xxx\(C'\fR counterparts:
jpayne@68	5722 .Sp
jpayne@68	5723 .Vb 2
jpayne@68	5724 \& ev_loop_destroy (EV_DEFAULT_UC);
jpayne@68	5725 \& ev_loop_fork (EV_DEFAULT);
jpayne@68	5726 .Ve
jpayne@68	5727 .IP "function/symbol renames" 4
jpayne@68	5728 .IX Item "function/symbol renames"
jpayne@68	5729 A number of functions and symbols have been renamed:
jpayne@68	5730 .Sp
jpayne@68	5731 .Vb 3
jpayne@68	5732 \& ev_loop => ev_run
jpayne@68	5733 \& EVLOOP_NONBLOCK => EVRUN_NOWAIT
jpayne@68	5734 \& EVLOOP_ONESHOT => EVRUN_ONCE
jpayne@68	5735 \&
jpayne@68	5736 \& ev_unloop => ev_break
jpayne@68	5737 \& EVUNLOOP_CANCEL => EVBREAK_CANCEL
jpayne@68	5738 \& EVUNLOOP_ONE => EVBREAK_ONE
jpayne@68	5739 \& EVUNLOOP_ALL => EVBREAK_ALL
jpayne@68	5740 \&
jpayne@68	5741 \& EV_TIMEOUT => EV_TIMER
jpayne@68	5742 \&
jpayne@68	5743 \& ev_loop_count => ev_iteration
jpayne@68	5744 \& ev_loop_depth => ev_depth
jpayne@68	5745 \& ev_loop_verify => ev_verify
jpayne@68	5746 .Ve
jpayne@68	5747 .Sp
jpayne@68	5748 Most functions working on \f(CW\(C`struct ev_loop\(C'\fR objects don't have an
jpayne@68	5749 \&\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	5750 associated constants have been renamed to not collide with the \f(CW\*(C`struct
jpayne@68	5751 ev_loop\(C'\fR anymore and \f(CW\(C`EV_TIMER\*(C'\fR now follows the same naming scheme
jpayne@68	5752 as all other watcher types. Note that \f(CW\(C`ev_loop_fork\(C'\fR is still called
jpayne@68	5753 \&\f(CW\(C`ev_loop_fork\(C'\fR because it would otherwise clash with the \f(CW\(C`ev_fork\(C'\fR
jpayne@68	5754 typedef.
jpayne@68	5755 .ie n .IP """EV_MINIMAL"" mechanism replaced by ""EV_FEATURES""" 4
jpayne@68	5756 .el .IP "\f(CWEV_MINIMAL\fR mechanism replaced by \f(CWEV_FEATURES\fR" 4
jpayne@68	5757 .IX Item "EV_MINIMAL mechanism replaced by EV_FEATURES"
jpayne@68	5758 The preprocessor symbol \f(CW\(C`EV_MINIMAL\(C'\fR has been replaced by a different
jpayne@68	5759 mechanism, \f(CW\(C`EV_FEATURES\(C'\fR. Programs using \f(CW\(C`EV_MINIMAL\(C'\fR usually compile
jpayne@68	5760 and work, but the library code will of course be larger.
jpayne@68	5761 .SH "GLOSSARY"
jpayne@68	5762 .IX Header "GLOSSARY"
jpayne@68	5763 .IP "active" 4
jpayne@68	5764 .IX Item "active"
jpayne@68	5765 A watcher is active as long as it has been started and not yet stopped.
jpayne@68	5766 See \(L"\s-1WATCHER STATES\(R"\s0 for details.
jpayne@68	5767 .IP "application" 4
jpayne@68	5768 .IX Item "application"
jpayne@68	5769 In this document, an application is whatever is using libev.
jpayne@68	5770 .IP "backend" 4
jpayne@68	5771 .IX Item "backend"
jpayne@68	5772 The part of the code dealing with the operating system interfaces.
jpayne@68	5773 .IP "callback" 4
jpayne@68	5774 .IX Item "callback"
jpayne@68	5775 The address of a function that is called when some event has been
jpayne@68	5776 detected. Callbacks are being passed the event loop, the watcher that
jpayne@68	5777 received the event, and the actual event bitset.
jpayne@68	5778 .IP "callback/watcher invocation" 4
jpayne@68	5779 .IX Item "callback/watcher invocation"
jpayne@68	5780 The act of calling the callback associated with a watcher.
jpayne@68	5781 .IP "event" 4
jpayne@68	5782 .IX Item "event"
jpayne@68	5783 A change of state of some external event, such as data now being available
jpayne@68	5784 for reading on a file descriptor, time having passed or simply not having
jpayne@68	5785 any other events happening anymore.
jpayne@68	5786 .Sp
jpayne@68	5787 In libev, events are represented as single bits (such as \f(CW\(C`EV_READ\(C'\fR or
jpayne@68	5788 \&\f(CW\(C`EV_TIMER\(C'\fR).
jpayne@68	5789 .IP "event library" 4
jpayne@68	5790 .IX Item "event library"
jpayne@68	5791 A software package implementing an event model and loop.
jpayne@68	5792 .IP "event loop" 4
jpayne@68	5793 .IX Item "event loop"
jpayne@68	5794 An entity that handles and processes external events and converts them
jpayne@68	5795 into callback invocations.
jpayne@68	5796 .IP "event model" 4
jpayne@68	5797 .IX Item "event model"
jpayne@68	5798 The model used to describe how an event loop handles and processes
jpayne@68	5799 watchers and events.
jpayne@68	5800 .IP "pending" 4
jpayne@68	5801 .IX Item "pending"
jpayne@68	5802 A watcher is pending as soon as the corresponding event has been
jpayne@68	5803 detected. See \(L"\s-1WATCHER STATES\(R"\s0 for details.
jpayne@68	5804 .IP "real time" 4
jpayne@68	5805 .IX Item "real time"
jpayne@68	5806 The physical time that is observed. It is apparently strictly monotonic :)
jpayne@68	5807 .IP "wall-clock time" 4
jpayne@68	5808 .IX Item "wall-clock time"
jpayne@68	5809 The time and date as shown on clocks. Unlike real time, it can actually
jpayne@68	5810 be wrong and jump forwards and backwards, e.g. when you adjust your
jpayne@68	5811 clock.
jpayne@68	5812 .IP "watcher" 4
jpayne@68	5813 .IX Item "watcher"
jpayne@68	5814 A data structure that describes interest in certain events. Watchers need
jpayne@68	5815 to be started (attached to an event loop) before they can receive events.
jpayne@68	5816 .SH "AUTHOR"
jpayne@68	5817 .IX Header "AUTHOR"
jpayne@68	5818 Marc Lehmann <libev@schmorp.de>, with repeated corrections by Mikael
jpayne@68	5819 Magnusson and Emanuele Giaquinta, and minor corrections by many others.

Mercurial > repos > rliterman > csp2

annotate CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/share/man/man3/ev.3 @ 68:5028fdace37b