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.279 by root, Sun Aug 9 16:05:11 2009 UTC

… …
806=over 4 806=over 4
807 807
808=item Backends that are autoprobed when no other event loop can be found. 808=item Backends that are autoprobed when no other event loop can be found.
809 809
810EV is the preferred backend when no other event loop seems to be in 810EV 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 811use. 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 812pure-perl implementation, which is available everywhere as it comes with
813available everywhere as it comes with AnyEvent itself. 813AnyEvent itself.
814 814
815 AnyEvent::Impl::EV based on EV (interface to libev, best choice). 815 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. 816 AnyEvent::Impl::Perl pure-perl implementation, fast and portable.
818 817
819=item Backends that are transparently being picked up when they are used. 818=item Backends that are transparently being picked up when they are used.
820 819
821These will be used when they are currently loaded when the first watcher 820These 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 821is created, in which case it is assumed that the application is using
823them. This means that AnyEvent will automatically pick the right backend 822them. This means that AnyEvent will automatically pick the right backend
824when the main program loads an event module before anything starts to 823when the main program loads an event module before anything starts to
825create watchers. Nothing special needs to be done by the main program. 824create watchers. Nothing special needs to be done by the main program.
826 825
826 AnyEvent::Impl::Event based on Event, very stable, few glitches.
827 AnyEvent::Impl::Glib based on Glib, slow but very stable. 827 AnyEvent::Impl::Glib based on Glib, slow but very stable.
828 AnyEvent::Impl::Tk based on Tk, very broken. 828 AnyEvent::Impl::Tk based on Tk, very broken.
829 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 829 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
830 AnyEvent::Impl::POE based on POE, very slow, some limitations. 830 AnyEvent::Impl::POE based on POE, very slow, some limitations.
831 AnyEvent::Impl::Irssi used when running within irssi. 831 AnyEvent::Impl::Irssi used when running within irssi.
… …
1115 1115
1116BEGIN { AnyEvent::common_sense } 1116BEGIN { AnyEvent::common_sense }
1117 1117
1118use Carp (); 1118use Carp ();
1119 1119
1120our $VERSION = 4.92; 1120our $VERSION = '5.0';
1121our $MODEL; 1121our $MODEL;
1122 1122
1123our $AUTOLOAD; 1123our $AUTOLOAD;
1124our @ISA; 1124our @ISA;
1125 1125
… …
1151 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6"; 1151 $ENV{PERL_ANYEVENT_PROTOCOLS} || "ipv4,ipv6";
1152} 1152}
1153 1153
1154my @models = ( 1154my @models = (
1155 [EV:: => AnyEvent::Impl::EV:: , 1], 1155 [EV:: => AnyEvent::Impl::EV:: , 1],
1156 [Event:: => AnyEvent::Impl::Event::, 1],
1157 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl:: , 1], 1156 [AnyEvent::Impl::Perl:: => AnyEvent::Impl::Perl:: , 1],
1158 # everything below here will not (normally) be autoprobed 1157 # everything below here will not (normally) be autoprobed
1159 # as the pureperl backend should work everywhere 1158 # as the pureperl backend should work everywhere
1160 # and is usually faster 1159 # and is usually faster
1160 [Event:: => AnyEvent::Impl::Event::, 1],
1161 [Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers 1161 [Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers
1162 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 1162 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
1163 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package 1163 [Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package
1164 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles 1164 [Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
1165 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 1165 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
… …
1168 [Prima:: => AnyEvent::Impl::POE::], 1168 [Prima:: => AnyEvent::Impl::POE::],
1169 # IO::Async is just too broken - we would need workarounds for its 1169 # IO::Async is just too broken - we would need workarounds for its
1170 # byzantine signal and broken child handling, among others. 1170 # byzantine signal and broken child handling, among others.
1171 # IO::Async is rather hard to detect, as it doesn't have any 1171 # IO::Async is rather hard to detect, as it doesn't have any
1172 # obvious default class. 1172 # obvious default class.
1173# [0, IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program 1173 [IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program
1174# [0, IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program 1174 [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program
1175# [0, IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program 1175 [IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program
1176 [AnyEvent::Impl::IOAsync:: => AnyEvent::Impl::IOAsync::], # requires special main program
1176); 1177);
1177 1178
1178our %method = map +($_ => 1), 1179our %method = map +($_ => 1),
1179 qw(io timer time now now_update signal child idle condvar one_event DESTROY); 1180 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
1180 1181
… …
1287 # we assume CLOEXEC is already set by perl in all important cases 1288 # we assume CLOEXEC is already set by perl in all important cases
1288 1289
1289 ($fh2, $rw) 1290 ($fh2, $rw)
1290} 1291}
1291 1292
1292############################################################################# 1293=head1 SIMPLIFIED AE API
1293# "new" API, currently only emulation of it 1294
1294############################################################################# 1295Starting with version 5.0, AnyEvent officially supports a second, much
1296simpler, API that is designed to reduce the calling, typing and memory
1297overhead.
1298
1299See the L<AE> manpage for details.
1300
1301=cut
1295 1302
1296package AE; 1303package AE;
1297 1304
1298our $VERSION = $AnyEvent::VERSION; 1305our $VERSION = $AnyEvent::VERSION;
1299 1306
1300sub io($$$) { 1307sub io($$$) {
1301 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2]) 1308 AnyEvent->io (fh => $_[0], poll => $_[1] ? "w" : "r", cb => $_[2])
1302} 1309}
1303 1310
1304sub timer($$$) { 1311sub timer($$$) {
1305 AnyEvent->timer (after => $_[0], interval => $_[1], cb => $_[2]); 1312 AnyEvent->timer (after => $_[0], interval => $_[1], cb => $_[2])
1306} 1313}
1307 1314
1308sub signal($$) { 1315sub signal($$) {
1309 AnyEvent->signal (signal => $_[0], cb => $_[1]); 1316 AnyEvent->signal (signal => $_[0], cb => $_[1])
1310} 1317}
1311 1318
1312sub child($$) { 1319sub child($$) {
1313 AnyEvent->child (pid => $_[0], cb => $_[1]); 1320 AnyEvent->child (pid => $_[0], cb => $_[1])
1314} 1321}
1315 1322
1316sub idle($) { 1323sub idle($) {
1317 AnyEvent->idle (cb => $_[0]); 1324 AnyEvent->idle (cb => $_[0])
1318} 1325}
1319 1326
1320sub cv(;&) { 1327sub cv(;&) {
1321 AnyEvent->condvar (@_ ? (cb => $_[0]) : ()) 1328 AnyEvent->condvar (@_ ? (cb => $_[0]) : ())
1322} 1329}
… …
2054through AnyEvent. The benchmark creates a lot of timers (with a zero 2061through AnyEvent. The benchmark creates a lot of timers (with a zero
2055timeout) and I/O watchers (watching STDOUT, a pty, to become writable, 2062timeout) and I/O watchers (watching STDOUT, a pty, to become writable,
2056which it is), lets them fire exactly once and destroys them again. 2063which it is), lets them fire exactly once and destroys them again.
2057 2064
2058Source code for this benchmark is found as F<eg/bench> in the AnyEvent 2065Source code for this benchmark is found as F<eg/bench> in the AnyEvent
2059distribution. 2066distribution. It uses the L<AE> interface, which makes a real difference
2067for the EV and Perl backends only.
2060 2068
2061=head3 Explanation of the columns 2069=head3 Explanation of the columns
2062 2070
2063I<watcher> is the number of event watchers created/destroyed. Since 2071I<watcher> is the number of event watchers created/destroyed. Since
2064different event models feature vastly different performances, each event 2072different event models feature vastly different performances, each event
… …
2085watcher. 2093watcher.
2086 2094
2087=head3 Results 2095=head3 Results
2088 2096
2089 name watchers bytes create invoke destroy comment 2097 name watchers bytes create invoke destroy comment
2090 EV/EV 400000 224 0.47 0.35 0.27 EV native interface 2098 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 2099 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 2100 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 2101 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 2102 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 2103 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 2104 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 2105 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 2106 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 2107 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 2108 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 2109 POE/Any 2000 6648 94.79 774.40 575.51 via POE::Loop::Select
2102 2110
2103=head3 Discussion 2111=head3 Discussion
2104 2112
2105The benchmark does I<not> measure scalability of the event loop very 2113The 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) 2114well. For example, a select-based event loop (such as the pure perl one)
… …
2118benchmark machine, handling an event takes roughly 1600 CPU cycles with 2126benchmark machine, handling an event takes roughly 1600 CPU cycles with
2119EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000 CPU 2127EV, 3100 CPU cycles with AnyEvent's pure perl loop and almost 3000000 CPU
2120cycles with POE. 2128cycles with POE.
2121 2129
2122C<EV> is the sole leader regarding speed and memory use, which are both 2130C<EV> is the sole leader regarding speed and memory use, which are both
2123maximal/minimal, respectively. Even when going through AnyEvent, it uses 2131maximal/minimal, respectively. When using the L<AE> API there is zero
2132overhead (when going through the AnyEvent API create is about 5-6 times
2133slower, 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 2134any other event loop and is still faster than Event natively).
2125natively.
2126 2135
2127The pure perl implementation is hit in a few sweet spots (both the 2136The 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 2137constant timeout and the use of a single fd hit optimisations in the perl
2129interpreter and the backend itself). Nevertheless this shows that it 2138interpreter and the backend itself). Nevertheless this shows that it
2130adds very little overhead in itself. Like any select-based backend its 2139adds very little overhead in itself. Like any select-based backend its
… …
2204In this benchmark, we use 10000 socket pairs (20000 sockets), of which 100 2213In 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 2214(1%) are active. This mirrors the activity of large servers with many
2206connections, most of which are idle at any one point in time. 2215connections, most of which are idle at any one point in time.
2207 2216
2208Source code for this benchmark is found as F<eg/bench2> in the AnyEvent 2217Source code for this benchmark is found as F<eg/bench2> in the AnyEvent
2209distribution. 2218distribution. It uses the L<AE> interface, which makes a real difference
2219for the EV and Perl backends only.
2210 2220
2211=head3 Explanation of the columns 2221=head3 Explanation of the columns
2212 2222
2213I<sockets> is the number of sockets, and twice the number of "servers" (as 2223I<sockets> is the number of sockets, and twice the number of "servers" (as
2214each server has a read and write socket end). 2224each server has a read and write socket end).
… …
2222a new one that moves the timeout into the future. 2232a new one that moves the timeout into the future.
2223 2233
2224=head3 Results 2234=head3 Results
2225 2235
2226 name sockets create request 2236 name sockets create request
2227 EV 20000 69.01 11.16 2237 EV 20000 62.66 7.99
2228 Perl 20000 73.32 35.87 2238 Perl 20000 68.32 32.64
2229 IOAsync 20000 157.00 98.14 epoll 2239 IOAsync 20000 174.06 101.15 epoll
2230 IOAsync 20000 159.31 616.06 poll 2240 IOAsync 20000 174.67 610.84 poll
2231 Event 20000 212.62 257.32 2241 Event 20000 202.69 242.91
2232 Glib 20000 651.16 1896.30 2242 Glib 20000 557.01 1689.52
2233 POE 20000 349.67 12317.24 uses POE::Loop::Event 2243 POE 20000 341.54 12086.32 uses POE::Loop::Event
2234 2244
2235=head3 Discussion 2245=head3 Discussion
2236 2246
2237This benchmark I<does> measure scalability and overall performance of the 2247This benchmark I<does> measure scalability and overall performance of the
2238particular event loop. 2248particular event loop.

Diff Legend

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