[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent.pm

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.215 by root, Tue Jun 23 12:19:33 2009 UTC vs.
Revision 1.232 by root, Thu Jul 9 01:08:22 2009 UTC

 =head2 I/O WATCHERS
 You can create an I/O watcher by calling the C<< AnyEvent->io >> method
 with the following mandatory key-value pairs as arguments:
-C<fh> is the Perl I<file handle> (I<not> file descriptor) to watch
+C<fh> is the Perl I<file handle> (or a naked file descriptor) to watch
 for events (AnyEvent might or might not keep a reference to this file
 handle). Note that only file handles pointing to things for which
 non-blocking operation makes sense are allowed. This includes sockets,
 most character devices, pipes, fifos and so on, but not for example files
 or block devices.
 There is a slight catch to child watchers, however: you usually start them
 I<after> the child process was created, and this means the process could
 have exited already (and no SIGCHLD will be sent anymore).
-Not all event models handle this correctly (POE doesn't), but even for
+Not all event models handle this correctly (neither POE nor IO::Async do,
+see their AnyEvent::Impl manpages for details), but even for event models
-event models that I<do> handle this correctly, they usually need to be
+that I<do> handle this correctly, they usually need to be loaded before
-loaded before the process exits (i.e. before you fork in the first place).
+the process exits (i.e. before you fork in the first place). AnyEvent's
+pure perl event loop handles all cases correctly regardless of when you
+start the watcher.
-This means you cannot create a child watcher as the very first thing in an
+This means you cannot create a child watcher as the very first
-AnyEvent program, you I<have> to create at least one watcher before you
+thing in an AnyEvent program, you I<have> to create at least one
-C<fork> the child (alternatively, you can call C<AnyEvent::detect>).
+watcher before you C<fork> the child (alternatively, you can call
+C<AnyEvent::detect>).
 Example: fork a process and wait for it
    my $done = AnyEvent->condvar;
 =item $cv->begin ([group callback])
 =item $cv->end
-These two methods are EXPERIMENTAL and MIGHT CHANGE.
 These two methods can be used to combine many transactions/events into
 one. For example, a function that pings many hosts in parallel might want
 to use a condition variable for the whole process.
 Every call to C<< ->begin >> will increment a counter, and every call to
 C<< ->end >> will decrement it.  If the counter reaches C<0> in C<< ->end
 >>, the (last) callback passed to C<begin> will be executed. That callback
 is I<supposed> to call C<< ->send >>, but that is not required. If no
 callback was set, C<send> will be called without any arguments.
-Let's clarify this with the ping example:
+You can think of C<< $cv->send >> giving you an OR condition (one call
+sends), while C<< $cv->begin >> and C<< $cv->end >> giving you an AND
+condition (all C<begin> calls must be C<end>'ed before the condvar sends).
+Let's start with a simple example: you have two I/O watchers (for example,
+STDOUT and STDERR for a program), and you want to wait for both streams to
+close before activating a condvar:
+   my $cv = AnyEvent->condvar;
+   $cv->begin; # first watcher
+   my $w1 = AnyEvent->io (fh => $fh1, cb => sub {
+      defined sysread $fh1, my $buf, 4096
+         or $cv->end;
+   });
+   $cv->begin; # second watcher
+   my $w2 = AnyEvent->io (fh => $fh2, cb => sub {
+      defined sysread $fh2, my $buf, 4096
+         or $cv->end;
+   });
+   $cv->recv;
+This works because for every event source (EOF on file handle), there is
+one call to C<begin>, so the condvar waits for all calls to C<end> before
+sending.
+The ping example mentioned above is slightly more complicated, as the
+there are results to be passwd back, and the number of tasks that are
+begung can potentially be zero:
    my $cv = AnyEvent->condvar;
    my %result;
    $cv->begin (sub { $cv->send (\%result) });
 loop, which serves two important purposes: first, it sets the callback
 to be called once the counter reaches C<0>, and second, it ensures that
 C<send> is called even when C<no> hosts are being pinged (the loop
 doesn't execute once).
-This is the general pattern when you "fan out" into multiple subrequests:
+This is the general pattern when you "fan out" into multiple (but
-use an outer C<begin>/C<end> pair to set the callback and ensure C<end>
+potentially none) subrequests: use an outer C<begin>/C<end> pair to set
-is called at least once, and then, for each subrequest you start, call
+the callback and ensure C<end> is called at least once, and then, for each
-C<begin> and for each subrequest you finish, call C<end>.
+subrequest you start, call C<begin> and for each subrequest you finish,
+call C<end>.
 =back
 =head3 METHODS FOR CONSUMERS
 variable itself. Calling C<recv> inside the callback or at any later time
 is guaranteed not to block.
 =back
+=head1 SUPPORTED EVENT LOOPS/BACKENDS
+The available backend classes are (every class has its own manpage):
+=over 4
+=item Backends that are autoprobed when no other event loop can be found.
+EV is the preferred backend when no other event loop seems to be in
+use. If EV is not installed, then AnyEvent will try Event, and, failing
+that, will fall back to its own pure-perl implementation, which is
+available everywhere as it comes with AnyEvent itself.
+   AnyEvent::Impl::EV        based on EV (interface to libev, best choice).
+   AnyEvent::Impl::Event     based on Event, very stable, few glitches.
+   AnyEvent::Impl::Perl      pure-perl implementation, fast and portable.
+=item Backends that are transparently being picked up when they are used.
+These will be used when they are currently loaded when the first watcher
+is created, in which case it is assumed that the application is using
+them. This means that AnyEvent will automatically pick the right backend
+when the main program loads an event module before anything starts to
+create watchers. Nothing special needs to be done by the main program.
+   AnyEvent::Impl::Glib      based on Glib, slow but very stable.
+   AnyEvent::Impl::Tk        based on Tk, very broken.
+   AnyEvent::Impl::EventLib  based on Event::Lib, leaks memory and worse.
+   AnyEvent::Impl::POE       based on POE, very slow, some limitations.
+=item Backends with special needs.
+Qt requires the Qt::Application to be instantiated first, but will
+otherwise be picked up automatically. As long as the main program
+instantiates the application before any AnyEvent watchers are created,
+everything should just work.
+   AnyEvent::Impl::Qt        based on Qt.
+Support for IO::Async can only be partial, as it is too broken and
+architecturally limited to even support the AnyEvent API. It also
+is the only event loop that needs the loop to be set explicitly, so
+it can only be used by a main program knowing about AnyEvent. See
+L<AnyEvent::Impl::Async> for the gory details.
+   AnyEvent::Impl::IOAsync   based on IO::Async, cannot be autoprobed.
+=item Event loops that are indirectly supported via other backends.
+Some event loops can be supported via other modules:
+There is no direct support for WxWidgets (L<Wx>) or L<Prima>.
+B<WxWidgets> has no support for watching file handles. However, you can
+use WxWidgets through the POE adaptor, as POE has a Wx backend that simply
+polls 20 times per second, which was considered to be too horrible to even
+consider for AnyEvent.
+B<Prima> is not supported as nobody seems to be using it, but it has a POE
+backend, so it can be supported through POE.
+AnyEvent knows about both L<Prima> and L<Wx>, however, and will try to
+load L<POE> when detecting them, in the hope that POE will pick them up,
+in which case everything will be automatic.
+=back
 =head1 GLOBAL VARIABLES AND FUNCTIONS
 =over 4
 =item $AnyEvent::MODEL
 Contains C<undef> until the first watcher is being created. Then it
 contains the event model that is being used, which is the name of the
 Perl class implementing the model. This class is usually one of the
 C<AnyEvent::Impl:xxx> modules, but can be any other class in the case
 AnyEvent has been extended at runtime (e.g. in I<rxvt-unicode>).
-The known classes so far are:
-   AnyEvent::Impl::EV        based on EV (an interface to libev, best choice).
-   AnyEvent::Impl::Event     based on Event, second best choice.
-   AnyEvent::Impl::Perl      pure-perl implementation, fast and portable.
-   AnyEvent::Impl::Glib      based on Glib, third-best choice.
-   AnyEvent::Impl::Tk        based on Tk, very bad choice.
-   AnyEvent::Impl::Qt        based on Qt, cannot be autoprobed (see its docs).
-   AnyEvent::Impl::EventLib  based on Event::Lib, leaks memory and worse.
-   AnyEvent::Impl::POE       based on POE, not generic enough for full support.
-There is no support for WxWidgets, as WxWidgets has no support for
-watching file handles. However, you can use WxWidgets through the
-POE Adaptor, as POE has a Wx backend that simply polls 20 times per
-second, which was considered to be too horrible to even consider for
-AnyEvent. Likewise, other POE backends can be used by AnyEvent by using
-it's adaptor.
-AnyEvent knows about L<Prima> and L<Wx> and will try to use L<POE> when
-autodetecting them.
 =item AnyEvent::detect
 Returns C<$AnyEvent::MODEL>, forcing autodetection of the event model
 if necessary. You should only call this function right before you would
 =head1 OTHER MODULES
 The following is a non-exhaustive list of additional modules that use
-AnyEvent and can therefore be mixed easily with other AnyEvent modules
+AnyEvent as a client and can therefore be mixed easily with other AnyEvent
-in the same program. Some of the modules come with AnyEvent, some are
+modules and other event loops in the same program. Some of the modules
-available via CPAN.
+come with AnyEvent, most are available via CPAN.
 =over 4
 =item L<AnyEvent::Util>
 =item L<AnyEvent::Handle>
 Provide read and write buffers, manages watchers for reads and writes,
 supports raw and formatted I/O, I/O queued and fully transparent and
-non-blocking SSL/TLS.
+non-blocking SSL/TLS (via L<AnyEvent::TLS>.
 =item L<AnyEvent::DNS>
 Provides rich asynchronous DNS resolver capabilities.
 =item L<AnyEvent::GPSD>
 A non-blocking interface to gpsd, a daemon delivering GPS information.
+=item L<AnyEvent::IRC>
+AnyEvent based IRC client module family (replacing the older Net::IRC3).
+=item L<AnyEvent::XMPP>
+AnyEvent based XMPP (Jabber protocol) module family (replacing the older
+Net::XMPP2>.
 =item L<AnyEvent::IGS>
 A non-blocking interface to the Internet Go Server protocol (used by
 L<App::IGS>).
-=item L<AnyEvent::IRC>
-AnyEvent based IRC client module family (replacing the older Net::IRC3).
-=item L<Net::XMPP2>
-AnyEvent based XMPP (Jabber protocol) module family.
 =item L<Net::FCP>
 AnyEvent-based implementation of the Freenet Client Protocol, birthplace
 of AnyEvent.
 =item L<Coro>
 Has special support for AnyEvent via L<Coro::AnyEvent>.
-=item L<IO::Lambda>
-The lambda approach to I/O - don't ask, look there. Can use AnyEvent.
 =back
 =cut
 package AnyEvent;
 no warnings;
 use strict qw(vars subs);
 use Carp;
-our $VERSION = 4.411;
+our $VERSION = 4.801;
 our $MODEL;
 our $AUTOLOAD;
 our @ISA;
    [Event::                => AnyEvent::Impl::Event::],
    [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl::],
    # everything below here will not be autoprobed
    # as the pureperl backend should work everywhere
    # and is usually faster
-   [Tk::                   => AnyEvent::Impl::Tk::],       # crashes with many handles
    [Glib::                 => AnyEvent::Impl::Glib::],     # becomes extremely slow with many watchers
    [Event::Lib::           => AnyEvent::Impl::EventLib::], # too buggy
+   [Tk::                   => AnyEvent::Impl::Tk::],       # crashes with many handles
+   [POE::Kernel::          => AnyEvent::Impl::POE::],      # lasciate ogni speranza
    [Qt::                   => AnyEvent::Impl::Qt::],       # requires special main program
-   [POE::Kernel::          => AnyEvent::Impl::POE::],      # lasciate ogni speranza
    [Wx::                   => AnyEvent::Impl::POE::],
    [Prima::                => AnyEvent::Impl::POE::],
+   # IO::Async is just too broken - we would need workarounds for its
+   # byzantine signal and broken child handling, among others.
+   # IO::Async is rather hard to detect, as it doesn't have any
+   # obvious default class.
+#   [IO::Async::            => AnyEvent::Impl::IOAsync::],  # requires special main program
+#   [IO::Async::Loop::      => AnyEvent::Impl::IOAsync::],  # requires special main program
+#   [IO::Async::Notifier::  => AnyEvent::Impl::IOAsync::],  # requires special main program
 );
 our %method = map +($_ => 1),
    qw(io timer time now now_update signal child idle condvar one_event DESTROY);
 }
 # utility function to dup a filehandle. this is used by many backends
 # to support binding more than one watcher per filehandle (they usually
 # allow only one watcher per fd, so we dup it to get a different one).
-sub _dupfh($$$$) {
+sub _dupfh($$;$$) {
    my ($poll, $fh, $r, $w) = @_;
    # cygwin requires the fh mode to be matching, unix doesn't
-   my ($rw, $mode) = $poll eq "r" ? ($r, "<")
+   my ($rw, $mode) = $poll eq "r" ? ($r, "<") : ($w, ">");
-                   : $poll eq "w" ? ($w, ">")
-                   : Carp::croak "AnyEvent->io requires poll set to either 'r' or 'w'";
-   open my $fh2, "$mode&" . fileno $fh
+   open my $fh2, "$mode&", $fh
-      or die "cannot dup() filehandle: $!,";
+      or die "AnyEvent->io: cannot dup() filehandle in mode '$poll': $!,";
    # we assume CLOEXEC is already set by perl in all important cases
    ($fh2, $rw)
 }
 =item C<PERL_ANYEVENT_STRICT>
 AnyEvent does not do much argument checking by default, as thorough
 argument checking is very costly. Setting this variable to a true value
 will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly
-check the arguments passed to most method calls. If it finds any problems
+check the arguments passed to most method calls. If it finds any problems,
 it will croak.
 In other words, enables "strict" mode.
-Unlike C<use strict>, it is definitely recommended ot keep it off in
+Unlike C<use strict>, it is definitely recommended to keep it off in
 production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while
 developing programs can be very useful, however.
 =item C<PERL_ANYEVENT_MODEL>
 =item C<PERL_ANYEVENT_MAX_FORKS>
 The maximum number of child processes that C<AnyEvent::Util::fork_call>
 will create in parallel.
+=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>
+The default value for the C<max_outstanding> parameter for the default DNS
+resolver - this is the maximum number of parallel DNS requests that are
+sent to the DNS server.
+=item C<PERL_ANYEVENT_RESOLV_CONF>
+The file to use instead of F</etc/resolv.conf> (or OS-specific
+configuration) in the default resolver. When set to the empty string, no
+default config will be used.
+=item C<PERL_ANYEVENT_CA_FILE>, C<PERL_ANYEVENT_CA_PATH>.
+When neither C<ca_file> nor C<ca_path> was specified during
+L<AnyEvent::TLS> context creation, and either of these environment
+variables exist, they will be used to specify CA certificate locations
+instead of a system-dependent default.
 =back
 =head1 SUPPLYING YOUR OWN EVENT MODEL INTERFACE
         EV/Any   100000   224   2.88   0.34    0.27 EV + AnyEvent watchers
     CoroEV/Any   100000   224   2.85   0.35    0.28 coroutines + Coro::Signal
       Perl/Any   100000   452   4.13   0.73    0.95 pure perl implementation
    Event/Event    16000   517  32.20  31.80    0.81 Event native interface
      Event/Any    16000   590  35.85  31.55    1.06 Event + AnyEvent watchers
+   IOAsync/Any    16000   989  38.10  32.77   11.13 via IO::Async::Loop::IO_Poll
+   IOAsync/Any    16000   990  37.59  29.50   10.61 via IO::Async::Loop::Epoll
       Glib/Any    16000  1357 102.33  12.31   51.00 quadratic behaviour
         Tk/Any     2000  1860  27.20  66.31   14.00 SEGV with >> 2000 watchers
      POE/Event     2000  6328 109.99 751.67   14.02 via POE::Loop::Event
     POE/Select     2000  6027  94.54 809.13  579.80 via POE::Loop::Select
 performance becomes really bad with lots of file descriptors (and few of
 them active), of course, but this was not subject of this benchmark.
 The C<Event> module has a relatively high setup and callback invocation
 cost, but overall scores in on the third place.
+C<IO::Async> performs admirably well, about on par with C<Event>, even
+when using its pure perl backend.
 C<Glib>'s memory usage is quite a bit higher, but it features a
 faster callback invocation and overall ends up in the same class as
 C<Event>. However, Glib scales extremely badly, doubling the number of
 watchers increases the processing time by more than a factor of four,
 it to another server. This includes deleting the old timeout and creating
 a new one that moves the timeout into the future.
 =head3 Results
-    name sockets create  request
+     name sockets create  request
-      EV   20000  69.01    11.16
+       EV   20000  69.01    11.16
-    Perl   20000  73.32    35.87
+     Perl   20000  73.32    35.87
+  IOAsync   20000 157.00    98.14 epoll
+  IOAsync   20000 159.31   616.06 poll
-   Event   20000 212.62   257.32
+    Event   20000 212.62   257.32
-    Glib   20000 651.16  1896.30
+     Glib   20000 651.16  1896.30
-     POE   20000 349.67 12317.24 uses POE::Loop::Event
+      POE   20000 349.67 12317.24 uses POE::Loop::Event
 =head3 Discussion
 This benchmark I<does> measure scalability and overall performance of the
 particular event loop.
 EV is again fastest. Since it is using epoll on my system, the setup time
 is relatively high, though.
 Perl surprisingly comes second. It is much faster than the C-based event
 loops Event and Glib.
+IO::Async performs very well when using its epoll backend, and still quite
+good compared to Glib when using its pure perl backend.
 Event suffers from high setup time as well (look at its code and you will
 understand why). Callback invocation also has a high overhead compared to
 the C<< $_->() for .. >>-style loop that the Perl event loop uses. Event
 uses select or poll in basically all documented configurations.
 Recently I was told about the benchmark in the IO::Lambda manpage, which
 could be misinterpreted to make AnyEvent look bad. In fact, the benchmark
 simply compares IO::Lambda with POE, and IO::Lambda looks better (which
 shouldn't come as a surprise to anybody). As such, the benchmark is
-fine, and shows that the AnyEvent backend from IO::Lambda isn't very
+fine, and mostly shows that the AnyEvent backend from IO::Lambda isn't
-optimal. But how would AnyEvent compare when used without the extra
+very optimal. But how would AnyEvent compare when used without the extra
 baggage? To explore this, I wrote the equivalent benchmark for AnyEvent.
 The benchmark itself creates an echo-server, and then, for 500 times,
 connects to the echo server, sends a line, waits for the reply, and then
 creates the next connection. This is a rather bad benchmark, as it doesn't
-test the efficiency of the framework, but it is a benchmark nevertheless.
+test the efficiency of the framework or much non-blocking I/O, but it is a
+benchmark nevertheless.
    name                    runtime
    Lambda/select           0.330 sec
       + optimized          0.122 sec
    Lambda/AnyEvent         0.327 sec
    AnyEvent/select/nb      0.085 sec
    AnyEvent/EV/nb          0.068 sec
       +state machine       0.134 sec
-The benchmark is also a bit unfair (my fault) - the IO::Lambda
+The benchmark is also a bit unfair (my fault): the IO::Lambda/POE
 benchmarks actually make blocking connects and use 100% blocking I/O,
 defeating the purpose of an event-based solution. All of the newly
 written AnyEvent benchmarks use 100% non-blocking connects (using
 AnyEvent::Socket::tcp_connect and the asynchronous pure perl DNS
-resolver), so AnyEvent is at a disadvantage here as non-blocking connects
+resolver), so AnyEvent is at a disadvantage here, as non-blocking connects
 generally require a lot more bookkeeping and event handling than blocking
 connects (which involve a single syscall only).
 The last AnyEvent benchmark additionally uses L<AnyEvent::Handle>, which
-offers similar expressive power as POE and IO::Lambda (using conventional
+offers similar expressive power as POE and IO::Lambda, using conventional
-Perl syntax), which means both the echo server and the client are 100%
+Perl syntax. This means that both the echo server and the client are 100%
-non-blocking w.r.t. I/O, further placing it at a disadvantage.
+non-blocking, further placing it at a disadvantage.
-As you can see, AnyEvent + EV even beats the hand-optimised "raw sockets
+As you can see, the AnyEvent + EV combination even beats the
-benchmark", while AnyEvent + its pure perl backend easily beats
+hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl
-IO::Lambda and POE.
+backend easily beats IO::Lambda and POE.
 And even the 100% non-blocking version written using the high-level (and
-slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda,
+slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda by a
-even thought it does all of DNS, tcp-connect and socket I/O in a
+large margin, even though it does all of DNS, tcp-connect and socket I/O
-non-blocking way.
+in a non-blocking way.
+The two AnyEvent benchmarks programs can be found as F<eg/ae0.pl> and
+F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are
+part of the IO::lambda distribution and were used without any changes.
 =head1 SIGNALS
 AnyEvent currently installs handlers for these signals:
 =item SIGCHLD
 A handler for C<SIGCHLD> is installed by AnyEvent's child watcher
 emulation for event loops that do not support them natively. Also, some
 event loops install a similar handler.
+If, when AnyEvent is loaded, SIGCHLD is set to IGNORE, then AnyEvent will
+reset it to default, to avoid losing child exit statuses.
 =item SIGPIPE
 A no-op handler is installed for C<SIGPIPE> when C<$SIG{PIPE}> is C<undef>
 when AnyEvent gets loaded.
 =back
 =cut
+undef $SIG{CHLD}
+   if $SIG{CHLD} eq 'IGNORE';
 $SIG{PIPE} = sub { }
    unless defined $SIG{PIPE};
 =head1 FORK
 Most event libraries are not fork-safe. The ones who are usually are
 because they rely on inefficient but fork-safe C<select> or C<poll>
 Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
 be used to probe what backend is used and gain other information (which is
 probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
 $ENV{PERL_ANYEVENT_STRICT}.
+Note that AnyEvent will remove I<all> environment variables starting with
+C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
+enabled.
 =head1 BUGS
 Perl 5.8 has numerous memleaks that sometimes hit this module and are hard
 to work around. If you suffer from memleaks, first upgrade to Perl 5.10
 L<Glib>, L<Tk>, L<Event::Lib>, L<Qt>, L<POE>.
 Implementations: L<AnyEvent::Impl::EV>, L<AnyEvent::Impl::Event>,
 L<AnyEvent::Impl::Glib>, L<AnyEvent::Impl::Tk>, L<AnyEvent::Impl::Perl>,
 L<AnyEvent::Impl::EventLib>, L<AnyEvent::Impl::Qt>,
-L<AnyEvent::Impl::POE>.
+L<AnyEvent::Impl::POE>, L<AnyEvent::Impl::IOAsync>.
 Non-blocking file handles, sockets, TCP clients and
-servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>.
+servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
 Asynchronous DNS: L<AnyEvent::DNS>.
-Coroutine support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>,
+Coroutine support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>,
+L<Coro::Event>,
-Nontrivial usage examples: L<Net::FCP>, L<Net::XMPP2>, L<AnyEvent::DNS>.
+Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::XMPP>,
+L<AnyEvent::HTTP>.
 =head1 AUTHOR
    Marc Lehmann <schmorp@schmorp.de>

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent.pm (file contents): Revision 1.215 by root, Tue Jun 23 12:19:33 2009 UTC vs. Revision 1.232 by root, Thu Jul 9 01:08:22 2009 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.215 by root, Tue Jun 23 12:19:33 2009 UTC vs.
Revision 1.232 by root, Thu Jul 9 01:08:22 2009 UTC