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

Comparing libev/ev.pod (file contents):
Revision 1.172 by root, Wed Aug 6 07:01:25 2008 UTC vs.
Revision 1.181 by root, Fri Sep 19 03:47:50 2008 UTC

 writing a server, you should C<accept ()> in a loop to accept as many
 connections as possible during one iteration. You might also want to have
 a look at C<ev_set_io_collect_interval ()> to increase the amount of
 readiness notifications you get per iteration.
+This backend maps C<EV_READ> to the C<readfds> set and C<EV_WRITE> to the
+C<writefds> set (and to work around Microsoft Windows bugs, also onto the
+C<exceptfds> set on that platform).
 =item C<EVBACKEND_POLL>    (value 2, poll backend, available everywhere except on windows)
 And this is your standard poll(2) backend. It's more complicated
 than select, but handles sparse fds better and has no artificial
 limit on the number of fds you can use (except it will slow down
 considerably with a lot of inactive fds). It scales similarly to select,
 i.e. O(total_fds). See the entry for C<EVBACKEND_SELECT>, above, for
 performance tips.
+This backend maps C<EV_READ> to C<POLLIN | POLLERR | POLLHUP>, and
+C<EV_WRITE> to C<POLLOUT | POLLERR | POLLHUP>.
 =item C<EVBACKEND_EPOLL>   (value 4, Linux)
 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
 keep at least one watcher active per fd at all times.
 While nominally embeddable in other event loops, this feature is broken in
 all kernel versions tested so far.
+This backend maps C<EV_READ> and C<EV_WRITE> in the same way as
+C<EVBACKEND_POLL>.
 =item C<EVBACKEND_KQUEUE>  (value 8, most BSD clones)
 Kqueue deserves special mention, as at the time of this writing, it
 was broken on all BSDs except NetBSD (usually it doesn't work reliably
 with anything but sockets and pipes, except on Darwin, where of course
 almost everywhere, you should only use it when you have a lot of sockets
 (for which it usually works), by embedding it into another event loop
 (e.g. C<EVBACKEND_SELECT> or C<EVBACKEND_POLL>) and using it only for
 sockets.
+This backend maps C<EV_READ> into an C<EVFILT_READ> kevent with
+C<NOTE_EOF>, and C<EV_WRITE> into an C<EVFILT_WRITE> kevent with
+C<NOTE_EOF>.
 =item C<EVBACKEND_DEVPOLL> (value 16, Solaris 8)
 This is not implemented yet (and might never be, unless you send me an
 implementation). According to reports, C</dev/poll> only supports sockets
 and is not embeddable, which would limit the usefulness of this backend
 might perform better.
 On the positive side, ignoring the spurious readiness notifications, this
 backend actually performed to specification in all tests and is fully
 embeddable, which is a rare feat among the OS-specific backends.
+This backend maps C<EV_READ> and C<EV_WRITE> in the same way as
+C<EVBACKEND_POLL>.
 =item C<EVBACKEND_ALL>
 Try all backends (even potentially broken ones that wouldn't be tried
 with C<EVFLAG_AUTO>). Since this is a mask, you can do stuff such as
 Returns the current "event loop time", which is the time the event loop
 received 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 occurring (or more correctly, libev finding out about it).
+=item ev_now_update (loop)
+Establishes the current time by querying the kernel, updating the time
+returned by C<ev_now ()> in the progress. This is a costly operation and
+is usually done automatically within C<ev_loop ()>.
+This function is rarely useful, but when some event callback runs for a
+very long time without entering the event loop, updating libev's idea of
+the current time is a good idea.
+See also "The special problem of time updates" in the C<ev_timer> section.
 =item ev_loop (loop, int flags)
 Finally, this is it, the event handler. This function usually is called
 after you initialised all your watchers and you want to start handling
    {
      struct ev_io io;
      int otherfd;
      void *somedata;
      struct whatever *mostinteresting;
-   }
+   };
+   ...
+   struct my_io w;
+   ev_io_init (&w.io, my_cb, fd, EV_READ);
 And since your callback will be called with a pointer to the watcher, you
 can cast it back to your own type:
    static void my_cb (struct ev_loop *loop, struct ev_io *w_, int revents)
    }
 More interesting and less C-conformant ways of casting your callback type
 instead have been omitted.
-Another common scenario is having some data structure with multiple
+Another common scenario is to use some data structure with multiple
-watchers:
+embedded watchers:
    struct my_biggy
    {
      int some_data;
      ev_timer t1;
      ev_timer t2;
    }
-In this case getting the pointer to C<my_biggy> is a bit more complicated,
+In this case getting the pointer to C<my_biggy> is a bit more
-you need to use C<offsetof>:
+complicated: Either you store the address of your C<my_biggy> struct
+in the C<data> member of the watcher, or you need to use some pointer
+arithmetic using C<offsetof> inside your watchers:
    #include <stddef.h>
    static void
    t1_cb (EV_P_ struct ev_timer *w, int revents)
 C<EVBACKEND_POLL>.
 =head3 The special problem of SIGPIPE
 While not really specific to libev, it is easy to forget about SIGPIPE:
-when reading from a pipe whose other end has been closed, your program
+when writing to a pipe whose other end has been closed, your program gets
-gets send a SIGPIPE, which, by default, aborts your program. For most
+send a SIGPIPE, which, by default, aborts your program. For most programs
-programs this is sensible behaviour, for daemons, this is usually
+this is sensible behaviour, for daemons, this is usually undesirable.
-undesirable.
 So when you encounter spurious, unexplained daemon exits, make sure you
 ignore SIGPIPE (and maybe make sure you log the exit status of your daemon
 somewhere, as that would have given you a big clue).
 times out after an hour and you reset your system clock to January last
 year, it will still time out after (roughly) and hour. "Roughly" because
 detecting time jumps is hard, and some inaccuracies are unavoidable (the
 monotonic clock option helps a lot here).
+The callback is guaranteed to be invoked only after its timeout has passed,
+but if multiple timers become ready during the same loop iteration then
+order of execution is undefined.
+=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
+time only before and after C<ev_loop> polls for new events, which causes
+a growing difference between C<ev_now ()> and C<ev_time ()> when handling
+lots of events.
 The relative timeouts are calculated relative to the C<ev_now ()>
 time. This is usually the right thing as this timestamp refers to the time
 of the event triggering whatever timeout you are modifying/starting. If
-you suspect event processing to be delayed and you I<need> to base the timeout
+you suspect event processing to be delayed and you I<need> to base the
-on the current time, use something like this to adjust for this:
+timeout on the current time, use something like this to adjust for this:
    ev_timer_set (&timer, after + ev_now () - ev_time (), 0.);
-The callback is guaranteed to be invoked only after its timeout has passed,
+If the event loop is suspended for a long time, you can also force an
-but if multiple timers become ready during the same loop iteration then
+update of the time returned by C<ev_now ()> by calling C<ev_now_update
-order of execution is undefined.
+()>.
 =head3 Watcher-Specific Functions and Data Members
 =over 4
 handler, you can override it easily by installing your own handler for
 C<SIGCHLD> after initialising the default loop, and making sure the
 default loop never gets destroyed. You are encouraged, however, to use an
 event-based approach to child reaping and thus use libev's support for
 that, so other libev users can use C<ev_child> watchers freely.
+=head3 Stopping the Child Watcher
+Currently, the child watcher never gets stopped, even when the
+child terminates, so normally one needs to stop the watcher in the
+callback. Future versions of libev might stop the watcher automatically
+when a child exit is detected.
 =head3 Watcher-Specific Functions and Data Members
 =over 4
 =head1 THREADS AND COROUTINES
 =head2 THREADS
-Libev itself is completely thread-safe, but it uses no locking. This
+Libev itself is thread-safe (unless the opposite is specifically
+documented for a function), but it uses no locking itself. This means that
-means that you can use as many loops as you want in parallel, as long as
+you can use as many loops as you want in parallel, as long as only one
-only one thread ever calls into one libev function with the same loop
+thread ever calls into one libev function with the same loop parameter:
-parameter.
+libev guarentees that different event loops share no data structures that
+need locking.
-Or put differently: calls with different loop parameters can be done in
+Or to put it differently: calls with different loop parameters can be done
-parallel from multiple threads, calls with the same loop parameter must be
+concurrently from multiple threads, calls with the same loop parameter
-done serially (but can be done from different threads, as long as only one
+must be done serially (but can be done from different threads, as long as
-thread ever is inside a call at any point in time, e.g. by using a mutex
+only one thread ever is inside a call at any point in time, e.g. by using
-per loop).
+a mutex per loop).
+Specifically to support threads (and signal handlers), libev implements
+so-called C<ev_async> watchers, which allow some limited form of
+concurrency on the same event loop.
 If you want to know which design (one loop, locking, or multiple loops
 without or something else still) is best for your problem, then I cannot
 help you. I can give some generic advice however:
 better than you currently do :-)
 =item * often you need to talk to some other thread which blocks in the
 event loop - C<ev_async> watchers can be used to wake them up from other
 threads safely (or from signal contexts...).
+=item * some watcher types are only supported in the default loop - use
+C<ev_async> watchers to tell your other loops about any such events.
 =back
 =head2 COROUTINES
 coroutines (e.g. you can call C<ev_loop> 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 C<ev_periodic> reschedule callbacks.
-Care has been invested into making sure that libev does not keep local
+Care has been taken to ensure that libev does not keep local state inside
-state inside C<ev_loop>, and other calls do not usually allow coroutine
+C<ev_loop>, and other calls do not usually allow coroutine switches.
-switches.
 =head1 COMPLEXITIES
 In this section the complexities of (many of) the algorithms used inside

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.172 by root, Wed Aug 6 07:01:25 2008 UTC vs. Revision 1.181 by root, Fri Sep 19 03:47:50 2008 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.172 by root, Wed Aug 6 07:01:25 2008 UTC vs.
Revision 1.181 by root, Fri Sep 19 03:47:50 2008 UTC