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

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.8 by root, Thu Apr 4 01:54:40 2013 UTC vs.
Revision 1.17 by root, Fri Apr 5 23:42:24 2013 UTC

…		…
3	AnyEvent::Fork - everything you wanted to use fork() for, but couldn't	3	AnyEvent::Fork - everything you wanted to use fork() for, but couldn't
4		4
5	=head1 SYNOPSIS	5	=head1 SYNOPSIS
6		6
7	use AnyEvent::Fork;	7	use AnyEvent::Fork;
		8
		9	##################################################################
		10	# create a single new process, tell it to run your worker function
		11
		12	AnyEvent::Fork
		13	->new
		14	->require ("MyModule")
		15	->run ("MyModule::worker, sub {
		16	my ($master_filehandle) = @_;
		17
		18	# now $master_filehandle is connected to the
		19	# $slave_filehandle in the new process.
		20	});
		21
		22	# MyModule::worker might look like this
		23	sub MyModule::worker {
		24	my ($slave_filehandle) = @_;
		25
		26	# now $slave_filehandle is connected to the $master_filehandle
		27	# in the original prorcess. have fun!
		28	}
		29
		30	##################################################################
		31	# create a pool of server processes all accepting on the same socket
		32
		33	# create listener socket
		34	my $listener = ...;
		35
		36	# create a pool template, initialise it and give it the socket
		37	my $pool = AnyEvent::Fork
		38	->new
		39	->require ("Some::Stuff", "My::Server")
		40	->send_fh ($listener);
		41
		42	# now create 10 identical workers
		43	for my $id (1..10) {
		44	$pool
		45	->fork
		46	->send_arg ($id)
		47	->run ("My::Server::run");
		48	}
		49
		50	# now do other things - maybe use the filehandle provided by run
		51	# to wait for the processes to die. or whatever.
		52
		53	# My::Server::run might look like this
		54	sub My::Server::run {
		55	my ($slave, $listener, $id) = @_;
		56
		57	close $slave; # we do not use the socket, so close it to save resources
		58
		59	# we could go ballistic and use e.g. AnyEvent here, or IO::AIO,
		60	# or anything we usually couldn't do in a process forked normally.
		61	while (my $socket = $listener->accept) {
		62	# do sth. with new socket
		63	}
		64	}
8		65
9	=head1 DESCRIPTION	66	=head1 DESCRIPTION
10		67
11	This module allows you to create new processes, without actually forking	68	This module allows you to create new processes, without actually forking
12	them from your current process (avoiding the problems of forking), but	69	them from your current process (avoiding the problems of forking), but
13	preserving most of the advantages of fork.	70	preserving most of the advantages of fork.
14		71
15	It can be used to create new worker processes or new independent	72	It can be used to create new worker processes or new independent
16	subprocesses for short- and long-running jobs, process pools (e.g. for use	73	subprocesses for short- and long-running jobs, process pools (e.g. for use
17	in pre-forked servers) but also to spawn new external processes (such as	74	in pre-forked servers) but also to spawn new external processes (such as
18	CGI scripts from a webserver), which can be faster (and more well behaved)	75	CGI scripts from a web server), which can be faster (and more well behaved)
19	than using fork+exec in big processes.	76	than using fork+exec in big processes.
20		77
21	Special care has been taken to make this module useful from other modules,	78	Special care has been taken to make this module useful from other modules,
22	while still supporting specialised environments such as L<App::Staticperl>	79	while still supporting specialised environments such as L<App::Staticperl>
23	or L<PAR::Packer>.	80	or L<PAR::Packer>.
		81
		82	=head1 WHAT THIS MODULE IS NOT
		83
		84	This module only creates processes and lets you pass file handles and
		85	strings to it, and run perl code. It does not implement any kind of RPC -
		86	there is no back channel from the process back to you, and there is no RPC
		87	or message passing going on.
		88
		89	If you need some form of RPC, you can either implement it yourself
		90	in whatever way you like, use some message-passing module such
		91	as L<AnyEvent::MP>, some pipe such as L<AnyEvent::ZeroMQ>, use
		92	L<AnyEvent::Handle> on both sides to send e.g. JSON or Storable messages,
		93	and so on.
24		94
25	=head1 PROBLEM STATEMENT	95	=head1 PROBLEM STATEMENT
26		96
27	There are two ways to implement parallel processing on UNIX like operating	97	There are two ways to implement parallel processing on UNIX like operating
28	systems - fork and process, and fork+exec and process. They have different	98	systems - fork and process, and fork+exec and process. They have different
…		…
40	or fork+exec instead.	110	or fork+exec instead.
41		111
42	=item Forking usually creates a copy-on-write copy of the parent	112	=item Forking usually creates a copy-on-write copy of the parent
43	process. Memory (for example, modules or data files that have been	113	process. Memory (for example, modules or data files that have been
44	will not take additional memory). When exec'ing a new process, modules	114	will not take additional memory). When exec'ing a new process, modules
45	and data files might need to be loaded again, at extra cpu and memory	115	and data files might need to be loaded again, at extra CPU and memory
46	cost. Likewise when forking, all data structures are copied as well - if	116	cost. Likewise when forking, all data structures are copied as well - if
47	the program frees them and replaces them by new data, the child processes	117	the program frees them and replaces them by new data, the child processes
48	will retain the memory even if it isn't used.	118	will retain the memory even if it isn't used.
49		119
50	This module allows the main program to do a controlled fork, and allows	120	This module allows the main program to do a controlled fork, and allows
…		…
62	as template, and also tries hard to identify the correct path to the perl	132	as template, and also tries hard to identify the correct path to the perl
63	interpreter. With a cooperative main program, exec'ing the interpreter	133	interpreter. With a cooperative main program, exec'ing the interpreter
64	might not even be necessary.	134	might not even be necessary.
65		135
66	=item Forking might be impossible when a program is running. For example,	136	=item Forking might be impossible when a program is running. For example,
67	POSIX makes it almost impossible to fork from a multithreaded program and	137	POSIX makes it almost impossible to fork from a multi-threaded program and
68	do anything useful in the child - strictly speaking, if your perl program	138	do anything useful in the child - strictly speaking, if your perl program
69	uses posix threads (even indirectly via e.g. L<IO::AIO> or L<threads>),	139	uses posix threads (even indirectly via e.g. L<IO::AIO> or L<threads>),
70	you cannot call fork on the perl level anymore, at all.	140	you cannot call fork on the perl level anymore, at all.
71		141
72	This module can safely fork helper processes at any time, by caling	142	This module can safely fork helper processes at any time, by calling
73	fork+exec in C, in a POSIX-compatible way.	143	fork+exec in C, in a POSIX-compatible way.
74		144
75	=item Parallel processing with fork might be inconvenient or difficult	145	=item Parallel processing with fork might be inconvenient or difficult
76	to implement. For example, when a program uses an event loop and creates	146	to implement. For example, when a program uses an event loop and creates
77	watchers it becomes very hard to use the event loop from a child	147	watchers it becomes very hard to use the event loop from a child
…		…
109	needed the first time. Forking from this process shares the memory used	179	needed the first time. Forking from this process shares the memory used
110	for the perl interpreter with the new process, but loading modules takes	180	for the perl interpreter with the new process, but loading modules takes
111	time, and the memory is not shared with anything else.	181	time, and the memory is not shared with anything else.
112		182
113	This is ideal for when you only need one extra process of a kind, with the	183	This is ideal for when you only need one extra process of a kind, with the
114	option of starting and stipping it on demand.	184	option of starting and stopping it on demand.
		185
		186	Example:
		187
		188	AnyEvent::Fork
		189	->new
		190	->require ("Some::Module")
		191	->run ("Some::Module::run", sub {
		192	my ($fork_fh) = @_;
		193	});
115		194
116	=item fork a new template process, load code, then fork processes off of	195	=item fork a new template process, load code, then fork processes off of
117	it and run the code	196	it and run the code
118		197
119	When you need to have a bunch of processes that all execute the same (or	198	When you need to have a bunch of processes that all execute the same (or
…		…
125	modules you loaded) is shared between the processes, and each new process	204	modules you loaded) is shared between the processes, and each new process
126	consumes relatively little memory of its own.	205	consumes relatively little memory of its own.
127		206
128	The disadvantage of this approach is that you need to create a template	207	The disadvantage of this approach is that you need to create a template
129	process for the sole purpose of forking new processes from it, but if you	208	process for the sole purpose of forking new processes from it, but if you
130	only need a fixed number of proceses you can create them, and then destroy	209	only need a fixed number of processes you can create them, and then destroy
131	the template process.	210	the template process.
		211
		212	Example:
		213
		214	my $template = AnyEvent::Fork->new->require ("Some::Module");
		215
		216	for (1..10) {
		217	$template->fork->run ("Some::Module::run", sub {
		218	my ($fork_fh) = @_;
		219	});
		220	}
		221
		222	# at this point, you can keep $template around to fork new processes
		223	# later, or you can destroy it, which causes it to vanish.
132		224
133	=item execute a new perl interpreter, load some code, run it	225	=item execute a new perl interpreter, load some code, run it
134		226
135	This is relatively slow, and doesn't allow you to share memory between	227	This is relatively slow, and doesn't allow you to share memory between
136	multiple processes.	228	multiple processes.
…		…
138	The only advantage is that you don't have to have a template process	230	The only advantage is that you don't have to have a template process
139	hanging around all the time to fork off some new processes, which might be	231	hanging around all the time to fork off some new processes, which might be
140	an advantage when there are long time spans where no extra processes are	232	an advantage when there are long time spans where no extra processes are
141	needed.	233	needed.
142		234
		235	Example:
		236
		237	AnyEvent::Fork
		238	->new_exec
		239	->require ("Some::Module")
		240	->run ("Some::Module::run", sub {
		241	my ($fork_fh) = @_;
		242	});
		243
143	=back	244	=back
144		245
145	=head1 FUNCTIONS	246	=head1 FUNCTIONS
146		247
147	=over 4	248	=over 4
…		…
153	use common::sense;	254	use common::sense;
154		255
155	use Socket ();	256	use Socket ();
156		257
157	use AnyEvent;	258	use AnyEvent;
158	use AnyEvent::Fork::Util;
159	use AnyEvent::Util ();	259	use AnyEvent::Util ();
		260
		261	use IO::FDPass;
		262
		263	our $VERSION = 0.2;
160		264
161	our $PERL; # the path to the perl interpreter, deduces with various forms of magic	265	our $PERL; # the path to the perl interpreter, deduces with various forms of magic
162		266
163	=item my $pool = new AnyEvent::Fork key => value...	267	=item my $pool = new AnyEvent::Fork key => value...
164		268
…		…
177	our $TEMPLATE;	281	our $TEMPLATE;
178		282
179	sub _cmd {	283	sub _cmd {
180	my $self = shift;	284	my $self = shift;
181		285
		286	#TODO: maybe append the packet to any existing string command already in the queue
		287
182	# ideally, we would want to use "a (w/a)*" as format string, but perl versions	288	# ideally, we would want to use "a (w/a)*" as format string, but perl versions
183	# from at least 5.8.9 to 5.16.3 are all buggy and can't unpack it.	289	# from at least 5.8.9 to 5.16.3 are all buggy and can't unpack it.
184	push @{ $self->[2] }, pack "N/a", pack "(w/a)*", @_;	290	push @{ $self->[2] }, pack "L/a", pack "(w/a)*", @_;
185		291
186	$self->[3] \|\|= AE::io $self->[1], 1, sub {	292	$self->[3] \|\|= AE::io $self->[1], 1, sub {
		293	# send the next "thing" in the queue - either a reference to an fh,
		294	# or a plain string.
		295
187	if (ref $self->[2][0]) {	296	if (ref $self->[2][0]) {
		297	# send fh
188	AnyEvent::Fork::Util::fd_send fileno $self->[1], fileno ${ $self->[2][0] }	298	IO::FDPass::send fileno $self->[1], fileno ${ $self->[2][0] }
189	and shift @{ $self->[2] };	299	and shift @{ $self->[2] };
190		300
191	} else {	301	} else {
		302	# send string
192	my $len = syswrite $self->[1], $self->[2][0]	303	my $len = syswrite $self->[1], $self->[2][0]
193	or do { undef $self->[3]; die "AnyEvent::Fork: command write failure: $!" };	304	or do { undef $self->[3]; die "AnyEvent::Fork: command write failure: $!" };
194		305
195	substr $self->[2][0], 0, $len, "";	306	substr $self->[2][0], 0, $len, "";
196	shift @{ $self->[2] } unless length $self->[2][0];	307	shift @{ $self->[2] } unless length $self->[2][0];
197	}	308	}
198		309
199	unless (@{ $self->[2] }) {	310	unless (@{ $self->[2] }) {
200	undef $self->[3];	311	undef $self->[3];
		312	# invoke run callback
201	$self->[0]->($self->[1]) if $self->[0];	313	$self->[0]->($self->[1]) if $self->[0];
202	}	314	}
203	};	315	};
		316
		317	() # make sure we don't leak the watcher
204	}	318	}
205		319
206	sub _new {	320	sub _new {
207	my ($self, $fh) = @_;	321	my ($self, $fh) = @_;
208		322
…		…
213	$fh,	327	$fh,
214	[], # write queue - strings or fd's	328	[], # write queue - strings or fd's
215	undef, # AE watcher	329	undef, # AE watcher
216	], $self;	330	], $self;
217		331
218	# my ($a, $b) = AnyEvent::Util::portable_socketpair;
219
220	# queue_cmd $template, "Iabc";
221	# push @{ $template->[2] }, \$b;
222
223	# use Coro::AnyEvent; Coro::AnyEvent::sleep 1;
224	# undef $b;
225	# die "x" . <$a>;
226
227	$self	332	$self
228	}	333	}
229		334
230	# fork template from current process, used by AnyEvent::Fork::Early/Template	335	# fork template from current process, used by AnyEvent::Fork::Early/Template
231	sub _new_fork {	336	sub _new_fork {
…		…
237	if ($pid eq 0) {	342	if ($pid eq 0) {
238	require AnyEvent::Fork::Serve;	343	require AnyEvent::Fork::Serve;
239	$AnyEvent::Fork::Serve::OWNER = $parent;	344	$AnyEvent::Fork::Serve::OWNER = $parent;
240	close $fh;	345	close $fh;
241	$0 = "$_[1] of $parent";	346	$0 = "$_[1] of $parent";
		347	$SIG{CHLD} = 'IGNORE';
242	AnyEvent::Fork::Serve::serve ($slave);	348	AnyEvent::Fork::Serve::serve ($slave);
243	AnyEvent::Fork::Util::_exit 0;	349	exit 0;
244	} elsif (!$pid) {	350	} elsif (!$pid) {
245	die "AnyEvent::Fork::Early/Template: unable to fork template process: $!";	351	die "AnyEvent::Fork::Early/Template: unable to fork template process: $!";
246	}	352	}
247		353
248	AnyEvent::Fork->_new ($fh)	354	AnyEvent::Fork->_new ($fh)
…		…
254	object for further manipulation.	360	object for further manipulation.
255		361
256	The new process is forked from a template process that is kept around	362	The new process is forked from a template process that is kept around
257	for this purpose. When it doesn't exist yet, it is created by a call to	363	for this purpose. When it doesn't exist yet, it is created by a call to
258	C<new_exec> and kept around for future calls.	364	C<new_exec> and kept around for future calls.
		365
		366	When the process object is destroyed, it will release the file handle
		367	that connects it with the new process. When the new process has not yet
		368	called C<run>, then the process will exit. Otherwise, what happens depends
		369	entirely on the code that is executed.
259		370
260	=cut	371	=cut
261		372
262	sub new {	373	sub new {
263	my $class = shift;	374	my $class = shift;
…		…
299	reduces the amount of memory sharing that is possible, and is also slower.	410	reduces the amount of memory sharing that is possible, and is also slower.
300		411
301	You should use C<new> whenever possible, except when having a template	412	You should use C<new> whenever possible, except when having a template
302	process around is unacceptable.	413	process around is unacceptable.
303		414
304	The path to the perl interpreter is divined usign various methods - first	415	The path to the perl interpreter is divined using various methods - first
305	C<$^X> is investigated to see if the path ends with something that sounds	416	C<$^X> is investigated to see if the path ends with something that sounds
306	as if it were the perl interpreter. Failing this, the module falls back to	417	as if it were the perl interpreter. Failing this, the module falls back to
307	using C<$Config::Config{perlpath}>.	418	using C<$Config::Config{perlpath}>.
308		419
309	=cut	420	=cut
…		…
318	my $perl = $;	429	my $perl = $;
319		430
320	# first we try $^X, but the path must be absolute (always on win32), and end in sth.	431	# first we try $^X, but the path must be absolute (always on win32), and end in sth.
321	# that looks like perl. this obviously only works for posix and win32	432	# that looks like perl. this obviously only works for posix and win32
322	unless (	433	unless (
323	(AnyEvent::Fork::Util::WIN32 \|\| $perl =~ m%^/%)	434	($^O eq "MSWin32" \|\| $perl =~ m%^/%)
324	&& $perl =~ m%[/\\]perl(?:[0-9]+(\.[0-9]+)+)?(\.exe)?$%i	435	&& $perl =~ m%[/\\]perl(?:[0-9]+(\.[0-9]+)+)?(\.exe)?$%i
325	) {	436	) {
326	# if it doesn't look perlish enough, try Config	437	# if it doesn't look perlish enough, try Config
327	require Config;	438	require Config;
328	$perl = $Config::Config{perlpath};	439	$perl = $Config::Config{perlpath};
…		…
332	require Proc::FastSpawn;	443	require Proc::FastSpawn;
333		444
334	my ($fh, $slave) = AnyEvent::Util::portable_socketpair;	445	my ($fh, $slave) = AnyEvent::Util::portable_socketpair;
335	Proc::FastSpawn::fd_inherit (fileno $slave);	446	Proc::FastSpawn::fd_inherit (fileno $slave);
336		447
		448	# new fh's should always be set cloexec (due to $^F),
		449	# but hey, not on win32, so we always clear the inherit flag.
		450	Proc::FastSpawn::fd_inherit (fileno $fh, 0);
		451
337	# quick. also doesn't work in win32. of course. what did you expect	452	# quick. also doesn't work in win32. of course. what did you expect
338	#local $ENV{PERL5LIB} = join ":", grep !ref, @INC;	453	#local $ENV{PERL5LIB} = join ":", grep !ref, @INC;
339	my %env = %ENV;	454	my %env = %ENV;
340	$env{PERL5LIB} = join +(AnyEvent::Fork::Util::WIN32 ? ";" : ":"), grep !ref, @INC;	455	$env{PERL5LIB} = join +($^O eq "MSWin32" ? ";" : ":"), grep !ref, @INC;
341		456
342	Proc::FastSpawn::spawn (	457	Proc::FastSpawn::spawn (
343	$perl,	458	$perl,
344	["perl", "-MAnyEvent::Fork::Serve", "-e", "AnyEvent::Fork::Serve::me", fileno $slave, $$],	459	["perl", "-MAnyEvent::Fork::Serve", "-e", "AnyEvent::Fork::Serve::me", fileno $slave, $$],
345	[map "$_=$env{$_}", keys %env],	460	[map "$_=$env{$_}", keys %env],
346	) or die "unable to spawn AnyEvent::Fork server: $!";	461	) or die "unable to spawn AnyEvent::Fork server: $!";
347		462
348	$self->_new ($fh)	463	$self->_new ($fh)
349	}	464	}
350		465
		466	=item $proc = $proc->eval ($perlcode, @args)
		467
		468	Evaluates the given C<$perlcode> as ... perl code, while setting C<@_> to
		469	the strings specified by C<@args>.
		470
		471	This call is meant to do any custom initialisation that might be required
		472	(for example, the C<require> method uses it). It's not supposed to be used
		473	to completely take over the process, use C<run> for that.
		474
		475	The code will usually be executed after this call returns, and there is no
		476	way to pass anything back to the calling process. Any evaluation errors
		477	will be reported to stderr and cause the process to exit.
		478
		479	Returns the process object for easy chaining of method calls.
		480
		481	=cut
		482
		483	sub eval {
		484	my ($self, $code, @args) = @_;
		485
		486	$self->_cmd (e => $code, @args);
		487
		488	$self
		489	}
		490
351	=item $proc = $proc->require ($module, ...)	491	=item $proc = $proc->require ($module, ...)
352		492
353	Tries to load the given modules into the process	493	Tries to load the given module(s) into the process
354		494
355	Returns the process object for easy chaining of method calls.	495	Returns the process object for easy chaining of method calls.
		496
		497	=cut
		498
		499	sub require {
		500	my ($self, @modules) = @_;
		501
		502	s%::%/%g for @modules;
		503	$self->eval ('require "$_.pm" for @_', @modules);
		504
		505	$self
		506	}
356		507
357	=item $proc = $proc->send_fh ($handle, ...)	508	=item $proc = $proc->send_fh ($handle, ...)
358		509
359	Send one or more file handles (I<not> file descriptors) to the process,	510	Send one or more file handles (I<not> file descriptors) to the process,
360	to prepare a call to C<run>.	511	to prepare a call to C<run>.
…		…
364	accomplished by simply not storing the file handles anywhere after passing	515	accomplished by simply not storing the file handles anywhere after passing
365	them to this method.	516	them to this method.
366		517
367	Returns the process object for easy chaining of method calls.	518	Returns the process object for easy chaining of method calls.
368		519
		520	Example: pass a file handle to a process, and release it without
		521	closing. It will be closed automatically when it is no longer used.
		522
		523	$proc->send_fh ($my_fh);
		524	undef $my_fh; # free the reference if you want, but DO NOT CLOSE IT
		525
369	=cut	526	=cut
370		527
371	sub send_fh {	528	sub send_fh {
372	my ($self, @fh) = @_;	529	my ($self, @fh) = @_;
373		530
374	for my $fh (@fh) {	531	for my $fh (@fh) {
375	$self->_cmd ("h");	532	$self->_cmd ("h");
376	push @{ $self->[2] }, \$fh;	533	push @{ $self->[2] }, \$fh;
377	push @$self, $fh; # dire hack
378	}	534	}
379		535
380	$self	536	$self
381	}	537	}
382		538
383	=item $proc = $proc->send_arg ($string, ...)	539	=item $proc = $proc->send_arg ($string, ...)
384		540
385	Send one or more argument strings to the process, to prepare a call to	541	Send one or more argument strings to the process, to prepare a call to
386	C<run>. The strings can be any octet string.	542	C<run>. The strings can be any octet string.
387		543
388	Returns the process object for easy chaining of emthod calls.	544	Returns the process object for easy chaining of method calls.
389		545
390	=cut	546	=cut
391		547
392	sub send_arg {	548	sub send_arg {
393	my ($self, @arg) = @_;	549	my ($self, @arg) = @_;
…		…
414	If the communication socket isn't used, it should be closed on both sides,	570	If the communication socket isn't used, it should be closed on both sides,
415	to save on kernel memory.	571	to save on kernel memory.
416		572
417	The socket is non-blocking in the parent, and blocking in the newly	573	The socket is non-blocking in the parent, and blocking in the newly
418	created process. The close-on-exec flag is set on both. Even if not used	574	created process. The close-on-exec flag is set on both. Even if not used
419	otherwise, the socket can be a good indicator for the existance of the	575	otherwise, the socket can be a good indicator for the existence of the
420	process - if the other process exits, you get a readable event on it,	576	process - if the other process exits, you get a readable event on it,
421	because exiting the process closes the socket (if it didn't create any	577	because exiting the process closes the socket (if it didn't create any
422	children using fork).	578	children using fork).
423		579
		580	Example: create a template for a process pool, pass a few strings, some
		581	file handles, then fork, pass one more string, and run some code.
		582
		583	my $pool = AnyEvent::Fork
		584	->new
		585	->send_arg ("str1", "str2")
		586	->send_fh ($fh1, $fh2);
		587
		588	for (1..2) {
		589	$pool
		590	->fork
		591	->send_arg ("str3")
		592	->run ("Some::function", sub {
		593	my ($fh) = @_;
		594
		595	# fh is nonblocking, but we trust that the OS can accept these
		596	# extra 3 octets anyway.
		597	syswrite $fh, "hi #$_\n";
		598
		599	# $fh is being closed here, as we don't store it anywhere
		600	});
		601	}
		602
		603	# Some::function might look like this - all parameters passed before fork
		604	# and after will be passed, in order, after the communications socket.
		605	sub Some::function {
		606	my ($fh, $str1, $str2, $fh1, $fh2, $str3) = @_;
		607
		608	print scalar <$fh>; # prints "hi 1\n" and "hi 2\n"
		609	}
		610
424	=cut	611	=cut
425		612
426	sub run {	613	sub run {
427	my ($self, $func, $cb) = @_;	614	my ($self, $func, $cb) = @_;
428		615
429	$self->[0] = $cb;	616	$self->[0] = $cb;
430	$self->_cmd ("r", $func);	617	$self->_cmd (r => $func);
431	}	618	}
432		619
433	=back	620	=back
434		621
		622	=head1 PERFORMANCE
		623
		624	Now for some unscientific benchmark numbers (all done on an amd64
		625	GNU/Linux box). These are intended to give you an idea of the relative
		626	performance you can expect.
		627
		628	OK, so, I ran a simple benchmark that creates a socket pair, forks, calls
		629	exit in the child and waits for the socket to close in the parent. I did
		630	load AnyEvent, EV and AnyEvent::Fork, for a total process size of 6312kB.
		631
		632	2079 new processes per second, using socketpair + fork manually
		633
		634	Then I did the same thing, but instead of calling fork, I called
		635	AnyEvent::Fork->new->run ("CORE::exit") and then again waited for the
		636	socket form the child to close on exit. This does the same thing as manual
		637	socket pair + fork, except that what is forked is the template process
		638	(2440kB), and the socket needs to be passed to the server at the other end
		639	of the socket first.
		640
		641	2307 new processes per second, using AnyEvent::Fork->new
		642
		643	And finally, using C<new_exec> instead C<new>, using vforks+execs to exec
		644	a new perl interpreter and compile the small server each time, I get:
		645
		646	479 vfork+execs per second, using AnyEvent::Fork->new_exec
		647
		648	So how can C<< AnyEvent->new >> be faster than a standard fork, even
		649	though it uses the same operations, but adds a lot of overhead?
		650
		651	The difference is simply the process size: forking the 6MB process takes
		652	so much longer than forking the 2.5MB template process that the overhead
		653	introduced is canceled out.
		654
		655	If the benchmark process grows, the normal fork becomes even slower:
		656
		657	1340 new processes, manual fork in a 20MB process
		658	731 new processes, manual fork in a 200MB process
		659	235 new processes, manual fork in a 2000MB process
		660
		661	What that means (to me) is that I can use this module without having a
		662	very bad conscience because of the extra overhead required to start new
		663	processes.
		664
		665	=head1 TYPICAL PROBLEMS
		666
		667	This section lists typical problems that remain. I hope by recognising
		668	them, most can be avoided.
		669
		670	=over 4
		671
		672	=item exit runs destructors
		673
		674	=item "leaked" file descriptors for exec'ed processes
		675
		676	POSIX systems inherit file descriptors by default when exec'ing a new
		677	process. While perl itself laudably sets the close-on-exec flags on new
		678	file handles, most C libraries don't care, and even if all cared, it's
		679	often not possible to set the flag in a race-free manner.
		680
		681	That means some file descriptors can leak through. And since it isn't
		682	possible to know which file descriptors are "good" and "necessary" (or
		683	even to know which file descriptors are open), there is no good way to
		684	close the ones that might harm.
		685
		686	As an example of what "harm" can be done consider a web server that
		687	accepts connections and afterwards some module uses AnyEvent::Fork for the
		688	first time, causing it to fork and exec a new process, which might inherit
		689	the network socket. When the server closes the socket, it is still open
		690	in the child (which doesn't even know that) and the client might conclude
		691	that the connection is still fine.
		692
		693	For the main program, there are multiple remedies available -
		694	L<AnyEvent::Fork::Early> is one, creating a process early and not using
		695	C<new_exec> is another, as in both cases, the first process can be exec'ed
		696	well before many random file descriptors are open.
		697
		698	In general, the solution for these kind of problems is to fix the
		699	libraries or the code that leaks those file descriptors.
		700
		701	Fortunately, most of these leaked descriptors do no harm, other than
		702	sitting on some resources.
		703
		704	=item "leaked" file descriptors for fork'ed processes
		705
		706	Normally, L<AnyEvent::Fork> does start new processes by exec'ing them,
		707	which closes file descriptors not marked for being inherited.
		708
		709	However, L<AnyEvent::Fork::Early> and L<AnyEvent::Fork::Template> offer
		710	a way to create these processes by forking, and this leaks more file
		711	descriptors than exec'ing them, as there is no way to mark descriptors as
		712	"close on fork".
		713
		714	An example would be modules like L<EV>, L<IO::AIO> or L<Gtk2>. Both create
		715	pipes for internal uses, and L<Gtk2> might open a connection to the X
		716	server. L<EV> and L<IO::AIO> can deal with fork, but Gtk2 might have
		717	trouble with a fork.
		718
		719	The solution is to either not load these modules before use'ing
		720	L<AnyEvent::Fork::Early> or L<AnyEvent::Fork::Template>, or to delay
		721	initialising them, for example, by calling C<init Gtk2> manually.
		722
		723	=back
		724
435	=head1 PORTABILITY NOTES	725	=head1 PORTABILITY NOTES
436		726
437	Win32 is a loser - code has been written for this platform, pain has been	727	Native win32 perls are somewhat supported (AnyEvent::Fork::Early is a nop,
438	felt, but in the end, this platform is just too broken - maybe a later	728	and ::Template is not going to work), and it cost a lot of blood and sweat
439	version can do it.	729	to make it so, mostly due to the bloody broken perl that nobody seems to
		730	care about. The fork emulation is a bad joke - I have yet to see something
		731	useful that you can do with it without running into memory corruption
		732	issues or other braindamage. Hrrrr.
		733
		734	Cygwin perl is not supported at the moment, as it should implement fd
		735	passing, but doesn't, and rolling my own is hard, as cygwin doesn't
		736	support enough functionality to do it.
		737
		738	=head1 SEE ALSO
		739
		740	L<AnyEvent::Fork::Early> (to avoid executing a perl interpreter),
		741	L<AnyEvent::Fork::Template> (to create a process by forking the main
		742	program at a convenient time).
440		743
441	=head1 AUTHOR	744	=head1 AUTHOR
442		745
443	Marc Lehmann <schmorp@schmorp.de>	746	Marc Lehmann <schmorp@schmorp.de>
444	http://home.schmorp.de/	747	http://home.schmorp.de/

Diff Legend

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

Comparing AnyEvent-Fork/Fork.pm (file contents): Revision 1.8 by root, Thu Apr 4 01:54:40 2013 UTC vs. Revision 1.17 by root, Fri Apr 5 23:42:24 2013 UTC

Diff Legend

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.8 by root, Thu Apr 4 01:54:40 2013 UTC vs.
Revision 1.17 by root, Fri Apr 5 23:42:24 2013 UTC