[ViewVC] Diff of: cvs/AnyEvent-Fork/Fork.pm

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.27 by root, Sat Apr 6 09:05:50 2013 UTC vs.
Revision 1.46 by root, Thu Apr 18 11:18:23 2013 UTC

…		…
27		27
28	Special care has been taken to make this module useful from other modules,	28	Special care has been taken to make this module useful from other modules,
29	while still supporting specialised environments such as L<App::Staticperl>	29	while still supporting specialised environments such as L<App::Staticperl>
30	or L<PAR::Packer>.	30	or L<PAR::Packer>.
31		31
32	=head1 WHAT THIS MODULE IS NOT	32	=head2 WHAT THIS MODULE IS NOT
33		33
34	This module only creates processes and lets you pass file handles and	34	This module only creates processes and lets you pass file handles and
35	strings to it, and run perl code. It does not implement any kind of RPC -	35	strings to it, and run perl code. It does not implement any kind of RPC -
36	there is no back channel from the process back to you, and there is no RPC	36	there is no back channel from the process back to you, and there is no RPC
37	or message passing going on.	37	or message passing going on.
38		38
39	If you need some form of RPC, you can either implement it yourself	39	If you need some form of RPC, you could use the L<AnyEvent::Fork::RPC>
40	in whatever way you like, use some message-passing module such	40	companion module, which adds simple RPC/job queueing to a process created
41	as L<AnyEvent::MP>, some pipe such as L<AnyEvent::ZeroMQ>, use	41	by this module.
42	L<AnyEvent::Handle> on both sides to send e.g. JSON or Storable messages,
43	and so on.
44		42
		43	Or you can implement it yourself in whatever way you like, use some
		44	message-passing module such as L<AnyEvent::MP>, some pipe such as
		45	L<AnyEvent::ZeroMQ>, use L<AnyEvent::Handle> on both sides to send
		46	e.g. JSON or Storable messages, and so on.
		47
		48	=head2 COMPARISON TO OTHER MODULES
		49
		50	There is an abundance of modules on CPAN that do "something fork", such as
		51	L<Parallel::ForkManager>, L<AnyEvent::ForkManager>, L<AnyEvent::Worker>
		52	or L<AnyEvent::Subprocess>. There are modules that implement their own
		53	process management, such as L<AnyEvent::DBI>.
		54
		55	The problems that all these modules try to solve are real, however, none
		56	of them (from what I have seen) tackle the very real problems of unwanted
		57	memory sharing, efficiency, not being able to use event processing or
		58	similar modules in the processes they create.
		59
		60	This module doesn't try to replace any of them - instead it tries to solve
		61	the problem of creating processes with a minimum of fuss and overhead (and
		62	also luxury). Ideally, most of these would use AnyEvent::Fork internally,
		63	except they were written before AnyEvent:Fork was available, so obviously
		64	had to roll their own.
		65
45	=head1 PROBLEM STATEMENT	66	=head2 PROBLEM STATEMENT
46		67
47	There are two traditional ways to implement parallel processing on UNIX	68	There are two traditional ways to implement parallel processing on UNIX
48	like operating systems - fork and process, and fork+exec and process. They	69	like operating systems - fork and process, and fork+exec and process. They
49	have different advantages and disadvantages that I describe below,	70	have different advantages and disadvantages that I describe below,
50	together with how this module tries to mitigate the disadvantages.	71	together with how this module tries to mitigate the disadvantages.
…		…
152		173
153	# now $master_filehandle is connected to the	174	# now $master_filehandle is connected to the
154	# $slave_filehandle in the new process.	175	# $slave_filehandle in the new process.
155	});	176	});
156		177
157	# MyModule::worker might look like this	178	C<MyModule> might look like this:
		179
		180	package MyModule;
		181
158	sub MyModule::worker {	182	sub worker {
159	my ($slave_filehandle) = @_;	183	my ($slave_filehandle) = @_;
160		184
161	# now $slave_filehandle is connected to the $master_filehandle	185	# now $slave_filehandle is connected to the $master_filehandle
162	# in the original prorcess. have fun!	186	# in the original prorcess. have fun!
163	}	187	}
…		…
182	}	206	}
183		207
184	# now do other things - maybe use the filehandle provided by run	208	# now do other things - maybe use the filehandle provided by run
185	# to wait for the processes to die. or whatever.	209	# to wait for the processes to die. or whatever.
186		210
187	# My::Server::run might look like this	211	C<My::Server> might look like this:
188	sub My::Server::run {	212
		213	package My::Server;
		214
		215	sub run {
189	my ($slave, $listener, $id) = @_;	216	my ($slave, $listener, $id) = @_;
190		217
191	close $slave; # we do not use the socket, so close it to save resources	218	close $slave; # we do not use the socket, so close it to save resources
192		219
193	# we could go ballistic and use e.g. AnyEvent here, or IO::AIO,	220	# we could go ballistic and use e.g. AnyEvent here, or IO::AIO,
…		…
197	}	224	}
198	}	225	}
199		226
200	=head2 use AnyEvent::Fork as a faster fork+exec	227	=head2 use AnyEvent::Fork as a faster fork+exec
201		228
202	This runs /bin/echo hi, with stdout redirected to /tmp/log and stderr to	229	This runs C</bin/echo hi>, with standard output redirected to F</tmp/log>
203	the communications socket. It is usually faster than fork+exec, but still	230	and standard error redirected to the communications socket. It is usually
204	let's you prepare the environment.	231	faster than fork+exec, but still lets you prepare the environment.
205		232
206	open my $output, ">/tmp/log" or die "$!";	233	open my $output, ">/tmp/log" or die "$!";
207		234
208	AnyEvent::Fork	235	AnyEvent::Fork
209	->new	236	->new
210	->eval ('	237	->eval ('
		238	# compile a helper function for later use
211	sub run {	239	sub run {
212	my ($fh, $output, @cmd) = @_;	240	my ($fh, $output, @cmd) = @_;
213		241
214	# perl will clear close-on-exec on STDOUT/STDERR	242	# perl will clear close-on-exec on STDOUT/STDERR
215	open STDOUT, ">&", $output or die;	243	open STDOUT, ">&", $output or die;
…		…
226		254
227	=head1 CONCEPTS	255	=head1 CONCEPTS
228		256
229	This module can create new processes either by executing a new perl	257	This module can create new processes either by executing a new perl
230	process, or by forking from an existing "template" process.	258	process, or by forking from an existing "template" process.
		259
		260	All these processes are called "child processes" (whether they are direct
		261	children or not), while the process that manages them is called the
		262	"parent process".
231		263
232	Each such process comes with its own file handle that can be used to	264	Each such process comes with its own file handle that can be used to
233	communicate with it (it's actually a socket - one end in the new process,	265	communicate with it (it's actually a socket - one end in the new process,
234	one end in the main process), and among the things you can do in it are	266	one end in the main process), and among the things you can do in it are
235	load modules, fork new processes, send file handles to it, and execute	267	load modules, fork new processes, send file handles to it, and execute
…		…
314	=head1 THE C<AnyEvent::Fork> CLASS	346	=head1 THE C<AnyEvent::Fork> CLASS
315		347
316	This module exports nothing, and only implements a single class -	348	This module exports nothing, and only implements a single class -
317	C<AnyEvent::Fork>.	349	C<AnyEvent::Fork>.
318		350
319	There are two constructors that both create new processes - C<new> and	351	There are two class constructors that both create new processes - C<new>
320	C<new_exec>. The C<fork> method creates a new process by forking an	352	and C<new_exec>. The C<fork> method creates a new process by forking an
321	existing one and could be considered a third constructor.	353	existing one and could be considered a third constructor.
322		354
323	Most of the remaining methods deal with preparing the new process, by	355	Most of the remaining methods deal with preparing the new process, by
324	loading code, evaluating code and sending data to the new process. They	356	loading code, evaluating code and sending data to the new process. They
325	usually return the process object, so you can chain method calls.	357	usually return the process object, so you can chain method calls.
326		358
327	If a process object is destroyed before calling its C<run> method, then	359	If a process object is destroyed before calling its C<run> method, then
328	the process simply exits. After C<run> is called, all responsibility is	360	the process simply exits. After C<run> is called, all responsibility is
329	passed to the specified function.	361	passed to the specified function.
330		362
		363	As long as there is any outstanding work to be done, process objects
		364	resist being destroyed, so there is no reason to store them unless you
		365	need them later - configure and forget works just fine.
		366
331	=over 4	367	=over 4
332		368
333	=cut	369	=cut
334		370
335	package AnyEvent::Fork;	371	package AnyEvent::Fork;
…		…
341	use AnyEvent;	377	use AnyEvent;
342	use AnyEvent::Util ();	378	use AnyEvent::Util ();
343		379
344	use IO::FDPass;	380	use IO::FDPass;
345		381
346	our $VERSION = 0.5;	382	our $VERSION = 0.6;
347
348	our $PERL; # the path to the perl interpreter, deduces with various forms of magic
349
350	=item my $pool = new AnyEvent::Fork key => value...
351
352	Create a new process pool. The following named parameters are supported:
353
354	=over 4
355
356	=back
357
358	=cut
359		383
360	# the early fork template process	384	# the early fork template process
361	our $EARLY;	385	our $EARLY;
362		386
363	# the empty template process	387	# the empty template process
364	our $TEMPLATE;	388	our $TEMPLATE;
		389
		390	sub QUEUE() { 0 }
		391	sub FH() { 1 }
		392	sub WW() { 2 }
		393	sub PID() { 3 }
		394	sub CB() { 4 }
		395
		396	sub _new {
		397	my ($self, $fh, $pid) = @_;
		398
		399	AnyEvent::Util::fh_nonblocking $fh, 1;
		400
		401	$self = bless [
		402	[], # write queue - strings or fd's
		403	$fh,
		404	undef, # AE watcher
		405	$pid,
		406	], $self;
		407
		408	$self
		409	}
365		410
366	sub _cmd {	411	sub _cmd {
367	my $self = shift;	412	my $self = shift;
368		413
369	# ideally, we would want to use "a (w/a)*" as format string, but perl	414	# ideally, we would want to use "a (w/a)*" as format string, but perl
370	# versions from at least 5.8.9 to 5.16.3 are all buggy and can't unpack	415	# versions from at least 5.8.9 to 5.16.3 are all buggy and can't unpack
371	# it.	416	# it.
372	push @{ $self->[2] }, pack "a L/a*", $_[0], $_[1];	417	push @{ $self->[QUEUE] }, pack "a L/a*", $_[0], $_[1];
373		418
374	$self->[3] \|\|= AE::io $self->[1], 1, sub {	419	$self->[WW] \|\|= AE::io $self->[FH], 1, sub {
375	do {	420	do {
376	# send the next "thing" in the queue - either a reference to an fh,	421	# send the next "thing" in the queue - either a reference to an fh,
377	# or a plain string.	422	# or a plain string.
378		423
379	if (ref $self->[2][0]) {	424	if (ref $self->[QUEUE][0]) {
380	# send fh	425	# send fh
381	unless (IO::FDPass::send fileno $self->[1], fileno ${ $self->[2][0] }) {	426	unless (IO::FDPass::send fileno $self->[FH], fileno ${ $self->[QUEUE][0] }) {
382	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;	427	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;
383	undef $self->[3];	428	undef $self->[WW];
384	die "AnyEvent::Fork: file descriptor send failure: $!";	429	die "AnyEvent::Fork: file descriptor send failure: $!";
385	}	430	}
386		431
387	shift @{ $self->[2] };	432	shift @{ $self->[QUEUE] };
388		433
389	} else {	434	} else {
390	# send string	435	# send string
391	my $len = syswrite $self->[1], $self->[2][0];	436	my $len = syswrite $self->[FH], $self->[QUEUE][0];
392		437
393	unless ($len) {	438	unless ($len) {
394	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;	439	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;
395	undef $self->[3];	440	undef $self->[3];
396	die "AnyEvent::Fork: command write failure: $!";	441	die "AnyEvent::Fork: command write failure: $!";
397	}	442	}
398		443
399	substr $self->[2][0], 0, $len, "";	444	substr $self->[QUEUE][0], 0, $len, "";
400	shift @{ $self->[2] } unless length $self->[2][0];	445	shift @{ $self->[QUEUE] } unless length $self->[QUEUE][0];
401	}	446	}
402	} while @{ $self->[2] };	447	} while @{ $self->[QUEUE] };
403		448
404	# everything written	449	# everything written
405	undef $self->[3];	450	undef $self->[WW];
406		451
407	# invoke run callback, if any	452	# invoke run callback, if any
408	$self->[4]->($self->[1]) if $self->[4];	453	$self->[CB]->($self->[FH]) if $self->[CB];
409	};	454	};
410		455
411	() # make sure we don't leak the watcher	456	() # make sure we don't leak the watcher
412	}
413
414	sub _new {
415	my ($self, $fh, $pid) = @_;
416
417	AnyEvent::Util::fh_nonblocking $fh, 1;
418
419	$self = bless [
420	$pid,
421	$fh,
422	[], # write queue - strings or fd's
423	undef, # AE watcher
424	], $self;
425
426	$self
427	}	457	}
428		458
429	# fork template from current process, used by AnyEvent::Fork::Early/Template	459	# fork template from current process, used by AnyEvent::Fork::Early/Template
430	sub _new_fork {	460	sub _new_fork {
431	my ($fh, $slave) = AnyEvent::Util::portable_socketpair;	461	my ($fh, $slave) = AnyEvent::Util::portable_socketpair;
…		…
436	if ($pid eq 0) {	466	if ($pid eq 0) {
437	require AnyEvent::Fork::Serve;	467	require AnyEvent::Fork::Serve;
438	$AnyEvent::Fork::Serve::OWNER = $parent;	468	$AnyEvent::Fork::Serve::OWNER = $parent;
439	close $fh;	469	close $fh;
440	$0 = "$_[1] of $parent";	470	$0 = "$_[1] of $parent";
441	$SIG{CHLD} = 'IGNORE';
442	AnyEvent::Fork::Serve::serve ($slave);	471	AnyEvent::Fork::Serve::serve ($slave);
443	exit 0;	472	exit 0;
444	} elsif (!$pid) {	473	} elsif (!$pid) {
445	die "AnyEvent::Fork::Early/Template: unable to fork template process: $!";	474	die "AnyEvent::Fork::Early/Template: unable to fork template process: $!";
446	}	475	}
…		…
453	Create a new "empty" perl interpreter process and returns its process	482	Create a new "empty" perl interpreter process and returns its process
454	object for further manipulation.	483	object for further manipulation.
455		484
456	The new process is forked from a template process that is kept around	485	The new process is forked from a template process that is kept around
457	for this purpose. When it doesn't exist yet, it is created by a call to	486	for this purpose. When it doesn't exist yet, it is created by a call to
458	C<new_exec> and kept around for future calls.	487	C<new_exec> first and then stays around for future calls.
459
460	When the process object is destroyed, it will release the file handle
461	that connects it with the new process. When the new process has not yet
462	called C<run>, then the process will exit. Otherwise, what happens depends
463	entirely on the code that is executed.
464		488
465	=cut	489	=cut
466		490
467	sub new {	491	sub new {
468	my $class = shift;	492	my $class = shift;
…		…
558	}	582	}
559		583
560	=item $pid = $proc->pid	584	=item $pid = $proc->pid
561		585
562	Returns the process id of the process I<iff it is a direct child of the	586	Returns the process id of the process I<iff it is a direct child of the
563	process> running AnyEvent::Fork, and C<undef> otherwise.	587	process running AnyEvent::Fork>, and C<undef> otherwise.
564		588
565	Normally, only processes created via C<< AnyEvent::Fork->new_exec >> and	589	Normally, only processes created via C<< AnyEvent::Fork->new_exec >> and
566	L<AnyEvent::Fork::Template> are direct children, and you are responsible	590	L<AnyEvent::Fork::Template> are direct children, and you are responsible
567	to clean up their zombies when they die.	591	to clean up their zombies when they die.
568		592
569	All other processes are not direct children, and will be cleaned up by	593	All other processes are not direct children, and will be cleaned up by
570	AnyEvent::Fork.	594	AnyEvent::Fork itself.
571		595
572	=cut	596	=cut
573		597
574	sub pid {	598	sub pid {
575	$_[0][0]	599	$_[0][PID]
576	}	600	}
577		601
578	=item $proc = $proc->eval ($perlcode, @args)	602	=item $proc = $proc->eval ($perlcode, @args)
579		603
580	Evaluates the given C<$perlcode> as ... perl code, while setting C<@_> to	604	Evaluates the given C<$perlcode> as ... Perl code, while setting C<@_> to
581	the strings specified by C<@args>, in the "main" package.	605	the strings specified by C<@args>, in the "main" package.
582		606
583	This call is meant to do any custom initialisation that might be required	607	This call is meant to do any custom initialisation that might be required
584	(for example, the C<require> method uses it). It's not supposed to be used	608	(for example, the C<require> method uses it). It's not supposed to be used
585	to completely take over the process, use C<run> for that.	609	to completely take over the process, use C<run> for that.
586		610
587	The code will usually be executed after this call returns, and there is no	611	The code will usually be executed after this call returns, and there is no
588	way to pass anything back to the calling process. Any evaluation errors	612	way to pass anything back to the calling process. Any evaluation errors
589	will be reported to stderr and cause the process to exit.	613	will be reported to stderr and cause the process to exit.
590		614
591	If you want to execute some code to take over the process (see the	615	If you want to execute some code (that isn't in a module) to take over the
592	"fork+exec" example in the SYNOPSIS), you should compile a function via	616	process, you should compile a function via C<eval> first, and then call
593	C<eval> first, and then call it via C<run>. This also gives you access to	617	it via C<run>. This also gives you access to any arguments passed via the
594	any arguments passed via the C<send_xxx> methods, such as file handles.	618	C<send_xxx> methods, such as file handles. See the L<use AnyEvent::Fork as
		619	a faster fork+exec> example to see it in action.
595		620
596	Returns the process object for easy chaining of method calls.	621	Returns the process object for easy chaining of method calls.
597		622
598	=cut	623	=cut
599		624
…		…
625	=item $proc = $proc->send_fh ($handle, ...)	650	=item $proc = $proc->send_fh ($handle, ...)
626		651
627	Send one or more file handles (I<not> file descriptors) to the process,	652	Send one or more file handles (I<not> file descriptors) to the process,
628	to prepare a call to C<run>.	653	to prepare a call to C<run>.
629		654
630	The process object keeps a reference to the handles until this is done,	655	The process object keeps a reference to the handles until they have
631	so you must not explicitly close the handles. This is most easily	656	been passed over to the process, so you must not explicitly close the
632	accomplished by simply not storing the file handles anywhere after passing	657	handles. This is most easily accomplished by simply not storing the file
633	them to this method.	658	handles anywhere after passing them to this method - when AnyEvent::Fork
		659	is finished using them, perl will automatically close them.
634		660
635	Returns the process object for easy chaining of method calls.	661	Returns the process object for easy chaining of method calls.
636		662
637	Example: pass a file handle to a process, and release it without	663	Example: pass a file handle to a process, and release it without
638	closing. It will be closed automatically when it is no longer used.	664	closing. It will be closed automatically when it is no longer used.
…		…
645	sub send_fh {	671	sub send_fh {
646	my ($self, @fh) = @_;	672	my ($self, @fh) = @_;
647		673
648	for my $fh (@fh) {	674	for my $fh (@fh) {
649	$self->_cmd ("h");	675	$self->_cmd ("h");
650	push @{ $self->[2] }, \$fh;	676	push @{ $self->[QUEUE] }, \$fh;
651	}	677	}
652		678
653	$self	679	$self
654	}	680	}
655		681
656	=item $proc = $proc->send_arg ($string, ...)	682	=item $proc = $proc->send_arg ($string, ...)
657		683
658	Send one or more argument strings to the process, to prepare a call to	684	Send one or more argument strings to the process, to prepare a call to
659	C<run>. The strings can be any octet string.	685	C<run>. The strings can be any octet strings.
660		686
661	The protocol is optimised to pass a moderate number of relatively short	687	The protocol is optimised to pass a moderate number of relatively short
662	strings - while you can pass up to 4GB of data in one go, this is more	688	strings - while you can pass up to 4GB of data in one go, this is more
663	meant to pass some ID information or other startup info, not big chunks of	689	meant to pass some ID information or other startup info, not big chunks of
664	data.	690	data.
…		…
680	Enter the function specified by the function name in C<$func> in the	706	Enter the function specified by the function name in C<$func> in the
681	process. The function is called with the communication socket as first	707	process. The function is called with the communication socket as first
682	argument, followed by all file handles and string arguments sent earlier	708	argument, followed by all file handles and string arguments sent earlier
683	via C<send_fh> and C<send_arg> methods, in the order they were called.	709	via C<send_fh> and C<send_arg> methods, in the order they were called.
684		710
		711	The process object becomes unusable on return from this function - any
		712	further method calls result in undefined behaviour.
		713
685	The function name should be fully qualified, but if it isn't, it will be	714	The function name should be fully qualified, but if it isn't, it will be
686	looked up in the main package.	715	looked up in the C<main> package.
687		716
688	If the called function returns, doesn't exist, or any error occurs, the	717	If the called function returns, doesn't exist, or any error occurs, the
689	process exits.	718	process exits.
690		719
691	Preparing the process is done in the background - when all commands have	720	Preparing the process is done in the background - when all commands have
692	been sent, the callback is invoked with the local communications socket	721	been sent, the callback is invoked with the local communications socket
693	as argument. At this point you can start using the socket in any way you	722	as argument. At this point you can start using the socket in any way you
694	like.	723	like.
695
696	The process object becomes unusable on return from this function - any
697	further method calls result in undefined behaviour.
698		724
699	If the communication socket isn't used, it should be closed on both sides,	725	If the communication socket isn't used, it should be closed on both sides,
700	to save on kernel memory.	726	to save on kernel memory.
701		727
702	The socket is non-blocking in the parent, and blocking in the newly	728	The socket is non-blocking in the parent, and blocking in the newly
…		…
741	=cut	767	=cut
742		768
743	sub run {	769	sub run {
744	my ($self, $func, $cb) = @_;	770	my ($self, $func, $cb) = @_;
745		771
746	$self->[4] = $cb;	772	$self->[CB] = $cb;
747	$self->_cmd (r => $func);	773	$self->_cmd (r => $func);
748	}	774	}
749		775
750	=back	776	=back
751		777
…		…
777	479 vfork+execs per second, using AnyEvent::Fork->new_exec	803	479 vfork+execs per second, using AnyEvent::Fork->new_exec
778		804
779	So how can C<< AnyEvent->new >> be faster than a standard fork, even	805	So how can C<< AnyEvent->new >> be faster than a standard fork, even
780	though it uses the same operations, but adds a lot of overhead?	806	though it uses the same operations, but adds a lot of overhead?
781		807
782	The difference is simply the process size: forking the 6MB process takes	808	The difference is simply the process size: forking the 5MB process takes
783	so much longer than forking the 2.5MB template process that the overhead	809	so much longer than forking the 2.5MB template process that the extra
784	introduced is canceled out.	810	overhead is canceled out.
785		811
786	If the benchmark process grows, the normal fork becomes even slower:	812	If the benchmark process grows, the normal fork becomes even slower:
787		813
788	1340 new processes, manual fork in a 20MB process	814	1340 new processes, manual fork of a 20MB process
789	731 new processes, manual fork in a 200MB process	815	731 new processes, manual fork of a 200MB process
790	235 new processes, manual fork in a 2000MB process	816	235 new processes, manual fork of a 2000MB process
791		817
792	What that means (to me) is that I can use this module without having a	818	What that means (to me) is that I can use this module without having a bad
793	very bad conscience because of the extra overhead required to start new	819	conscience because of the extra overhead required to start new processes.
794	processes.
795		820
796	=head1 TYPICAL PROBLEMS	821	=head1 TYPICAL PROBLEMS
797		822
798	This section lists typical problems that remain. I hope by recognising	823	This section lists typical problems that remain. I hope by recognising
799	them, most can be avoided.	824	them, most can be avoided.
800		825
801	=over 4	826	=over 4
802		827
803	=item "leaked" file descriptors for exec'ed processes	828	=item leaked file descriptors for exec'ed processes
804		829
805	POSIX systems inherit file descriptors by default when exec'ing a new	830	POSIX systems inherit file descriptors by default when exec'ing a new
806	process. While perl itself laudably sets the close-on-exec flags on new	831	process. While perl itself laudably sets the close-on-exec flags on new
807	file handles, most C libraries don't care, and even if all cared, it's	832	file handles, most C libraries don't care, and even if all cared, it's
808	often not possible to set the flag in a race-free manner.	833	often not possible to set the flag in a race-free manner.
…		…
828	libraries or the code that leaks those file descriptors.	853	libraries or the code that leaks those file descriptors.
829		854
830	Fortunately, most of these leaked descriptors do no harm, other than	855	Fortunately, most of these leaked descriptors do no harm, other than
831	sitting on some resources.	856	sitting on some resources.
832		857
833	=item "leaked" file descriptors for fork'ed processes	858	=item leaked file descriptors for fork'ed processes
834		859
835	Normally, L<AnyEvent::Fork> does start new processes by exec'ing them,	860	Normally, L<AnyEvent::Fork> does start new processes by exec'ing them,
836	which closes file descriptors not marked for being inherited.	861	which closes file descriptors not marked for being inherited.
837		862
838	However, L<AnyEvent::Fork::Early> and L<AnyEvent::Fork::Template> offer	863	However, L<AnyEvent::Fork::Early> and L<AnyEvent::Fork::Template> offer
…		…
847		872
848	The solution is to either not load these modules before use'ing	873	The solution is to either not load these modules before use'ing
849	L<AnyEvent::Fork::Early> or L<AnyEvent::Fork::Template>, or to delay	874	L<AnyEvent::Fork::Early> or L<AnyEvent::Fork::Template>, or to delay
850	initialising them, for example, by calling C<init Gtk2> manually.	875	initialising them, for example, by calling C<init Gtk2> manually.
851		876
852	=item exit runs destructors	877	=item exiting calls object destructors
853		878
854	This only applies to users of Lc<AnyEvent::Fork:Early> and	879	This only applies to users of L<AnyEvent::Fork:Early> and
855	L<AnyEvent::Fork::Template>.	880	L<AnyEvent::Fork::Template>, or when initialising code creates objects
		881	that reference external resources.
856		882
857	When a process created by AnyEvent::Fork exits, it might do so by calling	883	When a process created by AnyEvent::Fork exits, it might do so by calling
858	exit, or simply letting perl reach the end of the program. At which point	884	exit, or simply letting perl reach the end of the program. At which point
859	Perl runs all destructors.	885	Perl runs all destructors.
860		886
…		…
879	to make it so, mostly due to the bloody broken perl that nobody seems to	905	to make it so, mostly due to the bloody broken perl that nobody seems to
880	care about. The fork emulation is a bad joke - I have yet to see something	906	care about. The fork emulation is a bad joke - I have yet to see something
881	useful that you can do with it without running into memory corruption	907	useful that you can do with it without running into memory corruption
882	issues or other braindamage. Hrrrr.	908	issues or other braindamage. Hrrrr.
883		909
884	Cygwin perl is not supported at the moment, as it should implement fd	910	Cygwin perl is not supported at the moment due to some hilarious
885	passing, but doesn't, and rolling my own is hard, as cygwin doesn't	911	shortcomings of its API - see L<IO::FDPoll> for more details.
886	support enough functionality to do it.
887		912
888	=head1 SEE ALSO	913	=head1 SEE ALSO
889		914
890	L<AnyEvent::Fork::Early> (to avoid executing a perl interpreter),	915	L<AnyEvent::Fork::Early>, to avoid executing a perl interpreter at all
		916	(part of this distribution).
		917
891	L<AnyEvent::Fork::Template> (to create a process by forking the main	918	L<AnyEvent::Fork::Template>, to create a process by forking the main
892	program at a convenient time).	919	program at a convenient time (part of this distribution).
893		920
894	=head1 AUTHOR	921	L<AnyEvent::Fork::RPC>, for simple RPC to child processes (on CPAN).
		922
		923	=head1 AUTHOR AND CONTACT INFORMATION
895		924
896	Marc Lehmann <schmorp@schmorp.de>	925	Marc Lehmann <schmorp@schmorp.de>
897	http://home.schmorp.de/	926	http://software.schmorp.de/pkg/AnyEvent-Fork
898		927
899	=cut	928	=cut
900		929
901	1	930	1
902		931

Diff Legend

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

Comparing AnyEvent-Fork/Fork.pm (file contents): Revision 1.27 by root, Sat Apr 6 09:05:50 2013 UTC vs. Revision 1.46 by root, Thu Apr 18 11:18:23 2013 UTC

Diff Legend

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.27 by root, Sat Apr 6 09:05:50 2013 UTC vs.
Revision 1.46 by root, Thu Apr 18 11:18:23 2013 UTC