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.186 by root, Mon Oct 27 02:58:19 2008 UTC vs.
Revision 1.215 by root, Tue Jun 23 12:19:33 2009 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent - provide framework for multiple event loops 3AnyEvent - provide framework for multiple event loops
4 4
5EV, Event, Glib, Tk, Perl, Event::Lib, Qt, POE - various supported event loops 5EV, Event, Glib, Tk, Perl, Event::Lib, Qt and POE are various supported
6event loops.
6 7
7=head1 SYNOPSIS 8=head1 SYNOPSIS
8 9
9 use AnyEvent; 10 use AnyEvent;
10 11
12 # file descriptor readable
11 my $w = AnyEvent->io (fh => $fh, poll => "r|w", cb => sub { ... }); 13 my $w = AnyEvent->io (fh => $fh, poll => "r", cb => sub { ... });
12 14
15 # one-shot or repeating timers
13 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... }); 16 my $w = AnyEvent->timer (after => $seconds, cb => sub { ... });
14 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ... 17 my $w = AnyEvent->timer (after => $seconds, interval => $seconds, cb => ...
15 18
16 print AnyEvent->now; # prints current event loop time 19 print AnyEvent->now; # prints current event loop time
17 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time. 20 print AnyEvent->time; # think Time::HiRes::time or simply CORE::time.
18 21
22 # POSIX signal
19 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... }); 23 my $w = AnyEvent->signal (signal => "TERM", cb => sub { ... });
20 24
25 # child process exit
21 my $w = AnyEvent->child (pid => $pid, cb => sub { 26 my $w = AnyEvent->child (pid => $pid, cb => sub {
22 my ($pid, $status) = @_; 27 my ($pid, $status) = @_;
23 ... 28 ...
24 }); 29 });
30
31 # called when event loop idle (if applicable)
32 my $w = AnyEvent->idle (cb => sub { ... });
25 33
26 my $w = AnyEvent->condvar; # stores whether a condition was flagged 34 my $w = AnyEvent->condvar; # stores whether a condition was flagged
27 $w->send; # wake up current and all future recv's 35 $w->send; # wake up current and all future recv's
28 $w->recv; # enters "main loop" till $condvar gets ->send 36 $w->recv; # enters "main loop" till $condvar gets ->send
29 # use a condvar in callback mode: 37 # use a condvar in callback mode:
… …
137These watchers are normal Perl objects with normal Perl lifetime. After 145These watchers are normal Perl objects with normal Perl lifetime. After
138creating a watcher it will immediately "watch" for events and invoke the 146creating a watcher it will immediately "watch" for events and invoke the
139callback when the event occurs (of course, only when the event model 147callback when the event occurs (of course, only when the event model
140is in control). 148is in control).
141 149
150Note that B<callbacks must not permanently change global variables>
151potentially in use by the event loop (such as C<$_> or C<$[>) and that B<<
152callbacks must not C<die> >>. The former is good programming practise in
153Perl and the latter stems from the fact that exception handling differs
154widely between event loops.
155
142To disable the watcher you have to destroy it (e.g. by setting the 156To disable the watcher you have to destroy it (e.g. by setting the
143variable you store it in to C<undef> or otherwise deleting all references 157variable you store it in to C<undef> or otherwise deleting all references
144to it). 158to it).
145 159
146All watchers are created by calling a method on the C<AnyEvent> class. 160All watchers are created by calling a method on the C<AnyEvent> class.
… …
162=head2 I/O WATCHERS 176=head2 I/O WATCHERS
163 177
164You can create an I/O watcher by calling the C<< AnyEvent->io >> method 178You can create an I/O watcher by calling the C<< AnyEvent->io >> method
165with the following mandatory key-value pairs as arguments: 179with the following mandatory key-value pairs as arguments:
166 180
167C<fh> the Perl I<file handle> (I<not> file descriptor) to watch for events 181C<fh> is the Perl I<file handle> (I<not> file descriptor) to watch
168(AnyEvent might or might not keep a reference to this file handle). C<poll> 182for events (AnyEvent might or might not keep a reference to this file
183handle). Note that only file handles pointing to things for which
184non-blocking operation makes sense are allowed. This includes sockets,
185most character devices, pipes, fifos and so on, but not for example files
186or block devices.
187
169must be a string that is either C<r> or C<w>, which creates a watcher 188C<poll> must be a string that is either C<r> or C<w>, which creates a
170waiting for "r"eadable or "w"ritable events, respectively. C<cb> is the 189watcher waiting for "r"eadable or "w"ritable events, respectively.
190
171callback to invoke each time the file handle becomes ready. 191C<cb> is the callback to invoke each time the file handle becomes ready.
172 192
173Although the callback might get passed parameters, their value and 193Although the callback might get passed parameters, their value and
174presence is undefined and you cannot rely on them. Portable AnyEvent 194presence is undefined and you cannot rely on them. Portable AnyEvent
175callbacks cannot use arguments passed to I/O watcher callbacks. 195callbacks cannot use arguments passed to I/O watcher callbacks.
176 196
… …
307 327
308In either case, if you care (and in most cases, you don't), then you 328In either case, if you care (and in most cases, you don't), then you
309can get whatever behaviour you want with any event loop, by taking the 329can get whatever behaviour you want with any event loop, by taking the
310difference between C<< AnyEvent->time >> and C<< AnyEvent->now >> into 330difference between C<< AnyEvent->time >> and C<< AnyEvent->now >> into
311account. 331account.
332
333=item AnyEvent->now_update
334
335Some event loops (such as L<EV> or L<AnyEvent::Impl::Perl>) cache
336the current time for each loop iteration (see the discussion of L<<
337AnyEvent->now >>, above).
338
339When a callback runs for a long time (or when the process sleeps), then
340this "current" time will differ substantially from the real time, which
341might affect timers and time-outs.
342
343When this is the case, you can call this method, which will update the
344event loop's idea of "current time".
345
346Note that updating the time I<might> cause some events to be handled.
312 347
313=back 348=back
314 349
315=head2 SIGNAL WATCHERS 350=head2 SIGNAL WATCHERS
316 351
… …
383 ); 418 );
384 419
385 # do something else, then wait for process exit 420 # do something else, then wait for process exit
386 $done->recv; 421 $done->recv;
387 422
423=head2 IDLE WATCHERS
424
425Sometimes there is a need to do something, but it is not so important
426to do it instantly, but only when there is nothing better to do. This
427"nothing better to do" is usually defined to be "no other events need
428attention by the event loop".
429
430Idle watchers ideally get invoked when the event loop has nothing
431better to do, just before it would block the process to wait for new
432events. Instead of blocking, the idle watcher is invoked.
433
434Most event loops unfortunately do not really support idle watchers (only
435EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
436will simply call the callback "from time to time".
437
438Example: read lines from STDIN, but only process them when the
439program is otherwise idle:
440
441 my @lines; # read data
442 my $idle_w;
443 my $io_w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
444 push @lines, scalar <STDIN>;
445
446 # start an idle watcher, if not already done
447 $idle_w ||= AnyEvent->idle (cb => sub {
448 # handle only one line, when there are lines left
449 if (my $line = shift @lines) {
450 print "handled when idle: $line";
451 } else {
452 # otherwise disable the idle watcher again
453 undef $idle_w;
454 }
455 });
456 });
457
388=head2 CONDITION VARIABLES 458=head2 CONDITION VARIABLES
389 459
390If you are familiar with some event loops you will know that all of them 460If you are familiar with some event loops you will know that all of them
391require you to run some blocking "loop", "run" or similar function that 461require you to run some blocking "loop", "run" or similar function that
392will actively watch for new events and call your callbacks. 462will actively watch for new events and call your callbacks.
… …
861no warnings; 931no warnings;
862use strict qw(vars subs); 932use strict qw(vars subs);
863 933
864use Carp; 934use Carp;
865 935
866our $VERSION = 4.3; 936our $VERSION = 4.411;
867our $MODEL; 937our $MODEL;
868 938
869our $AUTOLOAD; 939our $AUTOLOAD;
870our @ISA; 940our @ISA;
871 941
872our @REGISTRY; 942our @REGISTRY;
873 943
874our $WIN32; 944our $WIN32;
875 945
876BEGIN { 946BEGIN {
877 my $win32 = ! ! ($^O =~ /mswin32/i); 947 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";
878 eval "sub WIN32(){ $win32 }"; 948 eval "sub TAINT(){ " . (${^TAINT}*1) . " }";
949
950 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
951 if ${^TAINT};
879} 952}
880 953
881our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1; 954our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1;
882 955
883our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 956our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
… …
903 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza 976 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
904 [Wx:: => AnyEvent::Impl::POE::], 977 [Wx:: => AnyEvent::Impl::POE::],
905 [Prima:: => AnyEvent::Impl::POE::], 978 [Prima:: => AnyEvent::Impl::POE::],
906); 979);
907 980
908our %method = map +($_ => 1), qw(io timer time now signal child condvar one_event DESTROY); 981our %method = map +($_ => 1),
982 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
909 983
910our @post_detect; 984our @post_detect;
911 985
912sub post_detect(&) { 986sub post_detect(&) {
913 my ($cb) = @_; 987 my ($cb) = @_;
… …
918 1 992 1
919 } else { 993 } else {
920 push @post_detect, $cb; 994 push @post_detect, $cb;
921 995
922 defined wantarray 996 defined wantarray
923 ? bless \$cb, "AnyEvent::Util::PostDetect" 997 ? bless \$cb, "AnyEvent::Util::postdetect"
924 : () 998 : ()
925 } 999 }
926} 1000}
927 1001
928sub AnyEvent::Util::PostDetect::DESTROY { 1002sub AnyEvent::Util::postdetect::DESTROY {
929 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1003 @post_detect = grep $_ != ${$_[0]}, @post_detect;
930} 1004}
931 1005
932sub detect() { 1006sub detect() {
933 unless ($MODEL) { 1007 unless ($MODEL) {
… …
970 last; 1044 last;
971 } 1045 }
972 } 1046 }
973 1047
974 $MODEL 1048 $MODEL
975 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib."; 1049 or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
976 } 1050 }
977 } 1051 }
978 1052
979 push @{"$MODEL\::ISA"}, "AnyEvent::Base"; 1053 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
980 1054
… …
1004# to support binding more than one watcher per filehandle (they usually 1078# to support binding more than one watcher per filehandle (they usually
1005# allow only one watcher per fd, so we dup it to get a different one). 1079# allow only one watcher per fd, so we dup it to get a different one).
1006sub _dupfh($$$$) { 1080sub _dupfh($$$$) {
1007 my ($poll, $fh, $r, $w) = @_; 1081 my ($poll, $fh, $r, $w) = @_;
1008 1082
1009 require Fcntl;
1010
1011 # cygwin requires the fh mode to be matching, unix doesn't 1083 # cygwin requires the fh mode to be matching, unix doesn't
1012 my ($rw, $mode) = $poll eq "r" ? ($r, "<") 1084 my ($rw, $mode) = $poll eq "r" ? ($r, "<")
1013 : $poll eq "w" ? ($w, ">") 1085 : $poll eq "w" ? ($w, ">")
1014 : Carp::croak "AnyEvent->io requires poll set to either 'r' or 'w'"; 1086 : Carp::croak "AnyEvent->io requires poll set to either 'r' or 'w'";
1015 1087
1016 open my $fh2, "$mode&" . fileno $fh 1088 open my $fh2, "$mode&" . fileno $fh
1017 or die "cannot dup() filehandle: $!"; 1089 or die "cannot dup() filehandle: $!,";
1018 1090
1019 # we assume CLOEXEC is already set by perl in all important cases 1091 # we assume CLOEXEC is already set by perl in all important cases
1020 1092
1021 ($fh2, $rw) 1093 ($fh2, $rw)
1022} 1094}
1023 1095
1024package AnyEvent::Base; 1096package AnyEvent::Base;
1025 1097
1026# default implementation for now and time 1098# default implementations for many methods
1027 1099
1028BEGIN { 1100BEGIN {
1029 if (eval "use Time::HiRes (); time (); 1") { 1101 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1030 *_time = \&Time::HiRes::time; 1102 *_time = \&Time::HiRes::time;
1031 # if (eval "use POSIX (); (POSIX::times())... 1103 # if (eval "use POSIX (); (POSIX::times())...
1032 } else { 1104 } else {
1033 *_time = sub { time }; # epic fail 1105 *_time = sub { time }; # epic fail
1034 } 1106 }
1035} 1107}
1036 1108
1037sub time { _time } 1109sub time { _time }
1038sub now { _time } 1110sub now { _time }
1111sub now_update { }
1039 1112
1040# default implementation for ->condvar 1113# default implementation for ->condvar
1041 1114
1042sub condvar { 1115sub condvar {
1043 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, AnyEvent::CondVar:: 1116 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1044} 1117}
1045 1118
1046# default implementation for ->signal 1119# default implementation for ->signal
1047 1120
1048our %SIG_CB; 1121our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1122
1123sub _signal_exec {
1124 sysread $SIGPIPE_R, my $dummy, 4;
1125
1126 while (%SIG_EV) {
1127 for (keys %SIG_EV) {
1128 delete $SIG_EV{$_};
1129 $_->() for values %{ $SIG_CB{$_} || {} };
1130 }
1131 }
1132}
1049 1133
1050sub signal { 1134sub signal {
1051 my (undef, %arg) = @_; 1135 my (undef, %arg) = @_;
1052 1136
1137 unless ($SIGPIPE_R) {
1138 require Fcntl;
1139
1140 if (AnyEvent::WIN32) {
1141 require AnyEvent::Util;
1142
1143 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1144 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R) if $SIGPIPE_R;
1145 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1146 } else {
1147 pipe $SIGPIPE_R, $SIGPIPE_W;
1148 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1149 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1150
1151 # not strictly required, as $^F is normally 2, but let's make sure...
1152 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1153 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1154 }
1155
1156 $SIGPIPE_R
1157 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1158
1159 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
1160 }
1161
1053 my $signal = uc $arg{signal} 1162 my $signal = uc $arg{signal}
1054 or Carp::croak "required option 'signal' is missing"; 1163 or Carp::croak "required option 'signal' is missing";
1055 1164
1056 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1165 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1057 $SIG{$signal} ||= sub { 1166 $SIG{$signal} ||= sub {
1058 $_->() for values %{ $SIG_CB{$signal} || {} }; 1167 local $!;
1168 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1169 undef $SIG_EV{$signal};
1059 }; 1170 };
1060 1171
1061 bless [$signal, $arg{cb}], "AnyEvent::Base::Signal" 1172 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1062} 1173}
1063 1174
1064sub AnyEvent::Base::Signal::DESTROY { 1175sub AnyEvent::Base::signal::DESTROY {
1065 my ($signal, $cb) = @{$_[0]}; 1176 my ($signal, $cb) = @{$_[0]};
1066 1177
1067 delete $SIG_CB{$signal}{$cb}; 1178 delete $SIG_CB{$signal}{$cb};
1068 1179
1180 # delete doesn't work with older perls - they then
1181 # print weird messages, or just unconditionally exit
1182 # instead of getting the default action.
1069 delete $SIG{$signal} unless keys %{ $SIG_CB{$signal} }; 1183 undef $SIG{$signal} unless keys %{ $SIG_CB{$signal} };
1070} 1184}
1071 1185
1072# default implementation for ->child 1186# default implementation for ->child
1073 1187
1074our %PID_CB; 1188our %PID_CB;
1075our $CHLD_W; 1189our $CHLD_W;
1076our $CHLD_DELAY_W; 1190our $CHLD_DELAY_W;
1077our $PID_IDLE;
1078our $WNOHANG; 1191our $WNOHANG;
1079 1192
1080sub _child_wait { 1193sub _sigchld {
1081 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1194 while (0 < (my $pid = waitpid -1, $WNOHANG)) {
1082 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }), 1195 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }),
1083 (values %{ $PID_CB{0} || {} }); 1196 (values %{ $PID_CB{0} || {} });
1084 } 1197 }
1085
1086 undef $PID_IDLE;
1087}
1088
1089sub _sigchld {
1090 # make sure we deliver these changes "synchronous" with the event loop.
1091 $CHLD_DELAY_W ||= AnyEvent->timer (after => 0, cb => sub {
1092 undef $CHLD_DELAY_W;
1093 &_child_wait;
1094 });
1095} 1198}
1096 1199
1097sub child { 1200sub child {
1098 my (undef, %arg) = @_; 1201 my (undef, %arg) = @_;
1099 1202
1100 defined (my $pid = $arg{pid} + 0) 1203 defined (my $pid = $arg{pid} + 0)
1101 or Carp::croak "required option 'pid' is missing"; 1204 or Carp::croak "required option 'pid' is missing";
1102 1205
1103 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1206 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1104 1207
1105 unless ($WNOHANG) {
1106 $WNOHANG = eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1208 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1107 }
1108 1209
1109 unless ($CHLD_W) { 1210 unless ($CHLD_W) {
1110 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1211 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1111 # child could be a zombie already, so make at least one round 1212 # child could be a zombie already, so make at least one round
1112 &_sigchld; 1213 &_sigchld;
1113 } 1214 }
1114 1215
1115 bless [$pid, $arg{cb}], "AnyEvent::Base::Child" 1216 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1116} 1217}
1117 1218
1118sub AnyEvent::Base::Child::DESTROY { 1219sub AnyEvent::Base::child::DESTROY {
1119 my ($pid, $cb) = @{$_[0]}; 1220 my ($pid, $cb) = @{$_[0]};
1120 1221
1121 delete $PID_CB{$pid}{$cb}; 1222 delete $PID_CB{$pid}{$cb};
1122 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1223 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1123 1224
1124 undef $CHLD_W unless keys %PID_CB; 1225 undef $CHLD_W unless keys %PID_CB;
1226}
1227
1228# idle emulation is done by simply using a timer, regardless
1229# of whether the process is idle or not, and not letting
1230# the callback use more than 50% of the time.
1231sub idle {
1232 my (undef, %arg) = @_;
1233
1234 my ($cb, $w, $rcb) = $arg{cb};
1235
1236 $rcb = sub {
1237 if ($cb) {
1238 $w = _time;
1239 &$cb;
1240 $w = _time - $w;
1241
1242 # never use more then 50% of the time for the idle watcher,
1243 # within some limits
1244 $w = 0.0001 if $w < 0.0001;
1245 $w = 5 if $w > 5;
1246
1247 $w = AnyEvent->timer (after => $w, cb => $rcb);
1248 } else {
1249 # clean up...
1250 undef $w;
1251 undef $rcb;
1252 }
1253 };
1254
1255 $w = AnyEvent->timer (after => 0.05, cb => $rcb);
1256
1257 bless \\$cb, "AnyEvent::Base::idle"
1258}
1259
1260sub AnyEvent::Base::idle::DESTROY {
1261 undef $${$_[0]};
1125} 1262}
1126 1263
1127package AnyEvent::CondVar; 1264package AnyEvent::CondVar;
1128 1265
1129our @ISA = AnyEvent::CondVar::Base::; 1266our @ISA = AnyEvent::CondVar::Base::;
… …
1203so on. 1340so on.
1204 1341
1205=head1 ENVIRONMENT VARIABLES 1342=head1 ENVIRONMENT VARIABLES
1206 1343
1207The following environment variables are used by this module or its 1344The following environment variables are used by this module or its
1208submodules: 1345submodules.
1346
1347Note that AnyEvent will remove I<all> environment variables starting with
1348C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
1349enabled.
1209 1350
1210=over 4 1351=over 4
1211 1352
1212=item C<PERL_ANYEVENT_VERBOSE> 1353=item C<PERL_ANYEVENT_VERBOSE>
1213 1354
… …
1263used, and preference will be given to protocols mentioned earlier in the 1404used, and preference will be given to protocols mentioned earlier in the
1264list. 1405list.
1265 1406
1266This variable can effectively be used for denial-of-service attacks 1407This variable can effectively be used for denial-of-service attacks
1267against local programs (e.g. when setuid), although the impact is likely 1408against local programs (e.g. when setuid), although the impact is likely
1268small, as the program has to handle connection errors already- 1409small, as the program has to handle conenction and other failures anyways.
1269 1410
1270Examples: C<PERL_ANYEVENT_PROTOCOLS=ipv4,ipv6> - prefer IPv4 over IPv6, 1411Examples: C<PERL_ANYEVENT_PROTOCOLS=ipv4,ipv6> - prefer IPv4 over IPv6,
1271but support both and try to use both. C<PERL_ANYEVENT_PROTOCOLS=ipv4> 1412but support both and try to use both. C<PERL_ANYEVENT_PROTOCOLS=ipv4>
1272- only support IPv4, never try to resolve or contact IPv6 1413- only support IPv4, never try to resolve or contact IPv6
1273addresses. C<PERL_ANYEVENT_PROTOCOLS=ipv6,ipv4> support either IPv4 or 1414addresses. C<PERL_ANYEVENT_PROTOCOLS=ipv6,ipv4> support either IPv4 or
… …
1533watcher. 1674watcher.
1534 1675
1535=head3 Results 1676=head3 Results
1536 1677
1537 name watchers bytes create invoke destroy comment 1678 name watchers bytes create invoke destroy comment
1538 EV/EV 400000 224 0.47 0.43 0.27 EV native interface 1679 EV/EV 400000 224 0.47 0.35 0.27 EV native interface
1539 EV/Any 100000 224 2.88 0.44 0.27 EV + AnyEvent watchers 1680 EV/Any 100000 224 2.88 0.34 0.27 EV + AnyEvent watchers
1540 CoroEV/Any 100000 224 2.85 0.45 0.28 coroutines + Coro::Signal 1681 CoroEV/Any 100000 224 2.85 0.35 0.28 coroutines + Coro::Signal
1541 Perl/Any 100000 452 4.14 0.75 0.99 pure perl implementation 1682 Perl/Any 100000 452 4.13 0.73 0.95 pure perl implementation
1542 Event/Event 16000 517 32.20 31.80 0.81 Event native interface 1683 Event/Event 16000 517 32.20 31.80 0.81 Event native interface
1543 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers 1684 Event/Any 16000 590 35.85 31.55 1.06 Event + AnyEvent watchers
1544 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour 1685 Glib/Any 16000 1357 102.33 12.31 51.00 quadratic behaviour
1545 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers 1686 Tk/Any 2000 1860 27.20 66.31 14.00 SEGV with >> 2000 watchers
1546 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event 1687 POE/Event 2000 6328 109.99 751.67 14.02 via POE::Loop::Event
… …
1753=item * C-based event loops perform very well with small number of 1894=item * C-based event loops perform very well with small number of
1754watchers, as the management overhead dominates. 1895watchers, as the management overhead dominates.
1755 1896
1756=back 1897=back
1757 1898
1899=head2 THE IO::Lambda BENCHMARK
1900
1901Recently I was told about the benchmark in the IO::Lambda manpage, which
1902could be misinterpreted to make AnyEvent look bad. In fact, the benchmark
1903simply compares IO::Lambda with POE, and IO::Lambda looks better (which
1904shouldn't come as a surprise to anybody). As such, the benchmark is
1905fine, and shows that the AnyEvent backend from IO::Lambda isn't very
1906optimal. But how would AnyEvent compare when used without the extra
1907baggage? To explore this, I wrote the equivalent benchmark for AnyEvent.
1908
1909The benchmark itself creates an echo-server, and then, for 500 times,
1910connects to the echo server, sends a line, waits for the reply, and then
1911creates the next connection. This is a rather bad benchmark, as it doesn't
1912test the efficiency of the framework, but it is a benchmark nevertheless.
1913
1914 name runtime
1915 Lambda/select 0.330 sec
1916 + optimized 0.122 sec
1917 Lambda/AnyEvent 0.327 sec
1918 + optimized 0.138 sec
1919 Raw sockets/select 0.077 sec
1920 POE/select, components 0.662 sec
1921 POE/select, raw sockets 0.226 sec
1922 POE/select, optimized 0.404 sec
1923
1924 AnyEvent/select/nb 0.085 sec
1925 AnyEvent/EV/nb 0.068 sec
1926 +state machine 0.134 sec
1927
1928The benchmark is also a bit unfair (my fault) - the IO::Lambda
1929benchmarks actually make blocking connects and use 100% blocking I/O,
1930defeating the purpose of an event-based solution. All of the newly
1931written AnyEvent benchmarks use 100% non-blocking connects (using
1932AnyEvent::Socket::tcp_connect and the asynchronous pure perl DNS
1933resolver), so AnyEvent is at a disadvantage here as non-blocking connects
1934generally require a lot more bookkeeping and event handling than blocking
1935connects (which involve a single syscall only).
1936
1937The last AnyEvent benchmark additionally uses L<AnyEvent::Handle>, which
1938offers similar expressive power as POE and IO::Lambda (using conventional
1939Perl syntax), which means both the echo server and the client are 100%
1940non-blocking w.r.t. I/O, further placing it at a disadvantage.
1941
1942As you can see, AnyEvent + EV even beats the hand-optimised "raw sockets
1943benchmark", while AnyEvent + its pure perl backend easily beats
1944IO::Lambda and POE.
1945
1946And even the 100% non-blocking version written using the high-level (and
1947slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda,
1948even thought it does all of DNS, tcp-connect and socket I/O in a
1949non-blocking way.
1950
1758 1951
1759=head1 SIGNALS 1952=head1 SIGNALS
1760 1953
1761AnyEvent currently installs handlers for these signals: 1954AnyEvent currently installs handlers for these signals:
1762 1955
… …
1819 use AnyEvent; 2012 use AnyEvent;
1820 2013
1821Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 2014Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1822be used to probe what backend is used and gain other information (which is 2015be used to probe what backend is used and gain other information (which is
1823probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and 2016probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
1824$ENV{PERL_ANYEGENT_STRICT}. 2017$ENV{PERL_ANYEVENT_STRICT}.
1825 2018
1826 2019
1827=head1 BUGS 2020=head1 BUGS
1828 2021
1829Perl 5.8 has numerous memleaks that sometimes hit this module and are hard 2022Perl 5.8 has numerous memleaks that sometimes hit this module and are hard
1830to work around. If you suffer from memleaks, first upgrade to Perl 5.10 2023to work around. If you suffer from memleaks, first upgrade to Perl 5.10
1831and check wether the leaks still show up. (Perl 5.10.0 has other annoying 2024and check wether the leaks still show up. (Perl 5.10.0 has other annoying
1832mamleaks, such as leaking on C<map> and C<grep> but it is usually not as 2025memleaks, such as leaking on C<map> and C<grep> but it is usually not as
1833pronounced). 2026pronounced).
1834 2027
1835 2028
1836=head1 SEE ALSO 2029=head1 SEE ALSO
1837 2030

Diff Legend

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