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

Comparing libev/ev.pod (file contents):
Revision 1.379 by root, Tue Jul 12 23:32:10 2011 UTC vs.
Revision 1.399 by root, Mon Apr 2 23:14:41 2012 UTC

 =item ev_tstamp ev_time ()
 Returns the current time as libev would use it. Please note that the
 C<ev_now> function is usually faster and also often returns the timestamp
 you actually want to know. Also interesting is the combination of
-C<ev_update_now> and C<ev_now>.
+C<ev_now_update> and C<ev_now>.
 =item ev_sleep (ev_tstamp interval)
 Sleep for the given interval: The current thread will be blocked
 until either it is interrupted or the given time interval has
 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 (but
+two event changes per incident. Support for C<fork ()> is very bad (you
-sane, unlike epoll) and it drops fds silently in similarly hard-to-detect
+might have to leak fd's on fork, but it's more sane than epoll) and it
-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
 without a previous call to C<ev_suspend>.
 Calling C<ev_suspend>/C<ev_resume> has the side effect of updating the
 event loop time (see C<ev_now_update>).
-=item ev_run (loop, int flags)
+=item bool ev_run (loop, int flags)
 Finally, this is it, the event handler. This function usually is called
 after you have initialised all your watchers and you want to start
 handling events. It will ask the operating system for any new events, call
-the watcher callbacks, an then repeat the whole process indefinitely: This
+the watcher callbacks, and then repeat the whole process indefinitely: This
 is why event loops are called I<loops>.
 If the flags argument is specified as C<0>, it will keep handling events
 until either no event watchers are active anymore or C<ev_break> was
 called.
+The return value is false if there are no more active watchers (which
+usually means "all jobs done" or "deadlock"), and true in all other cases
+(which usually means " you should call C<ev_run> again").
 Please note that an explicit C<ev_break> is usually better than
 relying on all watchers to be stopped when deciding when a program has
 finished (especially in interactive programs), but having a program
 that automatically loops as long as it has to and no longer by virtue
 of relying on its watchers stopping correctly, that is truly a thing of
 beauty.
-This function is also I<mostly> exception-safe - you can break out of
+This function is I<mostly> exception-safe - you can break out of a
-a C<ev_run> call by calling C<longjmp> in a callback, throwing a C++
+C<ev_run> call by calling C<longjmp> in a callback, throwing a C++
 exception and so on. This does not decrement the C<ev_depth> value, nor
 will it clear any outstanding C<EVBREAK_ONE> breaks.
 A flags value of C<EVRUN_NOWAIT> will look for new events, will handle
 those events and any already outstanding ones, but will not wait and
 can be done relatively simply by putting mutex_lock/unlock calls around
 each call to a libev function.
 However, C<ev_run> can run an indefinite time, so it is not feasible
 to wait for it to return. One way around this is to wake up the event
-loop via C<ev_break> and C<av_async_send>, another way is to set these
+loop via C<ev_break> and C<ev_async_send>, another way is to set these
 I<release> and I<acquire> callbacks on the loop.
 When set, then C<release> will be called just before the thread is
 suspended waiting for new events, and C<acquire> is called just
 afterwards.
 detecting time jumps is hard, and some inaccuracies are unavoidable (the
 monotonic clock option helps a lot here).
 The callback is guaranteed to be invoked only I<after> its timeout has
 passed (not I<at>, so on systems with very low-resolution clocks this
-might introduce a small delay). If multiple timers become ready during the
+might introduce a small delay, see "the special problem of being too
+early", below). If multiple timers become ready during the same loop
-same loop iteration then the ones with earlier time-out values are invoked
+iteration then the ones with earlier time-out values are invoked before
-before ones of the same priority with later time-out values (but this is
+ones of the same priority with later time-out values (but this is no
-no longer true when a callback calls C<ev_run> recursively).
+longer true when a callback calls C<ev_run> recursively).
 =head3 Be smart about timeouts
 Many real-world problems involve some kind of timeout, usually for error
 recovery. A typical example is an HTTP request - if the other side hangs,
 In this case, it would be more efficient to leave the C<ev_timer> alone,
 but remember the time of last activity, and check for a real timeout only
 within the callback:
+   ev_tstamp timeout = 60.;
    ev_tstamp last_activity; // time of last activity
+   ev_timer timer;
    static void
    callback (EV_P_ ev_timer *w, int revents)
    {
-     ev_tstamp now     = ev_now (EV_A);
+     // calculate when the timeout would happen
-     ev_tstamp timeout = last_activity + 60.;
+     ev_tstamp after = last_activity - ev_now (EV_A) + timeout;
-     // if last_activity + 60. is older than now, we did time out
+     // if negative, it means we the timeout already occured
-     if (timeout < now)
+     if (after < 0.)
        {
          // timeout occurred, take action
        }
      else
        {
-         // callback was invoked, but there was some activity, re-arm
+         // callback was invoked, but there was some recent
-         // the watcher to fire in last_activity + 60, which is
+         // activity. simply restart the timer to time out
-         // guaranteed to be in the future, so "again" is positive:
+         // after "after" seconds, which is the earliest time
-         w->repeat = timeout - now;
+         // the timeout can occur.
+         ev_timer_set (w, after, 0.);
-         ev_timer_again (EV_A_ w);
+         ev_timer_start (EV_A_ w);
        }
    }
-To summarise the callback: first calculate the real timeout (defined
+To summarise the callback: first calculate in how many seconds the
-as "60 seconds after the last activity"), then check if that time has
+timeout will occur (by calculating the absolute time when it would occur,
-been reached, which means something I<did>, in fact, time out. Otherwise
+C<last_activity + timeout>, and subtracting the current time, C<ev_now
-the callback was invoked too early (C<timeout> is in the future), so
+(EV_A)> from that).
-re-schedule the timer to fire at that future time, to see if maybe we have
-a timeout then.
-Note how C<ev_timer_again> is used, taking advantage of the
+If this value is negative, then we are already past the timeout, i.e. we
-C<ev_timer_again> optimisation when the timer is already running.
+timed out, and need to do whatever is needed in this case.
+Otherwise, we now the earliest time at which the timeout would trigger,
+and simply start the timer with this timeout value.
+In other words, each time the callback is invoked it will check whether
+the timeout cocured. If not, it will simply reschedule itself to check
+again at the earliest time it could time out. Rinse. Repeat.
 This scheme causes more callback invocations (about one every 60 seconds
 minus half the average time between activity), but virtually no calls to
 libev to change the timeout.
-To start the timer, simply initialise the watcher and set C<last_activity>
+To start the machinery, simply initialise the watcher and set
-to the current time (meaning we just have some activity :), then call the
+C<last_activity> to the current time (meaning there was some activity just
-callback, which will "do the right thing" and start the timer:
+now), then call the callback, which will "do the right thing" and start
+the timer:
+   last_activity = ev_now (EV_A);
-   ev_init (timer, callback);
+   ev_init (&timer, callback);
-   last_activity = ev_now (loop);
+   callback (EV_A_ &timer, 0);
-   callback (loop, timer, EV_TIMER);
-And when there is some activity, simply store the current time in
+When there is some activity, simply store the current time in
 C<last_activity>, no libev calls at all:
+   if (activity detected)
-   last_activity = ev_now (loop);
+     last_activity = ev_now (EV_A);
+When your timeout value changes, then the timeout can be changed by simply
+providing a new value, stopping the timer and calling the callback, which
+will agaion do the right thing (for example, time out immediately :).
+   timeout = new_value;
+   ev_timer_stop (EV_A_ &timer);
+   callback (EV_A_ &timer, 0);
 This technique is slightly more complex, but in most cases where the
 time-out is unlikely to be triggered, much more efficient.
-Changing the timeout is trivial as well (if it isn't hard-coded in the
-callback :) - just change the timeout and invoke the callback, which will
-fix things for you.
 =item 4. Wee, just use a double-linked list for your timeouts.
 If there is not one request, but many thousands (millions...), all
 employing some kind of timeout with the same timeout value, then one can
 Method #1 is almost always a bad idea, and buys you nothing. Method #4 is
 rather complicated, but extremely efficient, something that really pays
 off after the first million or so of active timers, i.e. it's usually
 overkill :)
+=head3 The special problem of being too early
+If you ask a timer to call your callback after three seconds, then
+you expect it to be invoked after three seconds - but of course, this
+cannot be guaranteed to infinite precision. Less obviously, it cannot be
+guaranteed to any precision by libev - imagine somebody suspending the
+process with a STOP signal for a few hours for example.
+So, libev tries to invoke your callback as soon as possible I<after> the
+delay has occurred, but cannot guarantee this.
+A less obvious failure mode is calling your callback too early: many event
+loops compare timestamps with a "elapsed delay >= requested delay", but
+this can cause your callback to be invoked much earlier than you would
+expect.
+To see why, imagine a system with a clock that only offers full second
+resolution (think windows if you can't come up with a broken enough OS
+yourself). If you schedule a one-second timer at the time 500.9, then the
+event loop will schedule your timeout to elapse at a system time of 500
+(500.9 truncated to the resolution) + 1, or 501.
+If an event library looks at the timeout 0.1s later, it will see "501 >=
+501" and invoke the callback 0.1s after it was started, even though a
+one-second delay was requested - this is being "too early", despite best
+intentions.
+This is the reason why libev will never invoke the callback if the elapsed
+delay equals the requested delay, but only when the elapsed delay is
+larger than the requested delay. In the example above, libev would only invoke
+the callback at system time 502, or 1.1s after the timer was started.
+So, while libev cannot guarantee that your callback will be invoked
+exactly when requested, it I<can> and I<does> guarantee that the requested
+delay has actually elapsed, or in other words, it always errs on the "too
+late" side of things.
 =head3 The special problem of time updates
-Establishing the current time is a costly operation (it usually takes at
+Establishing the current time is a costly operation (it usually takes
-least two system calls): EV therefore updates its idea of the current
+at least one system call): EV therefore updates its idea of the current
 time only before and after C<ev_run> collects new events, which causes a
 growing difference between C<ev_now ()> and C<ev_time ()> when handling
 lots of events in one iteration.
 The relative timeouts are calculated relative to the C<ev_now ()>
    ev_timer_set (&timer, after + ev_now () - ev_time (), 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
 ()>.
+=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
+jumps).
+Neither of these clocks is synchronised with each other or any other clock
+on the system, so C<ev_time ()> might return a considerably different time
+than C<gettimeofday ()> or C<time ()>. On a GNU/Linux system, for example,
+a call to C<gettimeofday> might return a second count that is one higher
+than a directly following call to C<time>.
+The moral of this is to only compare libev-related timestamps with
+C<ev_time ()> and C<ev_now ()>, at least if you want better precision than
+a second or so.
+One more problem arises due to this lack of synchronisation: if libev uses
+the system monotonic clock and you compare timestamps from C<ev_time>
+or C<ev_now> from when you started your timer and when your callback is
+invoked, you will find that sometimes the callback is a bit "early".
+This is because C<ev_timer>s work in real time, not wall clock time, so
+libev makes sure your callback is not invoked before the delay happened,
+I<measured according to the real time>, not the system clock.
+If your timeouts are based on a physical timescale (e.g. "time out this
+connection after 100 seconds") then this shouldn't bother you as it is
+exactly the right behaviour.
+If you want to compare wall clock/system timestamps to your timers, then
+you need to use C<ev_periodic>s, as these are based on the wall clock
+time, where your comparisons will always generate correct results.
 =head3 The special problems of suspended animation
 When you leave the server world it is quite customary to hit machines that
 can suspend/hibernate - what happens to the clocks during such a suspend?
 keep up with the timer (because it takes longer than those 10 seconds to
 do stuff) the timer will not fire more than once per event loop iteration.
 =item ev_timer_again (loop, ev_timer *)
-This will act as if the timer timed out and restarts it again if it is
+This will act as if the timer timed out, and restarts it again if it is
-repeating. The exact semantics are:
+repeating. It basically works like calling C<ev_timer_stop>, updating the
+timeout to the C<repeat> value and calling C<ev_timer_start>.
+The exact semantics are as in the following rules, all of which will be
+applied to the watcher:
+=over 4
-If the timer is pending, its pending status is cleared.
+=item If the timer is pending, the pending status is always cleared.
-If the timer is started but non-repeating, stop it (as if it timed out).
+=item If the timer is started but non-repeating, stop it (as if it timed
+out, without invoking it).
-If the timer is repeating, either start it if necessary (with the
+=item If the timer is repeating, make the C<repeat> value the new timeout
-C<repeat> value), or reset the running timer to the C<repeat> value.
+and start the timer, if necessary.
+=back
 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 *)
    ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);
 =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.
+the given events.
 =item ev_feed_signal_event (loop, int signum)
 Feed an event as if the given signal occurred. See also C<ev_feed_signal>,
 which is async-safe.
    {
      struct my_biggy big = (struct my_biggy *)
        (((char *)w) - offsetof (struct my_biggy, t2));
    }
+=head2 AVOIDING FINISHING BEFORE RETURNING
+Often you have structures like this in event-based programs:
+  callback ()
+  {
+    free (request);
+  }
+  request = start_new_request (..., callback);
+The intent is to start some "lengthy" operation. The C<request> could be
+used to cancel the operation, or do other things with it.
+It's not uncommon to have code paths in C<start_new_request> that
+immediately invoke the callback, for example, to report errors. Or you add
+some caching layer that finds that it can skip the lengthy aspects of the
+operation and simply invoke the callback with the result.
+The problem here is that this will happen I<before> C<start_new_request>
+has returned, so C<request> is not set.
+Even if you pass the request by some safer means to the callback, you
+might want to do something to the request after starting it, such as
+canceling it, which probably isn't working so well when the callback has
+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
+for example, or more sneakily, by reusing an existing (stopped) watcher
+and 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
+invoked, while not delaying callback invocation too much.
 =head2 MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS
 Often (especially in GUI toolkits) there are places where you have
 I<modal> interaction, which is most easily implemented by recursively
 invoking C<ev_run>.
    int exit_main_loop = 0;
    while (!exit_main_loop)
      ev_run (EV_DEFAULT_ EVRUN_ONCE);
-   // in a model watcher
+   // in a modal watcher
    int exit_nested_loop = 0;
    while (!exit_nested_loop)
      ev_run (EV_A_ EVRUN_ONCE);
      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
-this or any other coroutine. I am sure if you sue this your own :)
+this or any other coroutine.
 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.
 with C<operator ()> can be used as callbacks. Other types should be easy
 to add as long as they only need one additional pointer for context. If
 you need support for other types of functors please contact the author
 (preferably after implementing it).
+For all this to work, your C++ compiler either has to use the same calling
+conventions as your C compiler (for static member functions), or you have
+to embed libev and compile libev itself as C++.
 Here is a list of things available in the C<ev> namespace:
 =over 4
 =item C<ev::READ>, C<ev::WRITE> etc.
 =item C<ev::io>, C<ev::timer>, C<ev::periodic>, C<ev::idle>, C<ev::sig> etc.
 For each C<ev_TYPE> watcher in F<ev.h> there is a corresponding class of
 the same name in the C<ev> namespace, with the exception of C<ev_signal>
 which is called C<ev::sig> to avoid clashes with the C<signal> macro
-defines by many implementations.
+defined by many implementations.
 All of those classes have these methods:
 =over 4
 suitable for use with C<EV_A>.
 =item C<EV_DEFAULT>, C<EV_DEFAULT_>
 Similar to the other two macros, this gives you the value of the default
-loop, if multiple loops are supported ("ev loop default").
+loop, if multiple loops are supported ("ev loop default"). The default loop
+will be initialised if it isn't already initialised.
+For non-multiplicity builds, these macros do nothing, so you always have
+to initialise the loop somewhere.
 =item C<EV_DEFAULT_UC>, C<EV_DEFAULT_UC_>
 Usage identical to C<EV_DEFAULT> and C<EV_DEFAULT_>, but requires that the
 default loop has been initialised (C<UC> == unchecked). Their behaviour
 If defined to be C<1>, libev will compile in support for the Linux inotify
 interface to speed up C<ev_stat> watchers. Its actual availability will
 be detected at runtime. If undefined, it will be enabled if the headers
 indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
+=item EV_NO_SMP
+If defined to be C<1>, libev will assume that memory is always coherent
+between threads, that is, threads can be used, but threads never run on
+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
+from different threads, which is a stronger 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
 contexts. No such type is easily found in the C language, so you can
 will have the C<struct ev_loop *> as first argument, and you can create
 additional independent event loops. Otherwise there will be no support
 for multiple event loops and there is no first event loop pointer
 argument. Instead, all functions act on the single default loop.
+Note that C<EV_DEFAULT> and C<EV_DEFAULT_> will no longer provide a
+default loop when multiplicity is switched off - you always have to
+initialise the loop manually in this case.
 =item EV_MINPRI
 =item EV_MAXPRI
 The range of allowed priorities. C<EV_MINPRI> must be smaller or equal to
 With an intelligent-enough linker (gcc+binutils are intelligent enough
 when you use C<-Wl,--gc-sections -ffunction-sections>) functions unused by
 your program might be left out as well - a binary starting a timer and an
 I/O watcher then might come out at only 5Kb.
+=item EV_API_STATIC
+If this symbol is defined (by default it is not), then all identifiers
+will have static linkage. This means that libev will not export any
+identifiers, and you cannot link against libev anymore. This can be useful
+when you embed libev, only want to use libev functions in a single file,
+and do not want its identifiers to be visible.
+To use this, define C<EV_API_STATIC> and include F<ev.c> in the file that
+wants to use libev.
+This option only works when libev is compiled with a C compiler, as C++
+doesn't support the required declaration syntax.
 =item EV_AVOID_STDIO
 If this is set to C<1> at compiletime, then libev will avoid using stdio
 functions (printf, scanf, perror etc.). This will increase the code size
 good enough for at least into the year 4000 with millisecond accuracy
 (the design goal for libev). This requirement is overfulfilled by
 implementations using IEEE 754, which is basically all existing ones.
 With IEEE 754 doubles, you get microsecond accuracy until at least the
-year 2255 (and millisecond accuray till the year 287396 - by then, libev
+year 2255 (and millisecond accuracy till the year 287396 - by then, libev
 is either obsolete or somebody patched it to use C<long double> or
 something like that, just kidding).
 =back

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.379 by root, Tue Jul 12 23:32:10 2011 UTC vs. Revision 1.399 by root, Mon Apr 2 23:14:41 2012 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.379 by root, Tue Jul 12 23:32:10 2011 UTC vs.
Revision 1.399 by root, Mon Apr 2 23:14:41 2012 UTC