[ViewVC] Diff of: cvs/AnyEvent/lib/AnyEvent.pm

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.384 by root, Mon Sep 5 07:21:54 2011 UTC vs.
Revision 1.410 by root, Fri Mar 1 06:03:21 2013 UTC

…		…
415	not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's	415	not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's
416	pure perl implementation).	416	pure perl implementation).
417		417
418	=head3 Safe/Unsafe Signals	418	=head3 Safe/Unsafe Signals
419		419
420	Perl signals can be either "safe" (synchronous to opcode handling) or	420	Perl signals can be either "safe" (synchronous to opcode handling)
421	"unsafe" (asynchronous) - the former might get delayed indefinitely, the	421	or "unsafe" (asynchronous) - the former might delay signal delivery
422	latter might corrupt your memory.	422	indefinitely, the latter might corrupt your memory.
423		423
424	AnyEvent signal handlers are, in addition, synchronous to the event loop,	424	AnyEvent signal handlers are, in addition, synchronous to the event loop,
425	i.e. they will not interrupt your running perl program but will only be	425	i.e. they will not interrupt your running perl program but will only be
426	called as part of the normal event handling (just like timer, I/O etc.	426	called as part of the normal event handling (just like timer, I/O etc.
427	callbacks, too).	427	callbacks, too).
428		428
429	=head3 Signal Races, Delays and Workarounds	429	=head3 Signal Races, Delays and Workarounds
430		430
431	Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching	431	Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support
432	callbacks to signals in a generic way, which is a pity, as you cannot	432	attaching callbacks to signals in a generic way, which is a pity,
433	do race-free signal handling in perl, requiring C libraries for	433	as you cannot do race-free signal handling in perl, requiring
434	this. AnyEvent will try to do its best, which means in some cases,	434	C libraries for this. AnyEvent will try to do its best, which
435	signals will be delayed. The maximum time a signal might be delayed is	435	means in some cases, signals will be delayed. The maximum time
436	specified in C<$AnyEvent::MAX_SIGNAL_LATENCY> (default: 10 seconds). This	436	a signal might be delayed is 10 seconds by default, but can
437	variable can be changed only before the first signal watcher is created,	437	be overriden via C<$ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY}> or
438	and should be left alone otherwise. This variable determines how often	438	C<$AnyEvent::MAX_SIGNAL_LATENCY> - see the L<ENVIRONMENT VARIABLES>
439	AnyEvent polls for signals (in case a wake-up was missed). Higher values	439	section for details.
440	will cause fewer spurious wake-ups, which is better for power and CPU
441	saving.
442		440
443	All these problems can be avoided by installing the optional	441	All these problems can be avoided by installing the optional
444	L<Async::Interrupt> module, which works with most event loops. It will not	442	L<Async::Interrupt> module, which works with most event loops. It will not
445	work with inherently broken event loops such as L<Event> or L<Event::Lib>	443	work 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
447	one-second latency). For those, you just have to suffer the delays.	445	delays.
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
770	This code fragment supposedly pings a number of hosts and calls	772	This code fragment supposedly pings a number of hosts and calls
771	C<send> after results for all then have have been gathered - in any	773	C<send> after results for all then have have been gathered - in any
772	order. To achieve this, the code issues a call to C<begin> when it starts	774	order. To achieve this, the code issues a call to C<begin> when it starts
773	each ping request and calls C<end> when it has received some result for	775	each ping request and calls C<end> when it has received some result for
774	it. Since C<begin> and C<end> only maintain a counter, the order in which	776	it. Since C<begin> and C<end> only maintain a counter, the order in which
…		…
809		811
810	In list context, all parameters passed to C<send> will be returned,	812	In list context, all parameters passed to C<send> will be returned,
811	in scalar context only the first one will be returned.	813	in scalar context only the first one will be returned.
812		814
813	Note that doing a blocking wait in a callback is not supported by any	815	Note that doing a blocking wait in a callback is not supported by any
814	event loop, that is, recursive invocation of a blocking C<< ->recv	816	event 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	817	not allowed and the C<recv> call will C<croak> if such a condition is
816	condition is detected. This condition can be slightly loosened by using	818	detected. This requirement can be dropped by relying on L<Coro::AnyEvent>
817	L<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
818	any thread that doesn't run the event loop itself.	820	that doesn't run the event loop itself. L<Coro::AnyEvent> is loaded
		821	automatically when L<Coro> is used with L<AnyEvent>, so code does not need
		822	to do anything special to take advantage of that: any code that would
		823	normally block your program because it calls C<recv>, be executed in an
		824	C<async> thread instead without blocking other threads.
819		825
820	Not all event models support a blocking wait - some die in that case	826	Not 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
822	using this from a module, never require a blocking wait>. Instead, let the	828	using this from a module, never require a blocking wait>. Instead, let the
823	caller decide whether the call will block or not (for example, by coupling	829	caller decide whether the call will block or not (for example, by coupling
…		…
1225		1231
1226	package AnyEvent;	1232	package AnyEvent;
1227		1233
1228	# basically a tuned-down version of common::sense	1234	# basically a tuned-down version of common::sense
1229	sub common_sense {	1235	sub common_sense {
1230	# from common:.sense 3.4	1236	# from common:.sense 3.5
		1237	local $^W;
1231	${^WARNING_BITS} ^= ${^WARNING_BITS} ^ "\x3c\x3f\x33\x00\x0f\xf0\x0f\xc0\xf0\xfc\x33\x00";	1238	${^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)	1239	# use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1233	$^H \|= 0x00000600;	1240	$^H \|= 0x00000600;
1234	}	1241	}
1235		1242
1236	BEGIN { AnyEvent::common_sense }	1243	BEGIN { AnyEvent::common_sense }
1237		1244
1238	use Carp ();	1245	use Carp ();
1239		1246
1240	our $VERSION = '6.02';	1247	our $VERSION = '7.04';
1241	our $MODEL;	1248	our $MODEL;
1242	our @ISA;	1249	our @ISA;
1243	our @REGISTRY;	1250	our @REGISTRY;
1244	our $VERBOSE;	1251	our $VERBOSE;
1245	our $MAX_SIGNAL_LATENCY = 10;
1246	our %PROTOCOL; # (ipv4\|ipv6) => (1\|2), higher numbers are preferred	1252	our %PROTOCOL; # (ipv4\|ipv6) => (1\|2), higher numbers are preferred
		1253	our $MAX_SIGNAL_LATENCY = $ENV{PERL_ANYEVENT_MAX_SIGNAL_LATENCY} \|\| 10; # executes after the BEGIN block below (tainting!)
1247		1254
1248	BEGIN {	1255	BEGIN {
1249	require "AnyEvent/constants.pl";	1256	require "AnyEvent/constants.pl";
1250		1257
1251	eval "sub TAINT (){" . (${^TAINT}*1) . "}";	1258	eval "sub TAINT (){" . (${^TAINT}*1) . "}";
…		…
1304	}	1311	}
1305		1312
1306	sub log($$;@) {	1313	sub log($$;@) {
1307	# only load the big bloated module when we actually are about to log something	1314	# 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	1315	if ($_[0] <= ($VERBOSE \|\| 1)) { # also catches non-numeric levels(!) and fatal
		1316	local ($!, $@);
1309	require AnyEvent::Log; # among other things, sets $VERBOSE to 9	1317	require AnyEvent::Log; # among other things, sets $VERBOSE to 9
1310	# AnyEvent::Log overwrites this function	1318	# AnyEvent::Log overwrites this function
1311	goto &log;	1319	goto &log;
1312	}	1320	}
1313		1321
1314	0 # not logged	1322	0 # not logged
1315	}	1323	}
1316		1324
1317	sub logger($;$) {	1325	sub _logger($;$) {
1318	package AnyEvent::Log;
1319
1320	my ($level, $renabled) = @_;	1326	my ($level, $renabled) = @_;
1321		1327
1322	$$renabled = $level <= $VERBOSE;	1328	$$renabled = $level <= $VERBOSE;
1323		1329
1324	my $pkg = (caller)[0];
1325
1326	my $logger = [$pkg, $level, $renabled];	1330	my $logger = [(caller)[0], $level, $renabled];
1327		1331
1328	our %LOGGER;
1329	$LOGGER{$logger+0} = $logger;	1332	$AnyEvent::Log::LOGGER{$logger+0} = $logger;
1330		1333
		1334	# return unless defined wantarray;
		1335	#
1331	require AnyEvent::Util;	1336	# require AnyEvent::Util;
1332	my $guard = AnyEvent::Util::guard (sub {	1337	# my $guard = AnyEvent::Util::guard (sub {
1333	# "clean up"	1338	# # "clean up"
1334	delete $LOGGER{$logger+0};	1339	# delete $LOGGER{$logger+0};
1335	});	1340	# });
1336		1341	#
1337	sub {	1342	# sub {
1338	return 0 unless $$renabled;	1343	# return 0 unless $$renabled;
1339		1344	#
1340	$guard if 0; # keep guard alive, but don't cause runtime overhead	1345	# $guard if 0; # keep guard alive, but don't cause runtime overhead
1341	require AnyEvent::Log unless $AnyEvent::Log::VERSION;	1346	# require AnyEvent::Log unless $AnyEvent::Log::VERSION;
1342	package AnyEvent::Log;	1347	# package AnyEvent::Log;
1343	_log ($logger->[0], $level, @_) # logger->[0] has been converted at load time	1348	# _log ($logger->[0], $level, @_) # logger->[0] has been converted at load time
1344	}	1349	# }
1345	}	1350	}
1346		1351
1347	if (length $ENV{PERL_ANYEVENT_LOG}) {	1352	if (length $ENV{PERL_ANYEVENT_LOG}) {
1348	require AnyEvent::Log; # AnyEvent::Log does the thing for us	1353	require AnyEvent::Log; # AnyEvent::Log does the thing for us
1349	}	1354	}
1350		1355
1351	our @models = (	1356	our @models = (
1352	[EV:: => AnyEvent::Impl::EV:: , 1],	1357	[EV:: => AnyEvent::Impl::EV::],
1353	[AnyEvent::Loop:: => AnyEvent::Impl::Perl:: , 1],	1358	[AnyEvent::Loop:: => AnyEvent::Impl::Perl::],
1354	# everything below here will not (normally) be autoprobed	1359	# everything below here will not (normally) be autoprobed
1355	# as the pure perl backend should work everywhere	1360	# as the pure perl backend should work everywhere
1356	# and is usually faster	1361	# and is usually faster
		1362	[Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package, so msut be near the top
1357	[Event:: => AnyEvent::Impl::Event::, 1],	1363	[Event:: => AnyEvent::Impl::Event::], # slow, stable
1358	[Glib:: => AnyEvent::Impl::Glib:: , 1], # becomes extremely slow with many watchers	1364	[Glib:: => AnyEvent::Impl::Glib::], # becomes extremely slow with many watchers
		1365	# everything below here should not be autoloaded
1359	[Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy	1366	[Event::Lib:: => AnyEvent::Impl::EventLib::], # too buggy
1360	[Irssi:: => AnyEvent::Impl::Irssi::], # Irssi has a bogus "Event" package
1361	[Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles	1367	[Tk:: => AnyEvent::Impl::Tk::], # crashes with many handles
1362	[Qt:: => AnyEvent::Impl::Qt::], # requires special main program	1368	[Qt:: => AnyEvent::Impl::Qt::], # requires special main program
1363	[POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza	1369	[POE::Kernel:: => AnyEvent::Impl::POE::], # lasciate ogni speranza
1364	[Wx:: => AnyEvent::Impl::POE::],	1370	[Wx:: => AnyEvent::Impl::POE::],
1365	[Prima:: => AnyEvent::Impl::POE::],	1371	[Prima:: => AnyEvent::Impl::POE::],
…		…
1394	our @methods = qw(io timer time now now_update signal child idle condvar);	1400	our @methods = qw(io timer time now now_update signal child idle condvar);
1395		1401
1396	sub detect() {	1402	sub detect() {
1397	return $MODEL if $MODEL; # some programs keep references to detect	1403	return $MODEL if $MODEL; # some programs keep references to detect
1398		1404
		1405	# IO::Async::Loop::AnyEvent is extremely evil, refuse to work with it
		1406	# the author knows about the problems and what it does to AnyEvent as a whole
		1407	# (and the ability of others to use AnyEvent), but simply wants to abuse AnyEvent
		1408	# anyway.
		1409	AnyEvent::log fatal => "IO::Async::Loop::AnyEvent detected - that module is broken by\n"
		1410	. "design, abuses internals and breaks AnyEvent - will not continue."
		1411	if exists $INC{"IO/Async/Loop/AnyEvent.pm"};
		1412
1399	local $!; # for good measure	1413	local $!; # for good measure
1400	local $SIG{__DIE__}; # we use eval	1414	local $SIG{__DIE__}; # we use eval
1401		1415
1402	# free some memory	1416	# free some memory
1403	*detect = sub () { $MODEL };	1417	*detect = sub () { $MODEL };
…		…
1411		1425
1412	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) {	1426	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z0-9:]+)$/) {
1413	my $model = $1;	1427	my $model = $1;
1414	$model = "AnyEvent::Impl::$model" unless $model =~ s/::$//;	1428	$model = "AnyEvent::Impl::$model" unless $model =~ s/::$//;
1415	if (eval "require $model") {	1429	if (eval "require $model") {
1416	AnyEvent::log 7 => "loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";	1430	AnyEvent::log 7 => "Loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.";
1417	$MODEL = $model;	1431	$MODEL = $model;
1418	} else {	1432	} else {
1419	AnyEvent::log 4 => "unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";	1433	AnyEvent::log 4 => "Unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@";
1420	}	1434	}
1421	}	1435	}
1422		1436
1423	# check for already loaded models	1437	# check for already loaded models
1424	unless ($MODEL) {	1438	unless ($MODEL) {
1425	for (@REGISTRY, @models) {	1439	for (@REGISTRY, @models) {
1426	my ($package, $model) = @$_;	1440	my ($package, $model) = @$_;
1427	if (${"$package\::VERSION"} > 0) {	1441	if (${"$package\::VERSION"} > 0) {
1428	if (eval "require $model") {	1442	if (eval "require $model") {
1429	AnyEvent::log 7 => "autodetected model '$model', using it.";	1443	AnyEvent::log 7 => "Autodetected model '$model', using it.";
		1444	$MODEL = $model;
		1445	last;
		1446	} else {
		1447	AnyEvent::log 8 => "Detected event loop $package, but cannot load '$model', skipping: $@";
		1448	}
		1449	}
		1450	}
		1451
		1452	unless ($MODEL) {
		1453	# try to autoload a model
		1454	for (@REGISTRY, @models) {
		1455	my ($package, $model) = @$_;
		1456	if (
		1457	eval "require $package"
		1458	and ${"$package\::VERSION"} > 0
		1459	and eval "require $model"
		1460	) {
		1461	AnyEvent::log 7 => "Autoloaded model '$model', using it.";
1430	$MODEL = $model;	1462	$MODEL = $model;
1431	last;	1463	last;
1432	}	1464	}
1433	}	1465	}
1434	}
1435
1436	unless ($MODEL) {
1437	# try to autoload a model
1438	for (@REGISTRY, @models) {
1439	my ($package, $model, $autoload) = @$_;
1440	if (
1441	$autoload
1442	and eval "require $package"
1443	and ${"$package\::VERSION"} > 0
1444	and eval "require $model"
1445	) {
1446	AnyEvent::log 7 => "autoloaded model '$model', using it.";
1447	$MODEL = $model;
1448	last;
1449	}
1450	}
1451		1466
1452	$MODEL	1467	$MODEL
1453	or AnyEvent::log fatal => "AnyEvent: backend autodetection failed - did you properly install AnyEvent?";	1468	or AnyEvent::log fatal => "Backend autodetection failed - did you properly install AnyEvent?";
1454	}	1469	}
1455	}	1470	}
1456		1471
1457	# free memory only needed for probing	1472	# free memory only needed for probing
1458	undef @models;	1473	undef @models;
…		…
1605	# probe for availability of Time::HiRes	1620	# probe for availability of Time::HiRes
1606	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {	1621	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1607	*time = sub { Time::HiRes::time () };	1622	*time = sub { Time::HiRes::time () };
1608	*AE::time = \& Time::HiRes::time ;	1623	*AE::time = \& Time::HiRes::time ;
1609	*now = \&time;	1624	*now = \&time;
1610	AnyEvent::log 8 => "AnyEvent: using Time::HiRes for sub-second timing accuracy.";	1625	AnyEvent::log 8 => "using Time::HiRes for sub-second timing accuracy.";
1611	# if (eval "use POSIX (); (POSIX::times())...	1626	# if (eval "use POSIX (); (POSIX::times())...
1612	} else {	1627	} else {
1613	*time = sub { CORE::time };	1628	*time = sub { CORE::time };
1614	*AE::time = sub (){ CORE::time };	1629	*AE::time = sub (){ CORE::time };
1615	*now = \&time;	1630	*now = \&time;
1616	AnyEvent::log 3 => "using built-in time(), WARNING, no sub-second resolution!";	1631	AnyEvent::log 3 => "Using built-in time(), no sub-second resolution!";
1617	}	1632	}
1618	};	1633	};
1619	die if $@;	1634	die if $@;
1620		1635
1621	&time	1636	&time
…		…
1715		1730
1716	sub signal {	1731	sub signal {
1717	eval q{ # poor man's autoloading {}	1732	eval q{ # poor man's autoloading {}
1718	# probe for availability of Async::Interrupt	1733	# probe for availability of Async::Interrupt
1719	if (_have_async_interrupt) {	1734	if (_have_async_interrupt) {
1720	AnyEvent::log 8 => "using Async::Interrupt for race-free signal handling.";	1735	AnyEvent::log 8 => "Using Async::Interrupt for race-free signal handling.";
1721		1736
1722	$SIGPIPE_R = new Async::Interrupt::EventPipe;	1737	$SIGPIPE_R = new Async::Interrupt::EventPipe;
1723	$SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;	1738	$SIG_IO = AE::io $SIGPIPE_R->fileno, 0, \&_signal_exec;
1724		1739
1725	} else {	1740	} else {
1726	AnyEvent::log 8 => "using emulated perl signal handling with latency timer.";	1741	AnyEvent::log 8 => "Using emulated perl signal handling with latency timer.";
1727		1742
1728	if (AnyEvent::WIN32) {	1743	if (AnyEvent::WIN32) {
1729	require AnyEvent::Util;	1744	require AnyEvent::Util;
1730		1745
1731	($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();	1746	($SIGPIPE_R, $SIGPIPE_W) = AnyEvent::Util::portable_pipe ();
…		…
2067		2082
2068	=over 4	2083	=over 4
2069		2084
2070	=item C<PERL_ANYEVENT_VERBOSE>	2085	=item C<PERL_ANYEVENT_VERBOSE>
2071		2086
2072	By default, AnyEvent will only log messages with loglevel C<3>	2087	By default, AnyEvent will log messages with loglevel C<4> (C<error>) or
2073	(C<critical>) or higher (see L<AnyEvent::Log>). You can set this	2088	higher (see L<AnyEvent::Log>). You can set this environment variable to a
2074	environment variable to a numerical loglevel to make AnyEvent more (or	2089	numerical loglevel to make AnyEvent more (or less) talkative.
2075	less) talkative.
2076		2090
2077	If you want to do more than just set the global logging level	2091	If you want to do more than just set the global logging level
2078	you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more	2092	you should have a look at C<PERL_ANYEVENT_LOG>, which allows much more
2079	complex specifications.	2093	complex specifications.
2080		2094
2081	When set to C<0> (C<off>), then no messages whatsoever will be logged with	2095	When set to C<0> (C<off>), then no messages whatsoever will be logged with
2082	the default logging settings.	2096	everything else at defaults.
2083		2097
2084	When set to C<5> or higher (C<warn>), causes AnyEvent to warn about	2098	When set to C<5> or higher (C<warn>), AnyEvent warns about unexpected
2085	unexpected conditions, such as not being able to load the event model	2099	conditions, such as not being able to load the event model specified by
2086	specified by C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an	2100	C<PERL_ANYEVENT_MODEL>, or a guard callback throwing an exception - this
2087	exception - this is the minimum recommended level.	2101	is the minimum recommended level for use during development.
2088		2102
2089	When set to C<7> or higher (info), cause AnyEvent to report which event model it	2103	When set to C<7> or higher (info), AnyEvent reports which event model it
2090	chooses.	2104	chooses.
2091		2105
2092	When set to C<8> or higher (debug), then AnyEvent will report extra information on	2106	When set to C<8> or higher (debug), then AnyEvent will report extra
2093	which optional modules it loads and how it implements certain features.	2107	information on which optional modules it loads and how it implements
		2108	certain features.
2094		2109
2095	=item C<PERL_ANYEVENT_LOG>	2110	=item C<PERL_ANYEVENT_LOG>
2096		2111
2097	Accepts rather complex logging specifications. For example, you could log	2112	Accepts rather complex logging specifications. For example, you could log
2098	all C<debug> messages of some module to stderr, warnings and above to	2113	all C<debug> messages of some module to stderr, warnings and above to
…		…
2105	This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded,	2120	This variable is evaluated when AnyEvent (or L<AnyEvent::Log>) is loaded,
2106	so will take effect even before AnyEvent has initialised itself.	2121	so will take effect even before AnyEvent has initialised itself.
2107		2122
2108	Note that specifying this environment variable causes the L<AnyEvent::Log>	2123	Note that specifying this environment variable causes the L<AnyEvent::Log>
2109	module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only	2124	module to be loaded, while C<PERL_ANYEVENT_VERBOSE> does not, so only
2110	using the latter saves a few hundred kB of memory until the first message	2125	using the latter saves a few hundred kB of memory unless a module
2111	is being logged.	2126	explicitly needs the extra features of AnyEvent::Log.
2112		2127
2113	=item C<PERL_ANYEVENT_STRICT>	2128	=item C<PERL_ANYEVENT_STRICT>
2114		2129
2115	AnyEvent does not do much argument checking by default, as thorough	2130	AnyEvent does not do much argument checking by default, as thorough
2116	argument checking is very costly. Setting this variable to a true value	2131	argument checking is very costly. Setting this variable to a true value
…		…
2171	For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you	2186	For example, to force the pure perl model (L<AnyEvent::Loop::Perl>) you
2172	could start your program like this:	2187	could start your program like this:
2173		2188
2174	PERL_ANYEVENT_MODEL=Perl perl ...	2189	PERL_ANYEVENT_MODEL=Perl perl ...
2175		2190
		2191	=item C<PERL_ANYEVENT_IO_MODEL>
		2192
		2193	The current file I/O model - see L<AnyEvent::IO> for more info.
		2194
		2195	At the moment, only C<Perl> (small, pure-perl, synchronous) and
		2196	C<IOAIO> (truly asynchronous) are supported. The default is C<IOAIO> if
		2197	L<AnyEvent::AIO> can be loaded, otherwise it is C<Perl>.
		2198
2176	=item C<PERL_ANYEVENT_PROTOCOLS>	2199	=item C<PERL_ANYEVENT_PROTOCOLS>
2177		2200
2178	Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences	2201	Used by both L<AnyEvent::DNS> and L<AnyEvent::Socket> to determine preferences
2179	for IPv4 or IPv6. The default is unspecified (and might change, or be the result	2202	for IPv4 or IPv6. The default is unspecified (and might change, or be the result
2180	of auto probing).	2203	of auto probing).
…		…
2218	=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>	2241	=item C<PERL_ANYEVENT_MAX_OUTSTANDING_DNS>
2219		2242
2220	The default value for the C<max_outstanding> parameter for the default DNS	2243	The default value for the C<max_outstanding> parameter for the default DNS
2221	resolver - this is the maximum number of parallel DNS requests that are	2244	resolver - this is the maximum number of parallel DNS requests that are
2222	sent to the DNS server.	2245	sent to the DNS server.
		2246
		2247	=item C<PERL_ANYEVENT_MAX_SIGNAL_LATENCY>
		2248
		2249	Perl has inherently racy signal handling (you can basically choose between
		2250	losing signals and memory corruption) - pure perl event loops (including
		2251	C<AnyEvent::Loop>, when C<Async::Interrupt> isn't available) therefore
		2252	have to poll regularly to avoid losing signals.
		2253
		2254	Some event loops are racy, but don't poll regularly, and some event loops
		2255	are written in C but are still racy. For those event loops, AnyEvent
		2256	installs a timer that regularly wakes up the event loop.
		2257
		2258	By default, the interval for this timer is C<10> seconds, but you can
		2259	override this delay with this environment variable (or by setting
		2260	the C<$AnyEvent::MAX_SIGNAL_LATENCY> variable before creating signal
		2261	watchers).
		2262
		2263	Lower values increase CPU (and energy) usage, higher values can introduce
		2264	long delays when reaping children or waiting for signals.
		2265
		2266	The L<AnyEvent::Async> module, if available, will be used to avoid this
		2267	polling (with most event loops).
2223		2268
2224	=item C<PERL_ANYEVENT_RESOLV_CONF>	2269	=item C<PERL_ANYEVENT_RESOLV_CONF>
2225		2270
2226	The absolute path to a F<resolv.conf>-style file to use instead of	2271	The absolute path to a F<resolv.conf>-style file to use instead of
2227	F</etc/resolv.conf> (or the OS-specific configuration) in the default	2272	F</etc/resolv.conf> (or the OS-specific configuration) in the default
…		…
2884	This module is part of perl since release 5.008. It will be used when the	2929	This module is part of perl since release 5.008. It will be used when the
2885	chosen event library does not come with a timing source of its own. The	2930	chosen event library does not come with a timing source of its own. The
2886	pure-perl event loop (L<AnyEvent::Loop>) will additionally load it to	2931	pure-perl event loop (L<AnyEvent::Loop>) will additionally load it to
2887	try to use a monotonic clock for timing stability.	2932	try to use a monotonic clock for timing stability.
2888		2933
		2934	=item L<AnyEvent::AIO> (and L<IO::AIO>)
		2935
		2936	The default implementation of L<AnyEvent::IO> is to do I/O synchronously,
		2937	stopping programs while they access the disk, which is fine for a lot of
		2938	programs.
		2939
		2940	Installing AnyEvent::AIO (and its IO::AIO dependency) makes it switch to
		2941	a true asynchronous implementation, so event processing can continue even
		2942	while waiting for disk I/O.
		2943
2889	=back	2944	=back
2890		2945
2891		2946
2892	=head1 FORK	2947	=head1 FORK
2893		2948
…		…
2976	L<AnyEvent::Impl::FLTK>.	3031	L<AnyEvent::Impl::FLTK>.
2977		3032
2978	Non-blocking handles, pipes, stream sockets, TCP clients and	3033	Non-blocking handles, pipes, stream sockets, TCP clients and
2979	servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.	3034	servers: L<AnyEvent::Handle>, L<AnyEvent::Socket>, L<AnyEvent::TLS>.
2980		3035
		3036	Asynchronous File I/O: L<AnyEvent::IO>.
		3037
2981	Asynchronous DNS: L<AnyEvent::DNS>.	3038	Asynchronous DNS: L<AnyEvent::DNS>.
2982		3039
2983	Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>.	3040	Thread support: L<Coro>, L<Coro::AnyEvent>, L<Coro::EV>, L<Coro::Event>.
2984		3041
2985	Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::IRC>,	3042	Nontrivial usage examples: L<AnyEvent::GPSD>, L<AnyEvent::IRC>,
…		…
2987		3044
2988		3045
2989	=head1 AUTHOR	3046	=head1 AUTHOR
2990		3047
2991	Marc Lehmann <schmorp@schmorp.de>	3048	Marc Lehmann <schmorp@schmorp.de>
2992	http://home.schmorp.de/	3049	http://anyevent.schmorp.de
2993		3050
2994	=cut	3051	=cut
2995		3052
2996	1	3053	1
2997		3054

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent.pm (file contents): Revision 1.384 by root, Mon Sep 5 07:21:54 2011 UTC vs. Revision 1.410 by root, Fri Mar 1 06:03:21 2013 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.384 by root, Mon Sep 5 07:21:54 2011 UTC vs.
Revision 1.410 by root, Fri Mar 1 06:03:21 2013 UTC