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.205 by root, Sun Apr 19 12:09:46 2009 UTC vs.
Revision 1.219 by root, Thu Jun 25 11:16:08 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:
… …
384 392
385There is a slight catch to child watchers, however: you usually start them 393There is a slight catch to child watchers, however: you usually start them
386I<after> the child process was created, and this means the process could 394I<after> the child process was created, and this means the process could
387have exited already (and no SIGCHLD will be sent anymore). 395have exited already (and no SIGCHLD will be sent anymore).
388 396
389Not all event models handle this correctly (POE doesn't), but even for 397Not all event models handle this correctly (neither POE nor IO::Async do,
398see their AnyEvent::Impl manpages for details), but even for event models
390event models that I<do> handle this correctly, they usually need to be 399that I<do> handle this correctly, they usually need to be loaded before
391loaded before the process exits (i.e. before you fork in the first place). 400the process exits (i.e. before you fork in the first place). AnyEvent's
401pure perl event loop handles all cases correctly regardless of when you
402start the watcher.
392 403
393This means you cannot create a child watcher as the very first thing in an 404This means you cannot create a child watcher as the very first
394AnyEvent program, you I<have> to create at least one watcher before you 405thing in an AnyEvent program, you I<have> to create at least one
395C<fork> the child (alternatively, you can call C<AnyEvent::detect>). 406watcher before you C<fork> the child (alternatively, you can call
407C<AnyEvent::detect>).
396 408
397Example: fork a process and wait for it 409Example: fork a process and wait for it
398 410
399 my $done = AnyEvent->condvar; 411 my $done = AnyEvent->condvar;
400 412
… …
410 ); 422 );
411 423
412 # do something else, then wait for process exit 424 # do something else, then wait for process exit
413 $done->recv; 425 $done->recv;
414 426
427=head2 IDLE WATCHERS
428
429Sometimes there is a need to do something, but it is not so important
430to do it instantly, but only when there is nothing better to do. This
431"nothing better to do" is usually defined to be "no other events need
432attention by the event loop".
433
434Idle watchers ideally get invoked when the event loop has nothing
435better to do, just before it would block the process to wait for new
436events. Instead of blocking, the idle watcher is invoked.
437
438Most event loops unfortunately do not really support idle watchers (only
439EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
440will simply call the callback "from time to time".
441
442Example: read lines from STDIN, but only process them when the
443program is otherwise idle:
444
445 my @lines; # read data
446 my $idle_w;
447 my $io_w = AnyEvent->io (fh => \*STDIN, poll => 'r', cb => sub {
448 push @lines, scalar <STDIN>;
449
450 # start an idle watcher, if not already done
451 $idle_w ||= AnyEvent->idle (cb => sub {
452 # handle only one line, when there are lines left
453 if (my $line = shift @lines) {
454 print "handled when idle: $line";
455 } else {
456 # otherwise disable the idle watcher again
457 undef $idle_w;
458 }
459 });
460 });
461
415=head2 CONDITION VARIABLES 462=head2 CONDITION VARIABLES
416 463
417If you are familiar with some event loops you will know that all of them 464If you are familiar with some event loops you will know that all of them
418require you to run some blocking "loop", "run" or similar function that 465require you to run some blocking "loop", "run" or similar function that
419will actively watch for new events and call your callbacks. 466will actively watch for new events and call your callbacks.
… …
687 AnyEvent::Impl::Tk based on Tk, very bad choice. 734 AnyEvent::Impl::Tk based on Tk, very bad choice.
688 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs). 735 AnyEvent::Impl::Qt based on Qt, cannot be autoprobed (see its docs).
689 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse. 736 AnyEvent::Impl::EventLib based on Event::Lib, leaks memory and worse.
690 AnyEvent::Impl::POE based on POE, not generic enough for full support. 737 AnyEvent::Impl::POE based on POE, not generic enough for full support.
691 738
739 # warning, support for IO::Async is only partial, as it is too broken
740 # and limited toe ven support the AnyEvent API. See AnyEvent::Impl::Async.
741 AnyEvent::Impl::IOAsync based on IO::Async, cannot be autoprobed (see its docs).
742
692There is no support for WxWidgets, as WxWidgets has no support for 743There is no support for WxWidgets, as WxWidgets has no support for
693watching file handles. However, you can use WxWidgets through the 744watching file handles. However, you can use WxWidgets through the
694POE Adaptor, as POE has a Wx backend that simply polls 20 times per 745POE Adaptor, as POE has a Wx backend that simply polls 20 times per
695second, which was considered to be too horrible to even consider for 746second, which was considered to be too horrible to even consider for
696AnyEvent. Likewise, other POE backends can be used by AnyEvent by using 747AnyEvent. Likewise, other POE backends can be used by AnyEvent by using
… …
888no warnings; 939no warnings;
889use strict qw(vars subs); 940use strict qw(vars subs);
890 941
891use Carp; 942use Carp;
892 943
893our $VERSION = 4.351; 944our $VERSION = 4.412;
894our $MODEL; 945our $MODEL;
895 946
896our $AUTOLOAD; 947our $AUTOLOAD;
897our @ISA; 948our @ISA;
898 949
899our @REGISTRY; 950our @REGISTRY;
900 951
901our $WIN32; 952our $WIN32;
902 953
903BEGIN { 954BEGIN {
904 my $win32 = ! ! ($^O =~ /mswin32/i); 955 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";
905 eval "sub WIN32(){ $win32 }"; 956 eval "sub TAINT(){ " . (${^TAINT}*1) . " }";
957
958 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
959 if ${^TAINT};
906} 960}
907 961
908our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1; 962our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1;
909 963
910our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 964our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
… …
928 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy 982 [Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
929 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program 983 [Qt:: => AnyEvent::Impl::Qt::], # requires special main program
930 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza 984 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
931 [Wx:: => AnyEvent::Impl::POE::], 985 [Wx:: => AnyEvent::Impl::POE::],
932 [Prima:: => AnyEvent::Impl::POE::], 986 [Prima:: => AnyEvent::Impl::POE::],
987 # IO::Async is just too broken - we would need workaorunds for its
988 # byzantine signal and broken child handling, among others.
989 # IO::Async is rather hard to detect, as it doesn't have any
990 # obvious default class.
991# [IO::Async:: => AnyEvent::Impl::IOAsync::], # requires special main program
992# [IO::Async::Loop:: => AnyEvent::Impl::IOAsync::], # requires special main program
993# [IO::Async::Notifier:: => AnyEvent::Impl::IOAsync::], # requires special main program
933); 994);
934 995
935our %method = map +($_ => 1), 996our %method = map +($_ => 1),
936 qw(io timer time now now_update signal child condvar one_event DESTROY); 997 qw(io timer time now now_update signal child idle condvar one_event DESTROY);
937 998
938our @post_detect; 999our @post_detect;
939 1000
940sub post_detect(&) { 1001sub post_detect(&) {
941 my ($cb) = @_; 1002 my ($cb) = @_;
… …
946 1 1007 1
947 } else { 1008 } else {
948 push @post_detect, $cb; 1009 push @post_detect, $cb;
949 1010
950 defined wantarray 1011 defined wantarray
951 ? bless \$cb, "AnyEvent::Util::PostDetect" 1012 ? bless \$cb, "AnyEvent::Util::postdetect"
952 : () 1013 : ()
953 } 1014 }
954} 1015}
955 1016
956sub AnyEvent::Util::PostDetect::DESTROY { 1017sub AnyEvent::Util::postdetect::DESTROY {
957 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1018 @post_detect = grep $_ != ${$_[0]}, @post_detect;
958} 1019}
959 1020
960sub detect() { 1021sub detect() {
961 unless ($MODEL) { 1022 unless ($MODEL) {
… …
1029} 1090}
1030 1091
1031# utility function to dup a filehandle. this is used by many backends 1092# utility function to dup a filehandle. this is used by many backends
1032# to support binding more than one watcher per filehandle (they usually 1093# to support binding more than one watcher per filehandle (they usually
1033# allow only one watcher per fd, so we dup it to get a different one). 1094# allow only one watcher per fd, so we dup it to get a different one).
1034sub _dupfh($$$$) { 1095sub _dupfh($$;$$) {
1035 my ($poll, $fh, $r, $w) = @_; 1096 my ($poll, $fh, $r, $w) = @_;
1036 1097
1037 # cygwin requires the fh mode to be matching, unix doesn't 1098 # cygwin requires the fh mode to be matching, unix doesn't
1038 my ($rw, $mode) = $poll eq "r" ? ($r, "<") 1099 my ($rw, $mode) = $poll eq "r" ? ($r, "<")
1039 : $poll eq "w" ? ($w, ">") 1100 : $poll eq "w" ? ($w, ">")
… …
1050package AnyEvent::Base; 1111package AnyEvent::Base;
1051 1112
1052# default implementations for many methods 1113# default implementations for many methods
1053 1114
1054BEGIN { 1115BEGIN {
1055 if (eval "use Time::HiRes (); time (); 1") { 1116 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1056 *_time = \&Time::HiRes::time; 1117 *_time = \&Time::HiRes::time;
1057 # if (eval "use POSIX (); (POSIX::times())... 1118 # if (eval "use POSIX (); (POSIX::times())...
1058 } else { 1119 } else {
1059 *_time = sub { time }; # epic fail 1120 *_time = sub { time }; # epic fail
1060 } 1121 }
… …
1065sub now_update { } 1126sub now_update { }
1066 1127
1067# default implementation for ->condvar 1128# default implementation for ->condvar
1068 1129
1069sub condvar { 1130sub condvar {
1070 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, AnyEvent::CondVar:: 1131 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1071} 1132}
1072 1133
1073# default implementation for ->signal 1134# default implementation for ->signal
1074 1135
1075our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1136our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
… …
1099 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case 1160 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1100 } else { 1161 } else {
1101 pipe $SIGPIPE_R, $SIGPIPE_W; 1162 pipe $SIGPIPE_R, $SIGPIPE_W;
1102 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1163 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1103 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 1164 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case
1165
1166 # not strictly required, as $^F is normally 2, but let's make sure...
1167 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1168 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1104 } 1169 }
1105 1170
1106 $SIGPIPE_R 1171 $SIGPIPE_R
1107 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1172 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1108
1109 # not strictly required, as $^F is normally 2, but let's make sure...
1110 fcntl $SIGPIPE_R, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1111 fcntl $SIGPIPE_W, &Fcntl::F_SETFD, &Fcntl::FD_CLOEXEC;
1112 1173
1113 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec); 1174 $SIG_IO = AnyEvent->io (fh => $SIGPIPE_R, poll => "r", cb => \&_signal_exec);
1114 } 1175 }
1115 1176
1116 my $signal = uc $arg{signal} 1177 my $signal = uc $arg{signal}
… …
1121 local $!; 1182 local $!;
1122 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1183 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1123 undef $SIG_EV{$signal}; 1184 undef $SIG_EV{$signal};
1124 }; 1185 };
1125 1186
1126 bless [$signal, $arg{cb}], "AnyEvent::Base::Signal" 1187 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1127} 1188}
1128 1189
1129sub AnyEvent::Base::Signal::DESTROY { 1190sub AnyEvent::Base::signal::DESTROY {
1130 my ($signal, $cb) = @{$_[0]}; 1191 my ($signal, $cb) = @{$_[0]};
1131 1192
1132 delete $SIG_CB{$signal}{$cb}; 1193 delete $SIG_CB{$signal}{$cb};
1133 1194
1195 # delete doesn't work with older perls - they then
1196 # print weird messages, or just unconditionally exit
1197 # instead of getting the default action.
1134 delete $SIG{$signal} unless keys %{ $SIG_CB{$signal} }; 1198 undef $SIG{$signal} unless keys %{ $SIG_CB{$signal} };
1135} 1199}
1136 1200
1137# default implementation for ->child 1201# default implementation for ->child
1138 1202
1139our %PID_CB; 1203our %PID_CB;
1140our $CHLD_W; 1204our $CHLD_W;
1141our $CHLD_DELAY_W; 1205our $CHLD_DELAY_W;
1142our $PID_IDLE;
1143our $WNOHANG; 1206our $WNOHANG;
1144 1207
1145sub _child_wait { 1208sub _sigchld {
1146 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1209 while (0 < (my $pid = waitpid -1, $WNOHANG)) {
1147 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }), 1210 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }),
1148 (values %{ $PID_CB{0} || {} }); 1211 (values %{ $PID_CB{0} || {} });
1149 } 1212 }
1150
1151 undef $PID_IDLE;
1152}
1153
1154sub _sigchld {
1155 # make sure we deliver these changes "synchronous" with the event loop.
1156 $CHLD_DELAY_W ||= AnyEvent->timer (after => 0, cb => sub {
1157 undef $CHLD_DELAY_W;
1158 &_child_wait;
1159 });
1160} 1213}
1161 1214
1162sub child { 1215sub child {
1163 my (undef, %arg) = @_; 1216 my (undef, %arg) = @_;
1164 1217
1165 defined (my $pid = $arg{pid} + 0) 1218 defined (my $pid = $arg{pid} + 0)
1166 or Carp::croak "required option 'pid' is missing"; 1219 or Carp::croak "required option 'pid' is missing";
1167 1220
1168 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1221 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1169 1222
1170 unless ($WNOHANG) {
1171 $WNOHANG = eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1223 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1172 }
1173 1224
1174 unless ($CHLD_W) { 1225 unless ($CHLD_W) {
1175 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1226 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1176 # child could be a zombie already, so make at least one round 1227 # child could be a zombie already, so make at least one round
1177 &_sigchld; 1228 &_sigchld;
1178 } 1229 }
1179 1230
1180 bless [$pid, $arg{cb}], "AnyEvent::Base::Child" 1231 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1181} 1232}
1182 1233
1183sub AnyEvent::Base::Child::DESTROY { 1234sub AnyEvent::Base::child::DESTROY {
1184 my ($pid, $cb) = @{$_[0]}; 1235 my ($pid, $cb) = @{$_[0]};
1185 1236
1186 delete $PID_CB{$pid}{$cb}; 1237 delete $PID_CB{$pid}{$cb};
1187 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1238 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1188 1239
1189 undef $CHLD_W unless keys %PID_CB; 1240 undef $CHLD_W unless keys %PID_CB;
1241}
1242
1243# idle emulation is done by simply using a timer, regardless
1244# of whether the process is idle or not, and not letting
1245# the callback use more than 50% of the time.
1246sub idle {
1247 my (undef, %arg) = @_;
1248
1249 my ($cb, $w, $rcb) = $arg{cb};
1250
1251 $rcb = sub {
1252 if ($cb) {
1253 $w = _time;
1254 &$cb;
1255 $w = _time - $w;
1256
1257 # never use more then 50% of the time for the idle watcher,
1258 # within some limits
1259 $w = 0.0001 if $w < 0.0001;
1260 $w = 5 if $w > 5;
1261
1262 $w = AnyEvent->timer (after => $w, cb => $rcb);
1263 } else {
1264 # clean up...
1265 undef $w;
1266 undef $rcb;
1267 }
1268 };
1269
1270 $w = AnyEvent->timer (after => 0.05, cb => $rcb);
1271
1272 bless \\$cb, "AnyEvent::Base::idle"
1273}
1274
1275sub AnyEvent::Base::idle::DESTROY {
1276 undef $${$_[0]};
1190} 1277}
1191 1278
1192package AnyEvent::CondVar; 1279package AnyEvent::CondVar;
1193 1280
1194our @ISA = AnyEvent::CondVar::Base::; 1281our @ISA = AnyEvent::CondVar::Base::;
… …
1268so on. 1355so on.
1269 1356
1270=head1 ENVIRONMENT VARIABLES 1357=head1 ENVIRONMENT VARIABLES
1271 1358
1272The following environment variables are used by this module or its 1359The following environment variables are used by this module or its
1273submodules: 1360submodules.
1361
1362Note that AnyEvent will remove I<all> environment variables starting with
1363C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
1364enabled.
1274 1365
1275=over 4 1366=over 4
1276 1367
1277=item C<PERL_ANYEVENT_VERBOSE> 1368=item C<PERL_ANYEVENT_VERBOSE>
1278 1369
… …
1290=item C<PERL_ANYEVENT_STRICT> 1381=item C<PERL_ANYEVENT_STRICT>
1291 1382
1292AnyEvent does not do much argument checking by default, as thorough 1383AnyEvent does not do much argument checking by default, as thorough
1293argument checking is very costly. Setting this variable to a true value 1384argument checking is very costly. Setting this variable to a true value
1294will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly 1385will cause AnyEvent to load C<AnyEvent::Strict> and then to thoroughly
1295check the arguments passed to most method calls. If it finds any problems 1386check the arguments passed to most method calls. If it finds any problems,
1296it will croak. 1387it will croak.
1297 1388
1298In other words, enables "strict" mode. 1389In other words, enables "strict" mode.
1299 1390
1300Unlike C<use strict>, it is definitely recommended ot keep it off in 1391Unlike C<use strict>, it is definitely recommended to keep it off in
1301production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while 1392production. Keeping C<PERL_ANYEVENT_STRICT=1> in your environment while
1302developing programs can be very useful, however. 1393developing programs can be very useful, however.
1303 1394
1304=item C<PERL_ANYEVENT_MODEL> 1395=item C<PERL_ANYEVENT_MODEL>
1305 1396
… …
1818=item * C-based event loops perform very well with small number of 1909=item * C-based event loops perform very well with small number of
1819watchers, as the management overhead dominates. 1910watchers, as the management overhead dominates.
1820 1911
1821=back 1912=back
1822 1913
1914=head2 THE IO::Lambda BENCHMARK
1915
1916Recently I was told about the benchmark in the IO::Lambda manpage, which
1917could be misinterpreted to make AnyEvent look bad. In fact, the benchmark
1918simply compares IO::Lambda with POE, and IO::Lambda looks better (which
1919shouldn't come as a surprise to anybody). As such, the benchmark is
1920fine, and mostly shows that the AnyEvent backend from IO::Lambda isn't
1921very optimal. But how would AnyEvent compare when used without the extra
1922baggage? To explore this, I wrote the equivalent benchmark for AnyEvent.
1923
1924The benchmark itself creates an echo-server, and then, for 500 times,
1925connects to the echo server, sends a line, waits for the reply, and then
1926creates the next connection. This is a rather bad benchmark, as it doesn't
1927test the efficiency of the framework or much non-blocking I/O, but it is a
1928benchmark nevertheless.
1929
1930 name runtime
1931 Lambda/select 0.330 sec
1932 + optimized 0.122 sec
1933 Lambda/AnyEvent 0.327 sec
1934 + optimized 0.138 sec
1935 Raw sockets/select 0.077 sec
1936 POE/select, components 0.662 sec
1937 POE/select, raw sockets 0.226 sec
1938 POE/select, optimized 0.404 sec
1939
1940 AnyEvent/select/nb 0.085 sec
1941 AnyEvent/EV/nb 0.068 sec
1942 +state machine 0.134 sec
1943
1944The benchmark is also a bit unfair (my fault): the IO::Lambda/POE
1945benchmarks actually make blocking connects and use 100% blocking I/O,
1946defeating the purpose of an event-based solution. All of the newly
1947written AnyEvent benchmarks use 100% non-blocking connects (using
1948AnyEvent::Socket::tcp_connect and the asynchronous pure perl DNS
1949resolver), so AnyEvent is at a disadvantage here, as non-blocking connects
1950generally require a lot more bookkeeping and event handling than blocking
1951connects (which involve a single syscall only).
1952
1953The last AnyEvent benchmark additionally uses L<AnyEvent::Handle>, which
1954offers similar expressive power as POE and IO::Lambda, using conventional
1955Perl syntax. This means that both the echo server and the client are 100%
1956non-blocking, further placing it at a disadvantage.
1957
1958As you can see, the AnyEvent + EV combination even beats the
1959hand-optimised "raw sockets benchmark", while AnyEvent + its pure perl
1960backend easily beats IO::Lambda and POE.
1961
1962And even the 100% non-blocking version written using the high-level (and
1963slow :) L<AnyEvent::Handle> abstraction beats both POE and IO::Lambda by a
1964large margin, even though it does all of DNS, tcp-connect and socket I/O
1965in a non-blocking way.
1966
1967The two AnyEvent benchmarks programs can be found as F<eg/ae0.pl> and
1968F<eg/ae2.pl> in the AnyEvent distribution, the remaining benchmarks are
1969part of the IO::lambda distribution and were used without any changes.
1970
1823 1971
1824=head1 SIGNALS 1972=head1 SIGNALS
1825 1973
1826AnyEvent currently installs handlers for these signals: 1974AnyEvent currently installs handlers for these signals:
1827 1975
… …
1830=item SIGCHLD 1978=item SIGCHLD
1831 1979
1832A handler for C<SIGCHLD> is installed by AnyEvent's child watcher 1980A handler for C<SIGCHLD> is installed by AnyEvent's child watcher
1833emulation for event loops that do not support them natively. Also, some 1981emulation for event loops that do not support them natively. Also, some
1834event loops install a similar handler. 1982event loops install a similar handler.
1983
1984If, when AnyEvent is loaded, SIGCHLD is set to IGNORE, then AnyEvent will
1985reset it to default, to avoid losing child exit statuses.
1835 1986
1836=item SIGPIPE 1987=item SIGPIPE
1837 1988
1838A no-op handler is installed for C<SIGPIPE> when C<$SIG{PIPE}> is C<undef> 1989A no-op handler is installed for C<SIGPIPE> when C<$SIG{PIPE}> is C<undef>
1839when AnyEvent gets loaded. 1990when AnyEvent gets loaded.
… …
1851 2002
1852=back 2003=back
1853 2004
1854=cut 2005=cut
1855 2006
2007undef $SIG{CHLD}
2008 if $SIG{CHLD} eq 'IGNORE';
2009
1856$SIG{PIPE} = sub { } 2010$SIG{PIPE} = sub { }
1857 unless defined $SIG{PIPE}; 2011 unless defined $SIG{PIPE};
1858
1859 2012
1860=head1 FORK 2013=head1 FORK
1861 2014
1862Most event libraries are not fork-safe. The ones who are usually are 2015Most event libraries are not fork-safe. The ones who are usually are
1863because they rely on inefficient but fork-safe C<select> or C<poll> 2016because they rely on inefficient but fork-safe C<select> or C<poll>
… …
1884 use AnyEvent; 2037 use AnyEvent;
1885 2038
1886Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 2039Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1887be used to probe what backend is used and gain other information (which is 2040be used to probe what backend is used and gain other information (which is
1888probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and 2041probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
1889$ENV{PERL_ANYEGENT_STRICT}. 2042$ENV{PERL_ANYEVENT_STRICT}.
2043
2044Note that AnyEvent will remove I<all> environment variables starting with
2045C<PERL_ANYEVENT_> from C<%ENV> when it is loaded while taint mode is
2046enabled.
1890 2047
1891 2048
1892=head1 BUGS 2049=head1 BUGS
1893 2050
1894Perl 5.8 has numerous memleaks that sometimes hit this module and are hard 2051Perl 5.8 has numerous memleaks that sometimes hit this module and are hard

Diff Legend

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