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

Comparing libev/ev.pod (file contents):
Revision 1.451 by root, Mon Jun 24 00:19:26 2019 UTC vs.
Revision 1.467 by root, Sun Sep 13 22:17:02 2020 UTC

 When libev detects a usage error such as a negative timer interval, then
 it will print a diagnostic message and abort (via the C<assert> mechanism,
 so C<NDEBUG> will disable this checking): these are programming errors in
 the libev caller and need to be fixed there.
+Via the C<EV_FREQUENT> macro you can compile in and/or enable extensive
+consistency checking code inside libev that can be used to check for
+internal inconsistencies, suually caused by application bugs.
-Libev also has a few internal error-checking C<assert>ions, and also has
+Libev also has a few internal error-checking C<assert>ions. These do not
-extensive consistency checking code. These do not trigger under normal
-circumstances, as they indicate either a bug in libev or worse.
+trigger under normal circumstances, as they indicate either a bug in libev
+or worse.
 =head1 GLOBAL FUNCTIONS
 These functions can be called anytime, even before initialising the
 unblocking the signals.
 It's also required by POSIX in a threaded program, as libev calls
 C<sigprocmask>, whose behaviour is officially unspecified.
-This flag's behaviour will become the default in future versions of libev.
+=item C<EVFLAG_NOTIMERFD>
+When this flag is specified, the libev will avoid using a C<timerfd> to
+detect time jumps. It will still be able to detect time jumps, but takes
+longer and has a lower accuracy in doing so, but saves a file descriptor
+per loop.
+The current implementation only tries to use a C<timerfd> when the first
+C<ev_periodic> watcher is started and falls back on other methods if it
+cannot be created, but this behaviour might change in the future.
 =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,
 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)
-Use the linux-specific epoll(7) interface (for both pre- and post-2.6.9
+Use the Linux-specific epoll(7) interface (for both pre- and post-2.6.9
 kernels).
 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 like
 O(total_fds) where total_fds is the total number of fds (or the highest
 This backend maps C<EV_READ> and C<EV_WRITE> in the same way as
 C<EVBACKEND_POLL>.
 =item C<EVBACKEND_LINUXAIO>   (value 64, Linux)
-Use the linux-specific linux aio (I<not> C<< aio(7) >> but C<<
+Use the Linux-specific Linux AIO (I<not> C<< aio(7) >> but C<<
-io_submit(2) >>) event interface available in post-4.18 kernels.
+io_submit(2) >>) event interface available in post-4.18 kernels (but libev
+only tries to use it in 4.19+).
+This is another Linux train wreck of an event interface.
 If this backend works for you (as of this writing, it was very
-experimental), it is the best event interface available on linux and might
+experimental), it is the best event interface available on Linux and might
 be well worth enabling it - if it isn't available in your kernel this will
 be detected and this backend will be skipped.
 This backend can batch oneshot requests and supports a user-space ring
 buffer to receive events. It also doesn't suffer from most of the design
-problems of epoll (such as not being able to remove event sources from the
+problems of epoll (such as not being able to remove event sources from
-epoll set), and generally sounds too good to be true. Because, this being
+the epoll set), and generally sounds too good to be true. Because, this
-the linux kernel, of course it suffers from a whole new set of limitations.
+being the Linux kernel, of course it suffers from a whole new set of
+limitations, forcing you to fall back to epoll, inheriting all its design
+issues.
 For one, it is not easily embeddable (but probably could be done using
 an event fd at some extra overhead). It also is subject to a system wide
-limit that can be configured in F</proc/sys/fs/aio-max-nr> - each loop
+limit that can be configured in F</proc/sys/fs/aio-max-nr>. If no AIO
-currently requires C<61> of this number. If no aio requests are left, this
-backend will be skipped during initialisation.
+requests are left, this backend will be skipped during initialisation, and
+will switch to epoll when the loop is active.
-Most problematic in practise, however, is that not all file descriptors
+Most problematic in practice, however, is that not all file descriptors
-work with it. For example, in linux 5.1, tcp sockets, pipes, event fds,
+work with it. For example, in Linux 5.1, TCP sockets, pipes, event fds,
-files, F</dev/null> and a few others are supported, but ttys do not work
+files, F</dev/null> and many others are supported, but ttys do not work
 properly (a known bug that the kernel developers don't care about, see
 L<https://lore.kernel.org/patchwork/patch/1047453/>), so this is not
 (yet?) a generic event polling interface.
-Overall, it seems the linux developers just don't want it to have a
+Overall, it seems the Linux developers just don't want it to have a
 generic event handling mechanism other than C<select> or C<poll>.
-To work around the fd type problem, the current version of libev uses
+To work around all these problem, the current version of libev uses its
-epoll as a fallback for file deescriptor types that do not work. Epoll
+epoll backend as a fallback for file descriptor types that do not work. Or
-is used in, kind of, slow mode that hopefully avoids most of its design
+falls back completely to epoll if the kernel acts up.
-problems and requires 1-3 extra syscalls per active fd every iteration.
 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
+Kqueue deserves special mention, as at the time this backend was
-was broken on all BSDs except NetBSD (usually it doesn't work reliably
+implemented, it was broken on all BSDs except NetBSD (usually it doesn't
-with anything but sockets and pipes, except on Darwin, where of course
+work reliably with anything but sockets and pipes, except on Darwin,
-it's completely useless). Unlike epoll, however, whose brokenness
+where of course it's completely useless). Unlike epoll, however, whose
-is by design, these kqueue bugs can (and eventually will) be fixed
+brokenness is by design, these kqueue bugs can be (and mostly have been)
-without API changes to existing programs. For this reason it's not being
+fixed without API changes to existing programs. For this reason it's not
-"auto-detected" unless you explicitly specify it in the flags (i.e. using
+being "auto-detected" on all platforms unless you explicitly specify it
-C<EVBACKEND_KQUEUE>) or libev was compiled on a known-to-be-good (-enough)
+in the flags (i.e. using C<EVBACKEND_KQUEUE>) or libev was compiled on a
-system like NetBSD.
+known-to-be-good (-enough) system like NetBSD.
 You still can embed kqueue into a normal poll or select backend and use it
 only for sockets (after having made sure that sockets work with kqueue on
 the target platform). See C<ev_embed> watchers for more info.
 It scales in the same way as the epoll backend, but the interface to the
 kernel is more efficient (which says nothing about its actual speed, of
 course). While stopping, setting and starting an I/O watcher does never
 cause an extra system call as with C<EVBACKEND_EPOLL>, it still adds up to
 two event changes per incident. Support for C<fork ()> is very bad (you
-might have to leak fd's on fork, but it's more sane than epoll) and it
+might have to leak fds on fork, but it's more sane than epoll) and it
 drops fds silently in similarly hard-to-detect cases.
 This backend usually performs well under most conditions.
 While nominally embeddable in other event loops, this doesn't work
    - Queue all expired timers.
    - Queue all expired periodics.
    - Queue all idle watchers with priority higher than that of pending events.
    - Queue all check watchers.
    - Call all queued watchers in reverse order (i.e. check watchers first).
-     Signals and child watchers are implemented as I/O watchers, and will
+     Signals, async and child watchers are implemented as I/O watchers, and
-     be handled here by queueing them when their watcher gets executed.
+     will be handled here by queueing them when their watcher gets executed.
    - If ev_break has been called, or EVRUN_ONCE or EVRUN_NOWAIT
      were used, or there are no active watchers, goto FINISH, otherwise
      continue with step LOOP.
    FINISH:
    - Reset the ev_break status iff it was EVBREAK_ONE.
 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 *) >>.
 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
+must not touch the values stored in it except when explicitly documented
-reinitialise it or call its C<ev_TYPE_set> macro.
+otherwise. Most specifically you must never 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.
 =item bool ev_is_active (ev_TYPE *watcher)
 Returns a true value iff the watcher is active (i.e. it has been started
 and not yet been stopped). As long as a watcher is active you must not modify
-it.
+it unless documented otherwise.
 =item bool ev_is_pending (ev_TYPE *watcher)
 Returns a true value iff the watcher is pending, (i.e. it has outstanding
 events but its callback has not yet been invoked). As long as a watcher
 Many event loops support I<watcher priorities>, which are usually small
 integers that influence the ordering of event callback invocation
 between watchers in some way, all else being equal.
-In libev, Watcher priorities can be set using C<ev_set_priority>. See its
+In libev, watcher priorities can be set using C<ev_set_priority>. See its
 description for the more technical details such as the actual priority
 range.
 There are two common ways how these these priorities are being interpreted
 by event loops:
 This section describes each watcher in detail, but will not repeat
 information given in the last section. Any initialisation/set macros,
 functions and members specific to the watcher type are explained.
-Members are additionally marked with either I<[read-only]>, meaning that,
+Most members are additionally marked with either I<[read-only]>, meaning
-while the watcher is active, you can look at the member and expect some
+that, while the watcher is active, you can look at the member and expect
-sensible content, but you must not modify it (you can modify it while the
+some sensible content, but you must not modify it (you can modify it while
-watcher is stopped to your hearts content), or I<[read-write]>, which
+the watcher is stopped to your hearts content), or I<[read-write]>, which
-means you can expect it to have some sensible content while the watcher
+means you can expect it to have some sensible content while the watcher is
-is active, but you can also modify it. Modifying it may not do something
+active, but you can also modify it (within the same thread as the event
+loop, i.e. without creating data races). Modifying it may not do something
 sensible or take immediate effect (or do anything at all), but libev will
 not crash or malfunction in any way.
+In any case, the documentation for each member will explain what the
+effects are, and if there are any additional access restrictions.
 =head2 C<ev_io> - is this file descriptor readable or writable?
 I/O watchers check whether a file descriptor is readable or writable
 in each iteration of the event loop, or, more precisely, when reading
 when you rarely read from a file instead of from a socket, and want to
 reuse the same code path.
 =head3 The special problem of fork
-Some backends (epoll, kqueue, probably linuxaio) do not support C<fork ()>
+Some backends (epoll, kqueue, linuxaio, iouring) do not support C<fork ()>
 at all or exhibit useless behaviour. Libev fully supports fork, but needs
 to be told about it in the child if you want to continue to use it in the
 child.
 To support fork in your child processes, you have to call C<ev_loop_fork
 =item ev_io_init (ev_io *, callback, int fd, int events)
 =item ev_io_set (ev_io *, int fd, int events)
 Configures an C<ev_io> watcher. The C<fd> is the file descriptor to
-receive events for and C<events> is either C<EV_READ>, C<EV_WRITE> or
+receive events for and C<events> is either C<EV_READ>, C<EV_WRITE>, both
-C<EV_READ | EV_WRITE>, to express the desire to receive the given events.
+C<EV_READ | EV_WRITE> or C<0>, to express the desire to receive the given
+events.
-=item int fd [read-only]
+Note that setting the C<events> to C<0> and starting the watcher is
+supported, but not specially optimized - if your program sometimes happens
+to generate this combination this is fine, but if it is easy to avoid
+starting an io watcher watching for no events you should do so.
-The file descriptor being watched.
+=item ev_io_modify (ev_io *, int events)
+Similar to C<ev_io_set>, but only changes the requested events. Using this
+might be faster with some backends, as libev can assume that the C<fd>
+still refers to the same underlying file description, something it cannot
+do when using C<ev_io_set>.
+=item int fd [no-modify]
+The file descriptor being watched. While it can be read at any time, you
+must not modify this member even when the watcher is stopped - always use
+C<ev_io_set> for that.
-=item int events [read-only]
+=item int events [no-modify]
-The events being watched.
+The set of events the fd is being watched for, among other flags. Remember
+that this is a bit set - to test for C<EV_READ>, use C<< w->events &
+EV_READ >>, and similarly for C<EV_WRITE>.
+As with C<fd>, you must not modify this member even when the watcher is
+stopped, always use C<ev_io_set> or C<ev_io_modify> for that.
 =back
 =head3 Examples
 event loop thread and an unspecified mechanism to wake up the main thread.
 First, you need to associate some data with the event loop:
    typedef struct {
-     mutex_t lock; /* global loop lock */
+     pthread_mutex_t lock; /* global loop lock */
+     pthread_t tid;
+     pthread_cond_t invoke_cv;
      ev_async async_w;
-     thread_t tid;
-     cond_t invoke_cv;
    } userdata;
    void prepare_loop (EV_P)
    {
       // for simplicity, we use a static userdata struct.
       static userdata u;
-      ev_async_init (&u->async_w, async_cb);
+      ev_async_init (&u.async_w, async_cb);
-      ev_async_start (EV_A_ &u->async_w);
+      ev_async_start (EV_A_ &u.async_w);
-      pthread_mutex_init (&u->lock, 0);
+      pthread_mutex_init (&u.lock, 0);
-      pthread_cond_init (&u->invoke_cv, 0);
+      pthread_cond_init (&u.invoke_cv, 0);
       // now associate this with the loop
-      ev_set_userdata (EV_A_ u);
+      ev_set_userdata (EV_A_ &u);
       ev_set_invoke_pending_cb (EV_A_ l_invoke);
       ev_set_loop_release_cb (EV_A_ l_release, l_acquire);
       // then create the thread running ev_run
-      pthread_create (&u->tid, 0, l_run, EV_A);
+      pthread_create (&u.tid, 0, l_run, EV_A);
    }
 The callback for the C<ev_async> watcher does nothing: the watcher is used
 solely to wake up the event loop so it takes notice of any new watchers
 that might have been added:
 method.
 For C<ev::embed> watchers this method is called C<set_embed>, to avoid
 clashing with the C<set (loop)> method.
+For C<ev::io> watchers there is an additional C<set> method that acepts a
+new event mask only, and internally calls C<ev_io_modfify>.
 =item w->start ()
 Starts the watcher. Note that there is no C<loop> argument, as the
 constructor already stores the event loop.
    ev_select.c     only when select backend is enabled
    ev_poll.c       only when poll backend is enabled
    ev_epoll.c      only when the epoll backend is enabled
    ev_linuxaio.c   only when the linux aio backend is enabled
+   ev_iouring.c    only when the linux io_uring backend is enabled
    ev_kqueue.c     only when the kqueue backend is enabled
    ev_port.c       only when the solaris port backend is enabled
 F<ev.c> includes the backend files directly when enabled, so you only need
 to compile this single file.
 available and will probe for kernel support at runtime. This will improve
 C<ev_signal> and C<ev_async> performance and reduce resource consumption.
 If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
 2.7 or newer, otherwise disabled.
+=item EV_USE_SIGNALFD
+If defined to be C<1>, then libev will assume that C<signalfd ()> is
+available and will probe for kernel support at runtime. This enables
+the use of EVFLAG_SIGNALFD for faster and simpler signal handling. If
+undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
+2.7 or newer, otherwise disabled.
+=item EV_USE_TIMERFD
+If defined to be C<1>, then libev will assume that C<timerfd ()> is
+available and will probe for kernel support at runtime. This allows
+libev to detect time jumps accurately. If undefined, it will be enabled
+if the headers indicate GNU/Linux + Glibc 2.8 or newer and define
+C<TFD_TIMER_CANCEL_ON_SET>, otherwise disabled.
+=item EV_USE_EVENTFD
+If defined to be C<1>, then libev will assume that C<eventfd ()> is
+available and will probe for kernel support at runtime. This will improve
+C<ev_signal> and C<ev_async> performance and reduce resource consumption.
+If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
+2.7 or newer, otherwise disabled.
 =item EV_USE_SELECT
 If undefined or defined to be C<1>, libev will compile in support for the
 C<select>(2) backend. No attempt at auto-detection will be done: if no
 other method takes over, select will be it. Otherwise the select backend
 backend for GNU/Linux systems. If undefined, it will be enabled if the
 headers indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
 =item EV_USE_LINUXAIO
+If defined to be C<1>, libev will compile in support for the Linux aio
+backend (C<EV_USE_EPOLL> must also be enabled). If undefined, it will be
+enabled on linux, otherwise disabled.
+=item EV_USE_IOURING
 If defined to be C<1>, libev will compile in support for the Linux
-aio backend. Due to it's currenbt limitations it has to be requested
+io_uring backend (C<EV_USE_EPOLL> must also be enabled). Due to it's
-explicitly.  If undefined, it will be enabled on linux, otherwise
+current limitations it has to be requested explicitly. If undefined, it
-disabled.
+will be enabled on linux, otherwise disabled.
 =item EV_USE_KQUEUE
 If defined to be C<1>, libev will compile in support for the BSD style
 C<kqueue>(2) backend. Its actual availability will be detected at runtime,
 called. If set to C<2>, then the internal verification code will be
 called once per loop, which can slow down libev. If set to C<3>, then the
 verification code will be called very frequently, which will slow down
 libev considerably.
+Verification errors are reported via C's C<assert> mechanism, so if you
+disable that (e.g. by defining C<NDEBUG>) then no errors will be reported.
 The default is C<1>, unless C<EV_FEATURES> overrides it, in which case it
 will be C<0>.
 =item EV_COMMON

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.451 by root, Mon Jun 24 00:19:26 2019 UTC vs. Revision 1.467 by root, Sun Sep 13 22:17:02 2020 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.451 by root, Mon Jun 24 00:19:26 2019 UTC vs.
Revision 1.467 by root, Sun Sep 13 22:17:02 2020 UTC