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

Comparing libev/ev.3 (file contents):
Revision 1.63 by root, Wed Apr 2 15:23:11 2008 UTC vs.
Revision 1.66 by root, Sun May 18 10:36:38 2008 UTC

 .    ds Ae AE
 .\}
 .rm #[ #] #H #V #F C
 .\" ========================================================================
 .\"
-.IX Title "EV 1"
+.IX Title "LIBEV 3"
-.TH EV 1 "2008-04-02" "perl v5.10.0" "User Contributed Perl Documentation"
+.TH LIBEV 3 "2008-05-11" "libev-3.33" "libev - high perfromance full featured event loop"
 .\" For nroff, turn off justification.  Always turn off hyphenation; it makes
 .\" way too many mistakes in technical documents.
 .if n .ad l
 .nh
 .SH "NAME"
 .Ve
 .SH "DESCRIPTION"
 .IX Header "DESCRIPTION"
 The newest version of this document is also available as an html-formatted
 web page you might find easier to navigate when reading it for the first
-time: <http://cvs.schmorp.de/libev/ev.html>.
+time: <http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod>.
 .PP
 Libev is an event loop: you register interest in certain events (such as a
 file descriptor being readable or a timeout occurring), and it will manage
 these event sources and provide your program with events.
 .PP
 .Sp
 See the description of \f(CW\*(C`ev_embed\*(C'\fR watchers for more info.
 .IP "ev_set_allocator (void *(*cb)(void *ptr, long size))" 4
 .IX Item "ev_set_allocator (void *(*cb)(void *ptr, long size))"
 Sets the allocation function to use (the prototype is similar \- the
-semantics is identical \- to the realloc C function). It is used to
+semantics are identical to the \f(CW\*(C`realloc\*(C'\fR C89/SuS/POSIX function). It is
-allocate and free memory (no surprises here). If it returns zero when
+used to allocate and free memory (no surprises here). If it returns zero
-memory needs to be allocated, the library might abort or take some
+when memory needs to be allocated (\f(CW\*(C`size != 0\*(C'\fR), the library might abort
-potentially destructive action. The default is your system realloc
+or take some potentially destructive action.
-function.
+.Sp
+Since some systems (at least OpenBSD and Darwin) fail to implement
+correct \f(CW\*(C`realloc\*(C'\fR semantics, libev will use a wrapper around the system
+\&\f(CW\*(C`realloc\*(C'\fR and \f(CW\*(C`free\*(C'\fR functions by default.
 .Sp
 You could override this function in high-availability programs to, say,
 free some memory if it cannot allocate memory, to use a special allocator,
 or even to sleep a while and retry until some memory is available.
 .Sp
 Example: Replace the libev allocator with one that waits a bit and then
-retries).
+retries (example requires a standards-compliant \f(CW\*(C`realloc\*(C'\fR).
 .Sp
 .Vb 6
 \&   static void *
 \&   persistent_realloc (void *ptr, size_t size)
 \&   {
 .SH "FUNCTIONS CONTROLLING THE EVENT LOOP"
 .IX Header "FUNCTIONS CONTROLLING THE EVENT LOOP"
 An event loop is described by a \f(CW\*(C`struct ev_loop *\*(C'\fR. The library knows two
 types of such loops, the \fIdefault\fR loop, which supports signals and child
 events, and dynamically created loops which do not.
-.PP
-If you use threads, a common model is to run the default event loop
-in your main thread (or in a separate thread) and for each thread you
-create, you also create another event loop. Libev itself does no locking
-whatsoever, so if you mix calls to the same event loop in different
-threads, make sure you lock (this is usually a bad idea, though, even if
-done correctly, because it's hideous and inefficient).
 .IP "struct ev_loop *ev_default_loop (unsigned int flags)" 4
 .IX Item "struct ev_loop *ev_default_loop (unsigned int flags)"
 This will initialise the default event loop if it hasn't been initialised
 yet and return it. If the default loop could not be initialised, returns
 false. If it already was initialised it simply returns it (and ignores the
 For few fds, this backend is a bit little slower than poll and select,
 but it scales phenomenally better. While poll and select usually scale
 like O(total_fds) where n is the total number of fds (or the highest fd),
 epoll scales either O(1) or O(active_fds). The epoll design has a number
 of shortcomings, such as silently dropping events in some hard-to-detect
-cases and rewiring a syscall per fd change, no fork support and bad
+cases and requiring a syscall per fd change, no fork support and bad
 support for dup.
 .Sp
 While stopping, setting and starting an I/O watcher in the same iteration
 will result in some caching, there is still a syscall per such incident
 (because the fd could point to a different file description now), so its
 .IX Item "ev_periodic_again (loop, ev_periodic *)"
 Simply stops and restarts the periodic watcher again. This is only useful
 when you changed some parameters or the reschedule callback would return
 a different time than the last time it was called (e.g. in a crond like
 program when the crontabs have changed).
+.IP "ev_tstamp ev_periodic_at (ev_periodic *)" 4
+.IX Item "ev_tstamp ev_periodic_at (ev_periodic *)"
+When active, returns the absolute time that the watcher is supposed to
+trigger next.
 .IP "ev_tstamp offset [read\-write]" 4
 .IX Item "ev_tstamp offset [read-write]"
 When repeating, this contains the offset value, otherwise this is the
 absolute point in time (the \f(CW\*(C`at\*(C'\fR value passed to \f(CW\*(C`ev_periodic_set\*(C'\fR).
 .Sp
 .IP "ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) [read\-write]" 4
 .IX Item "ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) [read-write]"
 The current reschedule callback, or \f(CW0\fR, if this functionality is
 switched off. Can be changed any time, but changes only take effect when
 the periodic timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being called.
-.IP "ev_tstamp at [read\-only]" 4
-.IX Item "ev_tstamp at [read-only]"
-When active, contains the absolute time that the watcher is supposed to
-trigger next.
 .PP
 \fIExamples\fR
 .IX Subsection "Examples"
 .PP
 Example: Call a callback every hour, or, more precisely, whenever the
 as even with OS-supported change notifications, this can be
 resource-intensive.
 .PP
 At the time of this writing, only the Linux inotify interface is
 implemented (implementing kqueue support is left as an exercise for the
+reader, note, however, that the author sees no way of implementing ev_stat
-reader). Inotify will be used to give hints only and should not change the
+semantics with kqueue). Inotify will be used to give hints only and should
-semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers, which means that libev sometimes needs
+not change the semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers, which means that libev
-to fall back to regular polling again even with inotify, but changes are
+sometimes needs to fall back to regular polling again even with inotify,
-usually detected immediately, and if the file exists there will be no
+but changes are usually detected immediately, and if the file exists there
-polling.
+will be no polling.
 .PP
 \fI\s-1ABI\s0 Issues (Largefile Support)\fR
 .IX Subsection "ABI Issues (Largefile Support)"
 .PP
 Libev by default (unless the user overrides this) uses the default
 When \f(CW\*(C`inotify (7)\*(C'\fR support has been compiled into libev (generally only
 available on Linux) and present at runtime, it will be used to speed up
 change detection where possible. The inotify descriptor will be created lazily
 when the first \f(CW\*(C`ev_stat\*(C'\fR watcher is being started.
 .PP
-Inotify presense does not change the semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers
+Inotify presence does not change the semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers
 except that changes might be detected earlier, and in some cases, to avoid
-making regular \f(CW\*(C`stat\*(C'\fR calls. Even in the presense of inotify support
+making regular \f(CW\*(C`stat\*(C'\fR calls. Even in the presence of inotify support
 there are many cases where libev has to resort to regular \f(CW\*(C`stat\*(C'\fR polling.
 .PP
 (There is no support for kqueue, as apparently it cannot be used to
 implement this functionality, due to the requirement of having a file
 descriptor open on the object at all times).
 .PP
 The \f(CW\*(C`stat ()\*(C'\fR syscall only supports full-second resolution portably, and
 even on systems where the resolution is higher, many filesystems still
 only support whole seconds.
 .PP
-That means that, if the time is the only thing that changes, you might
+That means that, if the time is the only thing that changes, you can
-miss updates: on the first update, \f(CW\*(C`ev_stat\*(C'\fR detects a change and calls
+easily miss updates: on the first update, \f(CW\*(C`ev_stat\*(C'\fR detects a change and
-your callback, which does something. When there is another update within
+calls your callback, which does something. When there is another update
-the same second, \f(CW\*(C`ev_stat\*(C'\fR will be unable to detect it.
+within the same second, \f(CW\*(C`ev_stat\*(C'\fR will be unable to detect it as the stat
+data does not change.
 .PP
-The solution to this is to delay acting on a change for a second (or till
+The solution to this is to delay acting on a change for slightly more
-the next second boundary), using a roughly one-second delay \f(CW\*(C`ev_timer\*(C'\fR
+than second (or till slightly after the next full second boundary), using
-(\f(CW\*(C`ev_timer_set (w, 0., 1.01); ev_timer_again (loop, w)\*(C'\fR). The \f(CW.01\fR
+a roughly one-second-delay \f(CW\*(C`ev_timer\*(C'\fR (e.g. \f(CW\*(C`ev_timer_set (w, 0., 1.02);
-is added to work around small timing inconsistencies of some operating
+ev_timer_again (loop, w)\*(C'\fR).
-systems.
+.PP
+The \f(CW.02\fR offset is added to work around small timing inconsistencies
+of some operating systems (where the second counter of the current time
+might be be delayed. One such system is the Linux kernel, where a call to
+\&\f(CW\*(C`gettimeofday\*(C'\fR might return a timestamp with a full second later than
+a subsequent \f(CW\*(C`time\*(C'\fR call \- if the equivalent of \f(CW\*(C`time ()\*(C'\fR is used to
+update file times then there will be a small window where the kernel uses
+the previous second to update file times but libev might already execute
+the timer callback).
 .PP
 \fIWatcher-Specific Functions and Data Members\fR
 .IX Subsection "Watcher-Specific Functions and Data Members"
 .IP "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)" 4
 .IX Item "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)"
 \&\f(CW\*(C`path\*(C'\fR. The \f(CW\*(C`interval\*(C'\fR is a hint on how quickly a change is expected to
 be detected and should normally be specified as \f(CW0\fR to let libev choose
 a suitable value. The memory pointed to by \f(CW\*(C`path\*(C'\fR must point to the same
 path for as long as the watcher is active.
 .Sp
-The callback will be receive \f(CW\*(C`EV_STAT\*(C'\fR when a change was detected,
+The callback will receive \f(CW\*(C`EV_STAT\*(C'\fR when a change was detected, relative
-relative to the attributes at the time the watcher was started (or the
+to the attributes at the time the watcher was started (or the last change
-last change was detected).
+was detected).
 .IP "ev_stat_stat (loop, ev_stat *)" 4
 .IX Item "ev_stat_stat (loop, ev_stat *)"
 Updates the stat buffer immediately with new values. If you change the
-watched path in your callback, you could call this fucntion to avoid
+watched path in your callback, you could call this function to avoid
-detecting this change (while introducing a race condition). Can also be
+detecting this change (while introducing a race condition if you are not
-useful simply to find out the new values.
+the only one changing the path). Can also be useful simply to find out the
+new values.
 .IP "ev_statdata attr [read\-only]" 4
 .IX Item "ev_statdata attr [read-only]"
-The most-recently detected attributes of the file. Although the type is of
+The most-recently detected attributes of the file. Although the type is
 \&\f(CW\*(C`ev_statdata\*(C'\fR, this is usually the (or one of the) \f(CW\*(C`struct stat\*(C'\fR types
+suitable for your system, but you can only rely on the POSIX-standardised
-suitable for your system. If the \f(CW\*(C`st_nlink\*(C'\fR member is \f(CW0\fR, then there
+members to be present. If the \f(CW\*(C`st_nlink\*(C'\fR member is \f(CW0\fR, then there was
-was some error while \f(CW\*(C`stat\*(C'\fRing the file.
+some error while \f(CW\*(C`stat\*(C'\fRing the file.
 .IP "ev_statdata prev [read\-only]" 4
 .IX Item "ev_statdata prev [read-only]"
 The previous attributes of the file. The callback gets invoked whenever
-\&\f(CW\*(C`prev\*(C'\fR != \f(CW\*(C`attr\*(C'\fR.
+\&\f(CW\*(C`prev\*(C'\fR != \f(CW\*(C`attr\*(C'\fR, or, more precisely, one or more of these members
+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,
+\&\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.
 .IP "ev_tstamp interval [read\-only]" 4
 .IX Item "ev_tstamp interval [read-only]"
 The specified interval.
 .IP "const char *path [read\-only]" 4
 .IX Item "const char *path [read-only]"
 \&  }
 \&
 \&  ...
 \&  ev_stat_init (&passwd, stat_cb, "/etc/passwd", 0.);
 \&  ev_stat_start (loop, &passwd);
-\&  ev_timer_init (&timer, timer_cb, 0., 1.01);
+\&  ev_timer_init (&timer, timer_cb, 0., 1.02);
 .Ve
 .ie n .Sh """ev_idle"" \- when you've got nothing better to do..."
 .el .Sh "\f(CWev_idle\fP \- when you've got nothing better to do..."
 .IX Subsection "ev_idle - when you've got nothing better to do..."
 Idle watchers trigger events when no other events of the same or higher
 .PP
 It is recommended to give \f(CW\*(C`ev_check\*(C'\fR watchers highest (\f(CW\*(C`EV_MAXPRI\*(C'\fR)
 priority, to ensure that they are being run before any other watchers
 after the poll. Also, \f(CW\*(C`ev_check\*(C'\fR watchers (and \f(CW\*(C`ev_prepare\*(C'\fR watchers,
 too) should not activate (\*(L"feed\*(R") events into libev. While libev fully
-supports this, they will be called before other \f(CW\*(C`ev_check\*(C'\fR watchers
+supports this, they might get executed before other \f(CW\*(C`ev_check\*(C'\fR watchers
 did their job. As \f(CW\*(C`ev_check\*(C'\fR watchers are often used to embed other
 (non-libev) event loops those other event loops might be in an unusable
 state until their \f(CW\*(C`ev_check\*(C'\fR watcher ran (always remind yourself to
 coexist peacefully with others).
 .PP
 .IX Subsection "Examples"
 .PP
 There are a number of principal ways to embed other event loops or modules
 into libev. Here are some ideas on how to include libadns into libev
 (there is a Perl module named \f(CW\*(C`EV::ADNS\*(C'\fR that does this, which you could
-use for an actually working example. Another Perl module named \f(CW\*(C`EV::Glib\*(C'\fR
+use as a working example. Another Perl module named \f(CW\*(C`EV::Glib\*(C'\fR embeds a
-embeds a Glib main context into libev, and finally, \f(CW\*(C`Glib::EV\*(C'\fR embeds \s-1EV\s0
+Glib main context into libev, and finally, \f(CW\*(C`Glib::EV\*(C'\fR embeds \s-1EV\s0 into the
-into the Glib event loop).
+Glib event loop).
 .PP
 Method 1: Add \s-1IO\s0 watchers and a timeout watcher in a prepare handler,
 and in a check watcher, destroy them and call into libadns. What follows
 is pseudo-code only of course. This requires you to either use a low
 priority for the check watcher or use \f(CW\*(C`ev_clear_pending\*(C'\fR explicitly, as
 it a private \s-1API\s0).
 .IP "\(bu" 4
 Priorities are not currently supported. Initialising priorities
 will fail and all watchers will have the same priority, even though there
 is an ev_pri field.
+.IP "\(bu" 4
+In libevent, the last base created gets the signals, in libev, the
+first base created (== the default loop) gets the signals.
 .IP "\(bu" 4
 Other members are not supported.
 .IP "\(bu" 4
 The libev emulation is \fInot\fR \s-1ABI\s0 compatible to libevent, you need
 to use the libev header file and library.
 .ie n .IP """EV_DEFAULT""\fR, \f(CW""EV_DEFAULT_""" 4
 .el .IP "\f(CWEV_DEFAULT\fR, \f(CWEV_DEFAULT_\fR" 4
 .IX Item "EV_DEFAULT, EV_DEFAULT_"
 Similar to the other two macros, this gives you the value of the default
 loop, if multiple loops are supported (\*(L"ev loop default\*(R").
+.ie n .IP """EV_DEFAULT_UC""\fR, \f(CW""EV_DEFAULT_UC_""" 4
+.el .IP "\f(CWEV_DEFAULT_UC\fR, \f(CWEV_DEFAULT_UC_\fR" 4
+.IX Item "EV_DEFAULT_UC, EV_DEFAULT_UC_"
+Usage identical to \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR, but requires that the
+default loop has been initialised (\f(CW\*(C`UC\*(C'\fR == unchecked). Their behaviour
+is undefined when the default loop has not been initialised by a previous
+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.
+.Sp
+It is often prudent to use \f(CW\*(C`EV_DEFAULT\*(C'\fR when initialising the first
+watcher in a function but use \f(CW\*(C`EV_DEFAULT_UC\*(C'\fR afterwards.
 .PP
 Example: Declare and initialise a check watcher, utilising the above
 macros so it will work regardless of whether multiple loops are supported
 or not.
 .PP
 .Vb 1
 \&  libev.m4
 .Ve
 .Sh "\s-1PREPROCESSOR\s0 \s-1SYMBOLS/MACROS\s0"
 .IX Subsection "PREPROCESSOR SYMBOLS/MACROS"
-Libev can be configured via a variety of preprocessor symbols you have to define
+Libev can be configured via a variety of preprocessor symbols you have to
-before including any of its files. The default is not to build for multiplicity
+define before including any of its files. The default in the absense of
-and only include the select backend.
+autoconf is noted for every option.
 .IP "\s-1EV_STANDALONE\s0" 4
 .IX Item "EV_STANDALONE"
 Must always be \f(CW1\fR if you do not use autoconf configuration, which
 keeps libev from including \fIconfig.h\fR, and it also defines dummy
 implementations for some libevent functions (such as logging, which is not
 note about libraries in the description of \f(CW\*(C`EV_USE_MONOTONIC\*(C'\fR, though.
 .IP "\s-1EV_USE_NANOSLEEP\s0" 4
 .IX Item "EV_USE_NANOSLEEP"
 If defined to be \f(CW1\fR, libev will assume that \f(CW\*(C`nanosleep ()\*(C'\fR is available
 and will use it for delays. Otherwise it will use \f(CW\*(C`select ()\*(C'\fR.
+.IP "\s-1EV_USE_EVENTFD\s0" 4
+.IX Item "EV_USE_EVENTFD"
+If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is
+available and will probe for kernel support at runtime. This will improve
+\&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption.
+If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
+2.7 or newer, otherwise disabled.
 .IP "\s-1EV_USE_SELECT\s0" 4
 .IX Item "EV_USE_SELECT"
 If undefined or defined to be \f(CW1\fR, libev will compile in support for the
 \&\f(CW\*(C`select\*(C'\fR(2) backend. No attempt at autodetection will be done: if no
 other method takes over, select will be it. Otherwise the select backend
 takes precedence over select.
 .IP "\s-1EV_USE_EPOLL\s0" 4
 .IX Item "EV_USE_EPOLL"
 If defined to be \f(CW1\fR, libev will compile in support for the Linux
 \&\f(CW\*(C`epoll\*(C'\fR(7) backend. Its availability will be detected at runtime,
-otherwise another method will be used as fallback. This is the
+otherwise another method will be used as fallback. This is the preferred
-preferred backend for GNU/Linux systems.
+backend for GNU/Linux systems. If undefined, it will be enabled if the
+headers indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
 .IP "\s-1EV_USE_KQUEUE\s0" 4
 .IX Item "EV_USE_KQUEUE"
 If defined to be \f(CW1\fR, libev will compile in support for the \s-1BSD\s0 style
 \&\f(CW\*(C`kqueue\*(C'\fR(2) backend. Its actual availability will be detected at runtime,
 otherwise another method will be used as fallback. This is the preferred
 reserved for future expansion, works like the \s-1USE\s0 symbols above.
 .IP "\s-1EV_USE_INOTIFY\s0" 4
 .IX Item "EV_USE_INOTIFY"
 If defined to be \f(CW1\fR, libev will compile in support for the Linux inotify
 interface to speed up \f(CW\*(C`ev_stat\*(C'\fR watchers. Its actual availability will
-be detected at runtime.
+be detected at runtime. If undefined, it will be enabled if the headers
+indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
 .IP "\s-1EV_ATOMIC_T\s0" 4
 .IX Item "EV_ATOMIC_T"
 Libev requires an integer type (suitable for storing \f(CW0\fR or \f(CW1\fR) whose
 access is atomic with respect to other threads or signal contexts. No such
 type is easily found in the C language, so you can provide your own type
 If undefined or defined to be \f(CW1\fR, then async watchers are supported. If
 defined to be \f(CW0\fR, then they are not.
 .IP "\s-1EV_MINIMAL\s0" 4
 .IX Item "EV_MINIMAL"
 If you need to shave off some kilobytes of code at the expense of some
-speed, define this symbol to \f(CW1\fR. Currently only used for gcc to override
+speed, define this symbol to \f(CW1\fR. Currently this is used to override some
-some inlining decisions, saves roughly 30% codesize of amd64.
+inlining decisions, saves roughly 30% codesize of amd64. It also selects a
+much smaller 2\-heap for timer management over the default 4\-heap.
 .IP "\s-1EV_PID_HASHSIZE\s0" 4
 .IX Item "EV_PID_HASHSIZE"
 \&\f(CW\*(C`ev_child\*(C'\fR watchers use a small hash table to distribute workload by
 pid. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\*(C`EV_MINIMAL\*(C'\fR), usually more
 than enough. If you need to manage thousands of children you might want to
 \&\f(CW\*(C`ev_stat\*(C'\fR watchers use a small hash table to distribute workload by
 inotify watch id. The default size is \f(CW16\fR (or \f(CW1\fR with \f(CW\*(C`EV_MINIMAL\*(C'\fR),
 usually more than enough. If you need to manage thousands of \f(CW\*(C`ev_stat\*(C'\fR
 watchers you might want to increase this value (\fImust\fR be a power of
 two).
+.IP "\s-1EV_USE_4HEAP\s0" 4
+.IX Item "EV_USE_4HEAP"
+Heaps are not very cache-efficient. To improve the cache-efficiency of the
+timer and periodics heap, libev uses a 4\-heap when this symbol is defined
+to \f(CW1\fR. The 4\-heap uses more complicated (longer) code but has a
+noticable after performance with many (thousands) of watchers.
+.Sp
+The default is \f(CW1\fR unless \f(CW\*(C`EV_MINIMAL\*(C'\fR is set in which case it is \f(CW0\fR
+(disabled).
+.IP "\s-1EV_HEAP_CACHE_AT\s0" 4
+.IX Item "EV_HEAP_CACHE_AT"
+Heaps are not very cache-efficient. To improve the cache-efficiency of the
+timer and periodics heap, libev can cache the timestamp (\fIat\fR) within
+the heap structure (selected by defining \f(CW\*(C`EV_HEAP_CACHE_AT\*(C'\fR to \f(CW1\fR),
+which uses 8\-12 bytes more per watcher and a few hundred bytes more code,
+but avoids random read accesses on heap changes. This noticably improves
+performance noticably with with many (hundreds) of watchers.
+.Sp
+The default is \f(CW1\fR unless \f(CW\*(C`EV_MINIMAL\*(C'\fR is set in which case it is \f(CW0\fR
+(disabled).
 .IP "\s-1EV_COMMON\s0" 4
 .IX Item "EV_COMMON"
 By default, all watchers have a \f(CW\*(C`void *data\*(C'\fR member. By redefining
 this macro to a something else you can include more and other types of
 members. You have to define it each time you include one of the files,
 .PP
 .Vb 2
 \&  #include "ev_cpp.h"
 \&  #include "ev.c"
 .Ve
+.SH "THREADS AND COROUTINES"
+.IX Header "THREADS AND COROUTINES"
+.Sh "\s-1THREADS\s0"
+.IX Subsection "THREADS"
+Libev itself is completely threadsafe, but it uses no locking. This
+means that you can use as many loops as you want in parallel, as long as
+only one thread ever calls into one libev function with the same loop
+parameter.
+.PP
+Or put differently: calls with different loop parameters can be done in
+parallel from multiple threads, calls with the same loop parameter must be
+done serially (but can be done from different threads, as long as only one
+thread ever is inside a call at any point in time, e.g. by using a mutex
+per loop).
+.PP
+If you want to know which design is best for your problem, then I cannot
+help you but by giving some generic advice:
+.IP "\(bu" 4
+most applications have a main thread: use the default libev loop
+in that thread, or create a seperate thread running only the default loop.
+.Sp
+This helps integrating other libraries or software modules that use libev
+themselves and don't care/know about threading.
+.IP "\(bu" 4
+one loop per thread is usually a good model.
+.Sp
+Doing this is almost never wrong, sometimes a better-performance model
+exists, but it is always a good start.
+.IP "\(bu" 4
+other models exist, such as the leader/follower pattern, where one
+loop is handed through multiple threads in a kind of round-robbin fashion.
+.Sp
+Chosing a model is hard \- look around, learn, know that usually you cna do
+better than you currently do :\-)
+.IP "\(bu" 4
+often you need to talk to some other thread which blocks in the
+event loop \- \f(CW\*(C`ev_async\*(C'\fR watchers can be used to wake them up from other
+threads safely (or from signal contexts...).
+.Sh "\s-1COROUTINES\s0"
+.IX Subsection "COROUTINES"
+Libev is much more accomodating to coroutines (\*(L"cooperative threads\*(R"):
+libev fully supports nesting calls to it's functions from different
+coroutines (e.g. you can call \f(CW\*(C`ev_loop\*(C'\fR on the same loop from two
+different coroutines and switch freely between both coroutines running the
+loop, as long as you don't confuse yourself). The only exception is that
+you must not do this from \f(CW\*(C`ev_periodic\*(C'\fR reschedule callbacks.
+.PP
+Care has been invested into making sure that libev does not keep local
+state inside \f(CW\*(C`ev_loop\*(C'\fR, and other calls do not usually allow coroutine
+switches.
 .SH "COMPLEXITIES"
 .IX Header "COMPLEXITIES"
 In this section the complexities of (many of) the algorithms used inside
 libev will be explained. For complexity discussions about backends see the
 documentation for \f(CW\*(C`ev_default_init\*(C'\fR.
 These watchers are stored in lists then need to be walked to find the
 correct watcher to remove. The lists are usually short (you don't usually
 have many watchers waiting for the same fd or signal).
 .IP "Finding the next timer in each loop iteration: O(1)" 4
 .IX Item "Finding the next timer in each loop iteration: O(1)"
-By virtue of using a binary heap, the next timer is always found at the
+By virtue of using a binary or 4\-heap, the next timer is always found at a
-beginning of the storage array.
+fixed position in the storage array.
 .IP "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)" 4
 .IX Item "Each change on a file descriptor per loop iteration: O(number_of_watchers_for_this_fd)"
 A change means an I/O watcher gets started or stopped, which requires
 libev to recalculate its status (and possibly tell the kernel, depending
 on backend and wether \f(CW\*(C`ev_io_set\*(C'\fR was used).
 model. Libev still offers limited functionality on this platform in
 the form of the \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR backend, and only supports socket
 descriptors. This only applies when using Win32 natively, not when using
 e.g. cygwin.
 .PP
+Lifting these limitations would basically require the full
+re-implementation of the I/O system. If you are into these kinds of
+things, then note that glib does exactly that for you in a very portable
+way (note also that glib is the slowest event library known to man).
+.PP
 There is no supported compilation method available on windows except
 embedding it into other applications.
 .PP
-Due to the many, low, and arbitrary limits on the win32 platform and the
+Due to the many, low, and arbitrary limits on the win32 platform and
-abysmal performance of winsockets, using a large number of sockets is not
+the abysmal performance of winsockets, using a large number of sockets
-recommended (and not reasonable). If your program needs to use more than
+is not recommended (and not reasonable). If your program needs to use
-a hundred or so sockets, then likely it needs to use a totally different
+more than a hundred or so sockets, then likely it needs to use a totally
-implementation for windows, as libev offers the \s-1POSIX\s0 model, which cannot
+different implementation for windows, as libev offers the \s-1POSIX\s0 readyness
-be implemented efficiently on windows (microsoft monopoly games).
+notification model, which cannot be implemented efficiently on windows
+(microsoft monopoly games).
 .IP "The winsocket select function" 4
 .IX Item "The winsocket select function"
 The winsocket \f(CW\*(C`select\*(C'\fR function doesn't follow \s-1POSIX\s0 in that it requires
 socket \fIhandles\fR and not socket \fIfile descriptors\fR. This makes select
 very inefficient, and also requires a mapping from file descriptors
 .Sp
 Note that winsockets handling of fd sets is O(n), so you can easily get a
 complexity in the O(nA\*^X) range when using win32.
 .IP "Limited number of file descriptors" 4
 .IX Item "Limited number of file descriptors"
-Windows has numerous arbitrary (and low) limits on things. Early versions
+Windows has numerous arbitrary (and low) limits on things.
-of winsocket's select only supported waiting for a max. of \f(CW64\fR handles
+.Sp
-(probably owning to the fact that all windows kernels can only wait for
+Early versions of winsocket's select only supported waiting for a maximum
-\&\f(CW64\fR things at the same time internally; microsoft recommends spawning a
+of \f(CW64\fR handles (probably owning to the fact that all windows kernels
-chain of threads and wait for 63 handles and the previous thread in each).
+can only wait for \f(CW64\fR things at the same time internally; microsoft
+recommends spawning a chain of threads and wait for 63 handles and the
+previous thread in each. Great).
 .Sp
 Newer versions support more handles, but you need to define \f(CW\*(C`FD_SETSIZE\*(C'\fR
 to some high number (e.g. \f(CW2048\fR) before compiling the winsocket select
 call (which might be in libev or elsewhere, for example, perl does its own
 select emulation on windows).
 .Sp
 This might get you to about \f(CW512\fR or \f(CW2048\fR sockets (depending on
 windows version and/or the phase of the moon). To get more, you need to
 wrap all I/O functions and provide your own fd management, but the cost of
 calling select (O(nA\*^X)) will likely make this unworkable.
+.SH "PORTABILITY REQUIREMENTS"
+.IX Header "PORTABILITY REQUIREMENTS"
+In addition to a working ISO-C implementation, libev relies on a few
+additional extensions:
+.ie n .IP """sig_atomic_t volatile"" must be thread-atomic as well" 4
+.el .IP "\f(CWsig_atomic_t volatile\fR must be thread-atomic as well" 4
+.IX Item "sig_atomic_t volatile must be thread-atomic as well"
+The type \f(CW\*(C`sig_atomic_t volatile\*(C'\fR (or whatever is defined as
+\&\f(CW\*(C`EV_ATOMIC_T\*(C'\fR) must be atomic w.r.t. accesses from different
+threads. This is not part of the specification for \f(CW\*(C`sig_atomic_t\*(C'\fR, but is
+believed to be sufficiently portable.
+.ie n .IP """sigprocmask"" must work in a threaded environment" 4
+.el .IP "\f(CWsigprocmask\fR must work in a threaded environment" 4
+.IX Item "sigprocmask must work in a threaded environment"
+Libev uses \f(CW\*(C`sigprocmask\*(C'\fR to temporarily block signals. This is not
+allowed in a threaded program (\f(CW\*(C`pthread_sigmask\*(C'\fR has to be used). Typical
+pthread implementations will either allow \f(CW\*(C`sigprocmask\*(C'\fR in the \*(L"main
+thread\*(R" or will block signals process-wide, both behaviours would
+be compatible with libev. Interaction between \f(CW\*(C`sigprocmask\*(C'\fR and
+\&\f(CW\*(C`pthread_sigmask\*(C'\fR could complicate things, however.
+.Sp
+The most portable way to handle signals is to block signals in all threads
+except the initial one, and run the default loop in the initial thread as
+well.
+.ie n .IP """long"" must be large enough for common memory allocation sizes" 4
+.el .IP "\f(CWlong\fR must be large enough for common memory allocation sizes" 4
+.IX Item "long must be large enough for common memory allocation sizes"
+To improve portability and simplify using libev, libev uses \f(CW\*(C`long\*(C'\fR
+internally instead of \f(CW\*(C`size_t\*(C'\fR when allocating its data structures. On
+non-POSIX systems (Microsoft...) this might be unexpectedly low, but
+is still at least 31 bits everywhere, which is enough for hundreds of
+millions of watchers.
+.ie n .IP """double"" must hold a time value in seconds with enough accuracy" 4
+.el .IP "\f(CWdouble\fR must hold a time value in seconds with enough accuracy" 4
+.IX Item "double must hold a time value in seconds with enough accuracy"
+The type \f(CW\*(C`double\*(C'\fR is used to represent timestamps. It is required to
+have at least 51 bits of mantissa (and 9 bits of exponent), which is good
+enough for at least into the year 4000. This requirement is fulfilled by
+implementations implementing \s-1IEEE\s0 754 (basically all existing ones).
+.PP
+If you know of other additional requirements drop me a note.
 .SH "AUTHOR"
 .IX Header "AUTHOR"
 Marc Lehmann <libev@schmorp.de>.
 .SH "POD ERRORS"
 .IX Header "POD ERRORS"
 Hey! \fBThe above document had some coding errors, which are explained below:\fR
-.IP "Around line 2996:" 4
+.IP "Around line 3052:" 4
-.IX Item "Around line 2996:"
+.IX Item "Around line 3052:"
 You forgot a '=back' before '=head2'

Diff Legend

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

Comparing libev/ev.3 (file contents): Revision 1.63 by root, Wed Apr 2 15:23:11 2008 UTC vs. Revision 1.66 by root, Sun May 18 10:36:38 2008 UTC

Diff Legend

Comparing libev/ev.3 (file contents):
Revision 1.63 by root, Wed Apr 2 15:23:11 2008 UTC vs.
Revision 1.66 by root, Sun May 18 10:36:38 2008 UTC