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

Comparing libev/ev.pod (file contents):
Revision 1.405 by root, Thu May 3 15:07:15 2012 UTC vs.
Revision 1.444 by root, Mon Oct 29 00:00:22 2018 UTC

+=encoding utf-8
 =head1 NAME
 libev - a high performance full-featured event loop written in C
 =head1 SYNOPSIS
 =head1 WHAT TO READ WHEN IN A HURRY
 This manual tries to be very detailed, but unfortunately, this also makes
 it very long. If you just want to know the basics of libev, I suggest
-reading L<ANATOMY OF A WATCHER>, then the L<EXAMPLE PROGRAM> above and
+reading L</ANATOMY OF A WATCHER>, then the L</EXAMPLE PROGRAM> above and
-look up the missing functions in L<GLOBAL FUNCTIONS> and the C<ev_io> and
+look up the missing functions in L</GLOBAL FUNCTIONS> and the C<ev_io> and
-C<ev_timer> sections in L<WATCHER TYPES>.
+C<ev_timer> sections in L</WATCHER TYPES>.
 =head1 ABOUT LIBEV
 Libev is an event loop: you register interest in certain events (such as a
 file descriptor being readable or a timeout occurring), and it will manage
 If this flag bit is or'ed into the flag value (or the program runs setuid
 or setgid) then libev will I<not> look at the environment variable
 C<LIBEV_FLAGS>. Otherwise (the default), this environment variable will
 override the flags completely if it is found in the environment. This is
-useful to try out specific backends to test their performance, or to work
+useful to try out specific backends to test their performance, to work
-around bugs.
+around bugs, or to make libev threadsafe (accessing environment variables
+cannot be done in a threadsafe way, but usually it works if no other
+thread modifies them).
 =item C<EVFLAG_FORKCHECK>
 Instead of calling C<ev_loop_fork> manually after a fork, you can also
 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>
 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
-drops fds silently in similarly hard-to-detect cases
+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
 everywhere, so you might need to test for this. And since it is broken
 If you need dynamically allocated loops it is better to use C<ev_loop_new>
 and C<ev_loop_destroy>.
 =item ev_loop_fork (loop)
-This function sets a flag that causes subsequent C<ev_run> iterations to
+This function sets a flag that causes subsequent C<ev_run> iterations
-reinitialise the kernel state for backends that have one. Despite the
+to reinitialise the kernel state for backends that have one. Despite
-name, you can call it anytime, but it makes most sense after forking, in
+the name, you can call it anytime you are allowed to start or stop
-the child process. You I<must> call it (or use C<EVFLAG_FORKCHECK>) in the
+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
-child before resuming or calling C<ev_run>.
+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.
 On the other hand, you only need to call this function in the child
 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 L<The special problem of time updates> in the C<ev_timer> section.
+See also L</The special problem of time updates> in the C<ev_timer> section.
 =item ev_suspend (loop)
 =item ev_resume (loop)
 =item callback ev_cb (ev_TYPE *watcher)
 Returns the callback currently set on the watcher.
-=item ev_cb_set (ev_TYPE *watcher, callback)
+=item ev_set_cb (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, int priority)
 or might not have been clamped to the valid range.
 The default priority used by watchers when no priority has been set is
 always C<0>, which is supposed to not be too high and not be too low :).
-See L<WATCHER PRIORITY MODELS>, below, for a more thorough treatment of
+See L</WATCHER PRIORITY MODELS>, below, for a more thorough treatment of
 priorities.
 =item ev_invoke (loop, ev_TYPE *watcher, int revents)
 Invoke the C<watcher> with the given C<loop> and C<revents>. Neither
 See also C<ev_feed_fd_event> and C<ev_feed_signal_event> for related
 functions that do not need a watcher.
 =back
-See also the L<ASSOCIATING CUSTOM DATA WITH A WATCHER> and L<BUILDING YOUR
+See also the L</ASSOCIATING CUSTOM DATA WITH A WATCHER> and L</BUILDING YOUR
 OWN COMPOSITE WATCHERS> idioms.
 =head2 WATCHER STATES
 There are various watcher states mentioned throughout this manual -
 transition between them will be described in more detail - and while these
 rules might look complicated, they usually do "the right thing".
 =over 4
-=item initialiased
+=item initialised
 Before a watcher can be registered with the event loop it has to be
 initialised. This can be done with a call to C<ev_TYPE_init>, or calls to
 C<ev_init> followed by the watcher-specific C<ev_TYPE_set> function.
 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 on the current time, use something like this to adjust for this:
+timeout on the current time, use something like the following to adjust
+for it:
-   ev_timer_set (&timer, after + ev_now () - ev_time (), 0.);
+   ev_timer_set (&timer, after + (ev_time () - ev_now ()), 0.);
 If the event loop is suspended for a long time, you can also force an
 update of the time returned by C<ev_now ()> by calling C<ev_now_update
-()>.
+()>, although that will push the event time of all outstanding events
+further into the future.
 =head3 The special problem of unsynchronised clocks
 Modern systems have a variety of clocks - libev itself uses the normal
 "wall clock" clock and, if available, the monotonic clock (to avoid time
 =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
 =item If the timer is repeating, make the C<repeat> value the new timeout
 and start the timer, if necessary.
 =back
-This sounds a bit complicated, see L<Be smart about timeouts>, above, for a
+This sounds a bit complicated, see L</Be smart about timeouts>, above, for a
 usage example.
 =item ev_tstamp ev_timer_remaining (loop, ev_timer *)
 Returns the remaining time until a timer fires. If the timer is active,
 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 *)
    ev_periodic hourly_tick;
    ev_periodic_init (&hourly_tick, clock_cb,
                      fmod (ev_now (loop), 3600.), 3600., 0);
    ev_periodic_start (loop, &hourly_tick);
 =head2 C<ev_signal> - signal me when a signal gets signalled!
 Signal watchers will trigger an event when the process receives a specific
 signal one or more times. Even though signals are very asynchronous, libev
 only within the same loop, i.e. you can watch for C<SIGINT> in your
 default loop and for C<SIGIO> in another loop, but you cannot watch for
 C<SIGINT> in both the default loop and another loop at the same time. At
 the moment, C<SIGCHLD> is permanently tied to the default loop.
-When the first watcher gets started will libev actually register something
+Only after the first watcher for a signal is started will libev actually
-with the kernel (thus it coexists with your own signal handlers as long as
+register something with the kernel. It thus coexists with your own signal
-you don't register any with libev for the same signal).
+handlers as long as you don't register any with libev for the same signal.
 If possible and supported, libev will install its handlers with
 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
 =head2 C<ev_stat> - did the file attributes just change?
 This watches a file system path for attribute changes. That is, it calls
 C<stat> on that path in regular intervals (or when the OS says it changed)
-and sees if it changed compared to the last time, invoking the callback if
+and sees if it changed compared to the last time, invoking the callback
-it did.
+if it did. Starting the watcher C<stat>'s the file, so only changes that
+happen after the watcher has been started will be reported.
 The path does not need to exist: changing from "path exists" to "path does
 not exist" is a status change like any other. The condition "path does not
 exist" (or more correctly "path cannot be stat'ed") is signified by the
 C<st_nlink> field being zero (which is otherwise always forced to be at
 Apart from keeping your process non-blocking (which is a useful
 effect on its own sometimes), idle watchers are a good place to do
 "pseudo-background processing", or delay processing stuff to after the
 event loop has handled all outstanding events.
+=head3 Abusing an C<ev_idle> watcher for its side-effect
+As long as there is at least one active idle watcher, libev will never
+sleep unnecessarily. Or in other words, it will loop as fast as possible.
+For this to work, the idle watcher doesn't need to be invoked at all - the
+lowest priority will do.
+This mode of operation can be useful together with an C<ev_check> watcher,
+to do something on each event loop iteration - for example to balance load
+between different connections.
+See L</Abusing an ev_check watcher for its side-effect> for a longer
+example.
 =head3 Watcher-Specific Functions and Data Members
 =over 4
 =item ev_idle_init (ev_idle *, callback)
 callback, free it. Also, use no error checking, as usual.
    static void
    idle_cb (struct ev_loop *loop, ev_idle *w, int revents)
    {
+     // stop the watcher
+     ev_idle_stop (loop, w);
+     // now we can free it
      free (w);
      // now do something you wanted to do when the program has
      // no longer anything immediate to do.
    }
    ev_idle *idle_watcher = malloc (sizeof (ev_idle));
    ev_idle_start (loop, idle_watcher);
 =head2 C<ev_prepare> and C<ev_check> - customise your event loop!
-Prepare and check watchers are usually (but not always) used in pairs:
+Prepare and check watchers are often (but not always) used in pairs:
 prepare watchers get invoked before the process blocks and check watchers
 afterwards.
-You I<must not> call C<ev_run> or similar functions that enter
+You I<must not> call C<ev_run> (or similar functions that enter the
-the current event loop from either C<ev_prepare> or C<ev_check>
+current event loop) or C<ev_loop_fork> from either C<ev_prepare> or
-watchers. Other loops than the current one are fine, however. The
+C<ev_check> watchers. Other loops than the current one are fine,
-rationale behind this is that you do not need to check for recursion in
+however. The rationale behind this is that you do not need to check
-those watchers, i.e. the sequence will always be C<ev_prepare>, blocking,
+for recursion in those watchers, i.e. the sequence will always be
-C<ev_check> so if you have one watcher of each kind they will always be
+C<ev_prepare>, blocking, C<ev_check> so if you have one watcher of each
-called in pairs bracketing the blocking call.
+kind they will always be called in pairs bracketing the blocking call.
 Their main purpose is to integrate other event mechanisms into libev and
 their use is somewhat advanced. They could be used, for example, to track
 variable changes, implement your own watchers, integrate net-snmp or a
 coroutine library and lots more. They are also occasionally useful if
 with priority higher than or equal to the event loop and one coroutine
 of lower priority, but only once, using idle watchers to keep the event
 loop from blocking if lower-priority coroutines are active, thus mapping
 low-priority coroutines to idle/background tasks).
-It is recommended to give C<ev_check> watchers highest (C<EV_MAXPRI>)
+When used for this purpose, it is recommended to give C<ev_check> watchers
-priority, to ensure that they are being run before any other watchers
+highest (C<EV_MAXPRI>) priority, to ensure that they are being run before
-after the poll (this doesn't matter for C<ev_prepare> watchers).
+any other watchers after the poll (this doesn't matter for C<ev_prepare>
+watchers).
 Also, C<ev_check> watchers (and C<ev_prepare> watchers, too) should not
 activate ("feed") events into libev. While libev fully supports this, they
 might get executed before other C<ev_check> watchers did their job. As
 C<ev_check> watchers are often used to embed other (non-libev) event
 loops those other event loops might be in an unusable state until their
 C<ev_check> watcher ran (always remind yourself to coexist peacefully with
 others).
+=head3 Abusing an C<ev_check> watcher for its side-effect
+C<ev_check> (and less often also C<ev_prepare>) watchers can also be
+useful because they are called once per event loop iteration. For
+example, if you want to handle a large number of connections fairly, you
+normally only do a bit of work for each active connection, and if there
+is more work to do, you wait for the next event loop iteration, so other
+connections have a chance of making progress.
+Using an C<ev_check> watcher is almost enough: it will be called on the
+next event loop iteration. However, that isn't as soon as possible -
+without external events, your C<ev_check> watcher will not be invoked.
+This is where C<ev_idle> watchers come in handy - all you need is a
+single global idle watcher that is active as long as you have one active
+C<ev_check> watcher. The C<ev_idle> watcher makes sure the event loop
+will not sleep, and the C<ev_check> watcher makes sure a callback gets
+invoked. Neither watcher alone can do that.
 =head3 Watcher-Specific Functions and Data Members
 =over 4
 =over 4
 =item ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)
-=item ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)
+=item ev_embed_set (ev_embed *, struct ev_loop *embedded_loop)
 Configures the watcher to embed the given loop, which must be
 embeddable. If the callback is C<0>, then C<ev_embed_sweep> will be
 invoked automatically, otherwise it is the responsibility of the callback
 to invoke it (it will continue to be called until the sweep has been done,
 used).
    struct ev_loop *loop_hi = ev_default_init (0);
    struct ev_loop *loop_lo = 0;
    ev_embed embed;
    // see if there is a chance of getting one that works
    // (remember that a flags value of 0 means autodetection)
    loop_lo = ev_embeddable_backends () & ev_recommended_backends ()
      ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ())
      : 0;
 C<loop_socket>. (One might optionally use C<EVFLAG_NOENV>, too).
    struct ev_loop *loop = ev_default_init (0);
    struct ev_loop *loop_socket = 0;
    ev_embed embed;
    if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE)
      if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE))
        {
          ev_embed_init (&embed, 0, loop_socket);
          ev_embed_start (loop, &embed);
 =head2 C<ev_fork> - the audacity to resume the event loop after a fork
 Fork watchers are called when a C<fork ()> was detected (usually because
 whoever is a good citizen cared to tell libev about it by calling
-C<ev_default_fork> or C<ev_loop_fork>). The invocation is done before the
+C<ev_loop_fork>). The invocation is done before the event loop blocks next
-event loop blocks next and before C<ev_check> watchers are being called,
+and before C<ev_check> watchers are being called, and only in the child
-and only in the child after the fork. If whoever good citizen calling
+after the fork. If whoever good citizen calling C<ev_default_fork> cheats
-C<ev_default_fork> cheats and calls it in the wrong process, the fork
+and calls it in the wrong process, the fork handlers will be invoked, too,
-handlers will be invoked, too, of course.
+of course.
 =head3 The special problem of life after fork - how is it possible?
-Most uses of C<fork()> consist of forking, then some simple calls to set
+Most uses of C<fork ()> consist of forking, then some simple calls to set
 up/change the process environment, followed by a call to C<exec()>. This
 sequence should be handled by libev without any problems.
 This changes when the application actually wants to do event handling
 in the child, or both parent in child, in effect "continuing" after the
 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
 already been invoked.
 A common way around all these issues is to make sure that
 C<start_new_request> I<always> returns before the callback is invoked. If
 C<start_new_request> immediately knows the result, it can artificially
-delay invoking the callback by e.g. using a C<prepare> or C<idle> watcher
+delay invoking the callback by using a C<prepare> or C<idle> watcher for
-for example, or more sneakily, by reusing an existing (stopped) watcher
+example, or more sneakily, by reusing an existing (stopped) watcher and
-and pushing it into the pending queue:
+pushing it into the pending queue:
    ev_set_cb (watcher, callback);
    ev_feed_event (EV_A_ watcher, 0);
 This way, C<start_new_request> can safely return before the callback is
 This brings the problem of exiting - a callback might want to finish the
 main C<ev_run> call, but not the nested one (e.g. user clicked "Quit", but
 a modal "Are you sure?" dialog is still waiting), or just the nested one
 and not the main one (e.g. user clocked "Ok" in a modal dialog), or some
-other combination: In these cases, C<ev_break> will not work alone.
+other combination: In these cases, a simple C<ev_break> will not work.
 The solution is to maintain "break this loop" variable for each C<ev_run>
 invocation, and use a loop around C<ev_run> until the condition is
 triggered, using C<EVRUN_ONCE>:
 called):
    void
    wait_for_event (ev_watcher *w)
    {
-     ev_cb_set (w) = current_coro;
+     ev_set_cb (w, current_coro);
      switch_to (libev_coro);
    }
 That basically suspends the coroutine inside C<wait_for_event> and
 continues the libev coroutine, which, when appropriate, switches back to
 You can do similar tricks if you have, say, threads with an event queue -
 instead of storing a coroutine, you store the queue object and instead of
 switching to a coroutine, you push the watcher onto the queue and notify
 any waiters.
-To embed libev, see L<EMBEDDING>, but in short, it's easiest to create two
+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"
 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
-other callbacks (allocator, syserr, loop acquire/release and periodioc
+other callbacks (allocator, syserr, loop acquire/release and periodic
 reschedule callbacks) must not throw exceptions, and might need a C<throw
 ()> specification. If you have code that needs to be compiled as both C
 and C++ you can use the C<EV_THROW> macro for this:
    static void
 Libev comes with some simplistic wrapper classes for C++ that mainly allow
 you to use some convenience methods to start/stop watchers and also change
 the callback model to a model using method callbacks on objects.
 To use it,
    #include <ev++.h>
 This automatically includes F<ev.h> and puts all of its definitions (many
 of them macros) into the global namespace. All C++ specific things are
 put into the C<ev> namespace. It should support all the same embedding
      void operator() (ev::io &w, int revents)
      {
        ...
      }
    }
    myfunctor f;
    ev::io w;
    w.set (&f);
 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])
-Basically the same as C<ev_TYPE_set>, with the same arguments. Either this
+Basically the same as C<ev_TYPE_set> (except for C<ev::embed> watchers>),
-method or a suitable start method must be called at least once. Unlike the
+with the same arguments. Either this method or a suitable start method
-C counterpart, an active watcher gets automatically stopped and restarted
+must be called at least once. Unlike the C counterpart, an active watcher
-when reconfiguring it with this method.
+gets automatically stopped and restarted when reconfiguring it with this
+method.
+For C<ev::embed> watchers this method is called C<set_embed>, to avoid
+clashing with the C<set (loop)> method.
 =item w->start ()
 Starts the watcher. Note that there is no C<loop> argument, as the
 constructor already stores the event loop.
 Brian Maher has written a partial interface to libev for lua (at the
 time of this writing, only C<ev_io> and C<ev_timer>), to be found at
 L<http://github.com/brimworks/lua-ev>.
+=item Javascript
+Node.js (L<http://nodejs.org>) uses libev as the underlying event library.
+=item Others
+There are others, and I stopped counting.
 =back
 =head1 MACRO MAGIC
    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_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 programs implement their own fd to handle mapping on win32, then this
 macro can be used to override the C<close> function, useful to unregister
 file descriptors again. Note that the replacement function has to close
 the underlying OS handle.
+=item EV_USE_WSASOCKET
+If defined to be C<1>, libev will use C<WSASocket> to create its internal
+communication socket, which works better in some environments. Otherwise,
+the normal C<socket> function will be used, which works better in other
+environments.
 =item EV_USE_POLL
 If defined to be C<1>, libev will compile in support for the C<poll>(2)
 backend. Otherwise it will be enabled on non-win32 platforms. It
 different cpus (or different cpu cores). This reduces dependencies
 and makes libev faster.
 =item EV_NO_THREADS
-If defined to be C<1>, libev will assume that it will never be called
+If defined to be C<1>, libev will assume that it will never be called from
-from different threads, which is a stronger assumption than C<EV_NO_SMP>,
+different threads (that includes signal handlers), which is a stronger
-above. This reduces dependencies and makes libev faster.
+assumption than C<EV_NO_SMP>, above. This reduces dependencies and makes
+libev faster.
 =item EV_ATOMIC_T
 Libev requires an integer type (suitable for storing C<0> or C<1>) whose
-access is atomic and serialised with respect to other threads or signal
+access is atomic with respect to other threads or signal contexts. No
-contexts. No such type is easily found in the C language, so you can
+such type is easily found in the C language, so you can provide your own
-provide your own type that you know is safe for your purposes. It is used
+type that you know is safe for your purposes. It is used both for signal
-both for signal handler "locking" as well as for signal and thread safety
+handler "locking" as well as for signal and thread safety in C<ev_async>
-in C<ev_async> watchers.
+watchers.
 In the absence of this define, libev will use C<sig_atomic_t volatile>
-(from F<signal.h>), which is usually good enough on most platforms,
+(from F<signal.h>), which is usually good enough on most platforms.
-although strictly speaking using a type that also implies a memory fence
-is required.
 =item EV_H (h)
 The name of the F<ev.h> header file used to include it. The default if
 undefined is C<"ev.h"> in F<event.h>, F<ev.c> and F<ev++.h>. This can be
 default loop and triggering an C<ev_async> watcher from the default loop
 watcher callback into the event loop interested in the signal.
 =back
-See also L<THREAD LOCKING EXAMPLE>.
+See also L</THREAD LOCKING EXAMPLE>.
 =head3 COROUTINES
 Libev is very accommodating to coroutines ("cooperative threads"):
 libev fully supports nesting calls to its functions from different
 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.
 thread" or will block signals process-wide, both behaviours would
 be compatible with libev. Interaction between C<sigprocmask> and
 C<pthread_sigmask> could complicate things, however.
 The most portable way to handle signals is to block signals in all threads
-except the initial one, and run the default loop in the initial thread as
+except the initial one, and run the signal handling loop in the initial
-well.
+thread as well.
 =item C<long> must be large enough for common memory allocation sizes
 To improve portability and simplify its API, libev uses C<long> internally
 instead of C<size_t> when allocating its data structures. On non-POSIX
 =over 4
 =item C<EV_COMPAT3> backwards compatibility mechanism
 The backward compatibility mechanism can be controlled by
-C<EV_COMPAT3>. See L<PREPROCESSOR SYMBOLS/MACROS> in the L<EMBEDDING>
+C<EV_COMPAT3>. See L</"PREPROCESSOR SYMBOLS/MACROS"> in the L</EMBEDDING>
 section.
 =item C<ev_default_destroy> and C<ev_default_fork> have been removed
 These calls can be replaced easily by their C<ev_loop_xxx> counterparts:
 =over 4
 =item active
 A watcher is active as long as it has been started and not yet stopped.
-See L<WATCHER STATES> for details.
+See L</WATCHER STATES> for details.
 =item application
 In this document, an application is whatever is using libev.
 watchers and events.
 =item pending
 A watcher is pending as soon as the corresponding event has been
-detected. See L<WATCHER STATES> for details.
+detected. See L</WATCHER STATES> for details.
 =item real time
 The physical time that is observed. It is apparently strictly monotonic :)

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.405 by root, Thu May 3 15:07:15 2012 UTC vs. Revision 1.444 by root, Mon Oct 29 00:00:22 2018 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.405 by root, Thu May 3 15:07:15 2012 UTC vs.
Revision 1.444 by root, Mon Oct 29 00:00:22 2018 UTC