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

Comparing libev/ev.pod (file contents):
Revision 1.295 by root, Sat Jun 26 09:56:57 2010 UTC vs.
Revision 1.303 by root, Thu Oct 14 04:29:34 2010 UTC

 While this document tries to be as complete as possible in documenting
 libev, its usage and the rationale behind its design, it is not a tutorial
 on event-based programming, nor will it introduce event-based programming
 with libev.
-Familarity with event based programming techniques in general is assumed
+Familiarity with event based programming techniques in general is assumed
 throughout this document.
 =head1 ABOUT LIBEV
 Libev is an event loop: you register interest in certain events (such as a
 C<ev_resume> directly afterwards to resume timer processing.
 Effectively, all C<ev_timer> watchers will be delayed by the time spend
 between C<ev_suspend> and C<ev_resume>, and all C<ev_periodic> watchers
 will be rescheduled (that is, they will lose any events that would have
-occured while suspended).
+occurred while suspended).
 After calling C<ev_suspend> you B<must not> call I<any> function on the
 given loop other than C<ev_resume>, and you B<must not> call C<ev_resume>
 without a previous call to C<ev_suspend>.
 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.
 This "unloop state" will be cleared when entering C<ev_loop> again.
-It is safe to call C<ev_unloop> from otuside any C<ev_loop> calls.
+It is safe to call C<ev_unloop> from outside any C<ev_loop> calls.
 =item ev_ref (loop)
 =item ev_unref (loop)
 usually doesn't make much sense to set it to a lower value than C<0.01>,
 as this approaches the timing granularity of most systems. Note that if
 you do transactions with the outside world and you can't increase the
 parallelity, then this setting will limit your transaction rate (if you
 need to poll once per transaction and the I/O collect interval is 0.01,
-then you can't do more than 100 transations per second).
+then you can't do more than 100 transactions per second).
 Setting the I<timeout collect interval> can improve the opportunity for
 saving power, as the program will "bundle" timer callback invocations that
 are "near" in time together, by delaying some, thus reducing the number of
 times the process sleeps and wakes up again. Another useful technique to
 For example, to emulate how many other event libraries handle priorities,
 you can associate an C<ev_idle> watcher to each such watcher, and in
 the normal watcher callback, you just start the idle watcher. The real
 processing is done in the idle watcher callback. This causes libev to
-continously poll and process kernel event data for the watcher, but when
+continuously poll and process kernel event data for the watcher, but when
 the lock-out case is known to be rare (which in turn is rare :), this is
 workable.
 Usually, however, the lock-out model implemented that way will perform
 miserably under the type of load it was designed to handle. In that case,
    {
      // stop the I/O watcher, we received the event, but
      // are not yet ready to handle it.
      ev_io_stop (EV_A_ w);
-     // start the idle watcher to ahndle the actual event.
+     // start the idle watcher to handle the actual event.
      // it will not be executed as long as other watchers
      // with the default priority are receiving events.
      ev_idle_start (EV_A_ &idle);
    }
 If you cannot use non-blocking mode, 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>). The same applies to file
 descriptors for which non-blocking operation makes no sense (such as
-files) - libev doesn't guarentee any specific behaviour in that case.
+files) - libev doesn't guarantee any specific behaviour in that case.
 Another thing you have to watch out for is that it is quite easy to
 receive "spurious" readiness notifications, that is your callback might
 be called with C<EV_READ> but a subsequent C<read>(2) will actually block
 because there is no data. Not only are some backends known to create a
      ev_tstamp timeout = last_activity + 60.;
      // if last_activity + 60. is older than now, we did time out
      if (timeout < now)
        {
-         // timeout occured, take action
+         // timeout occurred, take action
        }
      else
        {
          // callback was invoked, but there was some activity, re-arm
          // the watcher to fire in last_activity + 60, which is
 Example: Call a callback every hour, or, more precisely, whenever the
 system time is divisible by 3600. The callback invocation times have
 potentially a lot of jitter, but good long-term stability.
    static void
-   clock_cb (struct ev_loop *loop, ev_io *w, int revents)
+   clock_cb (struct ev_loop *loop, ev_periodic *w, int revents)
    {
      ... its now a full hour (UTC, or TAI or whatever your clock follows)
    }
    ev_periodic hourly_tick;
 C<ev_default_fork> cheats and calls it in the wrong process, the fork
 handlers will be invoked, too, 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 ste
+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
 believe me.
 =back
-=head2 C<ev_async> - how to wake up another event loop
+=head2 C<ev_async> - how to wake up an event loop
 In general, you cannot use an C<ev_loop> from multiple threads or other
 asynchronous sources such as signal handlers (as opposed to multiple event
 loops - those are of course safe to use in different threads).
-Sometimes, however, you need to wake up another event loop you do not
+Sometimes, however, you need to wake up an event loop you do not control,
-control, for example because it belongs to another thread. This is what
+for example because it belongs to another thread. This is what C<ev_async>
-C<ev_async> watchers do: as long as the C<ev_async> watcher is active, you
+watchers do: as long as the C<ev_async> watcher is active, you can signal
-can signal it by calling C<ev_async_send>, which is thread- and signal
+it by calling C<ev_async_send>, which is thread- and signal safe.
-safe.
 This functionality is very similar to C<ev_signal> watchers, as signals,
 too, are asynchronous in nature, and signals, too, will be compressed
 (i.e. the number of callback invocations may be less than the number of
 C<ev_async_sent> calls).
    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
 EV_PREPARE_ENABLE, EV_CHECK_ENABLE, EV_FORK_ENABLE, EV_SIGNAL_ENABLE,
 EV_ASYNC_ENABLE, EV_CHILD_ENABLE.
 If undefined or defined to be C<1> (and the platform supports it), then
 the respective watcher type is supported. If defined to be C<0>, then it
-is not. Disabling watcher types mainly saves codesize.
+is not. Disabling watcher types mainly saves code size.
 =item EV_FEATURES
 If you need to shave off some kilobytes of code at the expense of some
 speed (but with the full API), you can define this symbol to request
 =item C<1> - faster/larger code
 Use larger code to speed up some operations.
-Currently this is used to override some inlining decisions (enlarging the  roughly
+Currently this is used to override some inlining decisions (enlarging the
-30% code size on amd64.
+code size by roughly 30% on amd64).
 When optimising for size, use of compiler flags such as C<-Os> with
-gcc recommended, as well as C<-DNDEBUG>, as libev contains a number of
+gcc is recommended, as well as C<-DNDEBUG>, as libev contains a number of
 assertions.
 =item C<2> - faster/larger data structures
 Replaces the small 2-heap for timer management by a faster 4-heap, larger
-hash table sizes and so on. This will usually further increase codesize
+hash table sizes and so on. This will usually further increase code size
 and can additionally have an effect on the size of data structures at
 runtime.
 =item C<4> - full API configuration
 I/O watcher then might come out at only 5Kb.
 =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 codesize
+functions (printf, scanf, perror etc.). This will increase the code size
 somewhat, but if your program doesn't otherwise depend on stdio and your
 libc allows it, this avoids linking in the stdio library which is quite
 big.
 Note that error messages might become less precise when this option is
 The highest supported signal number, +1 (or, the number of
 signals): Normally, libev tries to deduce the maximum number of signals
 automatically, but sometimes this fails, in which case it can be
 specified. Also, using a lower number than detected (C<32> should be
-good for about any system in existance) can save some memory, as libev
+good for about any system in existence) can save some memory, as libev
 statically allocates some 12-24 bytes per signal number.
 =item EV_PID_HASHSIZE
 C<ev_child> watchers use a small hash table to distribute workload by
 will be C<0>.
 =item EV_COMMON
 By default, all watchers have a C<void *data> member. By redefining
-this macro to a something else you can include more and other types of
+this macro to something else you can include more and other types of
 members. You have to define it each time you include one of the files,
 though, and it must be identical each time.
 For example, the perl EV module uses something like this:
 maintainable.
 And of course, some compiler warnings are just plain stupid, or simply
 wrong (because they don't actually warn about the condition their message
 seems to warn about). For example, certain older gcc versions had some
-warnings that resulted an extreme number of false positives. These have
+warnings that resulted in an extreme number of false positives. These have
 been fixed, but some people still insist on making code warn-free with
 such buggy versions.
 While libev is written to generate as few warnings as possible,
 "warn-free" code is not a goal, and it is recommended not to build libev
 I suggest using suppression lists.
 =head1 PORTABILITY NOTES
+=head2 GNU/LINUX 32 BIT LIMITATIONS
+GNU/Linux is the only common platform that supports 64 bit file/large file
+interfaces but I<disables> them by default.
+That means that libev compiled in the default environment doesn't support
+files larger than 2GiB or so, which mainly affects C<ev_stat> watchers.
+Unfortunately, many programs try to work around this GNU/Linux issue
+by enabling the large file API, which makes them incompatible with the
+standard libev compiled for their system.
+Likewise, libev cannot enable the large file API itself as this would
+suddenly make it incompatible to the default compile time environment,
+i.e. all programs not using special compile switches.
+=head2 OS/X AND DARWIN BUGS
+The whole thing is a bug if you ask me - basically any system interface
+you touch is broken, whether it is locales, poll, kqueue or even the
+OpenGL drivers.
+=head3 C<kqueue> is buggy
+The kqueue syscall is broken in all known versions - most versions support
+only sockets, many support pipes.
+=head3 C<poll> is buggy
+Instead of fixing C<kqueue>, Apple replaced their (working) C<poll>
+implementation by something calling C<kqueue> internally around the 10.5.6
+release, so now C<kqueue> I<and> C<poll> are broken.
+Libev tries to work around this by neither using C<kqueue> nor C<poll> by
+default on this rotten platform, but of course you cna still ask for them
+when creating a loop.
+=head3 C<select> is buggy
+All that's left is C<select>, and of course Apple found a way to fuck this
+one up as well: On OS/X, C<select> actively limits the number of file
+descriptors you can pass in to 1024 - your program suddenyl crashes when
+you use more.
+There is an undocumented "workaround" for this - defining
+C<_DARWIN_UNLIMITED_SELECT>, which libev tries to use, so select I<should>
+work on OS/X.
+=head2 SOLARIS PROBLEMS AND WORKAROUNDS
+=head3 C<errno> reentrancy
+The default compile environment on Solaris is unfortunately so
+thread-unsafe that you can't even use components/libraries compiled
+without C<-D_REENTRANT> (as long as they use C<errno>), which, of course,
+isn't defined by default.
+If you want to use libev in threaded environments you have to make sure
+it's compiled with C<_REENTRANT> defined.
+=head3 Event port backend
+The scalable event interface for Solaris is called "event ports". Unfortunately,
+this mechanism is very buggy. If you run into high CPU usage, your program
+freezes or you get a large number of spurious wakeups, make sure you have
+all the relevant and latest kernel patches applied. No, I don't know which
+ones, but there are multiple ones.
+If you can't get it to work, you can try running the program with
+C<LIBEV_FLAGS=3> to only allow C<poll> and C<select> backends.
+=head2 AIX POLL BUG
+AIX unfortunately has a broken C<poll.h> header. Libev works around
+this by trying to avoid the poll backend altogether (i.e. it's not even
+compiled in), which normally isn't a big problem as C<select> works fine
+with large bitsets, and AIX is dead anyway.
 =head2 WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS
+=head3 General issues
 Win32 doesn't support any of the standards (e.g. POSIX) that libev
 requires, and its I/O model is fundamentally incompatible with the POSIX
 model. Libev still offers limited functionality on this platform in
 the form of the C<EVBACKEND_SELECT> backend, and only supports socket
 descriptors. This only applies when using Win32 natively, not when using
-e.g. cygwin.
+e.g. cygwin. Actually, it only applies to the microsofts own compilers,
+as every compielr comes with a slightly differently broken/incompatible
+environment.
 Lifting these limitations would basically require the full
-re-implementation of the I/O system. If you are into these kinds of
+re-implementation of the I/O system. If you are into this kind of thing,
-things, then note that glib does exactly that for you in a very portable
+then note that glib does exactly that for you in a very portable way (note
-way (note also that glib is the slowest event library known to man).
+also that glib is the slowest event library known to man).
 There is no supported compilation method available on windows except
 embedding it into other applications.
 Sensible signal handling is officially unsupported by Microsoft - libev
 you do I<not> compile the F<ev.c> or any other embedded source files!):
    #include "evwrap.h"
    #include "ev.c"
-=over 4
-=item The winsocket select function
+=head3 The winsocket C<select> function
 The winsocket C<select> function doesn't follow POSIX in that it
 requires socket I<handles> and not socket I<file descriptors> (it is
 also extremely buggy). This makes select very inefficient, and also
 requires a mapping from file descriptors to socket handles (the Microsoft
    #define EV_SELECT_IS_WINSOCKET 1   /* forces EV_SELECT_USE_FD_SET, too */
 Note that winsockets handling of fd sets is O(n), so you can easily get a
 complexity in the O(n²) range when using win32.
-=item Limited number of file descriptors
+=head3 Limited number of file descriptors
 Windows has numerous arbitrary (and low) limits on things.
 Early versions of winsocket's select only supported waiting for a maximum
 of C<64> handles (probably owning to the fact that all windows kernels
 runtime libraries. This might get you to about C<512> or C<2048> sockets
 (depending on windows version and/or the phase of the moon). To get more,
 you need to wrap all I/O functions and provide your own fd management, but
 the cost of calling select (O(n²)) will likely make this unworkable.
-=back
 =head2 PORTABILITY REQUIREMENTS
 In addition to a working ISO-C implementation and of course the
 backend-specific APIs, libev relies on a few additional extensions:
 This is a simple rename - all other watcher types use their name
 as revents flag, and now C<ev_timer> does, too.
 Both C<EV_TIMER> and C<EV_TIMEOUT> symbols were present in 3.x versions
-and continue to be present for the forseeable future, so this is mostly a
+and continue to be present for the foreseeable future, so this is mostly a
 documentation change.
 =item C<EV_MINIMAL> mechanism replaced by C<EV_FEATURES>
 The preprocessor symbol C<EV_MINIMAL> has been replaced by a different

Diff Legend

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

Comparing libev/ev.pod (file contents): Revision 1.295 by root, Sat Jun 26 09:56:57 2010 UTC vs. Revision 1.303 by root, Thu Oct 14 04:29:34 2010 UTC

Diff Legend

Comparing libev/ev.pod (file contents):
Revision 1.295 by root, Sat Jun 26 09:56:57 2010 UTC vs.
Revision 1.303 by root, Thu Oct 14 04:29:34 2010 UTC