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

Comparing libev/ev.pod (file contents):
Revision 1.434 by root, Tue May 6 13:24:39 2014 UTC vs.
Revision 1.451 by root, Mon Jun 24 00:19:26 2019 UTC

 details of the event, and then hand it over to libev by I<starting> the
 watcher.
 =head2 FEATURES
-Libev supports C<select>, C<poll>, the Linux-specific C<epoll>, the
+Libev supports C<select>, C<poll>, the Linux-specific aio and C<epoll>
-BSD-specific C<kqueue> and the Solaris-specific event port mechanisms
+interfaces, the BSD-specific C<kqueue> and the Solaris-specific event port
-for file descriptor events (C<ev_io>), the Linux C<inotify> interface
+mechanisms for file descriptor events (C<ev_io>), the Linux C<inotify>
-(for C<ev_stat>), Linux eventfd/signalfd (for faster and cleaner
+interface (for C<ev_stat>), Linux eventfd/signalfd (for faster and cleaner
 inter-thread wakeup (C<ev_async>)/signal handling (C<ev_signal>)) relative
 timers (C<ev_timer>), absolute timers with customised rescheduling
 (C<ev_periodic>), synchronous signals (C<ev_signal>), process status
 change events (C<ev_child>), and event watchers dealing with the event
 loop mechanism itself (C<ev_idle>, C<ev_embed>, C<ev_prepare> and
 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.
+Example: The following is the C<realloc> function that libev itself uses
+which should work with C<realloc> and C<free> functions of all kinds and
+is probably a good basis for your own implementation.
+   static void *
+   ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
+   {
+     if (size)
+       return realloc (ptr, size);
+     free (ptr);
+     return 0;
+   }
 Example: Replace the libev allocator with one that waits a bit and then
-retries (example requires a standards-compliant C<realloc>).
+retries.
    static void *
    persistent_realloc (void *ptr, size_t size)
    {
+     if (!size)
+       {
+         free (ptr);
+         return 0;
+       }
      for (;;)
        {
          void *newptr = realloc (ptr, size);
          if (newptr)
 make libev check for a fork in each iteration by enabling this flag.
 This works by calling C<getpid ()> on every iteration of the loop,
 and thus this might slow down your event loop if you do a lot of loop
 iterations and little real work, but is usually not noticeable (on my
-GNU/Linux system for example, C<getpid> is actually a simple 5-insn sequence
+GNU/Linux system for example, C<getpid> is actually a simple 5-insn
-without a system call and thus I<very> fast, but my GNU/Linux system also has
+sequence without a system call and thus I<very> fast, but my GNU/Linux
-C<pthread_atfork> which is even faster).
+system also has C<pthread_atfork> which is even faster). (Update: glibc
+versions 2.25 apparently removed the C<getpid> optimisation again).
 The big advantage of this flag is that you can forget about fork (and
-forget about forgetting to tell libev about forking) when you use this
+forget about forgetting to tell libev about forking, although you still
-flag.
+have to ignore C<SIGPIPE>) when you use this flag.
 This flag setting cannot be overridden or specified in the C<LIBEV_FLAGS>
 environment variable.
 =item C<EVFLAG_NOINOTIFY>
 All this means that, in practice, C<EVBACKEND_SELECT> can be as fast or
 faster than epoll for maybe up to a hundred file descriptors, depending on
 the usage. So sad.
 While nominally embeddable in other event loops, this feature is broken in
-all kernel versions tested so far.
+a lot of kernel revisions, but probably(!) works in current versions.
+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<<
+io_submit(2) >>) event interface available in post-4.18 kernels.
+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
+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
+epoll set), and generally sounds too good to be true. Because, this being
+the linux kernel, of course it suffers from a whole new set of limitations.
+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
+currently requires C<61> of this number. If no aio requests are left, this
+backend will be skipped during initialisation.
+Most problematic in practise, however, is that not all file descriptors
+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
+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
+generic event handling mechanism other than C<select> or C<poll>.
+To work around the fd type problem, the current version of libev uses
+epoll as a fallback for file deescriptor types that do not work. Epoll
+is used in, kind of, slow mode that hopefully avoids most of its design
+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)
 Example: Use whatever libev has to offer, but make sure that kqueue is
 used if available.
    struct ev_loop *loop = ev_loop_new (ev_recommended_backends () | EVBACKEND_KQUEUE);
+Example: Similarly, on linux, you mgiht want to take advantage of the
+linux aio backend if possible, but fall back to something else if that
+isn't available.
+   struct ev_loop *loop = ev_loop_new (ev_recommended_backends () | EVBACKEND_LINUXAIO);
 =item ev_loop_destroy (loop)
 Destroys an event loop object (frees all memory and kernel state
 etc.). None of the active event watchers will be stopped in the normal
 sense, so e.g. C<ev_is_active> might still return true. It is your
 to reinitialise the kernel state for backends that have one. Despite
 the name, you can call it anytime you are allowed to start or stop
 watchers (except inside an C<ev_prepare> callback), but it makes most
 sense after forking, in the child process. You I<must> call it (or use
 C<EVFLAG_FORKCHECK>) in the child before resuming or calling C<ev_run>.
+In addition, if you want to reuse a loop (via this function or
+C<EVFLAG_FORKCHECK>), you I<also> have to ignore C<SIGPIPE>.
 Again, you I<have> to call it on I<any> loop that you want to re-use after
 a fork, I<even if you do not plan to use the loop in the parent>. This is
 because some kernel interfaces *cough* I<kqueue> *cough* do funny things
 during fork.
 But really, best use non-blocking mode.
 =head3 The special problem of disappearing file descriptors
-Some backends (e.g. kqueue, epoll) need to be told about closing a file
+Some backends (e.g. kqueue, epoll, linuxaio) need to be told about closing
-descriptor (either due to calling C<close> explicitly or any other means,
+a file descriptor (either due to calling C<close> explicitly or any other
-such as C<dup2>). The reason is that you register interest in some file
+means, such as C<dup2>). The reason is that you register interest in some
-descriptor, but when it goes away, the operating system will silently drop
+file descriptor, but when it goes away, the operating system will silently
-this interest. If another file descriptor with the same number then is
+drop this interest. If another file descriptor with the same number then
-registered with libev, there is no efficient way to see that this is, in
+is registered with libev, there is no efficient way to see that this is,
-fact, a different file descriptor.
+in fact, a different file descriptor.
 To avoid having to explicitly tell libev about such cases, libev follows
 the following policy:  Each time C<ev_io_set> is being called, libev
 will assume that this is potentially a new file descriptor, otherwise
 it is assumed that the file descriptor stays the same. That means that
 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) do not support C<fork ()> at all or exhibit
+Some backends (epoll, kqueue, probably linuxaio) do not support C<fork ()>
-useless behaviour. Libev fully supports fork, but needs to be told about
+at all or exhibit useless behaviour. Libev fully supports fork, but needs
-it in the child if you want to continue to use it in the child.
+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
 ()> after a fork in the child, enable C<EVFLAG_FORKCHECK>, or resort to
 C<EVBACKEND_SELECT> or C<EVBACKEND_POLL>.
 =item ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)
 =item ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)
-Configure the timer to trigger after C<after> seconds. If C<repeat>
+Configure the timer to trigger after C<after> seconds (fractional and
-is C<0.>, then it will automatically be stopped once the timeout is
+negative values are supported). If C<repeat> is C<0.>, then it will
-reached. If it is positive, then the timer will automatically be
+automatically be stopped once the timeout is reached. If it is positive,
-configured to trigger again C<repeat> seconds later, again, and again,
+then the timer will automatically be configured to trigger again C<repeat>
-until stopped manually.
+seconds later, again, and again, until stopped manually.
 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 normally
 trigger at exactly 10 second intervals. If, however, your program cannot
 keep up with the timer (because it takes longer than those 10 seconds to
 Periodic watchers are also timers of a kind, but they are very versatile
 (and unfortunately a bit complex).
 Unlike C<ev_timer>, periodic watchers are not based on real time (or
 relative time, the physical time that passes) but on wall clock time
-(absolute time, the thing you can read on your calender or clock). The
+(absolute time, the thing you can read on your calendar or clock). The
 difference is that wall clock time can run faster or slower than real
 time, and time jumps are not uncommon (e.g. when you adjust your
 wrist-watch).
 You can tell a periodic watcher to trigger after some specific point
 C<ev_timer>, which would still trigger roughly 10 seconds after starting
 it, as it uses a relative timeout).
 C<ev_periodic> watchers can also be used to implement vastly more complex
 timers, such as triggering an event on each "midnight, local time", or
-other complicated rules. This cannot be done with C<ev_timer> watchers, as
+other complicated rules. This cannot easily be done with C<ev_timer>
-those cannot react to time jumps.
+watchers, as those cannot react to time jumps.
 As with timers, the callback is guaranteed to be invoked only when the
 point in time where it is supposed to trigger has passed. If multiple
 timers become ready during the same loop iteration then the ones with
 earlier time-out values are invoked before ones with later time-out values
 NOTE: I<< This callback must always return a time that is higher than or
 equal to the passed C<now> value >>.
 This can be used to create very complex timers, such as a timer that
-triggers on "next midnight, local time". To do this, you would calculate the
+triggers on "next midnight, local time". To do this, you would calculate
-next midnight after C<now> and return the timestamp value for this. How
+the next midnight after C<now> and return the timestamp value for
-you do this is, again, up to you (but it is not trivial, which is the main
+this. Here is a (completely untested, no error checking) example on how to
-reason I omitted it as an example).
+do this:
+   #include <time.h>
+   static ev_tstamp
+   my_rescheduler (ev_periodic *w, ev_tstamp now)
+   {
+     time_t tnow = (time_t)now;
+     struct tm tm;
+     localtime_r (&tnow, &tm);
+     tm.tm_sec = tm.tm_min = tm.tm_hour = 0; // midnight current day
+     ++tm.tm_mday; // midnight next day
+     return mktime (&tm);
+   }
+Note: this code might run into trouble on days that have more then two
+midnights (beginning and end).
 =back
 =item ev_periodic_again (loop, ev_periodic *)
 There are some other functions of possible interest. Described. Here. Now.
 =over 4
-=item ev_once (loop, int fd, int events, ev_tstamp timeout, callback)
+=item ev_once (loop, int fd, int events, ev_tstamp timeout, callback, arg)
 This function combines a simple timer and an I/O watcher, calls your
 callback on whichever event happens first and automatically stops both
 watchers. This is useful if you want to wait for a single event on an fd
 or timeout without having to allocate/configure/start/stop/free one or
 To embed libev, see L</EMBEDDING>, but in short, it's easiest to create two
 files, F<my_ev.h> and F<my_ev.c> that include the respective libev files:
    // my_ev.h
    #define EV_CB_DECLARE(type)   struct my_coro *cb;
-   #define EV_CB_INVOKE(watcher) switch_to ((watcher)->cb);
+   #define EV_CB_INVOKE(watcher) switch_to ((watcher)->cb)
    #include "../libev/ev.h"
    // my_ev.c
    #define EV_H "my_ev.h"
    #include "../libev/ev.c"
 The normal C API should work fine when used from C++: both ev.h and the
 libev sources can be compiled as C++. Therefore, code that uses the C API
 will work fine.
 Proper exception specifications might have to be added to callbacks passed
-to libev: exceptions may be thrown only from watcher callbacks, all
+to libev: exceptions may be thrown only from watcher callbacks, all other
-other callbacks (allocator, syserr, loop acquire/release and periodic
+callbacks (allocator, syserr, loop acquire/release and periodic reschedule
-reschedule callbacks) must not throw exceptions, and might need a C<throw
+callbacks) must not throw exceptions, and might need a C<noexcept>
-()> specification. If you have code that needs to be compiled as both C
+specification. If you have code that needs to be compiled as both C and
-and C++ you can use the C<EV_THROW> macro for this:
+C++ you can use the C<EV_NOEXCEPT> macro for this:
    static void
-   fatal_error (const char *msg) EV_THROW
+   fatal_error (const char *msg) EV_NOEXCEPT
    {
      perror (msg);
      abort ();
    }
    ev_vars.h
    ev_wrap.h
    ev_win32.c      required on win32 platforms only
-   ev_select.c     only when select backend is enabled (which is enabled by default)
+   ev_select.c     only when select backend is enabled
-   ev_poll.c       only when poll backend is enabled (disabled by default)
+   ev_poll.c       only when poll backend is enabled
-   ev_epoll.c      only when the epoll backend is enabled (disabled by default)
+   ev_epoll.c      only when the epoll backend is enabled
+   ev_linuxaio.c   only when the linux aio backend is enabled
-   ev_kqueue.c     only when the kqueue backend is enabled (disabled by default)
+   ev_kqueue.c     only when the kqueue backend is enabled
-   ev_port.c       only when the solaris port backend is enabled (disabled by default)
+   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.
 =head3 LIBEVENT COMPATIBILITY API
 If defined to be C<1>, libev will compile in support for the Linux
 C<epoll>(7) backend. Its availability will be detected at runtime,
 otherwise another method will be used as fallback. This is the preferred
 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. Due to it's currenbt limitations it has to be requested
+explicitly.  If undefined, it 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,
 structure (guaranteed by POSIX but not by ISO C for example), but it also
 assumes that the same (machine) code can be used to call any watcher
 callback: The watcher callbacks have different type signatures, but libev
 calls them using an C<ev_watcher *> internally.
+=item null pointers and integer zero are represented by 0 bytes
+Libev uses C<memset> to initialise structs and arrays to C<0> bytes, and
+relies on this setting pointers and integers to null.
 =item pointer accesses must be thread-atomic
 Accessing a pointer value must be atomic, it must both be readable and
 writable in one piece - this is the case on all current architectures.

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.434 by root, Tue May 6 13:24:39 2014 UTC vs. Revision 1.451 by root, Mon Jun 24 00:19:26 2019 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.434 by root, Tue May 6 13:24:39 2014 UTC vs.
Revision 1.451 by root, Mon Jun 24 00:19:26 2019 UTC