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.273 by root, Thu Aug 6 13:45:04 2009 UTC vs.
Revision 1.290 by root, Tue Sep 1 18:27:46 2009 UTC

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

Diff Legend

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