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

Comparing libev/ev.pod (file contents):
Revision 1.214 by root, Wed Nov 5 03:52:15 2008 UTC vs.
Revision 1.223 by root, Sun Dec 14 21:58:08 2008 UTC

 =head2 EXAMPLE PROGRAM
    // a single header file is required
    #include <ev.h>
+   #include <stdio.h> // for puts
    // every watcher type has its own typedef'd struct
    // with the name ev_TYPE
    ev_io stdin_watcher;
    ev_timer timeout_watcher;
    int
    main (void)
    {
      // use the default event loop unless you have special needs
-     ev_loop *loop = ev_default_loop (0);
+     struct ev_loop *loop = ev_default_loop (0);
      // initialise an io watcher, then start it
      // this one will watch for stdin to become readable
      ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ);
      ev_io_start (loop, &stdin_watcher);
 starting a watcher (without re-setting it) also usually doesn't cause
 extra overhead. A fork can both result in spurious notifications as well
 as in libev having to destroy and recreate the epoll object, which can
 take considerable time and thus should be avoided.
-All this means that, in practise, C<EVBACKEND_SELECT> can be as fast or
+All this means that, in practice, C<EVBACKEND_SELECT> can be as fast or
-faster then epoll for maybe up to a hundred file descriptors, depending on
+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.
 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
 almost everywhere, you should only use it when you have a lot of sockets
 (for which it usually works), by embedding it into another event loop
-(e.g. C<EVBACKEND_SELECT> or C<EVBACKEND_POLL>) and, did I mention it,
+(e.g. C<EVBACKEND_SELECT> or C<EVBACKEND_POLL> (but C<poll> is of course
-using it only for sockets.
+also broken on OS X)) and, did I mention it, using it only for sockets.
 This backend maps C<EV_READ> into an C<EVFILT_READ> kevent with
 C<NOTE_EOF>, and C<EV_WRITE> into an C<EVFILT_WRITE> kevent with
 C<NOTE_EOF>.
      else
        {
          // callback was invoked, but there was some activity, re-arm
          // the watcher to fire in last_activity + 60, which is
          // guaranteed to be in the future, so "again" is positive:
-         w->again = timeout - now;
+         w->repeat = timeout - now;
          ev_timer_again (EV_A_ w);
        }
    }
 To summarise the callback: first calculate the real timeout (defined
 the process. The exception are C<ev_stat> watchers - those call C<stat
 ()>, which is a synchronous operation.
 For local paths, this usually doesn't matter: unless the system is very
 busy or the intervals between stat's are large, a stat call will be fast,
-as the path data is suually in memory already (except when starting the
+as the path data is usually in memory already (except when starting the
 watcher).
 For networked file systems, calling C<stat ()> can block an indefinite
 time due to network issues, and even under good conditions, a stat call
 often takes multiple milliseconds.
 some fds have to be watched and handled very quickly (with low latency),
 and even priorities and idle watchers might have too much overhead. In
 this case you would put all the high priority stuff in one loop and all
 the rest in a second one, and embed the second one in the first.
-As long as the watcher is active, the callback will be invoked every time
+As long as the watcher is active, the callback will be invoked every
-there might be events pending in the embedded loop. The callback must then
+time there might be events pending in the embedded loop. The callback
-call C<ev_embed_sweep (mainloop, watcher)> to make a single sweep and invoke
+must then call C<ev_embed_sweep (mainloop, watcher)> to make a single
-their callbacks (you could also start an idle watcher to give the embedded
+sweep and invoke their callbacks (the callback doesn't need to invoke the
-loop strictly lower priority for example). You can also set the callback
+C<ev_embed_sweep> function directly, it could also start an idle watcher
-to C<0>, in which case the embed watcher will automatically execute the
+to give the embedded loop strictly lower priority for example).
-embedded loop sweep.
-As long as the watcher is started it will automatically handle events. The
+You can also set the callback to C<0>, in which case the embed watcher
-callback will be invoked whenever some events have been handled. You can
+will automatically execute the embedded loop sweep whenever necessary.
-set the callback to C<0> to avoid having to specify one if you are not
-interested in that.
-Also, there have not currently been made special provisions for forking:
+Fork detection will be handled transparently while the C<ev_embed> watcher
-when you fork, you not only have to call C<ev_loop_fork> on both loops,
+is active, i.e., the embedded loop will automatically be forked when the
-but you will also have to stop and restart any C<ev_embed> watchers
+embedding loop forks. In other cases, the user is responsible for calling
-yourself - but you can use a fork watcher to handle this automatically,
+C<ev_loop_fork> on the embedded loop.
-and future versions of libev might do just that.
 Unfortunately, not all backends are embeddable: only the ones returned by
 C<ev_embeddable_backends> are, which, unfortunately, does not include any
 portable one.
    myclass obj;
    ev::io iow;
    iow.set <myclass, &myclass::io_cb> (&obj);
+=item w->set (object *)
+This is an B<experimental> feature that might go away in a future version.
+This is a variation of a method callback - leaving out the method to call
+will default the method to C<operator ()>, which makes it possible to use
+functor objects without having to manually specify the C<operator ()> all
+the time. Incidentally, you can then also leave out the template argument
+list.
+The C<operator ()> method prototype must be C<void operator ()(watcher &w,
+int revents)>.
+See the method-C<set> above for more details.
+Example: use a functor object as callback.
+   struct myfunctor
+   {
+     void operator() (ev::io &w, int revents)
+     {
+       ...
+     }
+   }
+   myfunctor f;
+   ev::io w;
+   w.set (&f);
 =item w->set<function> (void *data = 0)
 Also sets a callback, but uses a static method or plain function as
 callback. The optional C<data> argument will be stored in the watcher's
 C<data> member and is free for you to use.
 Tony Arcieri has written a ruby extension that offers access to a subset
 of the libev API and adds file handle abstractions, asynchronous DNS and
 more on top of it. It can be found via gem servers. Its homepage is at
 L<http://rev.rubyforge.org/>.
+Roger Pack reports that using the link order C<-lws2_32 -lmsvcrt-ruby-190>
+makes rev work even on mingw.
 =item D
 Leandro Lucarella has written a D language binding (F<ev.d>) for libev, to
 be found at L<http://proj.llucax.com.ar/wiki/evd>.
 keeps libev from including F<config.h>, and it also defines dummy
 implementations for some libevent functions (such as logging, which is not
 supported). It will also not define any of the structs usually found in
 F<event.h> that are not directly supported by the libev core alone.
+In stanbdalone mode, libev will still try to automatically deduce the
+configuration, but has to be more conservative.
 =item EV_USE_MONOTONIC
 If defined to be C<1>, libev will try to detect the availability of the
-monotonic clock option at both compile time and runtime. Otherwise no use
+monotonic clock option at both compile time and runtime. Otherwise no
-of the monotonic clock option will be attempted. If you enable this, you
+use of the monotonic clock option will be attempted. If you enable this,
-usually have to link against librt or something similar. Enabling it when
+you usually have to link against librt or something similar. Enabling it
-the functionality isn't available is safe, though, although you have
+when the functionality isn't available is safe, though, although you have
 to make sure you link against any libraries where the C<clock_gettime>
-function is hiding in (often F<-lrt>).
+function is hiding in (often F<-lrt>). See also C<EV_USE_CLOCK_SYSCALL>.
 =item EV_USE_REALTIME
 If defined to be C<1>, libev will try to detect the availability of the
 real-time clock option at compile time (and assume its availability at
 runtime if successful). Otherwise no use of the real-time clock option will
 be attempted. This effectively replaces C<gettimeofday> by C<clock_get
 (CLOCK_REALTIME, ...)> and will not normally affect correctness. See the
 note about libraries in the description of C<EV_USE_MONOTONIC>, though.
+=item EV_USE_CLOCK_SYSCALL
+If defined to be C<1>, libev will try to use a direct syscall instead
+of calling the system-provided C<clock_gettime> function. This option
+exists because on GNU/Linux, C<clock_gettime> is in C<librt>, but C<librt>
+unconditionally pulls in C<libpthread>, slowing down single-threaded
+programs needlessly. Using a direct syscall is slightly slower (in
+theory), because no optimised vdso implementation can be used, but avoids
+the pthread dependency. Defaults to C<1> on GNU/Linux with glibc 2.x or
+higher, as it simplifies linking (no need for C<-lrt>).
 =item EV_USE_NANOSLEEP
 If defined to be C<1>, libev will assume that C<nanosleep ()> is available
 and will use it for delays. Otherwise it will use C<select ()>.
 =item EV_SELECT_USE_FD_SET
 If defined to C<1>, then the select backend will use the system C<fd_set>
 structure. This is useful if libev doesn't compile due to a missing
-C<NFDBITS> or C<fd_mask> definition or it mis-guesses the bitset layout on
+C<NFDBITS> or C<fd_mask> definition or it mis-guesses the bitset layout
-exotic systems. This usually limits the range of file descriptors to some
+on exotic systems. This usually limits the range of file descriptors to
-low limit such as 1024 or might have other limitations (winsocket only
+some low limit such as 1024 or might have other limitations (winsocket
-allows 64 sockets). The C<FD_SETSIZE> macro, set before compilation, might
+only allows 64 sockets). The C<FD_SETSIZE> macro, set before compilation,
-influence the size of the C<fd_set> used.
+configures the maximum size of the C<fd_set>.
 =item EV_SELECT_IS_WINSOCKET
 When defined to C<1>, the select backend will assume that
 select/socket/connect etc. don't understand file descriptors but

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.214 by root, Wed Nov 5 03:52:15 2008 UTC vs. Revision 1.223 by root, Sun Dec 14 21:58:08 2008 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.214 by root, Wed Nov 5 03:52:15 2008 UTC vs.
Revision 1.223 by root, Sun Dec 14 21:58:08 2008 UTC