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

Comparing libev/ev.pod (file contents):
Revision 1.198 by root, Thu Oct 23 06:30:48 2008 UTC vs.
Revision 1.204 by root, Mon Oct 27 11:08:29 2008 UTC

    // a single header file is required
    #include <ev.h>
    // every watcher type has its own typedef'd struct
-   // with the name ev_<type>
+   // with the name ev_TYPE
    ev_io stdin_watcher;
    ev_timer timeout_watcher;
    // all watcher callbacks have a similar signature
    // this callback is called when data is readable on stdin
 =back
 =head1 FUNCTIONS CONTROLLING THE EVENT LOOP
-An event loop is described by a C<ev_loop *>. The library knows two
+An event loop is described by a C<struct ev_loop *> (the C<struct>
-types of such loops, the I<default> loop, which supports signals and child
+is I<not> optional in this case, as there is also an C<ev_loop>
-events, and dynamically created loops which do not.
+I<function>).
+The library knows two types of such loops, the I<default> loop, which
+supports signals and child events, and dynamically created loops which do
+not.
 =over 4
 =item struct ev_loop *ev_default_loop (unsigned int flags)
 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 requiring a system call per fd change, no fork support and bad
 support for dup.
+Epoll is also notoriously buggy - embedding epoll fds should work, but
+of course doesn't, and epoll just loves to report events for totally
+I<different> file descriptors (even already closed ones) than registered
+in the set (especially on SMP systems). Libev tries to counter these
+spurious notifications by employing an additional generation counter and
+comparing that against the events to filter out spurious ones.
 While stopping, setting and starting an I/O watcher in the same iteration
 will result in some caching, there is still a system call per such incident
 (because the fd could point to a different file description now), so its
 best to avoid that. Also, C<dup ()>'ed file descriptors might not work
 very well if you register events for both fds.
-Please note that epoll sometimes generates spurious notifications, so you
-need to use non-blocking I/O or other means to avoid blocking when no data
-(or space) is available.
 Best performance from this backend is achieved by not unregistering all
 watchers for a file descriptor until it has been closed, if possible,
 i.e. keep at least one watcher active per fd at all times. Stopping and
 starting a watcher (without re-setting it) also usually doesn't cause
 responsibility to either stop all watchers cleanly yourself I<before>
 calling this function, or cope with the fact afterwards (which is usually
 the easiest thing, you can just ignore the watchers and/or C<free ()> them
 for example).
-Note that certain global state, such as signal state, will not be freed by
+Note that certain global state, such as signal state (and installed signal
-this function, and related watchers (such as signal and child watchers)
+handlers), will not be freed by this function, and related watchers (such
-would need to be stopped manually.
+as signal and child watchers) would need to be stopped manually.
 In general it is not advisable to call this function except in the
 rare occasion where you really need to free e.g. the signal handling
 pipe fds. If you need dynamically allocated loops it is better to use
 C<ev_loop_new> and C<ev_loop_destroy>).
 they fire on, say, one-second boundaries only.
 =item ev_loop_verify (loop)
 This function only does something when C<EV_VERIFY> support has been
-compiled in. which is the default for non-minimal builds. It tries to go
+compiled in, which is the default for non-minimal builds. It tries to go
 through all internal structures and checks them for validity. If anything
 is found to be inconsistent, it will print an error message to standard
 error and call C<abort ()>.
 This can be used to catch bugs inside libev itself: under normal
 =back
 =head1 ANATOMY OF A WATCHER
+In the following description, uppercase C<TYPE> in names stands for the
+watcher type, e.g. C<ev_TYPE_start> can mean C<ev_timer_start> for timer
+watchers and C<ev_io_start> for I/O watchers.
 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 C<ev_io> watcher for that:
      ev_io_stop (w);
      ev_unloop (loop, EVUNLOOP_ALL);
    }
    struct ev_loop *loop = ev_default_loop (0);
    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);
 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,
+watcher structures (and it is I<usually> a bad idea to do this on the
-although this can sometimes be quite valid).
+stack).
+Each watcher has an associated watcher structure (called C<struct ev_TYPE>
+or simply C<ev_TYPE>, as typedefs are provided for all watcher structs).
 Each watcher structure must be initialised by a call to C<ev_init
 (watcher *, callback)>, which expects a callback to be provided. This
 callback gets invoked each time the event occurs (or, in the case of I/O
 watchers, each time the event loop detects that the file descriptor given
 is readable and/or writable).
-Each watcher type has its own C<< ev_<type>_set (watcher *, ...) >> macro
+Each watcher type further has its own C<< ev_TYPE_set (watcher *, ...) >>
-with arguments specific to this watcher type. There is also a macro
+macro to configure it, with arguments specific to the watcher type. There
-to combine initialisation and setting in one call: C<< ev_<type>_init
+is also a macro to combine initialisation and setting in one call: C<<
-(watcher *, callback, ...) >>.
+ev_TYPE_init (watcher *, callback, ...) >>.
 To make the watcher actually watch out for events, you have to start it
-with a watcher-specific start function (C<< ev_<type>_start (loop, watcher
+with a watcher-specific start function (C<< ev_TYPE_start (loop, watcher
 *) >>), and you can stop watching for events at any time by calling the
-corresponding stop function (C<< ev_<type>_stop (loop, watcher *) >>.
+corresponding stop function (C<< ev_TYPE_stop (loop, watcher *) >>.
 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 C<set> macro.
+reinitialise it or call its C<ev_TYPE_set> macro.
 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.
 =back
 =head2 GENERIC WATCHER FUNCTIONS
-In the following description, C<TYPE> stands for the watcher type,
-e.g. C<timer> for C<ev_timer> watchers and C<io> for C<ev_io> watchers.
 =over 4
 =item C<ev_init> (ev_TYPE *watcher, callback)
 This macro initialises the generic portion of a watcher. The contents
 The default priority used by watchers when no priority has been set is
 always C<0>, which is supposed to not be too high and not be too low :).
 Setting a priority outside the range of C<EV_MINPRI> to C<EV_MAXPRI> is
 fine, as long as you do not mind that the priority value you query might
-or might not have been adjusted to be within valid range.
+or might not have been clamped to the valid range.
 =item ev_invoke (loop, ev_TYPE *watcher, int revents)
 Invoke the C<watcher> with the given C<loop> and C<revents>. Neither
 C<loop> nor C<revents> need to be valid as long as the watcher callback
 passed, but if multiple timers become ready during the same loop iteration
 then order of execution is undefined.
 =head3 Be smart about timeouts
-Many real-world problems invole some kind of time-out, usually for error
+Many real-world problems involve some kind of timeout, usually for error
 recovery. A typical example is an HTTP request - if the other side hangs,
 you want to raise some error after a while.
-Here are some ways on how to handle this problem, from simple and
+What follows are some ways to handle this problem, from obvious and
-inefficient to very efficient.
+inefficient to smart and efficient.
-In the following examples a 60 second activity timeout is assumed - a
+In the following, a 60 second activity timeout is assumed - a timeout that
-timeout that gets reset to 60 seconds each time some data ("a lifesign")
+gets reset to 60 seconds each time there is activity (e.g. each time some
-was received.
+data or other life sign was received).
 =over 4
-=item 1. Use a timer and stop, reinitialise, start it on activity.
+=item 1. Use a timer and stop, reinitialise and start it on activity.
 This is the most obvious, but not the most simple way: In the beginning,
 start the watcher:
    ev_timer_init (timer, callback, 60., 0.);
    ev_timer_start (loop, timer);
-Then, each time there is some activity, C<ev_timer_stop> the timer,
+Then, each time there is some activity, C<ev_timer_stop> it, initialise it
-initialise it again, and start it:
+and start it again:
    ev_timer_stop (loop, timer);
    ev_timer_set (timer, 60., 0.);
    ev_timer_start (loop, timer);
-This is relatively simple to implement, but means that each time there
+This is relatively simple to implement, but means that each time there is
-is some activity, libev will first have to remove the timer from it's
+some activity, libev will first have to remove the timer from its internal
-internal data strcuture and then add it again.
+data structure and then add it again. Libev tries to be fast, but it's
+still not a constant-time operation.
 =item 2. Use a timer and re-start it with C<ev_timer_again> inactivity.
 This is the easiest way, and involves using C<ev_timer_again> instead of
 C<ev_timer_start>.
-For this, configure an C<ev_timer> with a C<repeat> value of C<60> and
+To implement this, configure an C<ev_timer> with a C<repeat> value
-then call C<ev_timer_again> at start and each time you successfully read
+of C<60> and then call C<ev_timer_again> at start and each time you
-or write some data. If you go into an idle state where you do not expect
+successfully read or write some data. If you go into an idle state where
-data to travel on the socket, you can C<ev_timer_stop> the timer, and
+you do not expect data to travel on the socket, you can C<ev_timer_stop>
-C<ev_timer_again> will automatically restart it if need be.
+the timer, and C<ev_timer_again> will automatically restart it if need be.
-That means you can ignore the C<after> value and C<ev_timer_start>
+That means you can ignore both the C<ev_timer_start> function and the
-altogether and only ever use the C<repeat> value and C<ev_timer_again>.
+C<after> argument to C<ev_timer_set>, and only ever use the C<repeat>
+member and C<ev_timer_again>.
 At start:
-   ev_timer_init (timer, callback, 0., 60.);
+   ev_timer_init (timer, callback);
+   timer->repeat = 60.;
    ev_timer_again (loop, timer);
-Each time you receive some data:
+Each time there is some activity:
    ev_timer_again (loop, timer);
-It is even possible to change the time-out on the fly:
+It is even possible to change the time-out on the fly, regardless of
+whether the watcher is active or not:
    timer->repeat = 30.;
    ev_timer_again (loop, timer);
 This is slightly more efficient then stopping/starting the timer each time
 you want to modify its timeout value, as libev does not have to completely
-remove and re-insert the timer from/into it's internal data structure.
+remove and re-insert the timer from/into its internal data structure.
+It is, however, even simpler than the "obvious" way to do it.
 =item 3. Let the timer time out, but then re-arm it as required.
 This method is more tricky, but usually most efficient: Most timeouts are
-relatively long compared to the loop iteration time - in our example,
+relatively long compared to the intervals between other activity - in
-within 60 seconds, there are usually many I/O events with associated
+our example, within 60 seconds, there are usually many I/O events with
-activity resets.
+associated activity resets.
 In this case, it would be more efficient to leave the C<ev_timer> alone,
 but remember the time of last activity, and check for a real timeout only
 within the callback:
    ev_tstamp last_activity; // time of last activity
    static void
    callback (EV_P_ ev_timer *w, int revents)
    {
-     ev_tstamp now = ev_now (EV_A);
+     ev_tstamp now     = ev_now (EV_A);
      ev_tstamp timeout = last_activity + 60.;
-     // if last_activity is older than now - timeout, we did time out
+     // if last_activity + 60. is older than now, we did time out
      if (timeout < now)
        {
          // timeout occured, take action
        }
      else
        {
          // callback was invoked, but there was some activity, re-arm
-         // to fire in last_activity + 60.
+         // the watcher to fire in last_activity + 60, which is
+         // guaranteed to be in the future, so "again" is positive:
          w->again = timeout - now;
          ev_timer_again (EV_A_ w);
        }
    }
-To summarise the callback: first calculate the real time-out (defined as
+To summarise the callback: first calculate the real timeout (defined
-"60 seconds after the last activity"), then check if that time has been
+as "60 seconds after the last activity"), then check if that time has
-reached, which means there was a real timeout. Otherwise the callback was
+been reached, which means something I<did>, in fact, time out. Otherwise
-invoked too early (timeout is in the future), so re-schedule the timer to
+the callback was invoked too early (C<timeout> is in the future), so
-fire at that future time.
+re-schedule the timer to fire at that future time, to see if maybe we have
+a timeout then.
 Note how C<ev_timer_again> is used, taking advantage of the
 C<ev_timer_again> optimisation when the timer is already running.
-This scheme causes more callback invocations (about one every 60 seconds),
+This scheme causes more callback invocations (about one every 60 seconds
-but virtually no calls to libev to change the timeout.
+minus half the average time between activity), but virtually no calls to
+libev to change the timeout.
-To start the timer, simply intiialise the watcher and C<last_activity>,
+To start the timer, simply initialise the watcher and set C<last_activity>
-then call the callback:
+to the current time (meaning we just have some activity :), then call the
+callback, which will "do the right thing" and start the timer:
    ev_timer_init (timer, callback);
    last_activity = ev_now (loop);
    callback (loop, timer, EV_TIMEOUT);
-And when there is some activity, simply remember the time in
+And when there is some activity, simply store the current time in
-C<last_activity>:
+C<last_activity>, no libev calls at all:
    last_actiivty = ev_now (loop);
 This technique is slightly more complex, but in most cases where the
 time-out is unlikely to be triggered, much more efficient.
+Changing the timeout is trivial as well (if it isn't hard-coded in the
+callback :) - just change the timeout and invoke the callback, which will
+fix things for you.
+=item 4. Wee, just use a double-linked list for your timeouts.
+If there is not one request, but many thousands (millions...), all
+employing some kind of timeout with the same timeout value, then one can
+do even better:
+When starting the timeout, calculate the timeout value and put the timeout
+at the I<end> of the list.
+Then use an C<ev_timer> to fire when the timeout at the I<beginning> of
+the list is expected to fire (for example, using the technique #3).
+When there is some activity, remove the timer from the list, recalculate
+the timeout, append it to the end of the list again, and make sure to
+update the C<ev_timer> if it was taken from the beginning of the list.
+This way, one can manage an unlimited number of timeouts in O(1) time for
+starting, stopping and updating the timers, at the expense of a major
+complication, and having to use a constant timeout. The constant timeout
+ensures that the list stays sorted.
 =back
+So which method the best?
+Method #2 is a simple no-brain-required solution that is adequate in most
+situations. Method #3 requires a bit more thinking, but handles many cases
+better, and isn't very complicated either. In most case, choosing either
+one is fine, with #3 being better in typical situations.
+Method #1 is almost always a bad idea, and buys you nothing. Method #4 is
+rather complicated, but extremely efficient, something that really pays
+off after the first million or so of active timers, i.e. it's usually
+overkill :)
 =head3 The special problem of time updates
 Establishing the current time is a costly operation (it usually takes at
 least two system calls): EV therefore updates its idea of the current
 =item D
 Leandro Lucarella has written a D language binding (F<ev.d>) for libev, to
 be found at L<http://proj.llucax.com.ar/wiki/evd>.
+=item Ocaml
+Erkki Seppala has written Ocaml bindings for libev, to be found at
+L<http://modeemi.cs.tut.fi/~flux/software/ocaml-ev/>.
 =back
 =head1 MACRO MAGIC

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.198 by root, Thu Oct 23 06:30:48 2008 UTC vs. Revision 1.204 by root, Mon Oct 27 11:08:29 2008 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.198 by root, Thu Oct 23 06:30:48 2008 UTC vs.
Revision 1.204 by root, Mon Oct 27 11:08:29 2008 UTC