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.386 by root, Mon Sep 26 11:32:19 2011 UTC vs.
Revision 1.414 by root, Wed Aug 21 08:40:28 2013 UTC

… …
271 271
272Example 2: fire an event after 0.5 seconds, then roughly every second. 272Example 2: fire an event after 0.5 seconds, then roughly every second.
273 273
274 my $w = AnyEvent->timer (after => 0.5, interval => 1, cb => sub { 274 my $w = AnyEvent->timer (after => 0.5, interval => 1, cb => sub {
275 warn "timeout\n"; 275 warn "timeout\n";
276 }; 276 });
277 277
278=head3 TIMING ISSUES 278=head3 TIMING ISSUES
279 279
280There are two ways to handle timers: based on real time (relative, "fire 280There are two ways to handle timers: based on real time (relative, "fire
281in 10 seconds") and based on wallclock time (absolute, "fire at 12 281in 10 seconds") and based on wallclock time (absolute, "fire at 12
… …
415not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's 415not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's
416pure perl implementation). 416pure perl implementation).
417 417
418=head3 Safe/Unsafe Signals 418=head3 Safe/Unsafe Signals
419 419
420Perl signals can be either "safe" (synchronous to opcode handling) or 420Perl signals can be either "safe" (synchronous to opcode handling)
421"unsafe" (asynchronous) - the former might get delayed indefinitely, the 421or "unsafe" (asynchronous) - the former might delay signal delivery
422latter might corrupt your memory. 422indefinitely, the latter might corrupt your memory.
423 423
424AnyEvent signal handlers are, in addition, synchronous to the event loop, 424AnyEvent signal handlers are, in addition, synchronous to the event loop,
425i.e. they will not interrupt your running perl program but will only be 425i.e. they will not interrupt your running perl program but will only be
426called as part of the normal event handling (just like timer, I/O etc. 426called as part of the normal event handling (just like timer, I/O etc.
427callbacks, too). 427callbacks, too).
428 428
429=head3 Signal Races, Delays and Workarounds 429=head3 Signal Races, Delays and Workarounds
430 430
431Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching 431Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support
432callbacks to signals in a generic way, which is a pity, as you cannot 432attaching callbacks to signals in a generic way, which is a pity,
433do race-free signal handling in perl, requiring C libraries for 433as you cannot do race-free signal handling in perl, requiring
434this. AnyEvent will try to do its best, which means in some cases, 434C libraries for this. AnyEvent will try to do its best, which
435signals will be delayed. The maximum time a signal might be delayed is 435means in some cases, signals will be delayed. The maximum time
436specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10 seconds). This 436a signal might be delayed is 10 seconds by default, but can
437variable can be changed only before the first signal watcher is created, 437be overriden via C<$ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY}> or
438and should be left alone otherwise. This variable determines how often 438C<$AnyEvent::MAX_SIGNAL_LATENCY> - see the L<ENVIRONMENT VARIABLES>
439AnyEvent polls for signals (in case a wake-up was missed). Higher values 439section for details.
440will cause fewer spurious wake-ups, which is better for power and CPU
441saving.
442 440
443All these problems can be avoided by installing the optional 441All these problems can be avoided by installing the optional
444L<Async::Interrupt> module, which works with most event loops. It will not 442L<Async::Interrupt> module, which works with most event loops. It will not
445work with inherently broken event loops such as L<Event> or L<Event::Lib> 443work with inherently broken event loops such as L<Event> or L<Event::Lib>
446(and not with L<POE> currently, as POE does its own workaround with 444(and not with L<POE> currently). For those, you just have to suffer the
447one-second latency). For those, you just have to suffer the delays. 445delays.
448 446
449=head2 CHILD PROCESS WATCHERS 447=head2 CHILD PROCESS WATCHERS
450 448
451 $w = AnyEvent->child (pid => <process id>, cb => <callback>); 449 $w = AnyEvent->child (pid => <process id>, cb => <callback>);
452 450
… …
765 }; 763 };
766 } 764 }
767 765
768 $cv->end; 766 $cv->end;
769 767
768 ...
769
770 my $results = $cv->recv;
771
770This code fragment supposedly pings a number of hosts and calls 772This code fragment supposedly pings a number of hosts and calls
771C<send> after results for all then have have been gathered - in any 773C<send> after results for all then have have been gathered - in any
772order. To achieve this, the code issues a call to C<begin> when it starts 774order. To achieve this, the code issues a call to C<begin> when it starts
773each ping request and calls C<end> when it has received some result for 775each ping request and calls C<end> when it has received some result for
774it. Since C<begin> and C<end> only maintain a counter, the order in which 776it. Since C<begin> and C<end> only maintain a counter, the order in which
… …
809 811
810In list context, all parameters passed to C<send> will be returned, 812In list context, all parameters passed to C<send> will be returned,
811in scalar context only the first one will be returned. 813in scalar context only the first one will be returned.
812 814
813Note that doing a blocking wait in a callback is not supported by any 815Note that doing a blocking wait in a callback is not supported by any
814event loop, that is, recursive invocation of a blocking C<< ->recv 816event loop, that is, recursive invocation of a blocking C<< ->recv >> is
815>> is not allowed, and the C<recv> call will C<croak> if such a 817not allowed and the C<recv> call will C<croak> if such a condition is
816condition is detected. This condition can be slightly loosened by using 818detected. This requirement can be dropped by relying on L<Coro::AnyEvent>
817L<Coro::AnyEvent>, which allows you to do a blocking C<< ->recv >> from 819, which allows you to do a blocking C<< ->recv >> from any thread
818any thread that doesn't run the event loop itself. 820that doesn't run the event loop itself. L<Coro::AnyEvent> is loaded
821automatically when L<Coro> is used with L<AnyEvent>, so code does not need
822to do anything special to take advantage of that: any code that would
823normally block your program because it calls C<recv>, be executed in an
824C<async> thread instead without blocking other threads.
819 825
820Not all event models support a blocking wait - some die in that case 826Not all event models support a blocking wait - some die in that case
821(programs might want to do that to stay interactive), so I<if you are 827(programs might want to do that to stay interactive), so I<if you are
822using this from a module, never require a blocking wait>. Instead, let the 828using this from a module, never require a blocking wait>. Instead, let the
823caller decide whether the call will block or not (for example, by coupling 829caller decide whether the call will block or not (for example, by coupling
… …
1141a longer non-exhaustive list), and the list is heavily biased towards 1147a longer non-exhaustive list), and the list is heavily biased towards
1142modules of the AnyEvent author himself :) 1148modules of the AnyEvent author himself :)
1143 1149
1144=over 4 1150=over 4
1145 1151
1146=item L<AnyEvent::Util> 1152=item L<AnyEvent::Util> (part of the AnyEvent distribution)
1147 1153
1148Contains various utility functions that replace often-used blocking 1154Contains various utility functions that replace often-used blocking
1149functions such as C<inet_aton> with event/callback-based versions. 1155functions such as C<inet_aton> with event/callback-based versions.
1150 1156
1151=item L<AnyEvent::Socket> 1157=item L<AnyEvent::Socket> (part of the AnyEvent distribution)
1152 1158
1153Provides various utility functions for (internet protocol) sockets, 1159Provides various utility functions for (internet protocol) sockets,
1154addresses and name resolution. Also functions to create non-blocking tcp 1160addresses and name resolution. Also functions to create non-blocking tcp
1155connections or tcp servers, with IPv6 and SRV record support and more. 1161connections or tcp servers, with IPv6 and SRV record support and more.
1156 1162
1157=item L<AnyEvent::Handle> 1163=item L<AnyEvent::Handle> (part of the AnyEvent distribution)
1158 1164
1159Provide read and write buffers, manages watchers for reads and writes, 1165Provide read and write buffers, manages watchers for reads and writes,
1160supports raw and formatted I/O, I/O queued and fully transparent and 1166supports raw and formatted I/O, I/O queued and fully transparent and
1161non-blocking SSL/TLS (via L<AnyEvent::TLS>). 1167non-blocking SSL/TLS (via L<AnyEvent::TLS>).
1162 1168
1163=item L<AnyEvent::DNS> 1169=item L<AnyEvent::DNS> (part of the AnyEvent distribution)
1164 1170
1165Provides rich asynchronous DNS resolver capabilities. 1171Provides rich asynchronous DNS resolver capabilities.
1166 1172
1167=item L<AnyEvent::HTTP>, L<AnyEvent::IRC>, L<AnyEvent::XMPP>, L<AnyEvent::GPSD>, L<AnyEvent::IGS>, L<AnyEvent::FCP> 1173=item L<AnyEvent::HTTP>, L<AnyEvent::IRC>, L<AnyEvent::XMPP>, L<AnyEvent::GPSD>, L<AnyEvent::IGS>, L<AnyEvent::FCP>
1168 1174
1169Implement event-based interfaces to the protocols of the same name (for 1175Implement event-based interfaces to the protocols of the same name (for
1170the curious, IGS is the International Go Server and FCP is the Freenet 1176the curious, IGS is the International Go Server and FCP is the Freenet
1171Client Protocol). 1177Client Protocol).
1172 1178
1173=item L<AnyEvent::AIO> 1179=item L<AnyEvent::AIO> (part of the AnyEvent distribution)
1174 1180
1175Truly asynchronous (as opposed to non-blocking) I/O, should be in the 1181Truly asynchronous (as opposed to non-blocking) I/O, should be in the
1176toolbox of every event programmer. AnyEvent::AIO transparently fuses 1182toolbox of every event programmer. AnyEvent::AIO transparently fuses
1177L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based 1183L<IO::AIO> and AnyEvent together, giving AnyEvent access to event-based
1178file I/O, and much more. 1184file I/O, and much more.
… …
1223 1229
1224=cut 1230=cut
1225 1231
1226package AnyEvent; 1232package AnyEvent;
1227 1233
1228# basically a tuned-down version of common::sense 1234BEGIN {
1229sub common_sense { 1235 require "AnyEvent/constants.pl";
1230 # from common:.sense 3.4 1236 &AnyEvent::common_sense;
1231 ${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00";
1232 # use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1233 $^H |= 0x00000600;
1234} 1237}
1235
1236BEGIN { AnyEvent::common_sense }
1237 1238
1238use Carp (); 1239use Carp ();
1239 1240
1240our $VERSION = '6.02'; 1241our $VERSION = '7.05';
1241our $MODEL; 1242our $MODEL;
1242our @ISA; 1243our @ISA;
1243our @REGISTRY; 1244our @REGISTRY;
1244our $VERBOSE; 1245our $VERBOSE;
1245our $MAX_SIGNAL_LATENCY = 10;
1246our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred 1246our %PROTOCOL; # (ipv4|ipv6) => (1|2), higher numbers are preferred
1247our $MAX_SIGNAL_LATENCY = $ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY} || 10; # executes after the BEGIN block below (tainting!)
1247 1248
1248BEGIN { 1249BEGIN {
1249 require "AnyEvent/constants.pl";
1250
1251 eval "sub TAINT (){" . (${^TAINT}*1) . "}"; 1250 eval "sub TAINT (){" . (${^TAINT}*1) . "}";
1252 1251
1253 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV} 1252 delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1254 if ${^TAINT}; 1253 if ${^TAINT};
1255 1254
… …
1304} 1303}
1305 1304
1306sub log($$;@) { 1305sub log($$;@) {
1307 # only load the big bloated module when we actually are about to log something 1306 # only load the big bloated module when we actually are about to log something
1308 if ($_[0] <= ($VERBOSE || 1)) { # also catches non-numeric levels(!) and fatal 1307 if ($_[0] <= ($VERBOSE || 1)) { # also catches non-numeric levels(!) and fatal
1308 local ($!, $@);
1309 require AnyEvent::Log; # among other things, sets $VERBOSE to 9 1309 require AnyEvent::Log; # among other things, sets $VERBOSE to 9
1310 # AnyEvent::Log overwrites this function 1310 # AnyEvent::Log overwrites this function
1311 goto &log; 1311 goto &log;
1312 } 1312 }
1313 1313
1314 0 # not logged 1314 0 # not logged
1315} 1315}
1316 1316
1317sub logger($;$) { 1317sub _logger($;$) {
1318 package AnyEvent::Log;
1319
1320 my ($level, $renabled) = @_; 1318 my ($level, $renabled) = @_;
1321 1319
1322 $$renabled = $level <= $VERBOSE; 1320 $$renabled = $level <= $VERBOSE;
1323 1321
1324 my $pkg = (caller)[0];
1325
1326 my $logger = [$pkg, $level, $renabled]; 1322 my $logger = [(caller)[0], $level, $renabled];
1327 1323
1328 our %LOGGER;
1329 $LOGGER{$logger+0} = $logger; 1324 $AnyEvent::Log::LOGGER{$logger+0} = $logger;
1330 1325
1326# return unless defined wantarray;
1327#
1331 require AnyEvent::Util; 1328# require AnyEvent::Util;
1332 my $guard = AnyEvent::Util::guard (sub { 1329# my $guard = AnyEvent::Util::guard (sub {
1333 # "clean up" 1330# # "clean up"
1334 delete $LOGGER{$logger+0}; 1331# delete $LOGGER{$logger+0};
1335 }); 1332# });
1336 1333#
1337 sub { 1334# sub {
1338 return 0 unless $$renabled; 1335# return 0 unless $$renabled;
1339 1336#
1340 $guard if 0; # keep guard alive, but don't cause runtime overhead 1337# $guard if 0; # keep guard alive, but don't cause runtime overhead
1341 require AnyEvent::Log unless $AnyEvent::Log::VERSION; 1338# require AnyEvent::Log unless $AnyEvent::Log::VERSION;
1342 package AnyEvent::Log; 1339# package AnyEvent::Log;
1343 _log ($logger->[0], $level, @_) # logger->[0] has been converted at load time 1340# _log ($logger->[0], $level, @_) # logger->[0] has been converted at load time
1344 } 1341# }
1345} 1342}
1346 1343
1347if (length $ENV{PERL_ANYEVENT_LOG}) { 1344if (length $ENV{PERL_ANYEVENT_LOG}) {
1348 require AnyEvent::Log; # AnyEvent::Log does the thing for us 1345 require AnyEvent::Log; # AnyEvent::Log does the thing for us
1349} 1346}
… …
1399 1396
1400 # IO::Async::Loop::AnyEvent is extremely evil, refuse to work with it 1397 # IO::Async::Loop::AnyEvent is extremely evil, refuse to work with it
1401 # the author knows about the problems and what it does to AnyEvent as a whole 1398 # the author knows about the problems and what it does to AnyEvent as a whole
1402 # (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent 1399 # (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent
1403 # anyway. 1400 # anyway.
1404 AnyEvent::log fatal => "AnyEvent: IO::Async::Loop::AnyEvent detected - this module is broken by design,\n" 1401 AnyEvent::log fatal => "IO::Async::Loop::AnyEvent detected - that module is broken by\n"
1405 . "abuses internals and breaks AnyEvent, will not continue." 1402 . "design, abuses internals and breaks AnyEvent - will not continue."
1406 if exists $INC{"IO/Async/Loop/AnyEvent.pm"}; 1403 if exists $INC{"IO/Async/Loop/AnyEvent.pm"};
1407 1404
1408 local $!; # for good measure 1405 local $!; # for good measure
1409 local $SIG{__DIE__}; # we use eval 1406 local $SIG{__DIE__}; # we use eval
1410 1407
… …
1420 1417
1421 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) { 1418 if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) {
1422 my $model = $1; 1419 my $model = $1;
1423 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//; 1420 $model = "AnyEvent::Impl::$model" unless $model =~ s/::$//;
1424 if (eval "require $model") { 1421 if (eval "require $model") {
1425 AnyEvent::log 7 => "loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it."; 1422 AnyEvent::log 7 => "Loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";
1426 $MODEL = $model; 1423 $MODEL = $model;
1427 } else { 1424 } else {
1428 AnyEvent::log 4 => "unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@"; 1425 AnyEvent::log 4 => "Unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";
1429 } 1426 }
1430 } 1427 }
1431 1428
1432 # check for already loaded models 1429 # check for already loaded models
1433 unless ($MODEL) { 1430 unless ($MODEL) {
1434 for (@REGISTRY, @models) { 1431 for (@REGISTRY, @models) {
1435 my ($package, $model) = @$_; 1432 my ($package, $model) = @$_;
1436 if (${"$package\::VERSION"} > 0) { 1433 if (${"$package\::VERSION"} > 0) {
1437 if (eval "require $model") { 1434 if (eval "require $model") {
1438 AnyEvent::log 7 => "autodetected model '$model', using it."; 1435 AnyEvent::log 7 => "Autodetected model '$model', using it.";
1439 $MODEL = $model; 1436 $MODEL = $model;
1440 last; 1437 last;
1438 } else {
1439 AnyEvent::log 8 => "Detected event loop $package, but cannot load '$model', skipping: $@";
1441 } 1440 }
1442 } 1441 }
1443 } 1442 }
1444 1443
1445 unless ($MODEL) { 1444 unless ($MODEL) {
… …
1449 if ( 1448 if (
1450 eval "require $package" 1449 eval "require $package"
1451 and ${"$package\::VERSION"} > 0 1450 and ${"$package\::VERSION"} > 0
1452 and eval "require $model" 1451 and eval "require $model"
1453 ) { 1452 ) {
1454 AnyEvent::log 7 => "autoloaded model '$model', using it."; 1453 AnyEvent::log 7 => "Autoloaded model '$model', using it.";
1455 $MODEL = $model; 1454 $MODEL = $model;
1456 last; 1455 last;
1457 } 1456 }
1458 } 1457 }
1459 1458
1460 $MODEL 1459 $MODEL
1461 or AnyEvent::log fatal => "AnyEvent: backend autodetection failed - did you properly install AnyEvent?"; 1460 or AnyEvent::log fatal => "Backend autodetection failed - did you properly install AnyEvent?";
1462 } 1461 }
1463 } 1462 }
1464 1463
1465 # free memory only needed for probing 1464 # free memory only needed for probing
1466 undef @models; 1465 undef @models;
… …
1613 # probe for availability of Time::HiRes 1612 # probe for availability of Time::HiRes
1614 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") { 1613 if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1615 *time = sub { Time::HiRes::time () }; 1614 *time = sub { Time::HiRes::time () };
1616 *AE::time = \& Time::HiRes::time ; 1615 *AE::time = \& Time::HiRes::time ;
1617 *now = \&time; 1616 *now = \&time;
1618 AnyEvent::log 8 => "AnyEvent: using Time::HiRes for sub-second timing accuracy."; 1617 AnyEvent::log 8 => "using Time::HiRes for sub-second timing accuracy.";
1619 # if (eval "use POSIX (); (POSIX::times())... 1618 # if (eval "use POSIX (); (POSIX::times())...
1620 } else { 1619 } else {
1621 *time = sub { CORE::time }; 1620 *time = sub { CORE::time };
1622 *AE::time = sub (){ CORE::time }; 1621 *AE::time = sub (){ CORE::time };
1623 *now = \&time; 1622 *now = \&time;
1624 AnyEvent::log 3 => "using built-in time(), WARNING, no sub-second resolution!"; 1623 AnyEvent::log 3 => "Using built-in time(), no sub-second resolution!";
1625 } 1624 }
1626 }; 1625 };
1627 die if $@; 1626 die if $@;
1628 1627
1629 &time 1628 &time
… …
1723 1722
1724sub signal { 1723sub signal {
1725 eval q{ # poor man's autoloading {} 1724 eval q{ # poor man's autoloading {}
1726 # probe for availability of Async::Interrupt 1725 # probe for availability of Async::Interrupt
1727 if (_have_async_interrupt) { 1726 if (_have_async_interrupt) {
1728 AnyEvent::log 8 => "using Async::Interrupt for race-free signal handling."; 1727 AnyEvent::log 8 => "Using Async::Interrupt for race-free signal handling.";
1729 1728
1730 $SIGPIPE_R = new Async::Interrupt::EventPipe; 1729 $SIGPIPE_R = new Async::Interrupt::EventPipe;
1731 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec; 1730 $SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1732 1731
1733 } else { 1732 } else {
1734 AnyEvent::log 8 => "using emulated perl signal handling with latency timer."; 1733 AnyEvent::log 8 => "Using emulated perl signal handling with latency timer.";
1735 1734
1736 if (AnyEvent::WIN32) { 1735 if (AnyEvent::WIN32) {
1737 require AnyEvent::Util; 1736 require AnyEvent::Util;
1738 1737
1739 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe (); 1738 ($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
… …
2075 2074
2076=over 4 2075=over 4
2077 2076
2078=item C<PERL_ANYEVENT_VERBOSE> 2077=item C<PERL_ANYEVENT_VERBOSE>
2079 2078
2080By default, AnyEvent will only log messages with loglevel C<3> 2079By default, AnyEvent will log messages with loglevel C<4> (C<error>) or
2081(C<critical>) or higher (see L<AnyEvent::Log>). You can set this 2080higher (see L<AnyEvent::Log>). You can set this environment variable to a
2082environment variable to a numerical loglevel to make AnyEvent more (or 2081numerical loglevel to make AnyEvent more (or less) talkative.
2083less) talkative.
2084 2082
2085If you want to do more than just set the global logging level 2083If you want to do more than just set the global logging level
2086you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more 2084you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more
2087complex specifications. 2085complex specifications.
2088 2086
2089When set to C<0> (C<off>), then no messages whatsoever will be logged with 2087When set to C<0> (C<off>), then no messages whatsoever will be logged with
2090the default logging settings. 2088everything else at defaults.
2091 2089
2092When set to C<5> or higher (C<warn>), causes AnyEvent to warn about 2090When set to C<5> or higher (C<warn>), AnyEvent warns about unexpected
2093unexpected conditions, such as not being able to load the event model 2091conditions, such as not being able to load the event model specified by
2094specified by C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an 2092C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an exception - this
2095exception - this is the minimum recommended level. 2093is the minimum recommended level for use during development.
2096 2094
2097When set to C<7> or higher (info), cause AnyEvent to report which event model it 2095When set to C<7> or higher (info), AnyEvent reports which event model it
2098chooses. 2096chooses.
2099 2097
2100When set to C<8> or higher (debug), then AnyEvent will report extra information on 2098When set to C<8> or higher (debug), then AnyEvent will report extra
2101which optional modules it loads and how it implements certain features. 2099information on which optional modules it loads and how it implements
2100certain features.
2102 2101
2103=item C<PERL_ANYEVENT_LOG> 2102=item C<PERL_ANYEVENT_LOG>
2104 2103
2105Accepts rather complex logging specifications. For example, you could log 2104Accepts rather complex logging specifications. For example, you could log
2106all C<debug> messages of some module to stderr, warnings and above to 2105all C<debug> messages of some module to stderr, warnings and above to
… …
2113This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded, 2112This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded,
2114so will take effect even before AnyEvent has initialised itself. 2113so will take effect even before AnyEvent has initialised itself.
2115 2114
2116Note that specifying this environment variable causes the L<AnyEvent::Log> 2115Note that specifying this environment variable causes the L<AnyEvent::Log>
2117module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only 2116module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only
2118using the latter saves a few hundred kB of memory until the first message 2117using the latter saves a few hundred kB of memory unless a module
2119is being logged. 2118explicitly needs the extra features of AnyEvent::Log.
2120 2119
2121=item C<PERL_ANYEVENT_STRICT> 2120=item C<PERL_ANYEVENT_STRICT>
2122 2121
2123AnyEvent does not do much argument checking by default, as thorough 2122AnyEvent does not do much argument checking by default, as thorough
2124argument checking is very costly. Setting this variable to a true value 2123argument checking is very costly. Setting this variable to a true value
… …
2179For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you 2178For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you
2180could start your program like this: 2179could start your program like this:
2181 2180
2182 PERL_ANYEVENT_MODEL=Perl perl ... 2181 PERL_ANYEVENT_MODEL=Perl perl ...
2183 2182
2183=item C<PERL_ANYEVENT_IO_MODEL>
2184
2185The current file I/O model - see L<AnyEvent::IO> for more info.
2186
2187At the moment, only C<Perl> (small, pure-perl, synchronous) and
2188C<IOAIO> (truly asynchronous) are supported. The default is C<IOAIO> if
2189L<AnyEvent::AIO> can be loaded, otherwise it is C<Perl>.
2190
2184=item C<PERL_ANYEVENT_PROTOCOLS> 2191=item C<PERL_ANYEVENT_PROTOCOLS>
2185 2192
2186Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences 2193Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences
2187for IPv4 or IPv6. The default is unspecified (and might change, or be the result 2194for IPv4 or IPv6. The default is unspecified (and might change, or be the result
2188of auto probing). 2195of auto probing).
… …
2226=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS> 2233=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>
2227 2234
2228The default value for the C<max_outstanding> parameter for the default DNS 2235The default value for the C<max_outstanding> parameter for the default DNS
2229resolver - this is the maximum number of parallel DNS requests that are 2236resolver - this is the maximum number of parallel DNS requests that are
2230sent to the DNS server. 2237sent to the DNS server.
2238
2239=item C<PERL_ANYEVENT_MAX_SIGNAL_LATENCY>
2240
2241Perl has inherently racy signal handling (you can basically choose between
2242losing signals and memory corruption) - pure perl event loops (including
2243C<AnyEvent::Loop>, when C<Async::Interrupt> isn't available) therefore
2244have to poll regularly to avoid losing signals.
2245
2246Some event loops are racy, but don't poll regularly, and some event loops
2247are written in C but are still racy. For those event loops, AnyEvent
2248installs a timer that regularly wakes up the event loop.
2249
2250By default, the interval for this timer is C<10> seconds, but you can
2251override this delay with this environment variable (or by setting
2252the C<$AnyEvent::MAX_SIGNAL_LATENCY> variable before creating signal
2253watchers).
2254
2255Lower values increase CPU (and energy) usage, higher values can introduce
2256long delays when reaping children or waiting for signals.
2257
2258The L<AnyEvent::Async> module, if available, will be used to avoid this
2259polling (with most event loops).
2231 2260
2232=item C<PERL_ANYEVENT_RESOLV_CONF> 2261=item C<PERL_ANYEVENT_RESOLV_CONF>
2233 2262
2234The absolute path to a F<resolv.conf>-style file to use instead of 2263The absolute path to a F<resolv.conf>-style file to use instead of
2235F</etc/resolv.conf> (or the OS-specific configuration) in the default 2264F</etc/resolv.conf> (or the OS-specific configuration) in the default
… …
2892This module is part of perl since release 5.008. It will be used when the 2921This module is part of perl since release 5.008. It will be used when the
2893chosen event library does not come with a timing source of its own. The 2922chosen event library does not come with a timing source of its own. The
2894pure-perl event loop (L<AnyEvent::Loop>) will additionally load it to 2923pure-perl event loop (L<AnyEvent::Loop>) will additionally load it to
2895try to use a monotonic clock for timing stability. 2924try to use a monotonic clock for timing stability.
2896 2925
2926=item L<AnyEvent::AIO> (and L<IO::AIO>)
2927
2928The default implementation of L<AnyEvent::IO> is to do I/O synchronously,
2929stopping programs while they access the disk, which is fine for a lot of
2930programs.
2931
2932Installing AnyEvent::AIO (and its IO::AIO dependency) makes it switch to
2933a true asynchronous implementation, so event processing can continue even
2934while waiting for disk I/O.
2935
2897=back 2936=back
2898 2937
2899 2938
2900=head1 FORK 2939=head1 FORK
2901 2940
… …
2984L<AnyEvent::Impl::FLTK>. 3023L<AnyEvent::Impl::FLTK>.
2985 3024
2986Non-blocking handles, pipes, stream sockets, TCP clients and 3025Non-blocking handles, pipes, stream sockets, TCP clients and
2987servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>. 3026servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
2988 3027
3028Asynchronous File I/O: L<AnyEvent::IO>.
3029
2989Asynchronous DNS: L<AnyEvent::DNS>. 3030Asynchronous DNS: L<AnyEvent::DNS>.
2990 3031
2991Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>. 3032Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>.
2992 3033
2993Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::IRC>, 3034Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::IRC>,
… …
2995 3036
2996 3037
2997=head1 AUTHOR 3038=head1 AUTHOR
2998 3039
2999 Marc Lehmann <schmorp@schmorp.de> 3040 Marc Lehmann <schmorp@schmorp.de>
3000 http://home.schmorp.de/ 3041 http://anyevent.schmorp.de
3001 3042
3002=cut 3043=cut
3003 3044
30041 30451
3005 3046

Diff Legend

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