=item ev_tstamp ev_time ()
-Returns the current time as libev would use it.
+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.
=item int ev_version_major ()
constructs, but the C<prepare> and C<check> watchers provide a better and
more generic mechanism.
+Here are the gory details of what ev_loop does:
+
+ 1. If there are no active watchers (reference count is zero), return.
+ 2. Queue and immediately call all prepare watchers.
+ 3. If we have been forked, recreate the kernel state.
+ 4. Update the kernel state with all outstanding changes.
+ 5. Update the "event loop time".
+ 6. Calculate for how long to block.
+ 7. Block the process, waiting for events.
+ 8. Update the "event loop time" and do time jump handling.
+ 9. Queue all outstanding timers.
+ 10. Queue all outstanding periodics.
+ 11. If no events are pending now, queue all idle watchers.
+ 12. Queue all check watchers.
+ 13. Call all queued watchers in reverse order (i.e. check watchers first).
+ 14. If ev_unloop has been called or EVLOOP_ONESHOT or EVLOOP_NONBLOCK
+ was used, return, otherwise continue with step #1.
+
=item ev_unloop (loop, how)
Can be used to make a call to C<ev_loop> return early (but only after it
has processed all outstanding events). The C<how> argument must be either
-C<EVUNLOOP_ONCE>, which will make the innermost C<ev_loop> call return, or
+C<EVUNLOOP_ONE>, which will make the innermost C<ev_loop> call return, or
C<EVUNLOOP_ALL>, which will make all nested C<ev_loop> calls return.
=item ev_ref (loop)
condition persists. Remember you can stop the watcher if you don't want to
act on the event and neither want to receive future events).
-In general you can register as many read and/or write event watchers oer
+In general you can register as many read and/or write event watchers per
fd as you want (as long as you don't confuse yourself). Setting all file
descriptors to non-blocking mode is also usually a good idea (but not
required if you know what you are doing).
You have to be careful with dup'ed file descriptors, though. Some backends
(the linux epoll backend is a notable example) cannot handle dup'ed file
descriptors correctly if you register interest in two or more fds pointing
-to the same file/socket etc. description.
+to the same underlying file/socket etc. description (that is, they share
+the same underlying "file open").
If you must do this, then force the use of a known-to-be-good backend
(at the time of this writing, this includes only EVMETHOD_SELECT and
given time, and optionally repeating in regular intervals after that.
The timers are based on real time, that is, if you register an event that
-times out after an hour and youreset your system clock to last years
+times out after an hour and you reset your system clock to last years
time, it will still time out after (roughly) and hour. "Roughly" because
-detecting time jumps is hard, and soem inaccuracies are unavoidable (the
+detecting time jumps is hard, and some inaccuracies are unavoidable (the
monotonic clock option helps a lot here).
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 *need* to base the timeout
-ion the current time, use something like this to adjust for this:
+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:
ev_timer_set (&timer, after + ev_now () - ev_time (), 0.);
+The callback is guarenteed to be invoked only when its timeout has passed,
+but if multiple timers become ready during the same loop iteration then
+order of execution is undefined.
+
=over 4
=item ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)
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 trigger at
exactly 10 second intervals. If, however, your program cannot keep up with
-the timer (ecause it takes longer than those 10 seconds to do stuff) the
+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)
They can also be used to implement vastly more complex timers, such as
triggering an event on eahc midnight, local time.
+As with timers, the callback is guarenteed to be invoked only when the
+time (C<at>) has been passed, but if multiple periodic timers become ready
+during the same loop iteration then order of execution is undefined.
+
=over 4
=item ev_periodic_init (ev_periodic *, callback, ev_tstamp at, ev_tstamp interval, reschedule_cb)
Lots of arguments, lets sort it out... There are basically three modes of
operation, and we will explain them from simplest to complex:
-
=over 4
=item * absolute timer (interval = reschedule_cb = 0)
This function combines a simple timer and an I/O watcher, calls your
callback on whichever event happens first and automatically stop both
watchers. This is useful if you want to wait for a single event on an fd
-or timeout without havign to allocate/configure/start/stop/free one or
+or timeout without having to allocate/configure/start/stop/free one or
more watchers yourself.
If C<fd> is less than 0, then no I/O watcher will be started and events
=head1 LIBEVENT EMULATION
-TBD.
+Libev offers a compatibility emulation layer for libevent. It cannot
+emulate the internals of libevent, so here are some usage hints:
+
+=over 4
+
+=item * Use it by including <event.h>, as usual.
+
+=item * The following members are fully supported: ev_base, ev_callback,
+ev_arg, ev_fd, ev_res, ev_events.
+
+=item * Avoid using ev_flags and the EVLIST_*-macros, while it is
+maintained by libev, it does not work exactly the same way as in libevent (consider
+it a private API).
+
+=item * Priorities are not currently supported. Initialising priorities
+will fail and all watchers will have the same priority, even though there
+is an ev_pri field.
+
+=item * Other members are not supported.
+
+=item * The libev emulation is I<not> ABI compatible to libevent, you need
+to use the libev header file and library.
+
+=back
=head1 C++ SUPPORT
projects / software / libev.git / blobdiff