--- /dev/null
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
+<head>
+ <title>libev</title>
+ <meta name="description" content="Pod documentation for libev" />
+ <meta name="inputfile" content="<standard input>" />
+ <meta name="outputfile" content="<standard output>" />
+ <meta name="created" content="Mon Nov 12 08:58:02 2007" />
+ <meta name="generator" content="Pod::Xhtml 1.57" />
+<link rel="stylesheet" href="http://res.tst.eu/pod.css"/></head>
+<body>
+<div class="pod">
+<!-- INDEX START -->
+<h3 id="TOP">Index</h3>
+
+<ul><li><a href="#NAME">NAME</a></li>
+<li><a href="#SYNOPSIS">SYNOPSIS</a></li>
+<li><a href="#DESCRIPTION">DESCRIPTION</a></li>
+<li><a href="#FEATURES">FEATURES</a></li>
+<li><a href="#CONVENTIONS">CONVENTIONS</a></li>
+<li><a href="#TIME_AND_OTHER_GLOBAL_FUNCTIONS">TIME AND OTHER GLOBAL FUNCTIONS</a></li>
+<li><a href="#FUNCTIONS_CONTROLLING_THE_EVENT_LOOP">FUNCTIONS CONTROLLING THE EVENT LOOP</a></li>
+<li><a href="#ANATOMY_OF_A_WATCHER">ANATOMY OF A WATCHER</a>
+<ul><li><a href="#ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</a></li>
+</ul>
+</li>
+<li><a href="#WATCHER_TYPES">WATCHER TYPES</a>
+<ul><li><a href="#struct_ev_io_is_my_file_descriptor_r">struct ev_io - is my file descriptor readable or writable</a></li>
+<li><a href="#struct_ev_timer_relative_and_optiona">struct ev_timer - relative and optionally recurring timeouts</a></li>
+<li><a href="#ev_periodic">ev_periodic</a></li>
+<li><a href="#ev_signal_signal_me_when_a_signal_ge">ev_signal - signal me when a signal gets signalled</a></li>
+<li><a href="#ev_child_wait_for_pid_status_changes">ev_child - wait for pid status changes</a></li>
+<li><a href="#ev_idle_when_you_ve_got_nothing_bett">ev_idle - when you've got nothing better to do</a></li>
+<li><a href="#prepare_and_check_your_hooks_into_th">prepare and check - your hooks into the event loop</a></li>
+</ul>
+</li>
+<li><a href="#OTHER_FUNCTIONS">OTHER FUNCTIONS</a></li>
+<li><a href="#AUTHOR">AUTHOR</a>
+</li>
+</ul><hr />
+<!-- INDEX END -->
+
+<h1 id="NAME">NAME</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="NAME_CONTENT">
+<p>libev - a high performance full-featured event loop written in C</p>
+
+</div>
+<h1 id="SYNOPSIS">SYNOPSIS</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="SYNOPSIS_CONTENT">
+<pre> #include <ev.h>
+
+</pre>
+
+</div>
+<h1 id="DESCRIPTION">DESCRIPTION</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="DESCRIPTION_CONTENT">
+<p>Libev is an event loop: you register interest in certain events (such as a
+file descriptor being readable or a timeout occuring), and it will manage
+these event sources and provide your program events.</p>
+<p>To do this, it must take more or less complete control over your process
+(or thread) by executing the <i>event loop</i> handler, and will then
+communicate events via a callback mechanism.</p>
+<p>You register interest in certain events by registering so-called <i>event
+watchers</i>, which are relatively small C structures you initialise with the
+details of the event, and then hand it over to libev by <i>starting</i> the
+watcher.</p>
+
+</div>
+<h1 id="FEATURES">FEATURES</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="FEATURES_CONTENT">
+<p>Libev supports select, poll, the linux-specific epoll and the bsd-specific
+kqueue mechanisms for file descriptor events, relative timers, absolute
+timers with customised rescheduling, signal events, process status change
+events (related to SIGCHLD), and event watchers dealing with the event
+loop mechanism itself (idle, prepare and check watchers).</p>
+
+</div>
+<h1 id="CONVENTIONS">CONVENTIONS</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="CONVENTIONS_CONTENT">
+<p>Libev is very configurable. In this manual the default configuration
+will be described, which supports multiple event loops. For more info
+about various configuraiton options please have a look at the file
+<cite>README.embed</cite> in the libev distribution. If libev was configured without
+support for multiple event loops, then all functions taking an initial
+argument of name <code>loop</code> (which is always of type <code>struct ev_loop *</code>)
+will not have this argument.</p>
+
+</div>
+<h1 id="TIME_AND_OTHER_GLOBAL_FUNCTIONS">TIME AND OTHER GLOBAL FUNCTIONS</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="TIME_AND_OTHER_GLOBAL_FUNCTIONS_CONT">
+<p>Libev represents time as a single floating point number. This type is
+called <code>ev_tstamp</code>, which is what you should use too. It usually aliases
+to the double type in C.</p>
+<dl>
+ <dt>ev_tstamp ev_time ()</dt>
+ <dd>
+ <p>Returns the current time as libev would use it.</p>
+ </dd>
+ <dt>int ev_version_major ()</dt>
+ <dt>int ev_version_minor ()</dt>
+ <dd>
+ <p>You can find out the major and minor version numbers of the library
+you linked against by calling the functions <code>ev_version_major</code> and
+<code>ev_version_minor</code>. If you want, you can compare against the global
+symbols <code>EV_VERSION_MAJOR</code> and <code>EV_VERSION_MINOR</code>, which specify the
+version of the library your program was compiled against.</p>
+ <p>Usually, its a good idea to terminate if the major versions mismatch,
+as this indicates an incompatible change. Minor versions are usually
+compatible to older versions, so a larger minor version alone is usually
+not a problem.</p>
+ </dd>
+ <dt>ev_set_allocator (void *(*cb)(void *ptr, long size))</dt>
+ <dd>
+ <p>Sets the allocation function to use (the prototype is similar to the
+realloc function). It is used to allocate and free memory (no surprises
+here). If it returns zero when memory needs to be allocated, the library
+might abort or take some potentially destructive action. The default is
+your system realloc function.</p>
+ <p>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.</p>
+ </dd>
+ <dt>ev_set_syserr_cb (void (*cb)(const char *msg));</dt>
+ <dd>
+ <p>Set the callback function to call on a retryable syscall error (such
+as failed select, poll, epoll_wait). The message is a printable string
+indicating the system call or subsystem causing the problem. If this
+callback is set, then libev will expect it to remedy the sitution, no
+matter what, when it returns. That is, libev will geenrally retry the
+requested operation, or, if the condition doesn't go away, do bad stuff
+(such as abort).</p>
+ </dd>
+</dl>
+
+</div>
+<h1 id="FUNCTIONS_CONTROLLING_THE_EVENT_LOOP">FUNCTIONS CONTROLLING THE EVENT LOOP</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="FUNCTIONS_CONTROLLING_THE_EVENT_LOOP-2">
+<p>An event loop is described by a <code>struct ev_loop *</code>. The library knows two
+types of such loops, the <i>default</i> loop, which supports signals and child
+events, and dynamically created loops which do not.</p>
+<p>If you use threads, a common model is to run the default event loop
+in your main thread (or in a separate thrad) and for each thread you
+create, you also create another event loop. Libev itself does no lockign
+whatsoever, so if you mix calls to different event loops, make sure you
+lock (this is usually a bad idea, though, even if done right).</p>
+<dl>
+ <dt>struct ev_loop *ev_default_loop (unsigned int flags)</dt>
+ <dd>
+ <p>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
+flags).</p>
+ <p>If you don't know what event loop to use, use the one returned from this
+function.</p>
+ <p>The flags argument can be used to specify special behaviour or specific
+backends to use, and is usually specified as 0 (or EVFLAG_AUTO)</p>
+ <p>It supports the following flags:</p>
+ <p>
+ <dl>
+ <dt>EVFLAG_AUTO</dt>
+ <dd>
+ <p>The default flags value. Use this if you have no clue (its the right
+thing, believe me).</p>
+ </dd>
+ <dt>EVFLAG_NOENV</dt>
+ <dd>
+ <p>If this flag bit is ored into the flag value then libev will <i>not</i> look
+at the environment variable <code>LIBEV_FLAGS</code>. Otherwise (the default), this
+environment variable will override the flags completely. This is useful
+to try out specific backends to tets their performance, or to work around
+bugs.</p>
+ </dd>
+ <dt>EVMETHOD_SELECT portable select backend</dt>
+ <dt>EVMETHOD_POLL poll backend (everywhere except windows)</dt>
+ <dt>EVMETHOD_EPOLL linux only</dt>
+ <dt>EVMETHOD_KQUEUE some bsds only</dt>
+ <dt>EVMETHOD_DEVPOLL solaris 8 only</dt>
+ <dt>EVMETHOD_PORT solaris 10 only</dt>
+ <dd>
+ <p>If one or more of these are ored into the flags value, then only these
+backends will be tried (in the reverse order as given here). If one are
+specified, any backend will do.</p>
+ </dd>
+ </dl>
+ </p>
+ </dd>
+ <dt>struct ev_loop *ev_loop_new (unsigned int flags)</dt>
+ <dd>
+ <p>Similar to <code>ev_default_loop</code>, but always creates a new event loop that is
+always distinct from the default loop. Unlike the default loop, it cannot
+handle signal and child watchers, and attempts to do so will be greeted by
+undefined behaviour (or a failed assertion if assertions are enabled).</p>
+ </dd>
+ <dt>ev_default_destroy ()</dt>
+ <dd>
+ <p>Destroys the default loop again (frees all memory and kernel state
+etc.). This stops all registered event watchers (by not touching them in
+any way whatsoever, although you cnanot rely on this :).</p>
+ </dd>
+ <dt>ev_loop_destroy (loop)</dt>
+ <dd>
+ <p>Like <code>ev_default_destroy</code>, but destroys an event loop created by an
+earlier call to <code>ev_loop_new</code>.</p>
+ </dd>
+ <dt>ev_default_fork ()</dt>
+ <dd>
+ <p>This function reinitialises the kernel state for backends that have
+one. Despite the name, you can call it anytime, but it makes most sense
+after forking, in either the parent or child process (or both, but that
+again makes little sense).</p>
+ <p>You <i>must</i> call this function after forking if and only if you want to
+use the event library in both processes. If you just fork+exec, you don't
+have to call it.</p>
+ <p>The function itself is quite fast and its usually not a problem to call
+it just in case after a fork. To make this easy, the function will fit in
+quite nicely into a call to <code>pthread_atfork</code>:</p>
+<pre> pthread_atfork (0, 0, ev_default_fork);
+
+</pre>
+ </dd>
+ <dt>ev_loop_fork (loop)</dt>
+ <dd>
+ <p>Like <code>ev_default_fork</code>, but acts on an event loop created by
+<code>ev_loop_new</code>. Yes, you have to call this on every allocated event loop
+after fork, and how you do this is entirely your own problem.</p>
+ </dd>
+ <dt>unsigned int ev_method (loop)</dt>
+ <dd>
+ <p>Returns one of the <code>EVMETHOD_*</code> flags indicating the event backend in
+use.</p>
+ </dd>
+ <dt>ev_tstamp = ev_now (loop)</dt>
+ <dd>
+ <p>Returns the current "event loop time", which is the time the event loop
+got events and started processing them. This timestamp does not change
+as long as callbacks are being processed, and this is also the base time
+used for relative timers. You can treat it as the timestamp of the event
+occuring (or more correctly, the mainloop finding out about it).</p>
+ </dd>
+ <dt>ev_loop (loop, int flags)</dt>
+ <dd>
+ <p>Finally, this is it, the event handler. This function usually is called
+after you initialised all your watchers and you want to start handling
+events.</p>
+ <p>If the flags argument is specified as 0, it will not return until either
+no event watchers are active anymore or <code>ev_unloop</code> was called.</p>
+ <p>A flags value of <code>EVLOOP_NONBLOCK</code> will look for new events, will handle
+those events and any outstanding ones, but will not block your process in
+case there are no events.</p>
+ <p>A flags value of <code>EVLOOP_ONESHOT</code> will look for new events (waiting if
+neccessary) and will handle those and any outstanding ones. It will block
+your process until at least one new event arrives.</p>
+ <p>This flags value could be used to implement alternative looping
+constructs, but the <code>prepare</code> and <code>check</code> watchers provide a better and
+more generic mechanism.</p>
+ </dd>
+ <dt>ev_unloop (loop, how)</dt>
+ <dd>
+ <p>Can be used to make a call to <code>ev_loop</code> return early. The <code>how</code> argument
+must be either <code>EVUNLOOP_ONCE</code>, which will make the innermost <code>ev_loop</code>
+call return, or <code>EVUNLOOP_ALL</code>, which will make all nested <code>ev_loop</code>
+calls return.</p>
+ </dd>
+ <dt>ev_ref (loop)</dt>
+ <dt>ev_unref (loop)</dt>
+ <dd>
+ <p>Ref/unref can be used to add or remove a refcount on the event loop: Every
+watcher keeps one reference. If you have a long-runing watcher you never
+unregister that should not keep ev_loop from running, ev_unref() after
+starting, and ev_ref() before stopping it. Libev itself uses this for
+example for its internal signal pipe: It is not visible to you as a user
+and should not keep <code>ev_loop</code> from exiting if the work is done. It is
+also an excellent way to do this for generic recurring timers or from
+within third-party libraries. Just remember to unref after start and ref
+before stop.</p>
+ </dd>
+</dl>
+
+</div>
+<h1 id="ANATOMY_OF_A_WATCHER">ANATOMY OF A WATCHER</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="ANATOMY_OF_A_WATCHER_CONTENT">
+<p>A watcher is a structure that you create and register to record your
+interest in some event. For instance, if you want to wait for STDIN to
+become readable, you would create an ev_io watcher for that:</p>
+<pre> static void my_cb (struct ev_loop *loop, struct ev_io *w, int revents)
+ {
+ ev_io_stop (w);
+ ev_unloop (loop, EVUNLOOP_ALL);
+ }
+
+ struct ev_loop *loop = ev_default_loop (0);
+ struct ev_io stdin_watcher;
+ ev_init (&stdin_watcher, my_cb);
+ ev_io_set (&stdin_watcher, STDIN_FILENO, EV_READ);
+ ev_io_start (loop, &stdin_watcher);
+ ev_loop (loop, 0);
+
+</pre>
+<p>As you can see, you are responsible for allocating the memory for your
+watcher structures (and it is usually a bad idea to do this on the stack,
+although this can sometimes be quite valid).</p>
+<p>Each watcher structure must be initialised by a call to <code>ev_init
+(watcher *, callback)</code>, which expects a callback to be provided. This
+callback gets invoked each time the event occurs (or, in the case of io
+watchers, each time the event loop detects that the file descriptor given
+is readable and/or writable).</p>
+<p>Each watcher type has its own <code>ev_<type>_set (watcher *, ...)</code> macro
+with arguments specific to this watcher type. There is also a macro
+to combine initialisation and setting in one call: <code>ev_<type>_init
+(watcher *, callback, ...)</code>.</p>
+<p>To make the watcher actually watch out for events, you have to start it
+with a watcher-specific start function (<code>ev_<type>_start (loop, watcher
+*)</code>), and you can stop watching for events at any time by calling the
+corresponding stop function (<code>ev_<type>_stop (loop, watcher *)</code>.</p>
+<p>As long as your watcher is active (has been started but not stopped) you
+must not touch the values stored in it. Most specifically you must never
+reinitialise it or call its set method.</p>
+<p>You cna check wether an event is active by calling the <code>ev_is_active
+(watcher *)</code> macro. To see wether an event is outstanding (but the
+callback for it has not been called yet) you cna use the <code>ev_is_pending
+(watcher *)</code> macro.</p>
+<p>Each and every callback receives the event loop pointer as first, the
+registered watcher structure as second, and a bitset of received events as
+third argument.</p>
+<p>The rceeived events usually include a single bit per event type received
+(you can receive multiple events at the same time). The possible bit masks
+are:</p>
+<dl>
+ <dt>EV_READ</dt>
+ <dt>EV_WRITE</dt>
+ <dd>
+ <p>The file descriptor in the ev_io watcher has become readable and/or
+writable.</p>
+ </dd>
+ <dt>EV_TIMEOUT</dt>
+ <dd>
+ <p>The ev_timer watcher has timed out.</p>
+ </dd>
+ <dt>EV_PERIODIC</dt>
+ <dd>
+ <p>The ev_periodic watcher has timed out.</p>
+ </dd>
+ <dt>EV_SIGNAL</dt>
+ <dd>
+ <p>The signal specified in the ev_signal watcher has been received by a thread.</p>
+ </dd>
+ <dt>EV_CHILD</dt>
+ <dd>
+ <p>The pid specified in the ev_child watcher has received a status change.</p>
+ </dd>
+ <dt>EV_IDLE</dt>
+ <dd>
+ <p>The ev_idle watcher has determined that you have nothing better to do.</p>
+ </dd>
+ <dt>EV_PREPARE</dt>
+ <dt>EV_CHECK</dt>
+ <dd>
+ <p>All ev_prepare watchers are invoked just <i>before</i> <code>ev_loop</code> starts
+to gather new events, and all ev_check watchers are invoked just after
+<code>ev_loop</code> has gathered them, but before it invokes any callbacks for any
+received events. Callbacks of both watcher types can start and stop as
+many watchers as they want, and all of them will be taken into account
+(for example, a ev_prepare watcher might start an idle watcher to keep
+<code>ev_loop</code> from blocking).</p>
+ </dd>
+ <dt>EV_ERROR</dt>
+ <dd>
+ <p>An unspecified error has occured, the watcher has been stopped. This might
+happen because the watcher could not be properly started because libev
+ran out of memory, a file descriptor was found to be closed or any other
+problem. You best act on it by reporting the problem and somehow coping
+with the watcher being stopped.</p>
+ <p>Libev will usually signal a few "dummy" events together with an error,
+for example it might indicate that a fd is readable or writable, and if
+your callbacks is well-written it can just attempt the operation and cope
+with the error from read() or write(). This will not work in multithreaded
+programs, though, so beware.</p>
+ </dd>
+</dl>
+
+</div>
+<h2 id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH">ASSOCIATING CUSTOM DATA WITH A WATCHER</h2>
+<div id="ASSOCIATING_CUSTOM_DATA_WITH_A_WATCH-2">
+<p>Each watcher has, by default, a member <code>void *data</code> that you can change
+and read at any time, libev will completely ignore it. This cna be used
+to associate arbitrary data with your watcher. If you need more data and
+don't want to allocate memory and store a pointer to it in that data
+member, you can also "subclass" the watcher type and provide your own
+data:</p>
+<pre> struct my_io
+ {
+ struct ev_io io;
+ int otherfd;
+ void *somedata;
+ struct whatever *mostinteresting;
+ }
+
+</pre>
+<p>And since your callback will be called with a pointer to the watcher, you
+can cast it back to your own type:</p>
+<pre> static void my_cb (struct ev_loop *loop, struct ev_io *w_, int revents)
+ {
+ struct my_io *w = (struct my_io *)w_;
+ ...
+ }
+
+</pre>
+<p>More interesting and less C-conformant ways of catsing your callback type
+have been omitted....</p>
+
+
+
+
+
+</div>
+<h1 id="WATCHER_TYPES">WATCHER TYPES</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="WATCHER_TYPES_CONTENT">
+<p>This section describes each watcher in detail, but will not repeat
+information given in the last section.</p>
+
+</div>
+<h2 id="struct_ev_io_is_my_file_descriptor_r">struct ev_io - is my file descriptor readable or writable</h2>
+<div id="struct_ev_io_is_my_file_descriptor_r-2">
+<p>I/O watchers check wether a file descriptor is readable or writable
+in each iteration of the event loop (This behaviour is called
+level-triggering because you keep receiving events as long as the
+condition persists. Remember you cna stop the watcher if you don't want to
+act on the event and neither want to receive future events).</p>
+<dl>
+ <dt>ev_io_init (ev_io *, callback, int fd, int events)</dt>
+ <dt>ev_io_set (ev_io *, int fd, int events)</dt>
+ <dd>
+ <p>Configures an ev_io watcher. The fd is the file descriptor to rceeive
+events for and events is either <code>EV_READ</code>, <code>EV_WRITE</code> or <code>EV_READ |
+EV_WRITE</code> to receive the given events.</p>
+ </dd>
+</dl>
+
+</div>
+<h2 id="struct_ev_timer_relative_and_optiona">struct ev_timer - relative and optionally recurring timeouts</h2>
+<div id="struct_ev_timer_relative_and_optiona-2">
+<p>Timer watchers are simple relative timers that generate an event after a
+given time, and optionally repeating in regular intervals after that.</p>
+<p>The timers are based on real time, that is, if you register an event that
+times out after an hour and youreset your system clock to last years
+time, it will still time out after (roughly) and hour. "Roughly" because
+detecting time jumps is hard, and soem inaccuracies are unavoidable (the
+monotonic clock option helps a lot here).</p>
+<dl>
+ <dt>ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)</dt>
+ <dt>ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)</dt>
+ <dd>
+ <p>Configure the timer to trigger after <code>after</code> seconds. If <code>repeat</code> is
+<code>0.</code>, then it will automatically be stopped. If it is positive, then the
+timer will automatically be configured to trigger again <code>repeat</code> seconds
+later, again, and again, until stopped manually.</p>
+ <p>The timer itself will do a best-effort at avoiding drift, that is, if you
+configure a timer to trigger every 10 seconds, then it will trigger at
+exactly 10 second intervals. If, however, your program cannot keep up with
+the timer (ecause it takes longer than those 10 seconds to do stuff) the
+timer will not fire more than once per event loop iteration.</p>
+ </dd>
+ <dt>ev_timer_again (loop)</dt>
+ <dd>
+ <p>This will act as if the timer timed out and restart it again if it is
+repeating. The exact semantics are:</p>
+ <p>If the timer is started but nonrepeating, stop it.</p>
+ <p>If the timer is repeating, either start it if necessary (with the repeat
+value), or reset the running timer to the repeat value.</p>
+ <p>This sounds a bit complicated, but here is a useful and typical
+example: Imagine you have a tcp connection and you want a so-called idle
+timeout, that is, you want to be called when there have been, say, 60
+seconds of inactivity on the socket. The easiest way to do this is to
+configure an ev_timer with after=repeat=60 and calling ev_timer_again each
+time you successfully read or write some data. If you go into an idle
+state where you do not expect data to travel on the socket, you can stop
+the timer, and again will automatically restart it if need be.</p>
+ </dd>
+</dl>
+
+</div>
+<h2 id="ev_periodic">ev_periodic</h2>
+<div id="ev_periodic_CONTENT">
+<p>Periodic watchers are also timers of a kind, but they are very versatile
+(and unfortunately a bit complex).</p>
+<p>Unlike ev_timer's, they are not based on real time (or relative time)
+but on wallclock time (absolute time). You can tell a periodic watcher
+to trigger "at" some specific point in time. For example, if you tell a
+periodic watcher to trigger in 10 seconds (by specifiying e.g. c<ev_now ()
++ 10.>) and then reset your system clock to the last year, then it will
+take a year to trigger the event (unlike an ev_timer, which would trigger
+roughly 10 seconds later and of course not if you reset your system time
+again).</p>
+<p>They can also be used to implement vastly more complex timers, such as
+triggering an event on eahc midnight, local time.</p>
+<dl>
+ <dt>ev_periodic_init (ev_periodic *, callback, ev_tstamp at, ev_tstamp interval, reschedule_cb)</dt>
+ <dt>ev_periodic_set (ev_periodic *, ev_tstamp after, ev_tstamp repeat, reschedule_cb)</dt>
+ <dd>
+ <p>Lots of arguments, lets sort it out... There are basically three modes of
+operation, and we will explain them from simplest to complex:</p>
+
+
+
+
+ <p>
+ <dl>
+ <dt>* absolute timer (interval = reschedule_cb = 0)</dt>
+ <dd>
+ <p>In this configuration the watcher triggers an event at the wallclock time
+<code>at</code> and doesn't repeat. It will not adjust when a time jump occurs,
+that is, if it is to be run at January 1st 2011 then it will run when the
+system time reaches or surpasses this time.</p>
+ </dd>
+ <dt>* non-repeating interval timer (interval > 0, reschedule_cb = 0)</dt>
+ <dd>
+ <p>In this mode the watcher will always be scheduled to time out at the next
+<code>at + N * interval</code> time (for some integer N) and then repeat, regardless
+of any time jumps.</p>
+ <p>This can be used to create timers that do not drift with respect to system
+time:</p>
+<pre> ev_periodic_set (&periodic, 0., 3600., 0);
+
+</pre>
+ <p>This doesn't mean there will always be 3600 seconds in between triggers,
+but only that the the callback will be called when the system time shows a
+full hour (UTC), or more correct, when the system time is evenly divisible
+by 3600.</p>
+ <p>Another way to think about it (for the mathematically inclined) is that
+ev_periodic will try to run the callback in this mode at the next possible
+time where <code>time = at (mod interval)</code>, regardless of any time jumps.</p>
+ </dd>
+ <dt>* manual reschedule mode (reschedule_cb = callback)</dt>
+ <dd>
+ <p>In this mode the values for <code>interval</code> and <code>at</code> are both being
+ignored. Instead, each time the periodic watcher gets scheduled, the
+reschedule callback will be called with the watcher as first, and the
+current time as second argument.</p>
+ <p>NOTE: <i>This callback MUST NOT stop or destroy the periodic or any other
+periodic watcher, ever, or make any event loop modificstions</i>. If you need
+to stop it, return 1e30 (or so, fudge fudge) and stop it afterwards.</p>
+ <p>Its prototype is c<ev_tstamp (*reschedule_cb)(struct ev_periodic *w,
+ev_tstamp now)>, e.g.:</p>
+<pre> static ev_tstamp my_rescheduler (struct ev_periodic *w, ev_tstamp now)
+ {
+ return now + 60.;
+ }
+
+</pre>
+ <p>It must return the next time to trigger, based on the passed time value
+(that is, the lowest time value larger than to the second argument). It
+will usually be called just before the callback will be triggered, but
+might be called at other times, too.</p>
+ <p>This can be used to create very complex timers, such as a timer that
+triggers on each midnight, local time. To do this, you would calculate the
+next midnight after <code>now</code> and return the timestamp value for this. How you do this
+is, again, up to you (but it is not trivial).</p>
+ </dd>
+ </dl>
+ </p>
+ </dd>
+ <dt>ev_periodic_again (loop, ev_periodic *)</dt>
+ <dd>
+ <p>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).</p>
+ </dd>
+</dl>
+
+</div>
+<h2 id="ev_signal_signal_me_when_a_signal_ge">ev_signal - signal me when a signal gets signalled</h2>
+<div id="ev_signal_signal_me_when_a_signal_ge-2">
+<p>Signal watchers will trigger an event when the process receives a specific
+signal one or more times. Even though signals are very asynchronous, libev
+will try its best to deliver signals synchronously, i.e. as part of the
+normal event processing, like any other event.</p>
+<p>You cna configure as many watchers as you like per signal. Only when the
+first watcher gets started will libev actually register a signal watcher
+with the kernel (thus it coexists with your own signal handlers as long
+as you don't register any with libev). Similarly, when the last signal
+watcher for a signal is stopped libev will reset the signal handler to
+SIG_DFL (regardless of what it was set to before).</p>
+<dl>
+ <dt>ev_signal_init (ev_signal *, callback, int signum)</dt>
+ <dt>ev_signal_set (ev_signal *, int signum)</dt>
+ <dd>
+ <p>Configures the watcher to trigger on the given signal number (usually one
+of the <code>SIGxxx</code> constants).</p>
+ </dd>
+</dl>
+
+</div>
+<h2 id="ev_child_wait_for_pid_status_changes">ev_child - wait for pid status changes</h2>
+<div id="ev_child_wait_for_pid_status_changes-2">
+<p>Child watchers trigger when your process receives a SIGCHLD in response to
+some child status changes (most typically when a child of yours dies).</p>
+<dl>
+ <dt>ev_child_init (ev_child *, callback, int pid)</dt>
+ <dt>ev_child_set (ev_child *, int pid)</dt>
+ <dd>
+ <p>Configures the watcher to wait for status changes of process <code>pid</code> (or
+<i>any</i> process if <code>pid</code> is specified as <code>0</code>). The callback can look
+at the <code>rstatus</code> member of the <code>ev_child</code> watcher structure to see
+the status word (use the macros from <code>sys/wait.h</code>). The <code>rpid</code> member
+contains the pid of the process causing the status change.</p>
+ </dd>
+</dl>
+
+</div>
+<h2 id="ev_idle_when_you_ve_got_nothing_bett">ev_idle - when you've got nothing better to do</h2>
+<div id="ev_idle_when_you_ve_got_nothing_bett-2">
+<p>Idle watchers trigger events when there are no other I/O or timer (or
+periodic) events pending. That is, as long as your process is busy
+handling sockets or timeouts it will not be called. But when your process
+is idle all idle watchers are being called again and again - until
+stopped, that is, or your process receives more events.</p>
+<p>The most noteworthy effect is that as long as any idle watchers are
+active, the process will not block when waiting for new events.</p>
+<p>Apart from keeping your process non-blocking (which is a useful
+effect on its own sometimes), idle watchers are a good place to do
+"pseudo-background processing", or delay processing stuff to after the
+event loop has handled all outstanding events.</p>
+<dl>
+ <dt>ev_idle_init (ev_signal *, callback)</dt>
+ <dd>
+ <p>Initialises and configures the idle watcher - it has no parameters of any
+kind. There is a <code>ev_idle_set</code> macro, but using it is utterly pointless,
+believe me.</p>
+ </dd>
+</dl>
+
+</div>
+<h2 id="prepare_and_check_your_hooks_into_th">prepare and check - your hooks into the event loop</h2>
+<div id="prepare_and_check_your_hooks_into_th-2">
+<p>Prepare and check watchers usually (but not always) are used in
+tandom. Prepare watchers get invoked before the process blocks and check
+watchers afterwards.</p>
+<p>Their main purpose is to integrate other event mechanisms into libev. This
+could be used, for example, to track variable changes, implement your own
+watchers, integrate net-snmp or a coroutine library and lots more.</p>
+<p>This is done by examining in each prepare call which file descriptors need
+to be watched by the other library, registering ev_io watchers for them
+and starting an ev_timer watcher for any timeouts (many libraries provide
+just this functionality). Then, in the check watcher you check for any
+events that occured (by making your callbacks set soem flags for example)
+and call back into the library.</p>
+<p>As another example, the perl Coro module uses these hooks to integrate
+coroutines into libev programs, by yielding to other active coroutines
+during each prepare and only letting the process block if no coroutines
+are ready to run.</p>
+<dl>
+ <dt>ev_prepare_init (ev_prepare *, callback)</dt>
+ <dt>ev_check_init (ev_check *, callback)</dt>
+ <dd>
+ <p>Initialises and configures the prepare or check watcher - they have no
+parameters of any kind. There are <code>ev_prepare_set</code> and <code>ev_check_set</code>
+macros, but using them is utterly, utterly pointless.</p>
+ </dd>
+</dl>
+
+</div>
+<h1 id="OTHER_FUNCTIONS">OTHER FUNCTIONS</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="OTHER_FUNCTIONS_CONTENT">
+<p>There are some other fucntions of possible interest. Described. Here. Now.</p>
+<dl>
+ <dt>ev_once (loop, int fd, int events, ev_tstamp timeout, callback)</dt>
+ <dd>
+ <p>This function combines a simple timer and an I/O watcher, calls your
+callback on whichever event happens first and automatically stop both
+watchers. This is useful if you want to wait for a single event on an fd
+or timeout without havign to allocate/configure/start/stop/free one or
+more watchers yourself.</p>
+ <p>If <code>fd</code> is less than 0, then no I/O watcher will be started and events is
+ignored. Otherwise, an ev_io watcher for the given <code>fd</code> and <code>events</code> set
+will be craeted and started.</p>
+ <p>If <code>timeout</code> is less than 0, then no timeout watcher will be
+started. Otherwise an ev_timer watcher with after = <code>timeout</code> (and repeat
+= 0) will be started.</p>
+ <p>The callback has the type <code>void (*cb)(int revents, void *arg)</code> and
+gets passed an events set (normally a combination of EV_ERROR, EV_READ,
+EV_WRITE or EV_TIMEOUT) and the <code>arg</code> value passed to <code>ev_once</code>:</p>
+<pre> static void stdin_ready (int revents, void *arg)
+ {
+ if (revents & EV_TIMEOUT)
+ /* doh, nothing entered */
+ else if (revents & EV_READ)
+ /* stdin might have data for us, joy! */
+ }
+
+ ev_once (STDIN_FILENO, EV_READm 10., stdin_ready, 0);
+
+</pre>
+ </dd>
+ <dt>ev_feed_event (loop, watcher, int events)</dt>
+ <dd>
+ <p>Feeds the given event set into the event loop, as if the specified event
+has happened for the specified watcher (which must be a pointer to an
+initialised but not necessarily active event watcher).</p>
+ </dd>
+ <dt>ev_feed_fd_event (loop, int fd, int revents)</dt>
+ <dd>
+ <p>Feed an event on the given fd, as if a file descriptor backend detected it.</p>
+ </dd>
+ <dt>ev_feed_signal_event (loop, int signum)</dt>
+ <dd>
+ <p>Feed an event as if the given signal occured (loop must be the default loop!).</p>
+ </dd>
+</dl>
+
+</div>
+<h1 id="AUTHOR">AUTHOR</h1><p><a href="#TOP" class="toplink">Top</a></p>
+<div id="AUTHOR_CONTENT">
+<p>Marc Lehmann <libev@schmorp.de>.</p>
+
+</div>
+</div></body>
+</html>
projects / software / libev.git / commitdiff