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

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.297 by root, Thu Nov 19 01:55:57 2009 UTC vs.
Revision 1.312 by root, Mon Feb 15 18:02:35 2010 UTC

…		…
402	correctly.	402	correctly.
403		403
404	Example: exit on SIGINT	404	Example: exit on SIGINT
405		405
406	my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });	406	my $w = AnyEvent->signal (signal => "INT", cb => sub { exit 1 });
		407
		408	=head3 Restart Behaviour
		409
		410	While restart behaviour is up to the event loop implementation, most will
		411	not restart syscalls (that includes L<Async::Interrupt> and AnyEvent's
		412	pure perl implementation).
		413
		414	=head3 Safe/Unsafe Signals
		415
		416	Perl signals can be either "safe" (synchronous to opcode handling) or
		417	"unsafe" (asynchronous) - the former might get delayed indefinitely, the
		418	latter might corrupt your memory.
		419
		420	AnyEvent signal handlers are, in addition, synchronous to the event loop,
		421	i.e. they will not interrupt your running perl program but will only be
		422	called as part of the normal event handling (just like timer, I/O etc.
		423	callbacks, too).
407		424
408	=head3 Signal Races, Delays and Workarounds	425	=head3 Signal Races, Delays and Workarounds
409		426
410	Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching	427	Many event loops (e.g. Glib, Tk, Qt, IO::Async) do not support attaching
411	callbacks to signals in a generic way, which is a pity, as you cannot	428	callbacks to signals in a generic way, which is a pity, as you cannot
…		…
486		503
487	=head2 IDLE WATCHERS	504	=head2 IDLE WATCHERS
488		505
489	$w = AnyEvent->idle (cb => <callback>);	506	$w = AnyEvent->idle (cb => <callback>);
490		507
491	Sometimes there is a need to do something, but it is not so important	508	Repeatedly invoke the callback after the process becomes idle, until
492	to do it instantly, but only when there is nothing better to do. This	509	either the watcher is destroyed or new events have been detected.
493	"nothing better to do" is usually defined to be "no other events need
494	attention by the event loop".
495		510
496	Idle watchers ideally get invoked when the event loop has nothing	511	Idle watchers are useful when there is a need to do something, but it
497	better to do, just before it would block the process to wait for new	512	is not so important (or wise) to do it instantly. The callback will be
498	events. Instead of blocking, the idle watcher is invoked.	513	invoked only when there is "nothing better to do", which is usually
		514	defined as "all outstanding events have been handled and no new events
		515	have been detected". That means that idle watchers ideally get invoked
		516	when the event loop has just polled for new events but none have been
		517	detected. Instead of blocking to wait for more events, the idle watchers
		518	will be invoked.
499		519
500	Most event loops unfortunately do not really support idle watchers (only	520	Unfortunately, most event loops do not really support idle watchers (only
501	EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent	521	EV, Event and Glib do it in a usable fashion) - for the rest, AnyEvent
502	will simply call the callback "from time to time".	522	will simply call the callback "from time to time".
503		523
504	Example: read lines from STDIN, but only process them when the	524	Example: read lines from STDIN, but only process them when the
505	program is otherwise idle:	525	program is otherwise idle:
…		…
949	You should check C<$AnyEvent::MODEL> before adding to this array, though:	969	You should check C<$AnyEvent::MODEL> before adding to this array, though:
950	if it is defined then the event loop has already been detected, and the	970	if it is defined then the event loop has already been detected, and the
951	array will be ignored.	971	array will be ignored.
952		972
953	Best use C<AnyEvent::post_detect { BLOCK }> when your application allows	973	Best use C<AnyEvent::post_detect { BLOCK }> when your application allows
954	it,as it takes care of these details.	974	it, as it takes care of these details.
955		975
956	This variable is mainly useful for modules that can do something useful	976	This variable is mainly useful for modules that can do something useful
957	when AnyEvent is used and thus want to know when it is initialised, but do	977	when AnyEvent is used and thus want to know when it is initialised, but do
958	not need to even load it by default. This array provides the means to hook	978	not need to even load it by default. This array provides the means to hook
959	into AnyEvent passively, without loading it.	979	into AnyEvent passively, without loading it.
		980
		981	Example: To load Coro::AnyEvent whenever Coro and AnyEvent are used
		982	together, you could put this into Coro (this is the actual code used by
		983	Coro to accomplish this):
		984
		985	if (defined $AnyEvent::MODEL) {
		986	# AnyEvent already initialised, so load Coro::AnyEvent
		987	require Coro::AnyEvent;
		988	} else {
		989	# AnyEvent not yet initialised, so make sure to load Coro::AnyEvent
		990	# as soon as it is
		991	push @AnyEvent::post_detect, sub { require Coro::AnyEvent };
		992	}
960		993
961	=back	994	=back
962		995
963	=head1 WHAT TO DO IN A MODULE	996	=head1 WHAT TO DO IN A MODULE
964		997
…		…
1114	package AnyEvent;	1147	package AnyEvent;
1115		1148
1116	# basically a tuned-down version of common::sense	1149	# basically a tuned-down version of common::sense
1117	sub common_sense {	1150	sub common_sense {
1118	# from common:.sense 1.0	1151	# from common:.sense 1.0
1119	${^WARNING_BITS} = "\xfc\x3f\xf3\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x03";	1152	${^WARNING_BITS} = "\xfc\x3f\x33\x00\x0f\xf3\xcf\xc0\xf3\xfc\x33\x00";
1120	# use strict vars subs	1153	# use strict vars subs - NO UTF-8, as Util.pm doesn't like this atm. (uts46data.pl)
1121	$^H \|= 0x00000600;	1154	$^H \|= 0x00000600;
1122	}	1155	}
1123		1156
1124	BEGIN { AnyEvent::common_sense }	1157	BEGIN { AnyEvent::common_sense }
1125		1158
1126	use Carp ();	1159	use Carp ();
1127		1160
1128	our $VERSION = '5.21';	1161	our $VERSION = '5.24';
1129	our $MODEL;	1162	our $MODEL;
1130		1163
1131	our $AUTOLOAD;	1164	our $AUTOLOAD;
1132	our @ISA;	1165	our @ISA;
1133		1166
1134	our @REGISTRY;	1167	our @REGISTRY;
1135		1168
1136	our $VERBOSE;	1169	our $VERBOSE;
1137		1170
1138	BEGIN {	1171	BEGIN {
		1172	eval "sub CYGWIN(){" . (($^O =~ /cygwin/i) *1) . "}";
1139	eval "sub WIN32(){ " . (($^O =~ /mswin32/i)*1) ." }";	1173	eval "sub WIN32 (){" . (($^O =~ /mswin32/i)*1) . "}";
1140	eval "sub TAINT(){ " . (${^TAINT}*1) . " }";	1174	eval "sub TAINT (){" . (${^TAINT} *1) . "}";
1141		1175
1142	delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}	1176	delete @ENV{grep /^PERL_ANYEVENT_/, keys %ENV}
1143	if ${^TAINT};	1177	if ${^TAINT};
1144		1178
1145	$VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;	1179	$VERBOSE = $ENV{PERL_ANYEVENT_VERBOSE}*1;
…		…
1206	sub AnyEvent::Util::postdetect::DESTROY {	1240	sub AnyEvent::Util::postdetect::DESTROY {
1207	@post_detect = grep $_ != ${$_[0]}, @post_detect;	1241	@post_detect = grep $_ != ${$_[0]}, @post_detect;
1208	}	1242	}
1209		1243
1210	sub detect() {	1244	sub detect() {
		1245	# free some memory
		1246	*detect = sub () { $MODEL };
		1247
		1248	local $!; # for good measure
		1249	local $SIG{__DIE__};
		1250
		1251	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {
		1252	my $model = "AnyEvent::Impl::$1";
		1253	if (eval "require $model") {
		1254	$MODEL = $model;
		1255	warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;
		1256	} else {
		1257	warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;
		1258	}
		1259	}
		1260
		1261	# check for already loaded models
1211	unless ($MODEL) {	1262	unless ($MODEL) {
1212	local $SIG{__DIE__};	1263	for (@REGISTRY, @models) {
1213		1264	my ($package, $model) = @$_;
1214	if ($ENV{PERL_ANYEVENT_MODEL} =~ /^([a-zA-Z]+)$/) {	1265	if (${"$package\::VERSION"} > 0) {
1215	my $model = "AnyEvent::Impl::$1";
1216	if (eval "require $model") {	1266	if (eval "require $model") {
1217	$MODEL = $model;	1267	$MODEL = $model;
1218	warn "AnyEvent: loaded model '$model' (forced by \$ENV{PERL_ANYEVENT_MODEL}), using it.\n" if $VERBOSE >= 2;	1268	warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;
1219	} else {	1269	last;
1220	warn "AnyEvent: unable to load model '$model' (from \$ENV{PERL_ANYEVENT_MODEL}):\n$@" if $VERBOSE;	1270	}
1221	}	1271	}
1222	}	1272	}
1223		1273
1224	# check for already loaded models
1225	unless ($MODEL) {	1274	unless ($MODEL) {
		1275	# try to autoload a model
1226	for (@REGISTRY, @models) {	1276	for (@REGISTRY, @models) {
1227	my ($package, $model) = @$_;	1277	my ($package, $model, $autoload) = @$_;
		1278	if (
		1279	$autoload
		1280	and eval "require $package"
1228	if (${"$package\::VERSION"} > 0) {	1281	and ${"$package\::VERSION"} > 0
1229	if (eval "require $model") {	1282	and eval "require $model"
		1283	) {
1230	$MODEL = $model;	1284	$MODEL = $model;
1231	warn "AnyEvent: autodetected model '$model', using it.\n" if $VERBOSE >= 2;	1285	warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1232	last;	1286	last;
1233	}
1234	}	1287	}
1235	}	1288	}
1236		1289
1237	unless ($MODEL) {
1238	# try to autoload a model
1239	for (@REGISTRY, @models) {
1240	my ($package, $model, $autoload) = @$_;
1241	if (
1242	$autoload
1243	and eval "require $package"
1244	and ${"$package\::VERSION"} > 0
1245	and eval "require $model"
1246	) {
1247	$MODEL = $model;
1248	warn "AnyEvent: autoloaded model '$model', using it.\n" if $VERBOSE >= 2;
1249	last;
1250	}
1251	}
1252
1253	$MODEL	1290	$MODEL
1254	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";	1291	or die "No event module selected for AnyEvent and autodetect failed. Install any one of these modules: EV, Event or Glib.\n";
1255	}
1256	}	1292	}
1257
1258	push @{"$MODEL\::ISA"}, "AnyEvent::Base";
1259
1260	unshift @ISA, $MODEL;
1261
1262	require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
1263
1264	(shift @post_detect)->() while @post_detect;
1265	}	1293	}
		1294
		1295	@models = (); # free probe data
		1296
		1297	push @{"$MODEL\::ISA"}, "AnyEvent::Base";
		1298	unshift @ISA, $MODEL;
		1299
		1300	require AnyEvent::Strict if $ENV{PERL_ANYEVENT_STRICT};
		1301
		1302	(shift @post_detect)->() while @post_detect;
1266		1303
1267	$MODEL	1304	$MODEL
1268	}	1305	}
1269		1306
1270	sub AUTOLOAD {	1307	sub AUTOLOAD {
1271	(my $func = $AUTOLOAD) =~ s/.*://;	1308	(my $func = $AUTOLOAD) =~ s/.*://;
1272		1309
1273	$method{$func}	1310	$method{$func}
1274	or Carp::croak "$func: not a valid method for AnyEvent objects";	1311	or Carp::croak "$func: not a valid AnyEvent class method";
1275		1312
1276	detect unless $MODEL;	1313	detect;
1277		1314
1278	my $class = shift;	1315	my $class = shift;
1279	$class->$func (@_);	1316	$class->$func (@_);
1280	}	1317	}
1281		1318
…		…
1349	package AnyEvent::Base;	1386	package AnyEvent::Base;
1350		1387
1351	# default implementations for many methods	1388	# default implementations for many methods
1352		1389
1353	sub _time() {	1390	sub _time() {
		1391	eval q{ # poor man's autoloading
1354	# probe for availability of Time::HiRes	1392	# probe for availability of Time::HiRes
1355	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {	1393	if (eval "use Time::HiRes (); Time::HiRes::time (); 1") {
1356	warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;	1394	warn "AnyEvent: using Time::HiRes for sub-second timing accuracy.\n" if $VERBOSE >= 8;
1357	*_time = \&Time::HiRes::time;	1395	*_time = \&Time::HiRes::time;
1358	# if (eval "use POSIX (); (POSIX::times())...	1396	# if (eval "use POSIX (); (POSIX::times())...
1359	} else {	1397	} else {
1360	warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;	1398	warn "AnyEvent: using built-in time(), WARNING, no sub-second resolution!\n" if $VERBOSE;
1361	*_time = sub { time }; # epic fail	1399	*_time = sub (){ time }; # epic fail
		1400	}
1362	}	1401	};
		1402	die if $@;
1363		1403
1364	&_time	1404	&_time
1365	}	1405	}
1366		1406
1367	sub time { _time }	1407	sub time { _time }
…		…
1388		1428
1389	our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);	1429	our ($SIGPIPE_R, $SIGPIPE_W, %SIG_CB, %SIG_EV, $SIG_IO);
1390	our (%SIG_ASY, %SIG_ASY_W);	1430	our (%SIG_ASY, %SIG_ASY_W);
1391	our ($SIG_COUNT, $SIG_TW);	1431	our ($SIG_COUNT, $SIG_TW);
1392		1432
1393	sub _signal_exec {
1394	$HAVE_ASYNC_INTERRUPT
1395	? $SIGPIPE_R->drain
1396	: sysread $SIGPIPE_R, (my $dummy), 9;
1397
1398	while (%SIG_EV) {
1399	for (keys %SIG_EV) {
1400	delete $SIG_EV{$_};
1401	$_->() for values %{ $SIG_CB{$_} \|\| {} };
1402	}
1403	}
1404	}
1405
1406	# install a dummy wakeup watcher to reduce signal catching latency	1433	# install a dummy wakeup watcher to reduce signal catching latency
		1434	# used by Impls
1407	sub _sig_add() {	1435	sub _sig_add() {
1408	unless ($SIG_COUNT++) {	1436	unless ($SIG_COUNT++) {
1409	# try to align timer on a full-second boundary, if possible	1437	# try to align timer on a full-second boundary, if possible
1410	my $NOW = AE::now;	1438	my $NOW = AE::now;
1411		1439
…		…
1542	# print weird messages, or just unconditionally exit	1570	# print weird messages, or just unconditionally exit
1543	# instead of getting the default action.	1571	# instead of getting the default action.
1544	undef $SIG{$signal}	1572	undef $SIG{$signal}
1545	unless keys %{ $SIG_CB{$signal} };	1573	unless keys %{ $SIG_CB{$signal} };
1546	};	1574	};
		1575
		1576	*_signal_exec = sub {
		1577	$HAVE_ASYNC_INTERRUPT
		1578	? $SIGPIPE_R->drain
		1579	: sysread $SIGPIPE_R, (my $dummy), 9;
		1580
		1581	while (%SIG_EV) {
		1582	for (keys %SIG_EV) {
		1583	delete $SIG_EV{$_};
		1584	$_->() for values %{ $SIG_CB{$_} \|\| {} };
		1585	}
		1586	}
		1587	};
1547	};	1588	};
1548	die if $@;	1589	die if $@;
		1590
1549	&signal	1591	&signal
1550	}	1592	}
1551		1593
1552	# default implementation for ->child	1594	# default implementation for ->child
1553		1595
1554	our %PID_CB;	1596	our %PID_CB;
1555	our $CHLD_W;	1597	our $CHLD_W;
1556	our $CHLD_DELAY_W;	1598	our $CHLD_DELAY_W;
1557	our $WNOHANG;	1599	our $WNOHANG;
1558		1600
		1601	# used by many Impl's
1559	sub _emit_childstatus($$) {	1602	sub _emit_childstatus($$) {
1560	my (undef, $rpid, $rstatus) = @_;	1603	my (undef, $rpid, $rstatus) = @_;
1561		1604
1562	$_->($rpid, $rstatus)	1605	$_->($rpid, $rstatus)
1563	for values %{ $PID_CB{$rpid} \|\| {} },	1606	for values %{ $PID_CB{$rpid} \|\| {} },
1564	values %{ $PID_CB{0} \|\| {} };	1607	values %{ $PID_CB{0} \|\| {} };
1565	}	1608	}
1566		1609
1567	sub _sigchld {
1568	my $pid;
1569
1570	AnyEvent->_emit_childstatus ($pid, $?)
1571	while ($pid = waitpid -1, $WNOHANG) > 0;
1572	}
1573
1574	sub child {	1610	sub child {
		1611	eval q{ # poor man's autoloading {}
		1612	*_sigchld = sub {
		1613	my $pid;
		1614
		1615	AnyEvent->_emit_childstatus ($pid, $?)
		1616	while ($pid = waitpid -1, $WNOHANG) > 0;
		1617	};
		1618
		1619	*child = sub {
1575	my (undef, %arg) = @_;	1620	my (undef, %arg) = @_;
1576		1621
1577	defined (my $pid = $arg{pid} + 0)	1622	defined (my $pid = $arg{pid} + 0)
1578	or Carp::croak "required option 'pid' is missing";	1623	or Carp::croak "required option 'pid' is missing";
1579		1624
1580	$PID_CB{$pid}{$arg{cb}} = $arg{cb};	1625	$PID_CB{$pid}{$arg{cb}} = $arg{cb};
1581		1626
1582	# WNOHANG is almost cetrainly 1 everywhere	1627	# WNOHANG is almost cetrainly 1 everywhere
1583	$WNOHANG \|\|= $^O =~ /^(?:openbsd\|netbsd\|linux\|freebsd\|cygwin\|MSWin32)$/	1628	$WNOHANG \|\|= $^O =~ /^(?:openbsd\|netbsd\|linux\|freebsd\|cygwin\|MSWin32)$/
1584	? 1	1629	? 1
1585	: eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } \|\| 1;	1630	: eval { local $SIG{__DIE__}; require POSIX; &POSIX::WNOHANG } \|\| 1;
1586		1631
1587	unless ($CHLD_W) {	1632	unless ($CHLD_W) {
1588	$CHLD_W = AE::signal CHLD => \&_sigchld;	1633	$CHLD_W = AE::signal CHLD => \&_sigchld;
1589	# child could be a zombie already, so make at least one round	1634	# child could be a zombie already, so make at least one round
1590	&_sigchld;	1635	&_sigchld;
1591	}	1636	}
1592		1637
1593	bless [$pid, $arg{cb}], "AnyEvent::Base::child"	1638	bless [$pid, $arg{cb}], "AnyEvent::Base::child"
1594	}	1639	};
1595		1640
1596	sub AnyEvent::Base::child::DESTROY {	1641	*AnyEvent::Base::child::DESTROY = sub {
1597	my ($pid, $cb) = @{$_[0]};	1642	my ($pid, $cb) = @{$_[0]};
1598		1643
1599	delete $PID_CB{$pid}{$cb};	1644	delete $PID_CB{$pid}{$cb};
1600	delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };	1645	delete $PID_CB{$pid} unless keys %{ $PID_CB{$pid} };
1601		1646
1602	undef $CHLD_W unless keys %PID_CB;	1647	undef $CHLD_W unless keys %PID_CB;
		1648	};
		1649	};
		1650	die if $@;
		1651
		1652	&child
1603	}	1653	}
1604		1654
1605	# idle emulation is done by simply using a timer, regardless	1655	# idle emulation is done by simply using a timer, regardless
1606	# of whether the process is idle or not, and not letting	1656	# of whether the process is idle or not, and not letting
1607	# the callback use more than 50% of the time.	1657	# the callback use more than 50% of the time.
1608	sub idle {	1658	sub idle {
		1659	eval q{ # poor man's autoloading {}
		1660	*idle = sub {
1609	my (undef, %arg) = @_;	1661	my (undef, %arg) = @_;
1610		1662
1611	my ($cb, $w, $rcb) = $arg{cb};	1663	my ($cb, $w, $rcb) = $arg{cb};
1612		1664
1613	$rcb = sub {	1665	$rcb = sub {
1614	if ($cb) {	1666	if ($cb) {
1615	$w = _time;	1667	$w = _time;
1616	&$cb;	1668	&$cb;
1617	$w = _time - $w;	1669	$w = _time - $w;
1618		1670
1619	# never use more then 50% of the time for the idle watcher,	1671	# never use more then 50% of the time for the idle watcher,
1620	# within some limits	1672	# within some limits
1621	$w = 0.0001 if $w < 0.0001;	1673	$w = 0.0001 if $w < 0.0001;
1622	$w = 5 if $w > 5;	1674	$w = 5 if $w > 5;
1623		1675
1624	$w = AE::timer $w, 0, $rcb;	1676	$w = AE::timer $w, 0, $rcb;
1625	} else {	1677	} else {
1626	# clean up...	1678	# clean up...
1627	undef $w;	1679	undef $w;
1628	undef $rcb;	1680	undef $rcb;
		1681	}
		1682	};
		1683
		1684	$w = AE::timer 0.05, 0, $rcb;
		1685
		1686	bless \\$cb, "AnyEvent::Base::idle"
1629	}	1687	};
		1688
		1689	*AnyEvent::Base::idle::DESTROY = sub {
		1690	undef $${$_[0]};
		1691	};
1630	};	1692	};
		1693	die if $@;
1631		1694
1632	$w = AE::timer 0.05, 0, $rcb;	1695	&idle
1633
1634	bless \\$cb, "AnyEvent::Base::idle"
1635	}
1636
1637	sub AnyEvent::Base::idle::DESTROY {
1638	undef $${$_[0]};
1639	}	1696	}
1640		1697
1641	package AnyEvent::CondVar;	1698	package AnyEvent::CondVar;
1642		1699
1643	our @ISA = AnyEvent::CondVar::Base::;	1700	our @ISA = AnyEvent::CondVar::Base::;
…		…
2431	it's built-in modules) are required to use it.	2488	it's built-in modules) are required to use it.
2432		2489
2433	That does not mean that AnyEvent won't take advantage of some additional	2490	That does not mean that AnyEvent won't take advantage of some additional
2434	modules if they are installed.	2491	modules if they are installed.
2435		2492
2436	This section epxlains which additional modules will be used, and how they	2493	This section explains which additional modules will be used, and how they
2437	affect AnyEvent's operetion.	2494	affect AnyEvent's operation.
2438		2495
2439	=over 4	2496	=over 4
2440		2497
2441	=item L<Async::Interrupt>	2498	=item L<Async::Interrupt>
2442		2499
…		…
2447	catch the signals) with some delay (default is 10 seconds, look for	2504	catch the signals) with some delay (default is 10 seconds, look for
2448	C<$AnyEvent::MAX_SIGNAL_LATENCY>).	2505	C<$AnyEvent::MAX_SIGNAL_LATENCY>).
2449		2506
2450	If this module is available, then it will be used to implement signal	2507	If this module is available, then it will be used to implement signal
2451	catching, which means that signals will not be delayed, and the event loop	2508	catching, which means that signals will not be delayed, and the event loop
2452	will not be interrupted regularly, which is more efficient (And good for	2509	will not be interrupted regularly, which is more efficient (and good for
2453	battery life on laptops).	2510	battery life on laptops).
2454		2511
2455	This affects not just the pure-perl event loop, but also other event loops	2512	This affects not just the pure-perl event loop, but also other event loops
2456	that have no signal handling on their own (e.g. Glib, Tk, Qt).	2513	that have no signal handling on their own (e.g. Glib, Tk, Qt).
2457		2514
…		…
2504		2561
2505		2562
2506	=head1 FORK	2563	=head1 FORK
2507		2564
2508	Most event libraries are not fork-safe. The ones who are usually are	2565	Most event libraries are not fork-safe. The ones who are usually are
2509	because they rely on inefficient but fork-safe C<select> or C<poll>	2566	because they rely on inefficient but fork-safe C<select> or C<poll> calls
2510	calls. Only L<EV> is fully fork-aware.	2567	- higher performance APIs such as BSD's kqueue or the dreaded Linux epoll
		2568	are usually badly thought-out hacks that are incompatible with fork in
		2569	one way or another. Only L<EV> is fully fork-aware and ensures that you
		2570	continue event-processing in both parent and child (or both, if you know
		2571	what you are doing).
		2572
		2573	This means that, in general, you cannot fork and do event processing in
		2574	the child if the event library was initialised before the fork (which
		2575	usually happens when the first AnyEvent watcher is created, or the library
		2576	is loaded).
2511		2577
2512	If you have to fork, you must either do so I<before> creating your first	2578	If you have to fork, you must either do so I<before> creating your first
2513	watcher OR you must not use AnyEvent at all in the child OR you must do	2579	watcher OR you must not use AnyEvent at all in the child OR you must do
2514	something completely out of the scope of AnyEvent.	2580	something completely out of the scope of AnyEvent.
		2581
		2582	The problem of doing event processing in the parent I<and> the child
		2583	is much more complicated: even for backends that I<are> fork-aware or
		2584	fork-safe, their behaviour is not usually what you want: fork clones all
		2585	watchers, that means all timers, I/O watchers etc. are active in both
		2586	parent and child, which is almost never what you want. USing C<exec>
		2587	to start worker children from some kind of manage rprocess is usually
		2588	preferred, because it is much easier and cleaner, at the expense of having
		2589	to have another binary.
2515		2590
2516		2591
2517	=head1 SECURITY CONSIDERATIONS	2592	=head1 SECURITY CONSIDERATIONS
2518		2593
2519	AnyEvent can be forced to load any event model via	2594	AnyEvent can be forced to load any event model via

Diff Legend

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

Comparing AnyEvent/lib/AnyEvent.pm (file contents): Revision 1.297 by root, Thu Nov 19 01:55:57 2009 UTC vs. Revision 1.312 by root, Mon Feb 15 18:02:35 2010 UTC

Diff Legend

Comparing AnyEvent/lib/AnyEvent.pm (file contents):
Revision 1.297 by root, Thu Nov 19 01:55:57 2009 UTC vs.
Revision 1.312 by root, Mon Feb 15 18:02:35 2010 UTC