ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent/lib/AnyEvent.pm
(Generate patch)

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.275 by root, Sun Aug 9 00:24:35 2009 UTC vs.
Revision 1.296 by root, Tue Nov 17 01:19:49 2009 UTC

… …
362this "current" time will differ substantially from the real time, which 362this "current" time will differ substantially from the real time, which
363might affect timers and time-outs. 363might affect timers and time-outs.
364 364
365When this is the case, you can call this method, which will update the 365When this is the case, you can call this method, which will update the
366event loop's idea of "current time". 366event loop's idea of "current time".
367
368A typical example would be a script in a web server (e.g. C<mod_perl>) -
369when mod_perl executes the script, then the event loop will have the wrong
370idea about the "current time" (being potentially far in the past, when the
371script ran the last time). In that case you should arrange a call to C<<
372AnyEvent->now_update >> each time the web server process wakes up again
373(e.g. at the start of your script, or in a handler).
367 374
368Note that updating the time I<might> cause some events to be handled. 375Note that updating the time I<might> cause some events to be handled.
369 376
370=back 377=back
371 378
… …
592 after => 1, 599 after => 1,
593 cb => sub { $result_ready->send }, 600 cb => sub { $result_ready->send },
594 ); 601 );
595 602
596 # this "blocks" (while handling events) till the callback 603 # this "blocks" (while handling events) till the callback
597 # calls -<send 604 # calls ->send
598 $result_ready->recv; 605 $result_ready->recv;
599 606
600Example: wait for a timer, but take advantage of the fact that condition 607Example: wait for a timer, but take advantage of the fact that condition
601variables are also callable directly. 608variables are also callable directly.
602 609
… …
666one. For example, a function that pings many hosts in parallel might want 673one. For example, a function that pings many hosts in parallel might want
667to use a condition variable for the whole process. 674to use a condition variable for the whole process.
668 675
669Every call to C<< ->begin >> will increment a counter, and every call to 676Every call to C<< ->begin >> will increment a counter, and every call to
670C<< ->end >> will decrement it. If the counter reaches C<0> in C<< ->end 677C<< ->end >> will decrement it. If the counter reaches C<0> in C<< ->end
671>>, the (last) callback passed to C<begin> will be executed. That callback 678>>, the (last) callback passed to C<begin> will be executed, passing the
672is I<supposed> to call C<< ->send >>, but that is not required. If no 679condvar as first argument. That callback is I<supposed> to call C<< ->send
673callback was set, C<send> will be called without any arguments. 680>>, but that is not required. If no group callback was set, C<send> will
681be called without any arguments.
674 682
675You can think of C<< $cv->send >> giving you an OR condition (one call 683You can think of C<< $cv->send >> giving you an OR condition (one call
676sends), while C<< $cv->begin >> and C<< $cv->end >> giving you an AND 684sends), while C<< $cv->begin >> and C<< $cv->end >> giving you an AND
677condition (all C<begin> calls must be C<end>'ed before the condvar sends). 685condition (all C<begin> calls must be C<end>'ed before the condvar sends).
678 686
… …
705begung can potentially be zero: 713begung can potentially be zero:
706 714
707 my $cv = AnyEvent->condvar; 715 my $cv = AnyEvent->condvar;
708 716
709 my %result; 717 my %result;
710 $cv->begin (sub { $cv->send (\%result) }); 718 $cv->begin (sub { shift->send (\%result) });
711 719
712 for my $host (@list_of_hosts) { 720 for my $host (@list_of_hosts) {
713 $cv->begin; 721 $cv->begin;
714 ping_host_then_call_callback $host, sub { 722 ping_host_then_call_callback $host, sub {
715 $result{$host} = ...; 723 $result{$host} = ...;
… …
806=over 4 814=over 4
807 815
808=item Backends that are autoprobed when no other event loop can be found. 816=item Backends that are autoprobed when no other event loop can be found.
809 817
810EV is the preferred backend when no other event loop seems to be in 818EV is the preferred backend when no other event loop seems to be in
811use. If EV is not installed, then AnyEvent will try Event, and, failing 819use. If EV is not installed, then AnyEvent will fall back to its own
812that, will fall back to its own pure-perl implementation, which is 820pure-perl implementation, which is available everywhere as it comes with
813available everywhere as it comes with AnyEvent itself. 821AnyEvent itself.
814 822
815 AnyEvent::Impl::EV based on EV (interface to libev, best choice). 823 AnyEvent::Impl::EV based on EV (interface to libev, best choice).
816 AnyEvent::Impl::Event based on Event, very stable, few glitches.
817 AnyEvent::Impl::Perl pure-perl implementation, fast and portable. 824 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
818 825
819=item Backends that are transparently being picked up when they are used. 826=item Backends that are transparently being picked up when they are used.
820 827
821These will be used when they are currently loaded when the first watcher 828These will be used when they are currently loaded when the first watcher
822is created, in which case it is assumed that the application is using 829is created, in which case it is assumed that the application is using
823them. This means that AnyEvent will automatically pick the right backend 830them. This means that AnyEvent will automatically pick the right backend
824when the main program loads an event module before anything starts to 831when the main program loads an event module before anything starts to
825create watchers. Nothing special needs to be done by the main program. 832create watchers. Nothing special needs to be done by the main program.
826 833
834 AnyEvent::Impl::Event based on Event, very stable, few glitches.
827 AnyEvent::Impl::Glib based on Glib, slow but very stable. 835 AnyEvent::Impl::Glib based on Glib, slow but very stable.
828 AnyEvent::Impl::Tk based on Tk, very broken. 836 AnyEvent::Impl::Tk based on Tk, very broken.
829 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 837 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
830 AnyEvent::Impl::POE based on POE, very slow, some limitations. 838 AnyEvent::Impl::POE based on POE, very slow, some limitations.
831 AnyEvent::Impl::Irssi used when running within irssi. 839 AnyEvent::Impl::Irssi used when running within irssi.
… …
1105 1113
1106package AnyEvent; 1114package AnyEvent;
1107 1115
1108# basically a tuned-down version of common::sense 1116# basically a tuned-down version of common::sense
1109sub common_sense { 1117sub common_sense {
1110 # no warnings 1118 # from common:.sense 1.0
1111 ${^WARNING_BITS} ^= ${^WARNING_BITS}; 1119 ${^WARNING_BITS} = "\xfc\x3f\xf3\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x03";
1112 # use strict vars subs 1120 # use strict vars subs
1113 $^H |= 0x00000600; 1121 $^H |= 0x00000600;
1114} 1122}
1115 1123
1116BEGIN { AnyEvent::common_sense } 1124BEGIN { AnyEvent::common_sense }
1117 1125
1118use Carp (); 1126use Carp ();
1119 1127
1120our $VERSION = 4.92; 1128our $VERSION = '5.202';
1121our $MODEL; 1129our $MODEL;
1122 1130
1123our $AUTOLOAD; 1131our $AUTOLOAD;
1124our @ISA; 1132our @ISA;
1125 1133
… …
1151 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6"; 1159 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6";
1152} 1160}
1153 1161
1154my @models = ( 1162my @models = (
1155 [EV:: => AnyEvent::Impl::EV:: , 1], 1163 [EV:: => AnyEvent::Impl::EV:: , 1],
1156 [Event:: => AnyEvent::Impl::Event::, 1],
1157 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl:: , 1], 1164 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl:: , 1],
1158 # everything below here will not (normally) be autoprobed 1165 # everything below here will not (normally) be autoprobed
1159 # as the pureperl backend should work everywhere 1166 # as the pureperl backend should work everywhere
1160 # and is usually faster 1167 # and is usually faster
1168 [Event:: => AnyEvent::Impl::Event::, 1],
1161 [Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers 1169 [Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers
1162 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 1170 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
1163 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package 1171 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package
1164 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles 1172 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
1165 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 1173 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
… …
1168 [Prima:: => AnyEvent::Impl::POE::], 1176 [Prima:: => AnyEvent::Impl::POE::],
1169 # IO::Async is just too broken - we would need workarounds for its 1177 # IO::Async is just too broken - we would need workarounds for its
1170 # byzantine signal and broken child handling, among others. 1178 # byzantine signal and broken child handling, among others.
1171 # IO::Async is rather hard to detect, as it doesn't have any 1179 # IO::Async is rather hard to detect, as it doesn't have any
1172 # obvious default class. 1180 # obvious default class.
1173# [0, IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program 1181 [IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program
1174# [0, IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program 1182 [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program
1175# [0, IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program 1183 [IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program
1184 [AnyEvent::Impl::IOAsync:: => AnyEvent::Impl::IOAsync::], # requires special main program
1176); 1185);
1177 1186
1178our %method = map +($_ => 1), 1187our %method = map +($_ => 1),
1179 qw(io timer time now now_update signal child idle condvar one_event DESTROY); 1188 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
1180 1189
… …
1287 # we assume CLOEXEC is already set by perl in all important cases 1296 # we assume CLOEXEC is already set by perl in all important cases
1288 1297
1289 ($fh2, $rw) 1298 ($fh2, $rw)
1290} 1299}
1291 1300
1292############################################################################# 1301=head1 SIMPLIFIED AE API
1293# "new" API, currently only emulation of it 1302
1294############################################################################# 1303Starting with version 5.0, AnyEvent officially supports a second, much
1304simpler, API that is designed to reduce the calling, typing and memory
1305overhead.
1306
1307See the L<AE> manpage for details.
1308
1309=cut
1295 1310
1296package AE; 1311package AE;
1297 1312
1298our $VERSION = $AnyEvent::VERSION; 1313our $VERSION = $AnyEvent::VERSION;
1299 1314
1300sub io($$$) { 1315sub io($$$) {
1301 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2]) 1316 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
1302} 1317}
1303 1318
1304sub timer($$$) { 1319sub timer($$$) {
1305 AnyEvent->timer (after => $_[0], interval => $_[1], cb => $_[2]); 1320 AnyEvent->timer (after => $_[0], interval => $_[1], cb => $_[2])
1306} 1321}
1307 1322
1308sub signal($$) { 1323sub signal($$) {
1309 AnyEvent->signal (signal => $_[0], cb => $_[1]); 1324 AnyEvent->signal (signal => $_[0], cb => $_[1])
1310} 1325}
1311 1326
1312sub child($$) { 1327sub child($$) {
1313 AnyEvent->child (pid => $_[0], cb => $_[1]); 1328 AnyEvent->child (pid => $_[0], cb => $_[1])
1314} 1329}
1315 1330
1316sub idle($) { 1331sub idle($) {
1317 AnyEvent->idle (cb => $_[0]); 1332 AnyEvent->idle (cb => $_[0])
1318} 1333}
1319 1334
1320sub cv(;&) { 1335sub cv(;&) {
1321 AnyEvent->condvar (@_ ? (cb => $_[0]) : ()) 1336 AnyEvent->condvar (@_ ? (cb => $_[0]) : ())
1322} 1337}
… …
1335 1350
1336package AnyEvent::Base; 1351package AnyEvent::Base;
1337 1352
1338# default implementations for many methods 1353# default implementations for many methods
1339 1354
1340sub _time { 1355sub _time() {
1341 # probe for availability of Time::HiRes 1356 # probe for availability of Time::HiRes
1342 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1357 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1343 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8; 1358 warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1344 *_time = \&Time::HiRes::time; 1359 *_time = \&Time::HiRes::time;
1345 # if (eval "use POSIX (); (POSIX::times())... 1360 # if (eval "use POSIX (); (POSIX::times())...
… …
1365 1380
1366our $HAVE_ASYNC_INTERRUPT; 1381our $HAVE_ASYNC_INTERRUPT;
1367 1382
1368sub _have_async_interrupt() { 1383sub _have_async_interrupt() {
1369 $HAVE_ASYNC_INTERRUPT = 1*(!$ENV{PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT} 1384 $HAVE_ASYNC_INTERRUPT = 1*(!$ENV{PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT}
1370 && eval "use Async::Interrupt 1.0 (); 1") 1385 && eval "use Async::Interrupt 1.02 (); 1")
1371 unless defined $HAVE_ASYNC_INTERRUPT; 1386 unless defined $HAVE_ASYNC_INTERRUPT;
1372 1387
1373 $HAVE_ASYNC_INTERRUPT 1388 $HAVE_ASYNC_INTERRUPT
1374} 1389}
1375 1390
… …
1378our ($SIG_COUNT, $SIG_TW); 1393our ($SIG_COUNT, $SIG_TW);
1379 1394
1380sub _signal_exec { 1395sub _signal_exec {
1381 $HAVE_ASYNC_INTERRUPT 1396 $HAVE_ASYNC_INTERRUPT
1382 ? $SIGPIPE_R->drain 1397 ? $SIGPIPE_R->drain
1383 : sysread $SIGPIPE_R, my $dummy, 9; 1398 : sysread $SIGPIPE_R, (my $dummy), 9;
1384 1399
1385 while (%SIG_EV) { 1400 while (%SIG_EV) {
1386 for (keys %SIG_EV) { 1401 for (keys %SIG_EV) {
1387 delete $SIG_EV{$_}; 1402 delete $SIG_EV{$_};
1388 $_->() for values %{ $SIG_CB{$_} || {} }; 1403 $_->() for values %{ $SIG_CB{$_} || {} };
… …
1904 warn "read: $input\n"; # output what has been read 1919 warn "read: $input\n"; # output what has been read
1905 $cv->send if $input =~ /^q/i; # quit program if /^q/i 1920 $cv->send if $input =~ /^q/i; # quit program if /^q/i
1906 }, 1921 },
1907 ); 1922 );
1908 1923
1909 my $time_watcher; # can only be used once
1910
1911 sub new_timer {
1912 $timer = AnyEvent->timer (after => 1, cb => sub { 1924 my $time_watcher = AnyEvent->timer (after => 1, interval => 1, cb => sub {
1913 warn "timeout\n"; # print 'timeout' about every second 1925 warn "timeout\n"; # print 'timeout' at most every second
1914 &new_timer; # and restart the time
1915 }); 1926 });
1916 }
1917
1918 new_timer; # create first timer
1919 1927
1920 $cv->recv; # wait until user enters /^q/i 1928 $cv->recv; # wait until user enters /^q/i
1921 1929
1922=head1 REAL-WORLD EXAMPLE 1930=head1 REAL-WORLD EXAMPLE
1923 1931
… …
2054through AnyEvent. The benchmark creates a lot of timers (with a zero 2062through AnyEvent. The benchmark creates a lot of timers (with a zero
2055timeout) and I/O watchers (watching STDOUT, a pty, to become writable, 2063timeout) and I/O watchers (watching STDOUT, a pty, to become writable,
2056which it is), lets them fire exactly once and destroys them again. 2064which it is), lets them fire exactly once and destroys them again.
2057 2065
2058Source code for this benchmark is found as F<eg/bench> in the AnyEvent 2066Source code for this benchmark is found as F<eg/bench> in the AnyEvent
2059distribution. 2067distribution. It uses the L<AE> interface, which makes a real difference
2068for the EV and Perl backends only.
2060 2069
2061=head3 Explanation of the columns 2070=head3 Explanation of the columns
2062 2071
2063I<watcher> is the number of event watchers created/destroyed. Since 2072I<watcher> is the number of event watchers created/destroyed. Since
2064different event models feature vastly different performances, each event 2073different event models feature vastly different performances, each event
… …
2085watcher. 2094watcher.
2086 2095
2087=head3 Results 2096=head3 Results
2088 2097
2089 name watchers bytes create invoke destroy comment 2098 name watchers bytes create invoke destroy comment
2090 EV/EV 400000 224 0.47 0.35 0.27 EV native interface 2099 EV/EV 100000 223 0.47 0.43 0.27 EV native interface
2091 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers 2100 EV/Any 100000 223 0.48 0.42 0.26 EV + AnyEvent watchers
2092 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal 2101 Coro::EV/Any 100000 223 0.47 0.42 0.26 coroutines + Coro::Signal
2093 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation 2102 Perl/Any 100000 431 2.70 0.74 0.92 pure perl implementation
2094 Event/Event 16000 517 32.20 31.80 0.81 Event native interface 2103 Event/Event 16000 516 31.16 31.84 0.82 Event native interface
2095 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers 2104 Event/Any 16000 1203 42.61 34.79 1.80 Event + AnyEvent watchers
2096 IOAsync/Any 16000 989 38.10 32.77 11.13 via IO::Async::Loop::IO_Poll 2105 IOAsync/Any 16000 1911 41.92 27.45 16.81 via IO::Async::Loop::IO_Poll
2097 IOAsync/Any 16000 990 37.59 29.50 10.61 via IO::Async::Loop::Epoll 2106 IOAsync/Any 16000 1726 40.69 26.37 15.25 via IO::Async::Loop::Epoll
2098 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour 2107 Glib/Any 16000 1118 89.00 12.57 51.17 quadratic behaviour
2099 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers 2108 Tk/Any 2000 1346 20.96 10.75 8.00 SEGV with >> 2000 watchers
2100 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event 2109 POE/Any 2000 6951 108.97 795.32 14.24 via POE::Loop::Event
2101 POE/Select 2000 6027 94.54 809.13 579.80 via POE::Loop::Select 2110 POE/Any 2000 6648 94.79 774.40 575.51 via POE::Loop::Select
2102 2111
2103=head3 Discussion 2112=head3 Discussion
2104 2113
2105The benchmark does I<not> measure scalability of the event loop very 2114The benchmark does I<not> measure scalability of the event loop very
2106well. For example, a select-based event loop (such as the pure perl one) 2115well. For example, a select-based event loop (such as the pure perl one)
… …
2118benchmark machine, handling an event takes roughly 1600 CPU cycles with 2127benchmark machine, handling an event takes roughly 1600 CPU cycles with
2119EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000 CPU 2128EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000 CPU
2120cycles with POE. 2129cycles with POE.
2121 2130
2122C<EV> is the sole leader regarding speed and memory use, which are both 2131C<EV> is the sole leader regarding speed and memory use, which are both
2123maximal/minimal, respectively. Even when going through AnyEvent, it uses 2132maximal/minimal, respectively. When using the L<AE> API there is zero
2133overhead (when going through the AnyEvent API create is about 5-6 times
2134slower, with other times being equal, so still uses far less memory than
2124far less memory than any other event loop and is still faster than Event 2135any other event loop and is still faster than Event natively).
2125natively.
2126 2136
2127The pure perl implementation is hit in a few sweet spots (both the 2137The pure perl implementation is hit in a few sweet spots (both the
2128constant timeout and the use of a single fd hit optimisations in the perl 2138constant timeout and the use of a single fd hit optimisations in the perl
2129interpreter and the backend itself). Nevertheless this shows that it 2139interpreter and the backend itself). Nevertheless this shows that it
2130adds very little overhead in itself. Like any select-based backend its 2140adds very little overhead in itself. Like any select-based backend its
… …
2204In this benchmark, we use 10000 socket pairs (20000 sockets), of which 100 2214In this benchmark, we use 10000 socket pairs (20000 sockets), of which 100
2205(1%) are active. This mirrors the activity of large servers with many 2215(1%) are active. This mirrors the activity of large servers with many
2206connections, most of which are idle at any one point in time. 2216connections, most of which are idle at any one point in time.
2207 2217
2208Source code for this benchmark is found as F<eg/bench2> in the AnyEvent 2218Source code for this benchmark is found as F<eg/bench2> in the AnyEvent
2209distribution. 2219distribution. It uses the L<AE> interface, which makes a real difference
2220for the EV and Perl backends only.
2210 2221
2211=head3 Explanation of the columns 2222=head3 Explanation of the columns
2212 2223
2213I<sockets> is the number of sockets, and twice the number of "servers" (as 2224I<sockets> is the number of sockets, and twice the number of "servers" (as
2214each server has a read and write socket end). 2225each server has a read and write socket end).
… …
2222a new one that moves the timeout into the future. 2233a new one that moves the timeout into the future.
2223 2234
2224=head3 Results 2235=head3 Results
2225 2236
2226 name sockets create request 2237 name sockets create request
2227 EV 20000 69.01 11.16 2238 EV 20000 62.66 7.99
2228 Perl 20000 73.32 35.87 2239 Perl 20000 68.32 32.64
2229 IOAsync 20000 157.00 98.14 epoll 2240 IOAsync 20000 174.06 101.15 epoll
2230 IOAsync 20000 159.31 616.06 poll 2241 IOAsync 20000 174.67 610.84 poll
2231 Event 20000 212.62 257.32 2242 Event 20000 202.69 242.91
2232 Glib 20000 651.16 1896.30 2243 Glib 20000 557.01 1689.52
2233 POE 20000 349.67 12317.24 uses POE::Loop::Event 2244 POE 20000 341.54 12086.32 uses POE::Loop::Event
2234 2245
2235=head3 Discussion 2246=head3 Discussion
2236 2247
2237This benchmark I<does> measure scalability and overall performance of the 2248This benchmark I<does> measure scalability and overall performance of the
2238particular event loop. 2249particular event loop.
… …
2364As you can see, the AnyEvent + EV combination even beats the 2375As you can see, the AnyEvent + EV combination even beats the
2365hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl 2376hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl
2366backend easily beats IO::Lambda and POE. 2377backend easily beats IO::Lambda and POE.
2367 2378
2368And even the 100% non-blocking version written using the high-level (and 2379And even the 100% non-blocking version written using the high-level (and
2369slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda by a 2380slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda
2370large margin, even though it does all of DNS, tcp-connect and socket I/O 2381higher level ("unoptimised") abstractions by a large margin, even though
2371in a non-blocking way. 2382it does all of DNS, tcp-connect and socket I/O in a non-blocking way.
2372 2383
2373The two AnyEvent benchmarks programs can be found as F<eg/ae0.pl> and 2384The two AnyEvent benchmarks programs can be found as F<eg/ae0.pl> and
2374F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are 2385F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are
2375part of the IO::lambda distribution and were used without any changes. 2386part of the IO::Lambda distribution and were used without any changes.
2376 2387
2377 2388
2378=head1 SIGNALS 2389=head1 SIGNALS
2379 2390
2380AnyEvent currently installs handlers for these signals: 2391AnyEvent currently installs handlers for these signals:
… …
2469lot less memory), but otherwise doesn't affect guard operation much. It is 2480lot less memory), but otherwise doesn't affect guard operation much. It is
2470purely used for performance. 2481purely used for performance.
2471 2482
2472=item L<JSON> and L<JSON::XS> 2483=item L<JSON> and L<JSON::XS>
2473 2484
2474This module is required when you want to read or write JSON data via 2485One of these modules is required when you want to read or write JSON data
2475L<AnyEvent::Handle>. It is also written in pure-perl, but can take 2486via L<AnyEvent::Handle>. It is also written in pure-perl, but can take
2476advantage of the ultra-high-speed L<JSON::XS> module when it is installed. 2487advantage of the ultra-high-speed L<JSON::XS> module when it is installed.
2477 2488
2478In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is 2489In fact, L<AnyEvent::Handle> will use L<JSON::XS> by default if it is
2479installed. 2490installed.
2480 2491

Diff Legend

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