ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.pod
(Generate patch)

Comparing libev/ev.pod (file contents):
Revision 1.258 by root, Wed Jul 15 16:58:53 2009 UTC vs.
Revision 1.263 by root, Mon Jul 27 01:10:17 2009 UTC

98=head2 FEATURES 98=head2 FEATURES
99 99
100Libev supports C<select>, C<poll>, the Linux-specific C<epoll>, the 100Libev supports C<select>, C<poll>, the Linux-specific C<epoll>, the
101BSD-specific C<kqueue> and the Solaris-specific event port mechanisms 101BSD-specific C<kqueue> and the Solaris-specific event port mechanisms
102for file descriptor events (C<ev_io>), the Linux C<inotify> interface 102for file descriptor events (C<ev_io>), the Linux C<inotify> interface
103(for C<ev_stat>), relative timers (C<ev_timer>), absolute timers 103(for C<ev_stat>), Linux eventfd/signalfd (for faster and cleaner
104with customised rescheduling (C<ev_periodic>), synchronous signals 104inter-thread wakeup (C<ev_async>)/signal handling (C<ev_signal>)) relative
105(C<ev_signal>), process status change events (C<ev_child>), and event 105timers (C<ev_timer>), absolute timers with customised rescheduling
106watchers dealing with the event loop mechanism itself (C<ev_idle>, 106(C<ev_periodic>), synchronous signals (C<ev_signal>), process status
107C<ev_embed>, C<ev_prepare> and C<ev_check> watchers) as well as 107change events (C<ev_child>), and event watchers dealing with the event
108file watchers (C<ev_stat>) and even limited support for fork events 108loop mechanism itself (C<ev_idle>, C<ev_embed>, C<ev_prepare> and
109(C<ev_fork>). 109C<ev_check> watchers) as well as file watchers (C<ev_stat>) and even
110limited support for fork events (C<ev_fork>).
110 111
111It also is quite fast (see this 112It also is quite fast (see this
112L<benchmark|http://libev.schmorp.de/bench.html> comparing it to libevent 113L<benchmark|http://libev.schmorp.de/bench.html> comparing it to libevent
113for example). 114for example).
114 115
361forget about forgetting to tell libev about forking) when you use this 362forget about forgetting to tell libev about forking) when you use this
362flag. 363flag.
363 364
364This flag setting cannot be overridden or specified in the C<LIBEV_FLAGS> 365This flag setting cannot be overridden or specified in the C<LIBEV_FLAGS>
365environment variable. 366environment variable.
367
368=item C<EVFLAG_NOINOTIFY>
369
370When this flag is specified, then libev will not attempt to use the
371I<inotify> API for it's C<ev_stat> watchers. Apart from debugging and
372testing, this flag can be useful to conserve inotify file descriptors, as
373otherwise each loop using C<ev_stat> watchers consumes one inotify handle.
374
375=item C<EVFLAG_NOSIGNALFD>
376
377When this flag is specified, then libev will not attempt to use the
378I<signalfd> API for it's C<ev_signal> (and C<ev_child>) watchers. This is
379probably only useful to work around any bugs in libev. Consequently, this
380flag might go away once the signalfd functionality is considered stable,
381so it's useful mostly in environment variables and not in program code.
366 382
367=item C<EVBACKEND_SELECT> (value 1, portable select backend) 383=item C<EVBACKEND_SELECT> (value 1, portable select backend)
368 384
369This is your standard select(2) backend. Not I<completely> standard, as 385This is your standard select(2) backend. Not I<completely> standard, as
370libev tries to roll its own fd_set with no limits on the number of fds, 386libev tries to roll its own fd_set with no limits on the number of fds,
518 534
519It is definitely not recommended to use this flag. 535It is definitely not recommended to use this flag.
520 536
521=back 537=back
522 538
523If one or more of these are or'ed into the flags value, then only these 539If one or more of the backend flags are or'ed into the flags value,
524backends will be tried (in the reverse order as listed here). If none are 540then only these backends will be tried (in the reverse order as listed
525specified, all backends in C<ev_recommended_backends ()> will be tried. 541here). If none are specified, all backends in C<ev_recommended_backends
542()> will be tried.
526 543
527Example: This is the most typical usage. 544Example: This is the most typical usage.
528 545
529 if (!ev_default_loop (0)) 546 if (!ev_default_loop (0))
530 fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?"); 547 fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?");
2076Signal watchers will trigger an event when the process receives a specific 2093Signal watchers will trigger an event when the process receives a specific
2077signal one or more times. Even though signals are very asynchronous, libev 2094signal one or more times. Even though signals are very asynchronous, libev
2078will try it's best to deliver signals synchronously, i.e. as part of the 2095will try it's best to deliver signals synchronously, i.e. as part of the
2079normal event processing, like any other event. 2096normal event processing, like any other event.
2080 2097
2081If you want signals asynchronously, just use C<sigaction> as you would 2098If you want signals to be delivered truly asynchronously, just use
2082do without libev and forget about sharing the signal. You can even use 2099C<sigaction> as you would do without libev and forget about sharing
2083C<ev_async> from a signal handler to synchronously wake up an event loop. 2100the signal. You can even use C<ev_async> from a signal handler to
2101synchronously wake up an event loop.
2084 2102
2085You can configure as many watchers as you like per signal. Only when the 2103You can configure as many watchers as you like for the same signal, but
2104only within the same loop, i.e. you can watch for C<SIGINT> in your
2105default loop and for C<SIGIO> in another loop, but you cannot watch for
2106C<SIGINT> in both the default loop and another loop at the same time. At
2107the moment, C<SIGCHLD> is permanently tied to the default loop.
2108
2086first watcher gets started will libev actually register a signal handler 2109When the first watcher gets started will libev actually register something
2087with the kernel (thus it coexists with your own signal handlers as long as 2110with the kernel (thus it coexists with your own signal handlers as long as
2088you don't register any with libev for the same signal). Similarly, when 2111you don't register any with libev for the same signal).
2089the last signal watcher for a signal is stopped, libev will reset the 2112
2090signal handler to SIG_DFL (regardless of what it was set to before). 2113Both the signal mask state (C<sigprocmask>) and the signal handler state
2114(C<sigaction>) are unspecified after starting a signal watcher (and after
2115sotpping it again), that is, libev might or might not block the signal,
2116and might or might not set or restore the installed signal handler.
2091 2117
2092If possible and supported, libev will install its handlers with 2118If possible and supported, libev will install its handlers with
2093C<SA_RESTART> behaviour enabled, so system calls should not be unduly 2119C<SA_RESTART> (or equivalent) behaviour enabled, so system calls should
2094interrupted. If you have a problem with system calls getting interrupted by 2120not be unduly interrupted. If you have a problem with system calls getting
2095signals you can block all signals in an C<ev_check> watcher and unblock 2121interrupted by signals you can block all signals in an C<ev_check> watcher
2096them in an C<ev_prepare> watcher. 2122and unblock them in an C<ev_prepare> watcher.
2097 2123
2098=head3 Watcher-Specific Functions and Data Members 2124=head3 Watcher-Specific Functions and Data Members
2099 2125
2100=over 4 2126=over 4
2101 2127
2146libev) 2172libev)
2147 2173
2148=head3 Process Interaction 2174=head3 Process Interaction
2149 2175
2150Libev grabs C<SIGCHLD> as soon as the default event loop is 2176Libev grabs C<SIGCHLD> as soon as the default event loop is
2151initialised. This is necessary to guarantee proper behaviour even if 2177initialised. This is necessary to guarantee proper behaviour even if the
2152the first child watcher is started after the child exits. The occurrence 2178first child watcher is started after the child exits. The occurrence
2153of C<SIGCHLD> is recorded asynchronously, but child reaping is done 2179of C<SIGCHLD> is recorded asynchronously, but child reaping is done
2154synchronously as part of the event loop processing. Libev always reaps all 2180synchronously as part of the event loop processing. Libev always reaps all
2155children, even ones not watched. 2181children, even ones not watched.
2156 2182
2157=head3 Overriding the Built-In Processing 2183=head3 Overriding the Built-In Processing
2167=head3 Stopping the Child Watcher 2193=head3 Stopping the Child Watcher
2168 2194
2169Currently, the child watcher never gets stopped, even when the 2195Currently, the child watcher never gets stopped, even when the
2170child terminates, so normally one needs to stop the watcher in the 2196child terminates, so normally one needs to stop the watcher in the
2171callback. Future versions of libev might stop the watcher automatically 2197callback. Future versions of libev might stop the watcher automatically
2172when a child exit is detected. 2198when a child exit is detected (calling C<ev_child_stop> twice is not a
2199problem).
2173 2200
2174=head3 Watcher-Specific Functions and Data Members 2201=head3 Watcher-Specific Functions and Data Members
2175 2202
2176=over 4 2203=over 4
2177 2204
3380=item Ocaml 3407=item Ocaml
3381 3408
3382Erkki Seppala has written Ocaml bindings for libev, to be found at 3409Erkki Seppala has written Ocaml bindings for libev, to be found at
3383L<http://modeemi.cs.tut.fi/~flux/software/ocaml-ev/>. 3410L<http://modeemi.cs.tut.fi/~flux/software/ocaml-ev/>.
3384 3411
3412=item Lua
3413
3414Brian Maher has written a partial interface to libev
3415for lua (only C<ev_io> and C<ev_timer>), to be found at
3416L<http://github.com/brimworks/lua-ev>.
3417
3385=back 3418=back
3386 3419
3387 3420
3388=head1 MACRO MAGIC 3421=head1 MACRO MAGIC
3389 3422
3555keeps libev from including F<config.h>, and it also defines dummy 3588keeps libev from including F<config.h>, and it also defines dummy
3556implementations for some libevent functions (such as logging, which is not 3589implementations for some libevent functions (such as logging, which is not
3557supported). It will also not define any of the structs usually found in 3590supported). It will also not define any of the structs usually found in
3558F<event.h> that are not directly supported by the libev core alone. 3591F<event.h> that are not directly supported by the libev core alone.
3559 3592
3560In stanbdalone mode, libev will still try to automatically deduce the 3593In standalone mode, libev will still try to automatically deduce the
3561configuration, but has to be more conservative. 3594configuration, but has to be more conservative.
3562 3595
3563=item EV_USE_MONOTONIC 3596=item EV_USE_MONOTONIC
3564 3597
3565If defined to be C<1>, libev will try to detect the availability of the 3598If defined to be C<1>, libev will try to detect the availability of the
3792Defining C<EV_MINIMAL> to C<2> will additionally reduce the core API to 3825Defining C<EV_MINIMAL> to C<2> will additionally reduce the core API to
3793provide a bare-bones event library. See C<ev.h> for details on what parts 3826provide a bare-bones event library. See C<ev.h> for details on what parts
3794of the API are still available, and do not complain if this subset changes 3827of the API are still available, and do not complain if this subset changes
3795over time. 3828over time.
3796 3829
3830=item EV_NSIG
3831
3832The highest supported signal number, +1 (or, the number of
3833signals): Normally, libev tries to deduce the maximum number of signals
3834automatically, but sometimes this fails, in which case it can be
3835specified. Also, using a lower number than detected (C<32> should be
3836good for about any system in existance) can save some memory, as libev
3837statically allocates some 12-24 bytes per signal number.
3838
3797=item EV_PID_HASHSIZE 3839=item EV_PID_HASHSIZE
3798 3840
3799C<ev_child> watchers use a small hash table to distribute workload by 3841C<ev_child> watchers use a small hash table to distribute workload by
3800pid. The default size is C<16> (or C<1> with C<EV_MINIMAL>), usually more 3842pid. The default size is C<16> (or C<1> with C<EV_MINIMAL>), usually more
3801than enough. If you need to manage thousands of children you might want to 3843than enough. If you need to manage thousands of children you might want to

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines