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

Comparing libev/ev.pod (file contents):
Revision 1.107 by root, Mon Dec 24 04:34:00 2007 UTC vs.
Revision 1.111 by root, Tue Dec 25 18:01:20 2007 UTC

 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 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 C<EVBACKEND_SELECT> and
 C<EVBACKEND_POLL>).
 Another thing you have to watch out for is that it is quite easy to
 =head3 The special problem of dup'ed file descriptors
 Some backends (e.g. epoll), cannot register events for file descriptors,
 but only events for the underlying file descriptions. That means when you
-have C<dup ()>'ed file descriptors and register events for them, only one
+have C<dup ()>'ed file descriptors or weirder constellations, and register
-file descriptor might actually receive events.
+events for them, only one file descriptor might actually receive events.
 There is no workaround possible except not registering events
 for potentially C<dup ()>'ed file descriptors, or to resort to
 C<EVBACKEND_SELECT> or C<EVBACKEND_POLL>.
 =item int events [read-only]
 The events being watched.
 =back
+=head3 Examples
 Example: Call C<stdin_readable_cb> when STDIN_FILENO has become, well
 readable, but only once. Since it is likely line-buffered, you could
 attempt to read a whole line in the callback.
 or C<ev_timer_again> is called and determines the next timeout (if any),
 which is also when any modifications are taken into account.
 =back
+=head3 Examples
 Example: Create a timer that fires after 60 seconds.
   static void
   one_minute_cb (struct ev_loop *loop, struct ev_timer *w, int revents)
   {
 When active, contains the absolute time that the watcher is supposed to
 trigger next.
 =back
+=head3 Examples
 Example: Call a callback every hour, or, more precisely, whenever the
 system clock is divisible by 3600. The callback invocation times have
 potentially a lot of jittering, but good long-term stability.
   static void
 The process exit/trace status caused by C<rpid> (see your systems
 C<waitpid> and C<sys/wait.h> documentation for details).
 =back
+=head3 Examples
 Example: Try to exit cleanly on SIGINT and SIGTERM.
   static void
   sigint_cb (struct ev_loop *loop, struct ev_signal *w, int revents)
 semantics of C<ev_stat> watchers, which means that libev sometimes needs
 to fall back to regular polling again even with inotify, but changes are
 usually detected immediately, and if the file exists there will be no
 polling.
+=head3 Inotify
+When C<inotify (7)> support has been compiled into libev (generally only
+available on Linux) and present at runtime, it will be used to speed up
+change detection where possible. The inotify descriptor will be created lazily
+when the first C<ev_stat> watcher is being started.
+Inotify presense does not change the semantics of C<ev_stat> watchers
+except that changes might be detected earlier, and in some cases, to avoid
+making regular C<stat> calls. Even in the presense of inotify support
+there are many cases where libev has to resort to regular C<stat> polling.
+(There is no support for kqueue, as apparently it cannot be used to
+implement this functionality, due to the requirement of having a file
+descriptor open on the object at all times).
 =head3 The special problem of stat time resolution
 The C<stat ()> syscall only supports full-second resolution portably, and
 even on systems where the resolution is higher, many filesystems still
 only support whole seconds.
 =item const char *path [read-only]
 The filesystem path that is being watched.
 =back
+=head3 Examples
 Example: Watch C</etc/passwd> for attribute changes.
   static void
   passwd_cb (struct ev_loop *loop, ev_stat *w, int revents)
 kind. There is a C<ev_idle_set> macro, but using it is utterly pointless,
 believe me.
 =back
+=head3 Examples
 Example: Dynamically allocate an C<ev_idle> watcher, start it, and in the
 callback, free it. Also, use no error checking, as usual.
   static void
   idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents)
 parameters of any kind. There are C<ev_prepare_set> and C<ev_check_set>
 macros, but using them is utterly, utterly and completely pointless.
 =back
+=head3 Examples
 There are a number of principal ways to embed other event loops or modules
 into libev. Here are some ideas on how to include libadns into libev
 (there is a Perl module named C<EV::ADNS> that does this, which you could
 use for an actually working example. Another Perl module named C<EV::Glib>
 embeds a Glib main context into libev, and finally, C<Glib::EV> embeds EV
 portable one.
 So when you want to use this feature you will always have to be prepared
 that you cannot get an embeddable loop. The recommended way to get around
 this is to have a separate variables for your embeddable loop, try to
-create it, and if that fails, use the normal loop for everything:
+create it, and if that fails, use the normal loop for everything.
+=head3 Watcher-Specific Functions and Data Members
+=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)
+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,
+if you do not want thta, you need to temporarily stop the embed watcher).
+=item ev_embed_sweep (loop, ev_embed *)
+Make a single, non-blocking sweep over the embedded loop. This works
+similarly to C<ev_loop (embedded_loop, EVLOOP_NONBLOCK)>, but in the most
+apropriate way for embedded loops.
+=item struct ev_loop *other [read-only]
+The embedded event loop.
+=back
+=head3 Examples
+Example: Try to get an embeddable event loop and embed it into the default
+event loop. If that is not possible, use the default loop. The default
+loop is stored in C<loop_hi>, while the mebeddable loop is stored in
+C<loop_lo> (which is C<loop_hi> in the acse no embeddable loop can be
+used).
   struct ev_loop *loop_hi = ev_default_init (0);
   struct ev_loop *loop_lo = 0;
   struct ev_embed embed;
       ev_embed_start (loop_hi, &embed);
     }
   else
     loop_lo = loop_hi;
-=head3 Watcher-Specific Functions and Data Members
+Example: Check if kqueue is available but not recommended and create
+a kqueue backend for use with sockets (which usually work with any
+kqueue implementation). Store the kqueue/socket-only event loop in
+C<loop_socket>. (One might optionally use C<EVFLAG_NOENV>, too).
-=over 4
+  struct ev_loop *loop = ev_default_init (0);
+  struct ev_loop *loop_socket = 0;
+  struct 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);
+      }
-=item ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)
+  if (!loop_socket)
+    loop_socket = loop;
-=item ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)
+  // now use loop_socket for all sockets, and loop for everything else
-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,
-if you do not want thta, you need to temporarily stop the embed watcher).
-=item ev_embed_sweep (loop, ev_embed *)
-Make a single, non-blocking sweep over the embedded loop. This works
-similarly to C<ev_loop (embedded_loop, EVLOOP_NONBLOCK)>, but in the most
-apropriate way for embedded loops.
-=item struct ev_loop *other [read-only]
-The embedded event loop.
-=back
 =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
 be detected at runtime.
 =item EV_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> and C<"ev.h"> in F<ev.c>. This
+undefined is C<"ev.h"> in F<event.h> and F<ev.c>. This can be used to
-can be used to virtually rename the F<ev.h> header file in case of conflicts.
+virtually rename the F<ev.h> header file in case of conflicts.
 =item EV_CONFIG_H
 If C<EV_STANDALONE> isn't C<1>, this variable can be used to override
 F<ev.c>'s idea of where to find the F<config.h> file, similarly to
 C<EV_H>, above.
 =item EV_EVENT_H
 Similarly to C<EV_H>, this macro can be used to override F<event.c>'s idea
-of how the F<event.h> header can be found.
+of how the F<event.h> header can be found, the dfeault is C<"event.h">.
 =item EV_PROTOTYPES
 If defined to be C<0>, then F<ev.h> will not define any function
 prototypes, but still define all the structs and other symbols. This is

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.107 by root, Mon Dec 24 04:34:00 2007 UTC vs. Revision 1.111 by root, Tue Dec 25 18:01:20 2007 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.107 by root, Mon Dec 24 04:34:00 2007 UTC vs.
Revision 1.111 by root, Tue Dec 25 18:01:20 2007 UTC