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

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.25 by root, Sat Apr 6 08:55:16 2013 UTC vs.
Revision 1.47 by root, Thu Apr 18 20:17:34 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.
…		…
125	becomes very hard to use the event loop from a child program, as the	146	becomes very hard to use the event loop from a child program, as the
126	watchers already exist but are only meaningful in the parent. Worse, a	147	watchers already exist but are only meaningful in the parent. Worse, a
127	module might want to use such a module, not knowing whether another module	148	module might want to use such a module, not knowing whether another module
128	or the main program also does, leading to problems.	149	or the main program also does, leading to problems.
129		150
		151	Apart from event loops, graphical toolkits also commonly fall into the
		152	"unsafe module" category, or just about anything that communicates with
		153	the external world, such as network libraries and file I/O modules, which
		154	usually don't like being copied and then allowed to continue in two
		155	processes.
		156
130	With this module only the main program is allowed to create new processes	157	With this module only the main program is allowed to create new processes
131	by forking (because only the main program can know when it is still safe	158	by forking (because only the main program can know when it is still safe
132	to do so) - all other processes are created via fork+exec, which makes it	159	to do so) - all other processes are created via fork+exec, which makes it
133	possible to use modules such as event loops or window interfaces safely.	160	possible to use modules such as event loops or window interfaces safely.
134		161
…		…
146		173
147	# now $master_filehandle is connected to the	174	# now $master_filehandle is connected to the
148	# $slave_filehandle in the new process.	175	# $slave_filehandle in the new process.
149	});	176	});
150		177
151	# MyModule::worker might look like this	178	C<MyModule> might look like this:
		179
		180	package MyModule;
		181
152	sub MyModule::worker {	182	sub worker {
153	my ($slave_filehandle) = @_;	183	my ($slave_filehandle) = @_;
154		184
155	# now $slave_filehandle is connected to the $master_filehandle	185	# now $slave_filehandle is connected to the $master_filehandle
156	# in the original prorcess. have fun!	186	# in the original prorcess. have fun!
157	}	187	}
…		…
176	}	206	}
177		207
178	# now do other things - maybe use the filehandle provided by run	208	# now do other things - maybe use the filehandle provided by run
179	# to wait for the processes to die. or whatever.	209	# to wait for the processes to die. or whatever.
180		210
181	# My::Server::run might look like this	211	C<My::Server> might look like this:
182	sub My::Server::run {	212
		213	package My::Server;
		214
		215	sub run {
183	my ($slave, $listener, $id) = @_;	216	my ($slave, $listener, $id) = @_;
184		217
185	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
186		219
187	# 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,
…		…
191	}	224	}
192	}	225	}
193		226
194	=head2 use AnyEvent::Fork as a faster fork+exec	227	=head2 use AnyEvent::Fork as a faster fork+exec
195		228
196	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>
197	the communications socket. It is usually faster than fork+exec, but still	230	and standard error redirected to the communications socket. It is usually
198	let's you prepare the environment.	231	faster than fork+exec, but still lets you prepare the environment.
199		232
200	open my $output, ">/tmp/log" or die "$!";	233	open my $output, ">/tmp/log" or die "$!";
201		234
202	AnyEvent::Fork	235	AnyEvent::Fork
203	->new	236	->new
204	->eval ('	237	->eval ('
		238	# compile a helper function for later use
205	sub run {	239	sub run {
206	my ($fh, $output, @cmd) = @_;	240	my ($fh, $output, @cmd) = @_;
207		241
208	# perl will clear close-on-exec on STDOUT/STDERR	242	# perl will clear close-on-exec on STDOUT/STDERR
209	open STDOUT, ">&", $output or die;	243	open STDOUT, ">&", $output or die;
…		…
220		254
221	=head1 CONCEPTS	255	=head1 CONCEPTS
222		256
223	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
224	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".
225		263
226	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
227	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,
228	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
229	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
…		…
303	my ($fork_fh) = @_;	341	my ($fork_fh) = @_;
304	});	342	});
305		343
306	=back	344	=back
307		345
308	=head1 FUNCTIONS	346	=head1 THE C<AnyEvent::Fork> CLASS
		347
		348	This module exports nothing, and only implements a single class -
		349	C<AnyEvent::Fork>.
		350
		351	There are two class constructors that both create new processes - C<new>
		352	and C<new_exec>. The C<fork> method creates a new process by forking an
		353	existing one and could be considered a third constructor.
		354
		355	Most of the remaining methods deal with preparing the new process, by
		356	loading code, evaluating code and sending data to the new process. They
		357	usually return the process object, so you can chain method calls.
		358
		359	If a process object is destroyed before calling its C<run> method, then
		360	the process simply exits. After C<run> is called, all responsibility is
		361	passed to the specified function.
		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.
309		366
310	=over 4	367	=over 4
311		368
312	=cut	369	=cut
313		370
…		…
320	use AnyEvent;	377	use AnyEvent;
321	use AnyEvent::Util ();	378	use AnyEvent::Util ();
322		379
323	use IO::FDPass;	380	use IO::FDPass;
324		381
325	our $VERSION = 0.5;	382	our $VERSION = 0.7;
326
327	our $PERL; # the path to the perl interpreter, deduces with various forms of magic
328
329	=item my $pool = new AnyEvent::Fork key => value...
330
331	Create a new process pool. The following named parameters are supported:
332
333	=over 4
334
335	=back
336
337	=cut
338		383
339	# the early fork template process	384	# the early fork template process
340	our $EARLY;	385	our $EARLY;
341		386
342	# the empty template process	387	# the empty template process
343	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	}
344		410
345	sub _cmd {	411	sub _cmd {
346	my $self = shift;	412	my $self = shift;
347		413
348	# 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
349	# 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
350	# it.	416	# it.
351	push @{ $self->[2] }, pack "a L/a*", $_[0], $_[1];	417	push @{ $self->[QUEUE] }, pack "a L/a*", $_[0], $_[1];
352		418
353	$self->[3] \|\|= AE::io $self->[1], 1, sub {	419	$self->[WW] \|\|= AE::io $self->[FH], 1, sub {
354	do {	420	do {
355	# 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,
356	# or a plain string.	422	# or a plain string.
357		423
358	if (ref $self->[2][0]) {	424	if (ref $self->[QUEUE][0]) {
359	# send fh	425	# send fh
360	unless (IO::FDPass::send fileno $self->[1], fileno ${ $self->[2][0] }) {	426	unless (IO::FDPass::send fileno $self->[FH], fileno ${ $self->[QUEUE][0] }) {
361	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;	427	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;
362	undef $self->[3];	428	undef $self->[WW];
363	die "AnyEvent::Fork: file descriptor send failure: $!";	429	die "AnyEvent::Fork: file descriptor send failure: $!";
364	}	430	}
365		431
366	shift @{ $self->[2] };	432	shift @{ $self->[QUEUE] };
367		433
368	} else {	434	} else {
369	# send string	435	# send string
370	my $len = syswrite $self->[1], $self->[2][0];	436	my $len = syswrite $self->[FH], $self->[QUEUE][0];
371		437
372	unless ($len) {	438	unless ($len) {
373	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;	439	return if $! == Errno::EAGAIN \|\| $! == Errno::EWOULDBLOCK;
374	undef $self->[3];	440	undef $self->[3];
375	die "AnyEvent::Fork: command write failure: $!";	441	die "AnyEvent::Fork: command write failure: $!";
376	}	442	}
377		443
378	substr $self->[2][0], 0, $len, "";	444	substr $self->[QUEUE][0], 0, $len, "";
379	shift @{ $self->[2] } unless length $self->[2][0];	445	shift @{ $self->[QUEUE] } unless length $self->[QUEUE][0];
380	}	446	}
381	} while @{ $self->[2] };	447	} while @{ $self->[QUEUE] };
382		448
383	# everything written	449	# everything written
384	undef $self->[3];	450	undef $self->[WW];
385		451
386	# invoke run callback, if any	452	# invoke run callback, if any
387	$self->[4]->($self->[1]) if $self->[4];	453	$self->[CB]->($self->[FH]) if $self->[CB];
388	};	454	};
389		455
390	() # make sure we don't leak the watcher	456	() # make sure we don't leak the watcher
391	}
392
393	sub _new {
394	my ($self, $fh, $pid) = @_;
395
396	AnyEvent::Util::fh_nonblocking $fh, 1;
397
398	$self = bless [
399	$pid,
400	$fh,
401	[], # write queue - strings or fd's
402	undef, # AE watcher
403	], $self;
404
405	$self
406	}	457	}
407		458
408	# fork template from current process, used by AnyEvent::Fork::Early/Template	459	# fork template from current process, used by AnyEvent::Fork::Early/Template
409	sub _new_fork {	460	sub _new_fork {
410	my ($fh, $slave) = AnyEvent::Util::portable_socketpair;	461	my ($fh, $slave) = AnyEvent::Util::portable_socketpair;
…		…
415	if ($pid eq 0) {	466	if ($pid eq 0) {
416	require AnyEvent::Fork::Serve;	467	require AnyEvent::Fork::Serve;
417	$AnyEvent::Fork::Serve::OWNER = $parent;	468	$AnyEvent::Fork::Serve::OWNER = $parent;
418	close $fh;	469	close $fh;
419	$0 = "$_[1] of $parent";	470	$0 = "$_[1] of $parent";
420	$SIG{CHLD} = 'IGNORE';
421	AnyEvent::Fork::Serve::serve ($slave);	471	AnyEvent::Fork::Serve::serve ($slave);
422	exit 0;	472	exit 0;
423	} elsif (!$pid) {	473	} elsif (!$pid) {
424	die "AnyEvent::Fork::Early/Template: unable to fork template process: $!";	474	die "AnyEvent::Fork::Early/Template: unable to fork template process: $!";
425	}	475	}
…		…
432	Create a new "empty" perl interpreter process and returns its process	482	Create a new "empty" perl interpreter process and returns its process
433	object for further manipulation.	483	object for further manipulation.
434		484
435	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
436	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
437	C<new_exec> and kept around for future calls.	487	C<new_exec> first and then stays around for future calls.
438
439	When the process object is destroyed, it will release the file handle
440	that connects it with the new process. When the new process has not yet
441	called C<run>, then the process will exit. Otherwise, what happens depends
442	entirely on the code that is executed.
443		488
444	=cut	489	=cut
445		490
446	sub new {	491	sub new {
447	my $class = shift;	492	my $class = shift;
…		…
537	}	582	}
538		583
539	=item $pid = $proc->pid	584	=item $pid = $proc->pid
540		585
541	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
542	process> running AnyEvent::Fork, and C<undef> otherwise.	587	process running AnyEvent::Fork>, and C<undef> otherwise.
543		588
544	Normally, only processes created via C<< AnyEvent::Fork->new_exec >> and	589	Normally, only processes created via C<< AnyEvent::Fork->new_exec >> and
545	L<AnyEvent::Fork::Template> are direct children, and you are responsible	590	L<AnyEvent::Fork::Template> are direct children, and you are responsible
546	to clean up their zombies when they die.	591	to clean up their zombies when they die.
547		592
548	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
549	AnyEvent::Fork.	594	AnyEvent::Fork itself.
550		595
551	=cut	596	=cut
552		597
553	sub pid {	598	sub pid {
554	$_[0][0]	599	$_[0][PID]
555	}	600	}
556		601
557	=item $proc = $proc->eval ($perlcode, @args)	602	=item $proc = $proc->eval ($perlcode, @args)
558		603
559	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
560	the strings specified by C<@args>, in the "main" package.	605	the strings specified by C<@args>, in the "main" package.
561		606
562	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
563	(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
564	to completely take over the process, use C<run> for that.	609	to completely take over the process, use C<run> for that.
565		610
566	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
567	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
568	will be reported to stderr and cause the process to exit.	613	will be reported to stderr and cause the process to exit.
569		614
570	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
571	"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
572	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
573	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.
574		620
575	Returns the process object for easy chaining of method calls.	621	Returns the process object for easy chaining of method calls.
576		622
577	=cut	623	=cut
578		624
…		…
604	=item $proc = $proc->send_fh ($handle, ...)	650	=item $proc = $proc->send_fh ($handle, ...)
605		651
606	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,
607	to prepare a call to C<run>.	653	to prepare a call to C<run>.
608		654
609	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
610	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
611	accomplished by simply not storing the file handles anywhere after passing	657	handles. This is most easily accomplished by simply not storing the file
612	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.
613		660
614	Returns the process object for easy chaining of method calls.	661	Returns the process object for easy chaining of method calls.
615		662
616	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
617	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.
…		…
624	sub send_fh {	671	sub send_fh {
625	my ($self, @fh) = @_;	672	my ($self, @fh) = @_;
626		673
627	for my $fh (@fh) {	674	for my $fh (@fh) {
628	$self->_cmd ("h");	675	$self->_cmd ("h");
629	push @{ $self->[2] }, \$fh;	676	push @{ $self->[QUEUE] }, \$fh;
630	}	677	}
631		678
632	$self	679	$self
633	}	680	}
634		681
635	=item $proc = $proc->send_arg ($string, ...)	682	=item $proc = $proc->send_arg ($string, ...)
636		683
637	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
638	C<run>. The strings can be any octet string.	685	C<run>. The strings can be any octet strings.
639		686
640	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
641	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
642	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
643	data.	690	data.
…		…
659	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
660	process. The function is called with the communication socket as first	707	process. The function is called with the communication socket as first
661	argument, followed by all file handles and string arguments sent earlier	708	argument, followed by all file handles and string arguments sent earlier
662	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.
663		710
		711	The process object becomes unusable on return from this function - any
		712	further method calls result in undefined behaviour.
		713
664	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
665	looked up in the main package.	715	looked up in the C<main> package.
666		716
667	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
668	process exits.	718	process exits.
669		719
670	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
671	been sent, the callback is invoked with the local communications socket	721	been sent, the callback is invoked with the local communications socket
672	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
673	like.	723	like.
674
675	The process object becomes unusable on return from this function - any
676	further method calls result in undefined behaviour.
677		724
678	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,
679	to save on kernel memory.	726	to save on kernel memory.
680		727
681	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
…		…
720	=cut	767	=cut
721		768
722	sub run {	769	sub run {
723	my ($self, $func, $cb) = @_;	770	my ($self, $func, $cb) = @_;
724		771
725	$self->[4] = $cb;	772	$self->[CB] = $cb;
726	$self->_cmd (r => $func);	773	$self->_cmd (r => $func);
727	}	774	}
728		775
729	=back	776	=back
730		777
…		…
756	479 vfork+execs per second, using AnyEvent::Fork->new_exec	803	479 vfork+execs per second, using AnyEvent::Fork->new_exec
757		804
758	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
759	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?
760		807
761	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
762	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
763	introduced is canceled out.	810	overhead is canceled out.
764		811
765	If the benchmark process grows, the normal fork becomes even slower:	812	If the benchmark process grows, the normal fork becomes even slower:
766		813
767	1340 new processes, manual fork in a 20MB process	814	1340 new processes, manual fork of a 20MB process
768	731 new processes, manual fork in a 200MB process	815	731 new processes, manual fork of a 200MB process
769	235 new processes, manual fork in a 2000MB process	816	235 new processes, manual fork of a 2000MB process
770		817
771	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
772	very bad conscience because of the extra overhead required to start new	819	conscience because of the extra overhead required to start new processes.
773	processes.
774		820
775	=head1 TYPICAL PROBLEMS	821	=head1 TYPICAL PROBLEMS
776		822
777	This section lists typical problems that remain. I hope by recognising	823	This section lists typical problems that remain. I hope by recognising
778	them, most can be avoided.	824	them, most can be avoided.
779		825
780	=over 4	826	=over 4
781		827
782	=item "leaked" file descriptors for exec'ed processes	828	=item leaked file descriptors for exec'ed processes
783		829
784	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
785	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
786	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
787	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.
…		…
807	libraries or the code that leaks those file descriptors.	853	libraries or the code that leaks those file descriptors.
808		854
809	Fortunately, most of these leaked descriptors do no harm, other than	855	Fortunately, most of these leaked descriptors do no harm, other than
810	sitting on some resources.	856	sitting on some resources.
811		857
812	=item "leaked" file descriptors for fork'ed processes	858	=item leaked file descriptors for fork'ed processes
813		859
814	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,
815	which closes file descriptors not marked for being inherited.	861	which closes file descriptors not marked for being inherited.
816		862
817	However, L<AnyEvent::Fork::Early> and L<AnyEvent::Fork::Template> offer	863	However, L<AnyEvent::Fork::Early> and L<AnyEvent::Fork::Template> offer
…		…
826		872
827	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
828	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
829	initialising them, for example, by calling C<init Gtk2> manually.	875	initialising them, for example, by calling C<init Gtk2> manually.
830		876
831	=item exit runs destructors	877	=item exiting calls object destructors
832		878
833	This only applies to users of Lc<AnyEvent::Fork:Early> and	879	This only applies to users of L<AnyEvent::Fork:Early> and
834	L<AnyEvent::Fork::Template>.	880	L<AnyEvent::Fork::Template>, or when initialising code creates objects
		881	that reference external resources.
835		882
836	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
837	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
838	Perl runs all destructors.	885	Perl runs all destructors.
839		886
…		…
858	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
859	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
860	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
861	issues or other braindamage. Hrrrr.	908	issues or other braindamage. Hrrrr.
862		909
863	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
864	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.
865	support enough functionality to do it.
866		912
867	=head1 SEE ALSO	913	=head1 SEE ALSO
868		914
869	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
870	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
871	program at a convenient time).	919	program at a convenient time (part of this distribution).
872		920
873	=head1 AUTHOR	921	L<AnyEvent::Fork::RPC>, for simple RPC to child processes (on CPAN).
		922
		923	=head1 AUTHOR AND CONTACT INFORMATION
874		924
875	Marc Lehmann <schmorp@schmorp.de>	925	Marc Lehmann <schmorp@schmorp.de>
876	http://home.schmorp.de/	926	http://software.schmorp.de/pkg/AnyEvent-Fork
877		927
878	=cut	928	=cut
879		929
880	1	930	1
881		931

Diff Legend

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

Comparing AnyEvent-Fork/Fork.pm (file contents): Revision 1.25 by root, Sat Apr 6 08:55:16 2013 UTC vs. Revision 1.47 by root, Thu Apr 18 20:17:34 2013 UTC

Diff Legend

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.25 by root, Sat Apr 6 08:55:16 2013 UTC vs.
Revision 1.47 by root, Thu Apr 18 20:17:34 2013 UTC