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

Comparing libev/ev.3 (file contents):
Revision 1.116 by root, Sun Jul 7 06:00:32 2019 UTC vs.
Revision 1.126 by root, Sat Jun 3 08:53:03 2023 UTC

-.\" Automatically generated by Pod::Man 4.11 (Pod::Simple 3.35)
+.\" Automatically generated by Pod::Man 4.14 (Pod::Simple 3.43)
 .\"
 .\" Standard preamble:
 .\" ========================================================================
 .de Sp \" Vertical space (when we can't use .PP)
 .if t .sp .5v
 .\}
 .rm #[ #] #H #V #F C
 .\" ========================================================================
 .\"
 .IX Title "LIBEV 3"
-.TH LIBEV 3 "2019-07-07" "libev-4.27" "libev - high performance full featured event loop"
+.TH LIBEV 3 "2023-05-15" "libev-4.33" "libev - high performance full featured event loop"
 .\" For nroff, turn off justification.  Always turn off hyphenation; it makes
 .\" way too many mistakes in technical documents.
 .if n .ad l
 .nh
 .SH "NAME"
 want to handle signals only in specific threads and want to avoid libev
 unblocking the signals.
 .Sp
 It's also required by \s-1POSIX\s0 in a threaded program, as libev calls
 \&\f(CW\*(C`sigprocmask\*(C'\fR, whose behaviour is officially unspecified.
+.ie n .IP """EVFLAG_NOTIMERFD""" 4
+.el .IP "\f(CWEVFLAG_NOTIMERFD\fR" 4
+.IX Item "EVFLAG_NOTIMERFD"
+When this flag is specified, the libev will avoid using a \f(CW\*(C`timerfd\*(C'\fR 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.
 .Sp
-This flag's behaviour will become the default in future versions of libev.
+The current implementation only tries to use a \f(CW\*(C`timerfd\*(C'\fR when the first
+\&\f(CW\*(C`ev_periodic\*(C'\fR watcher is started and falls back on other methods if it
+cannot be created, but this behaviour might change in the future.
 .ie n .IP """EVBACKEND_SELECT""  (value 1, portable select backend)" 4
 .el .IP "\f(CWEVBACKEND_SELECT\fR  (value 1, portable select backend)" 4
 .IX Item "EVBACKEND_SELECT (value 1, portable select backend)"
 This is your standard \fBselect\fR\|(2) backend. Not \fIcompletely\fR standard, as
 libev tries to roll its own fd_set with no limits on the number of fds,
 and is not embeddable, which would limit the usefulness of this backend
 immensely.
 .ie n .IP """EVBACKEND_PORT""    (value 32, Solaris 10)" 4
 .el .IP "\f(CWEVBACKEND_PORT\fR    (value 32, Solaris 10)" 4
 .IX Item "EVBACKEND_PORT (value 32, Solaris 10)"
-This uses the Solaris 10 event port mechanism. As with everything on Solaris,
+This uses the Solaris 10 event port mechanism. As with everything on
-it's really slow, but it still scales very well (O(active_fds)).
+Solaris, it's really slow, but it still scales very well (O(active_fds)).
 .Sp
 While this backend scales well, it requires one system call per active
 file descriptor per loop iteration. For small and medium numbers of file
 descriptors a \*(L"slow\*(R" \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR backend
 might perform better.
 \&   \- 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 (\f(CW\*(C`ev_TYPE_start (loop, watcher
 *)\*(C'\fR), and you can stop watching for events at any time by calling the
 corresponding stop function (\f(CW\*(C`ev_TYPE_stop (loop, watcher *)\*(C'\fR.
 .PP
 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 \f(CW\*(C`ev_TYPE_set\*(C'\fR macro.
+otherwise. Most specifically you must never reinitialise it or call its
+\&\f(CW\*(C`ev_TYPE_set\*(C'\fR macro.
 .PP
 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.
 .PP
 therefore a good idea to always call its \f(CW\*(C`ev_TYPE_stop\*(C'\fR function.
 .IP "bool ev_is_active (ev_TYPE *watcher)" 4
 .IX 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.
+.Sp
+Obviously, it is safe to call this on an active watcher, or actually any
+watcher that is initialised.
 .IP "bool ev_is_pending (ev_TYPE *watcher)" 4
 .IX 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
 is pending (but not active) you must not call an init function on it (but
 \&\f(CW\*(C`ev_TYPE_set\*(C'\fR is safe), you must not change its priority, and you must
 make sure the watcher is available to libev (e.g. you cannot \f(CW\*(C`free ()\*(C'\fR
 it).
+.Sp
+It is safe to call this on any watcher in any state as long as it is
+initialised.
 .IP "callback ev_cb (ev_TYPE *watcher)" 4
 .IX Item "callback ev_cb (ev_TYPE *watcher)"
 Returns the callback currently set on the watcher.
 .IP "ev_set_cb (ev_TYPE *watcher, callback)" 4
 .IX Item "ev_set_cb (ev_TYPE *watcher, callback)"
 from being executed (except for \f(CW\*(C`ev_idle\*(C'\fR watchers).
 .Sp
 If you need to suppress invocation when higher priority events are pending
 you need to look at \f(CW\*(C`ev_idle\*(C'\fR watchers, which provide this functionality.
 .Sp
-You \fImust not\fR change the priority of a watcher as long as it is active or
+You \fImust not\fR change the priority of a watcher as long as it is active
-pending.
+or pending. Reading the priority with \f(CW\*(C`ev_priority\*(C'\fR is fine in any state.
 .Sp
 Setting a priority outside the range of \f(CW\*(C`EV_MINPRI\*(C'\fR to \f(CW\*(C`EV_MAXPRI\*(C'\fR is
 fine, as long as you do not mind that the priority value you query might
 or might not have been clamped to the valid range.
 .Sp
 callback to be invoked, which can be accomplished with this function.
 .IP "ev_feed_event (loop, ev_TYPE *watcher, int revents)" 4
 .IX 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
+initialised but not necessarily started event watcher, though it can be
-not free the watcher as long as it has pending events.
+active). Obviously you must not free the watcher as long as it has pending
+events.
 .Sp
 Stopping the watcher, letting libev invoke it, or calling
 \&\f(CW\*(C`ev_clear_pending\*(C'\fR will clear the pending event, even if the watcher was
 not started in the first place.
 .Sp
 \&\f(CW\*(C`ev_TYPE_init\*(C'\fR again.
 .IP "started/running/active" 4
 .IX Item "started/running/active"
 Once a watcher has been started with a call to \f(CW\*(C`ev_TYPE_start\*(C'\fR it becomes
 property of the event loop, and is actively waiting for events. While in
-this state it cannot be accessed (except in a few documented ways), moved,
+this state it cannot be accessed (except in a few documented ways, such as
-freed or anything else \- the only legal thing is to keep a pointer to it,
+stoping it), moved, freed or anything else \- the only legal thing is to
-and call libev functions on it that are documented to work on active watchers.
+keep a pointer to it, and call libev functions on it that are documented
+to work on active watchers.
+.Sp
+As a rule of thumb, before accessing a member or calling any function on
+a watcher, it should be stopped (or freshly initialised). If that is not
+convenient, you can check the documentation for that function or member to
+see if it is safe to use on an active watcher.
 .IP "pending" 4
 .IX Item "pending"
 If a watcher is active and libev determines that an event it is interested
-in has occurred (such as a timer expiring), it will become pending. It will
+in has occurred (such as a timer expiring), it will become pending. It
-stay in this pending state until either it is stopped or its callback is
+will stay in this pending state until either it is explicitly stopped or
-about to be invoked, so it is not normally pending inside the watcher
+its callback is about to be invoked, so it is not normally pending inside
-callback.
+the watcher callback.
 .Sp
-The watcher might or might not be active while it is pending (for example,
+Generally, the watcher might or might not be active while it is pending
-an expired non-repeating timer can be pending but no longer active). If it
+(for example, an expired non-repeating timer can be pending but no longer
-is stopped, it can be freely accessed (e.g. by calling \f(CW\*(C`ev_TYPE_set\*(C'\fR),
+active). If it is pending but not active, it can be freely accessed (e.g.
-but it is still property of the event loop at this time, so cannot be
+by calling \f(CW\*(C`ev_TYPE_set\*(C'\fR), but it is still property of the event loop at
-moved, freed or reused. And if it is active the rules described in the
+this time, so cannot be moved, freed or reused. And if it is active the
-previous item still apply.
+rules described in the previous item still apply.
+.Sp
+Explicitly stopping a watcher will also clear the pending state
+unconditionally, so it is safe to stop a watcher and then free it.
 .Sp
 It is also possible to feed an event on a watcher that is not active (e.g.
 via \f(CW\*(C`ev_feed_event\*(C'\fR), in which case it becomes pending without being
 active.
 .IP "stopped" 4
 .IX Subsection "WATCHER PRIORITY MODELS"
 Many event loops support \fIwatcher priorities\fR, which are usually small
 integers that influence the ordering of event callback invocation
 between watchers in some way, all else being equal.
 .PP
-In libev, Watcher priorities can be set using \f(CW\*(C`ev_set_priority\*(C'\fR. See its
+In libev, watcher priorities can be set using \f(CW\*(C`ev_set_priority\*(C'\fR. See its
 description for the more technical details such as the actual priority
 range.
 .PP
 There are two common ways how these these priorities are being interpreted
 by event loops:
 .IX Header "WATCHER TYPES"
 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.
 .PP
-Members are additionally marked with either \fI[read\-only]\fR, meaning that,
+Most members are additionally marked with either \fI[read\-only]\fR, 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 \fI[read\-write]\fR, which
+the watcher is stopped to your hearts content), or \fI[read\-write]\fR, 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.
+.PP
+In any case, the documentation for each member will explain what the
+effects are, and if there are any additional access restrictions.
 .ie n .SS """ev_io"" \- is this file descriptor readable or writable?"
 .el .SS "\f(CWev_io\fP \- is this file descriptor readable or writable?"
 .IX Subsection "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
 .PD 0
 .IP "ev_io_set (ev_io *, int fd, int events)" 4
 .IX Item "ev_io_set (ev_io *, int fd, int events)"
 .PD
 Configures an \f(CW\*(C`ev_io\*(C'\fR watcher. The \f(CW\*(C`fd\*(C'\fR is the file descriptor to
-receive events for and \f(CW\*(C`events\*(C'\fR is either \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR or
+receive events for and \f(CW\*(C`events\*(C'\fR is either \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR, both
-\&\f(CW\*(C`EV_READ | EV_WRITE\*(C'\fR, to express the desire to receive the given events.
+\&\f(CW\*(C`EV_READ | EV_WRITE\*(C'\fR or \f(CW0\fR, to express the desire to receive the given
+events.
+.Sp
+Note that setting the \f(CW\*(C`events\*(C'\fR to \f(CW0\fR 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.
+.IP "ev_io_modify (ev_io *, int events)" 4
+.IX Item "ev_io_modify (ev_io *, int events)"
+Similar to \f(CW\*(C`ev_io_set\*(C'\fR, but only changes the requested events. Using this
+might be faster with some backends, as libev can assume that the \f(CW\*(C`fd\*(C'\fR
+still refers to the same underlying file description, something it cannot
+do when using \f(CW\*(C`ev_io_set\*(C'\fR.
-.IP "int fd [read\-only]" 4
+.IP "int fd [no\-modify]" 4
-.IX Item "int fd [read-only]"
+.IX Item "int fd [no-modify]"
-The file descriptor being watched.
+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
+\&\f(CW\*(C`ev_io_set\*(C'\fR for that.
-.IP "int events [read\-only]" 4
+.IP "int events [no\-modify]" 4
-.IX Item "int events [read-only]"
+.IX 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 \f(CW\*(C`EV_READ\*(C'\fR, use \f(CW\*(C`w\->events &
+EV_READ\*(C'\fR, and similarly for \f(CW\*(C`EV_WRITE\*(C'\fR.
+.Sp
+As with \f(CW\*(C`fd\*(C'\fR, you must not modify this member even when the watcher is
+stopped, always use \f(CW\*(C`ev_io_set\*(C'\fR or \f(CW\*(C`ev_io_modify\*(C'\fR for that.
 .PP
 \fIExamples\fR
 .IX Subsection "Examples"
 .PP
 Example: Call \f(CW\*(C`stdin_readable_cb\*(C'\fR when \s-1STDIN_FILENO\s0 has become, well
 .PP
 First, you need to associate some data with the event loop:
 .PP
 .Vb 6
 \&   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);
 \&   }
 .Ve
 .PP
 The callback for the \f(CW\*(C`ev_async\*(C'\fR watcher does nothing: the watcher is used
 solely to wake up the event loop so it takes notice of any new watchers
 gets automatically stopped and restarted when reconfiguring it with this
 method.
 .Sp
 For \f(CW\*(C`ev::embed\*(C'\fR watchers this method is called \f(CW\*(C`set_embed\*(C'\fR, to avoid
 clashing with the \f(CW\*(C`set (loop)\*(C'\fR method.
+.Sp
+For \f(CW\*(C`ev::io\*(C'\fR watchers there is an additional \f(CW\*(C`set\*(C'\fR method that acepts a
+new event mask only, and internally calls \f(CW\*(C`ev_io_modify\*(C'\fR.
 .IP "w\->start ()" 4
 .IX Item "w->start ()"
 Starts the watcher. Note that there is no \f(CW\*(C`loop\*(C'\fR argument, as the
 constructor already stores the event loop.
 .IP "w\->start ([arguments])" 4
 higher, as it simplifies linking (no need for \f(CW\*(C`\-lrt\*(C'\fR).
 .IP "\s-1EV_USE_NANOSLEEP\s0" 4
 .IX Item "EV_USE_NANOSLEEP"
 If defined to be \f(CW1\fR, libev will assume that \f(CW\*(C`nanosleep ()\*(C'\fR is available
 and will use it for delays. Otherwise it will use \f(CW\*(C`select ()\*(C'\fR.
+.IP "\s-1EV_USE_EVENTFD\s0" 4
+.IX Item "EV_USE_EVENTFD"
+If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is
+available and will probe for kernel support at runtime. This will improve
+\&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption.
+If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
+2.7 or newer, otherwise disabled.
+.IP "\s-1EV_USE_SIGNALFD\s0" 4
+.IX Item "EV_USE_SIGNALFD"
+If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`signalfd ()\*(C'\fR is
+available and will probe for kernel support at runtime. This enables
+the use of \s-1EVFLAG_SIGNALFD\s0 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.
+.IP "\s-1EV_USE_TIMERFD\s0" 4
+.IX Item "EV_USE_TIMERFD"
+If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`timerfd ()\*(C'\fR 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
+\&\f(CW\*(C`TFD_TIMER_CANCEL_ON_SET\*(C'\fR, otherwise disabled.
 .IP "\s-1EV_USE_EVENTFD\s0" 4
 .IX Item "EV_USE_EVENTFD"
 If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is
 available and will probe for kernel support at runtime. This will improve
 \&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption.

Diff Legend

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

Comparing libev/ev.3 (file contents): Revision 1.116 by root, Sun Jul 7 06:00:32 2019 UTC vs. Revision 1.126 by root, Sat Jun 3 08:53:03 2023 UTC

Diff Legend

Comparing libev/ev.3 (file contents):
Revision 1.116 by root, Sun Jul 7 06:00:32 2019 UTC vs.
Revision 1.126 by root, Sat Jun 3 08:53:03 2023 UTC