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.199 by root, Fri Mar 27 10:49:50 2009 UTC vs.
Revision 1.216 by root, Tue Jun 23 12:21:34 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:
… …
319 327
320In 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
321can 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
322difference between C<< AnyEvent->time >> and C<< AnyEvent->now >> into 330difference between C<< AnyEvent->time >> and C<< AnyEvent->now >> into
323account. 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.
324 347
325=back 348=back
326 349
327=head2 SIGNAL WATCHERS 350=head2 SIGNAL WATCHERS
328 351
… …
395 ); 418 );
396 419
397 # do something else, then wait for process exit 420 # do something else, then wait for process exit
398 $done->recv; 421 $done->recv;
399 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
400=head2 CONDITION VARIABLES 458=head2 CONDITION VARIABLES
401 459
402If 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
403require you to run some blocking "loop", "run" or similar function that 461require you to run some blocking "loop", "run" or similar function that
404will actively watch for new events and call your callbacks. 462will actively watch for new events and call your callbacks.
… …
873no warnings; 931no warnings;
874use strict qw(vars subs); 932use strict qw(vars subs);
875 933
876use Carp; 934use Carp;
877 935
878our $VERSION = 4.35; 936our $VERSION = 4.411;
879our $MODEL; 937our $MODEL;
880 938
881our $AUTOLOAD; 939our $AUTOLOAD;
882our @ISA; 940our @ISA;
883 941
884our @REGISTRY; 942our @REGISTRY;
885 943
886our $WIN32; 944our $WIN32;
887 945
888BEGIN { 946BEGIN {
889 my $win32 = ! ! ($^O =~ /mswin32/i); 947 eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";
890 eval "sub WIN32(){ $win32 }"; 948 eval "sub TAINT(){ " . (${^TAINT}*1) . " }";
949
950 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
951 if ${^TAINT};
891} 952}
892 953
893our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1; 954our $verbose = $ENV{PERL_ANYEVENT_VERBOSE}*1;
894 955
895our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 956our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
… …
915 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza 976 [POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
916 [Wx:: => AnyEvent::Impl::POE::], 977 [Wx:: => AnyEvent::Impl::POE::],
917 [Prima:: => AnyEvent::Impl::POE::], 978 [Prima:: => AnyEvent::Impl::POE::],
918); 979);
919 980
920our %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);
921 983
922our @post_detect; 984our @post_detect;
923 985
924sub post_detect(&) { 986sub post_detect(&) {
925 my ($cb) = @_; 987 my ($cb) = @_;
… …
930 1 992 1
931 } else { 993 } else {
932 push @post_detect, $cb; 994 push @post_detect, $cb;
933 995
934 defined wantarray 996 defined wantarray
935 ? bless \$cb, "AnyEvent::Util::PostDetect" 997 ? bless \$cb, "AnyEvent::Util::postdetect"
936 : () 998 : ()
937 } 999 }
938} 1000}
939 1001
940sub AnyEvent::Util::PostDetect::DESTROY { 1002sub AnyEvent::Util::postdetect::DESTROY {
941 @post_detect = grep $_ != ${$_[0]}, @post_detect; 1003 @post_detect = grep $_ != ${$_[0]}, @post_detect;
942} 1004}
943 1005
944sub detect() { 1006sub detect() {
945 unless ($MODEL) { 1007 unless ($MODEL) {
… …
982 last; 1044 last;
983 } 1045 }
984 } 1046 }
985 1047
986 $MODEL 1048 $MODEL
987 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";
988 } 1050 }
989 } 1051 }
990 1052
991 push @{"$MODEL\::ISA"}, "AnyEvent::Base"; 1053 push @{"$MODEL\::ISA"}, "AnyEvent::Base";
992 1054
… …
1022 my ($rw, $mode) = $poll eq "r" ? ($r, "<") 1084 my ($rw, $mode) = $poll eq "r" ? ($r, "<")
1023 : $poll eq "w" ? ($w, ">") 1085 : $poll eq "w" ? ($w, ">")
1024 : 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'";
1025 1087
1026 open my $fh2, "$mode&" . fileno $fh 1088 open my $fh2, "$mode&" . fileno $fh
1027 or die "cannot dup() filehandle: $!"; 1089 or die "cannot dup() filehandle: $!,";
1028 1090
1029 # 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
1030 1092
1031 ($fh2, $rw) 1093 ($fh2, $rw)
1032} 1094}
1033 1095
1034package AnyEvent::Base; 1096package AnyEvent::Base;
1035 1097
1036# default implementation for now and time 1098# default implementations for many methods
1037 1099
1038BEGIN { 1100BEGIN {
1039 if (eval "use Time::HiRes (); time (); 1") { 1101 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1040 *_time = \&Time::HiRes::time; 1102 *_time = \&Time::HiRes::time;
1041 # if (eval "use POSIX (); (POSIX::times())... 1103 # if (eval "use POSIX (); (POSIX::times())...
1042 } else { 1104 } else {
1043 *_time = sub { time }; # epic fail 1105 *_time = sub { time }; # epic fail
1044 } 1106 }
1045} 1107}
1046 1108
1047sub time { _time } 1109sub time { _time }
1048sub now { _time } 1110sub now { _time }
1111sub now_update { }
1049 1112
1050# default implementation for ->condvar 1113# default implementation for ->condvar
1051 1114
1052sub condvar { 1115sub condvar {
1053 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, AnyEvent::CondVar:: 1116 bless { @_ == 3 ? (_ae_cb => $_[2]) : () }, "AnyEvent::CondVar"
1054} 1117}
1055 1118
1056# default implementation for ->signal 1119# default implementation for ->signal
1057 1120
1058our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO); 1121our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
… …
1070 1133
1071sub signal { 1134sub signal {
1072 my (undef, %arg) = @_; 1135 my (undef, %arg) = @_;
1073 1136
1074 unless ($SIGPIPE_R) { 1137 unless ($SIGPIPE_R) {
1138 require Fcntl;
1139
1075 if (AnyEvent::WIN32) { 1140 if (AnyEvent::WIN32) {
1141 require AnyEvent::Util;
1142
1076 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1143 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
1077 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R) if $SIGPIPE_R; 1144 AnyEvent::Util::fh_nonblocking ($SIGPIPE_R) if $SIGPIPE_R;
1078 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case 1145 AnyEvent::Util::fh_nonblocking ($SIGPIPE_W) if $SIGPIPE_W; # just in case
1079 } else { 1146 } else {
1080 pipe $SIGPIPE_R, $SIGPIPE_W; 1147 pipe $SIGPIPE_R, $SIGPIPE_W;
1081 require Fcntl;
1082 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R; 1148 fcntl $SIGPIPE_R, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_R;
1083 fcntl $SIGPIPE_W, &Fcntl::F_SETFL, &Fcntl::O_NONBLOCK if $SIGPIPE_W; # just in case 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;
1084 } 1154 }
1085 1155
1086 $SIGPIPE_R 1156 $SIGPIPE_R
1087 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n"; 1157 or Carp::croak "AnyEvent: unable to create a signal reporting pipe: $!\n";
1088 1158
… …
1092 my $signal = uc $arg{signal} 1162 my $signal = uc $arg{signal}
1093 or Carp::croak "required option 'signal' is missing"; 1163 or Carp::croak "required option 'signal' is missing";
1094 1164
1095 $SIG_CB{$signal}{$arg{cb}} = $arg{cb}; 1165 $SIG_CB{$signal}{$arg{cb}} = $arg{cb};
1096 $SIG{$signal} ||= sub { 1166 $SIG{$signal} ||= sub {
1167 local $!;
1097 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV; 1168 syswrite $SIGPIPE_W, "\x00", 1 unless %SIG_EV;
1098 undef $SIG_EV{$signal}; 1169 undef $SIG_EV{$signal};
1099 }; 1170 };
1100 1171
1101 bless [$signal, $arg{cb}], "AnyEvent::Base::Signal" 1172 bless [$signal, $arg{cb}], "AnyEvent::Base::signal"
1102} 1173}
1103 1174
1104sub AnyEvent::Base::Signal::DESTROY { 1175sub AnyEvent::Base::signal::DESTROY {
1105 my ($signal, $cb) = @{$_[0]}; 1176 my ($signal, $cb) = @{$_[0]};
1106 1177
1107 delete $SIG_CB{$signal}{$cb}; 1178 delete $SIG_CB{$signal}{$cb};
1108 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.
1109 delete $SIG{$signal} unless keys %{ $SIG_CB{$signal} }; 1183 undef $SIG{$signal} unless keys %{ $SIG_CB{$signal} };
1110} 1184}
1111 1185
1112# default implementation for ->child 1186# default implementation for ->child
1113 1187
1114our %PID_CB; 1188our %PID_CB;
1115our $CHLD_W; 1189our $CHLD_W;
1116our $CHLD_DELAY_W; 1190our $CHLD_DELAY_W;
1117our $PID_IDLE;
1118our $WNOHANG; 1191our $WNOHANG;
1119 1192
1120sub _child_wait { 1193sub _sigchld {
1121 while (0 < (my $pid = waitpid -1, $WNOHANG)) { 1194 while (0 < (my $pid = waitpid -1, $WNOHANG)) {
1122 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }), 1195 $_->($pid, $?) for (values %{ $PID_CB{$pid} || {} }),
1123 (values %{ $PID_CB{0} || {} }); 1196 (values %{ $PID_CB{0} || {} });
1124 } 1197 }
1125
1126 undef $PID_IDLE;
1127}
1128
1129sub _sigchld {
1130 # make sure we deliver these changes "synchronous" with the event loop.
1131 $CHLD_DELAY_W ||= AnyEvent->timer (after => 0, cb => sub {
1132 undef $CHLD_DELAY_W;
1133 &_child_wait;
1134 });
1135} 1198}
1136 1199
1137sub child { 1200sub child {
1138 my (undef, %arg) = @_; 1201 my (undef, %arg) = @_;
1139 1202
1140 defined (my $pid = $arg{pid} + 0) 1203 defined (my $pid = $arg{pid} + 0)
1141 or Carp::croak "required option 'pid' is missing"; 1204 or Carp::croak "required option 'pid' is missing";
1142 1205
1143 $PID_CB{$pid}{$arg{cb}} = $arg{cb}; 1206 $PID_CB{$pid}{$arg{cb}} = $arg{cb};
1144 1207
1145 unless ($WNOHANG) {
1146 $WNOHANG = eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1; 1208 $WNOHANG ||= eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } || 1;
1147 }
1148 1209
1149 unless ($CHLD_W) { 1210 unless ($CHLD_W) {
1150 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld); 1211 $CHLD_W = AnyEvent->signal (signal => 'CHLD', cb => \&_sigchld);
1151 # 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
1152 &_sigchld; 1213 &_sigchld;
1153 } 1214 }
1154 1215
1155 bless [$pid, $arg{cb}], "AnyEvent::Base::Child" 1216 bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1156} 1217}
1157 1218
1158sub AnyEvent::Base::Child::DESTROY { 1219sub AnyEvent::Base::child::DESTROY {
1159 my ($pid, $cb) = @{$_[0]}; 1220 my ($pid, $cb) = @{$_[0]};
1160 1221
1161 delete $PID_CB{$pid}{$cb}; 1222 delete $PID_CB{$pid}{$cb};
1162 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} }; 1223 delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1163 1224
1164 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]};
1165} 1262}
1166 1263
1167package AnyEvent::CondVar; 1264package AnyEvent::CondVar;
1168 1265
1169our @ISA = AnyEvent::CondVar::Base::; 1266our @ISA = AnyEvent::CondVar::Base::;
… …
1243so on. 1340so on.
1244 1341
1245=head1 ENVIRONMENT VARIABLES 1342=head1 ENVIRONMENT VARIABLES
1246 1343
1247The following environment variables are used by this module or its 1344The following environment variables are used by this module or its
1248submodules: 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.
1249 1350
1250=over 4 1351=over 4
1251 1352
1252=item C<PERL_ANYEVENT_VERBOSE> 1353=item C<PERL_ANYEVENT_VERBOSE>
1253 1354
… …
1793=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
1794watchers, as the management overhead dominates. 1895watchers, as the management overhead dominates.
1795 1896
1796=back 1897=back
1797 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
1951The two AnyEvent benchmarks can be found as F<eg/ae0.pl> and F<eg/ae2.pl>
1952in the AnyEvent distribution, the remaining benchmarks are part of the
1953IO::lambda distribution and were used without any changes.
1954
1798 1955
1799=head1 SIGNALS 1956=head1 SIGNALS
1800 1957
1801AnyEvent currently installs handlers for these signals: 1958AnyEvent currently installs handlers for these signals:
1802 1959
… …
1859 use AnyEvent; 2016 use AnyEvent;
1860 2017
1861Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can 2018Similar considerations apply to $ENV{PERL_ANYEVENT_VERBOSE}, as that can
1862be used to probe what backend is used and gain other information (which is 2019be used to probe what backend is used and gain other information (which is
1863probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and 2020probably even less useful to an attacker than PERL_ANYEVENT_MODEL), and
1864$ENV{PERL_ANYEGENT_STRICT}. 2021$ENV{PERL_ANYEVENT_STRICT}.
1865 2022
1866 2023
1867=head1 BUGS 2024=head1 BUGS
1868 2025
1869Perl 5.8 has numerous memleaks that sometimes hit this module and are hard 2026Perl 5.8 has numerous memleaks that sometimes hit this module and are hard

Diff Legend

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