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.277 by root, Sun Aug 9 13:27:23 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} = ...;
… …
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.92; 1121our $VERSION = '5.12';
1121our $MODEL; 1122our $MODEL;
1122 1123
1123our $AUTOLOAD; 1124our $AUTOLOAD;
1124our @ISA; 1125our @ISA;
1125 1126
… …
1288 # 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
1289 1290
1290 ($fh2, $rw) 1291 ($fh2, $rw)
1291} 1292}
1292 1293
1293############################################################################# 1294=head1 SIMPLIFIED AE API
1294# "new" API, currently only emulation of it 1295
1295############################################################################# 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
1296 1303
1297package AE; 1304package AE;
1298 1305
1299our $VERSION = $AnyEvent::VERSION; 1306our $VERSION = $AnyEvent::VERSION;
1300 1307
… …
1336 1343
1337package AnyEvent::Base; 1344package AnyEvent::Base;
1338 1345
1339# default implementations for many methods 1346# default implementations for many methods
1340 1347
1341sub _time { 1348sub _time() {
1342 # probe for availability of Time::HiRes 1349 # probe for availability of Time::HiRes
1343 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1350 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1344 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;
1345 *_time = \&Time::HiRes::time; 1352 *_time = \&Time::HiRes::time;
1346 # if (eval "use POSIX (); (POSIX::times())... 1353 # if (eval "use POSIX (); (POSIX::times())...
… …
1366 1373
1367our $HAVE_ASYNC_INTERRUPT; 1374our $HAVE_ASYNC_INTERRUPT;
1368 1375
1369sub _have_async_interrupt() { 1376sub _have_async_interrupt() {
1370 $HAVE_ASYNC_INTERRUPT = 1*(!$ENV{PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT} 1377 $HAVE_ASYNC_INTERRUPT = 1*(!$ENV{PERL_ANYEVENT_AVOID_ASYNC_INTERRUPT}
1371 && eval "use Async::Interrupt 1.0 (); 1") 1378 && eval "use Async::Interrupt 1.02 (); 1")
1372 unless defined $HAVE_ASYNC_INTERRUPT; 1379 unless defined $HAVE_ASYNC_INTERRUPT;
1373 1380
1374 $HAVE_ASYNC_INTERRUPT 1381 $HAVE_ASYNC_INTERRUPT
1375} 1382}
1376 1383
… …
1905 warn "read: $input\n"; # output what has been read 1912 warn "read: $input\n"; # output what has been read
1906 $cv->send if $input =~ /^q/i; # quit program if /^q/i 1913 $cv->send if $input =~ /^q/i; # quit program if /^q/i
1907 }, 1914 },
1908 ); 1915 );
1909 1916
1910 my $time_watcher; # can only be used once
1911
1912 sub new_timer {
1913 $timer = AnyEvent->timer (after => 1, cb => sub { 1917 my $time_watcher = AnyEvent->timer (after => 1, interval => 1, cb => sub {
1914 warn "timeout\n"; # print 'timeout' about every second 1918 warn "timeout\n"; # print 'timeout' at most every second
1915 &new_timer; # and restart the time
1916 }); 1919 });
1917 }
1918
1919 new_timer; # create first timer
1920 1920
1921 $cv->recv; # wait until user enters /^q/i 1921 $cv->recv; # wait until user enters /^q/i
1922 1922
1923=head1 REAL-WORLD EXAMPLE 1923=head1 REAL-WORLD EXAMPLE
1924 1924
… …
2055through AnyEvent. The benchmark creates a lot of timers (with a zero 2055through AnyEvent. The benchmark creates a lot of timers (with a zero
2056timeout) and I/O watchers (watching STDOUT, a pty, to become writable, 2056timeout) and I/O watchers (watching STDOUT, a pty, to become writable,
2057which it is), lets them fire exactly once and destroys them again. 2057which it is), lets them fire exactly once and destroys them again.
2058 2058
2059Source 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
2060distribution. 2060distribution. It uses the L<AE> interface, which makes a real difference
2061for the EV and Perl backends only.
2061 2062
2062=head3 Explanation of the columns 2063=head3 Explanation of the columns
2063 2064
2064I<watcher> is the number of event watchers created/destroyed. Since 2065I<watcher> is the number of event watchers created/destroyed. Since
2065different event models feature vastly different performances, each event 2066different event models feature vastly different performances, each event
… …
2086watcher. 2087watcher.
2087 2088
2088=head3 Results 2089=head3 Results
2089 2090
2090 name watchers bytes create invoke destroy comment 2091 name watchers bytes create invoke destroy comment
2091 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
2092 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
2093 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
2094 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
2095 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
2096 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
2097 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
2098 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
2099 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
2100 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
2101 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
2102 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
2103 2104
2104=head3 Discussion 2105=head3 Discussion
2105 2106
2106The benchmark does I<not> measure scalability of the event loop very 2107The benchmark does I<not> measure scalability of the event loop very
2107well. 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)
… …
2119benchmark machine, handling an event takes roughly 1600 CPU cycles with 2120benchmark machine, handling an event takes roughly 1600 CPU cycles with
2120EV, 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
2121cycles with POE. 2122cycles with POE.
2122 2123
2123C<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
2124maximal/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
2125far less memory than any other event loop and is still faster than Event 2128any other event loop and is still faster than Event natively).
2126natively.
2127 2129
2128The 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
2129constant 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
2130interpreter and the backend itself). Nevertheless this shows that it 2132interpreter and the backend itself). Nevertheless this shows that it
2131adds very little overhead in itself. Like any select-based backend its 2133adds very little overhead in itself. Like any select-based backend its
… …
2205In 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
2206(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
2207connections, most of which are idle at any one point in time. 2209connections, most of which are idle at any one point in time.
2208 2210
2209Source 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
2210distribution. 2212distribution. It uses the L<AE> interface, which makes a real difference
2213for the EV and Perl backends only.
2211 2214
2212=head3 Explanation of the columns 2215=head3 Explanation of the columns
2213 2216
2214I<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
2215each server has a read and write socket end). 2218each server has a read and write socket end).
… …
2223a new one that moves the timeout into the future. 2226a new one that moves the timeout into the future.
2224 2227
2225=head3 Results 2228=head3 Results
2226 2229
2227 name sockets create request 2230 name sockets create request
2228 EV 20000 69.01 11.16 2231 EV 20000 62.66 7.99
2229 Perl 20000 73.32 35.87 2232 Perl 20000 68.32 32.64
2230 IOAsync 20000 157.00 98.14 epoll 2233 IOAsync 20000 174.06 101.15 epoll
2231 IOAsync 20000 159.31 616.06 poll 2234 IOAsync 20000 174.67 610.84 poll
2232 Event 20000 212.62 257.32 2235 Event 20000 202.69 242.91
2233 Glib 20000 651.16 1896.30 2236 Glib 20000 557.01 1689.52
2234 POE 20000 349.67 12317.24 uses POE::Loop::Event 2237 POE 20000 341.54 12086.32 uses POE::Loop::Event
2235 2238
2236=head3 Discussion 2239=head3 Discussion
2237 2240
2238This benchmark I<does> measure scalability and overall performance of the 2241This benchmark I<does> measure scalability and overall performance of the
2239particular event loop. 2242particular event loop.
… …
2365As you can see, the AnyEvent + EV combination even beats the 2368As you can see, the AnyEvent + EV combination even beats the
2366hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl 2369hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl
2367backend easily beats IO::Lambda and POE. 2370backend easily beats IO::Lambda and POE.
2368 2371
2369And 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
2370slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda by a 2373slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda
2371large margin, even though it does all of DNS, tcp-connect and socket I/O 2374higher level ("unoptimised") abstractions by a large margin, even though
2372in a non-blocking way. 2375it does all of DNS, tcp-connect and socket I/O in a non-blocking way.
2373 2376
2374The 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
2375F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are 2378F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are
2376part of the IO::lambda distribution and were used without any changes. 2379part of the IO::Lambda distribution and were used without any changes.
2377 2380
2378 2381
2379=head1 SIGNALS 2382=head1 SIGNALS
2380 2383
2381AnyEvent currently installs handlers for these signals: 2384AnyEvent currently installs handlers for these signals:

Diff Legend

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