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

Comparing libev/ev.pod (file contents):
Revision 1.273 by root, Tue Nov 24 14:46:59 2009 UTC vs.
Revision 1.279 by root, Mon Feb 15 05:15:55 2010 UTC

 Libev is very configurable. In this manual the default (and most common)
 configuration will be described, which supports multiple event loops. For
 more info about various configuration options please have a look at
 B<EMBED> section in this manual. If libev was configured without support
 for multiple event loops, then all functions taking an initial argument of
-name C<loop> (which is always of type C<ev_loop *>) will not have
+name C<loop> (which is always of type C<struct ev_loop *>) will not have
 this argument.
 =head2 TIME REPRESENTATION
 Libev represents time as a single floating point number, representing
 When this flag is specified, then libev will not attempt to use the
 I<inotify> API for it's C<ev_stat> watchers. Apart from debugging and
 testing, this flag can be useful to conserve inotify file descriptors, as
 otherwise each loop using C<ev_stat> watchers consumes one inotify handle.
-=item C<EVFLAG_NOSIGFD>
+=item C<EVFLAG_SIGNALFD>
-When this flag is specified, then libev will not attempt to use the
+When this flag is specified, then libev will attempt to use the
-I<signalfd> API for it's C<ev_signal> (and C<ev_child>) watchers. This is
+I<signalfd> API for it's C<ev_signal> (and C<ev_child>) watchers. This API
-probably only useful to work around any bugs in libev. Consequently, this
+delivers signals synchronously, which makes it both faster and might make
-flag might go away once the signalfd functionality is considered stable,
+it possible to get the queued signal data. It can also simplify signal
-so it's useful mostly in environment variables and not in program code.
+handling with threads, as long as you properly block signals in your
+threads that are not interested in handling them.
+Signalfd will not be used by default as this changes your signal mask, and
+there are a lot of shoddy libraries and programs (glib's threadpool for
+example) that can't properly initialise their signal masks.
 =item C<EVBACKEND_SELECT>  (value 1, portable select backend)
 This is your standard select(2) backend. Not I<completely> standard, as
 libev tries to roll its own fd_set with no limits on the number of fds,
 Ref/unref can be used to add or remove a reference count on the event
 loop: Every watcher keeps one reference, and as long as the reference
 count is nonzero, C<ev_loop> will not return on its own.
-If you have a watcher you never unregister that should not keep C<ev_loop>
+This is useful when you have a watcher that you never intend to
-from returning, call ev_unref() after starting, and ev_ref() before
+unregister, but that nevertheless should not keep C<ev_loop> from
+returning. In such a case, call C<ev_unref> after starting, and C<ev_ref>
-stopping it.
+before stopping it.
 As an example, libev itself uses this for its internal signal pipe: It
 is not visible to the libev user and should not keep C<ev_loop> from
 exiting if no event watchers registered by it are active. It is also an
 excellent way to do this for generic recurring timers or from within
 While event loop modifications are allowed between invocations of
 C<release> and C<acquire> (that's their only purpose after all), no
 modifications done will affect the event loop, i.e. adding watchers will
 have no effect on the set of file descriptors being watched, or the time
-waited. USe an C<ev_async> watcher to wake up C<ev_loop> when you want it
+waited. Use an C<ev_async> watcher to wake up C<ev_loop> when you want it
 to take note of any changes you made.
 In theory, threads executing C<ev_loop> will be async-cancel safe between
 invocations of C<release> and C<acquire>.
    ev_io w;
    ev_init (&w, my_cb);
    ev_io_set (&w, STDIN_FILENO, EV_READ);
-=item C<ev_TYPE_set> (ev_TYPE *, [args])
+=item C<ev_TYPE_set> (ev_TYPE *watcher, [args])
 This macro initialises the type-specific parts of a watcher. You need to
 call C<ev_init> at least once before you call this macro, but you can
 call C<ev_TYPE_set> any number of times. You must not, however, call this
 macro on a watcher that is active (it can be pending, however, which is a
 Example: Initialise and set an C<ev_io> watcher in one step.
    ev_io_init (&w, my_cb, STDIN_FILENO, EV_READ);
-=item C<ev_TYPE_start> (loop *, ev_TYPE *watcher)
+=item C<ev_TYPE_start> (loop, ev_TYPE *watcher)
 Starts (activates) the given watcher. Only active watchers will receive
 events. If the watcher is already active nothing will happen.
 Example: Start the C<ev_io> watcher that is being abused as example in this
 whole section.
    ev_io_start (EV_DEFAULT_UC, &w);
-=item C<ev_TYPE_stop> (loop *, ev_TYPE *watcher)
+=item C<ev_TYPE_stop> (loop, ev_TYPE *watcher)
 Stops the given watcher if active, and clears the pending status (whether
 the watcher was active or not).
 It is possible that stopped watchers are pending - for example,
 =item ev_cb_set (ev_TYPE *watcher, callback)
 Change the callback. You can change the callback at virtually any time
 (modulo threads).
-=item ev_set_priority (ev_TYPE *watcher, priority)
+=item ev_set_priority (ev_TYPE *watcher, int priority)
 =item int ev_priority (ev_TYPE *watcher)
 Set and query the priority of the watcher. The priority is a small
 integer between C<EV_MAXPRI> (default: C<2>) and C<EV_MINPRI>
 watcher isn't pending it does nothing and returns C<0>.
 Sometimes it can be useful to "poll" a watcher instead of waiting for its
 callback to be invoked, which can be accomplished with this function.
-=item ev_feed_event (struct ev_loop *, watcher *, int revents)
+=item ev_feed_event (loop, ev_TYPE *watcher, int revents)
 Feeds the given event set into the event loop, as if the specified event
 had happened for the specified watcher (which must be a pointer to an
 initialised but not necessarily started event watcher). Obviously you must
 not free the watcher as long as it has pending events.
 C<repeat> value), or reset the running timer to the C<repeat> value.
 This sounds a bit complicated, see L<Be smart about timeouts>, above, for a
 usage example.
-=item ev_timer_remaining (loop, ev_timer *)
+=item ev_tstamp ev_timer_remaining (loop, ev_timer *)
 Returns the remaining time until a timer fires. If the timer is active,
 then this time is relative to the current event loop time, otherwise it's
 the timeout value currently configured.
 C<SA_RESTART> (or equivalent) behaviour enabled, so system calls should
 not be unduly interrupted. If you have a problem with system calls getting
 interrupted by signals you can block all signals in an C<ev_check> watcher
 and unblock them in an C<ev_prepare> watcher.
-=head3 The special problem of inheritance over execve
+=head3 The special problem of inheritance over fork/execve/pthread_create
 Both the signal mask (C<sigprocmask>) and the signal disposition
 (C<sigaction>) are unspecified after starting a signal watcher (and after
 stopping it again), that is, libev might or might not block the signal,
 and might or might not set or restore the installed signal handler.
 The simplest way to ensure that the signal mask is reset in the child is
 to install a fork handler with C<pthread_atfork> that resets it. That will
 catch fork calls done by libraries (such as the libc) as well.
-In current versions of libev, you can also ensure that the signal mask is
+In current versions of libev, the signal will not be blocked indefinitely
-not blocking any signals (except temporarily, so thread users watch out)
+unless you use the C<signalfd> API (C<EV_SIGNALFD>). While this reduces
-by specifying the C<EVFLAG_NOSIGFD> when creating the event loop. This
+the window of opportunity for problems, it will not go away, as libev
-is not guaranteed for future versions, however.
+I<has> to modify the signal mask, at least temporarily.
+So I can't stress this enough: I<If you do not reset your signal mask when
+you expect it to be empty, you have a race condition in your code>. This
+is not a libev-specific thing, this is true for most event libraries.
 =head3 Watcher-Specific Functions and Data Members
 =over 4
 =head3 Queueing
 C<ev_async> does not support queueing of data in any way. The reason
 is that the author does not know of a simple (or any) algorithm for a
 multiple-writer-single-reader queue that works in all cases and doesn't
-need elaborate support such as pthreads.
+need elaborate support such as pthreads or unportable memory access
+semantics.
 That means that if you want to queue data, you have to provide your own
 queue. But at least I can tell you how to implement locking around your
 queue:
        /* doh, nothing entered */;
    }
    ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);
-=item ev_feed_fd_event (struct ev_loop *, int fd, int revents)
+=item ev_feed_fd_event (loop, int fd, int revents)
 Feed an event on the given fd, as if a file descriptor backend detected
 the given events it.
-=item ev_feed_signal_event (struct ev_loop *loop, int signum)
+=item ev_feed_signal_event (loop, int signum)
 Feed an event as if the given signal occurred (C<loop> must be the default
 loop!).
 =back
 =over 4
 =item ev::TYPE::TYPE ()
-=item ev::TYPE::TYPE (struct ev_loop *)
+=item ev::TYPE::TYPE (loop)
 =item ev::TYPE::~TYPE
 The constructor (optionally) takes an event loop to associate the watcher
 with. If it is omitted, it will use C<EV_DEFAULT>.
 Example: Use a plain function as callback.
    static void io_cb (ev::io &w, int revents) { }
    iow.set <io_cb> ();
-=item w->set (struct ev_loop *)
+=item w->set (loop)
 Associates a different C<struct ev_loop> with this watcher. You can only
 do this when the watcher is inactive (and not pending either).
 =item w->set ([arguments])
 Erkki Seppala has written Ocaml bindings for libev, to be found at
 L<http://modeemi.cs.tut.fi/~flux/software/ocaml-ev/>.
 =item Lua
-Brian Maher has written a partial interface to libev
+Brian Maher has written a partial interface to libev for lua (at the
-for lua (only C<ev_io> and C<ev_timer>), to be found at
+time of this writing, only C<ev_io> and C<ev_timer>), to be found at
 L<http://github.com/brimworks/lua-ev>.
 =back

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.273 by root, Tue Nov 24 14:46:59 2009 UTC vs. Revision 1.279 by root, Mon Feb 15 05:15:55 2010 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.273 by root, Tue Nov 24 14:46:59 2009 UTC vs.
Revision 1.279 by root, Mon Feb 15 05:15:55 2010 UTC