ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/AnyEvent-Fork/Fork.pm
(Generate patch)

Comparing AnyEvent-Fork/Fork.pm (file contents):
Revision 1.14 by root, Thu Apr 4 08:16:14 2013 UTC vs.
Revision 1.63 by root, Wed Nov 26 13:36:18 2014 UTC

1=head1 NAME 1=head1 NAME
2 2
3AnyEvent::Fork - everything you wanted to use fork() for, but couldn't 3AnyEvent::Fork - everything you wanted to use fork() for, but couldn't
4 4
5ATTENTION, this is a very early release, and very untested. Consider it a
6technology preview.
7
8=head1 SYNOPSIS 5=head1 SYNOPSIS
9 6
10 use AnyEvent::Fork; 7 use AnyEvent::Fork;
11 8
12 ################################################################## 9 AnyEvent::Fork
10 ->new
11 ->require ("MyModule")
12 ->run ("MyModule::server", my $cv = AE::cv);
13
14 my $fh = $cv->recv;
15
16=head1 DESCRIPTION
17
18This module allows you to create new processes, without actually forking
19them from your current process (avoiding the problems of forking), but
20preserving most of the advantages of fork.
21
22It can be used to create new worker processes or new independent
23subprocesses for short- and long-running jobs, process pools (e.g. for use
24in pre-forked servers) but also to spawn new external processes (such as
25CGI scripts from a web server), which can be faster (and more well behaved)
26than using fork+exec in big processes.
27
28Special care has been taken to make this module useful from other modules,
29while still supporting specialised environments such as L<App::Staticperl>
30or L<PAR::Packer>.
31
32=head2 WHAT THIS MODULE IS NOT
33
34This module only creates processes and lets you pass file handles and
35strings to it, and run perl code. It does not implement any kind of RPC -
36there is no back channel from the process back to you, and there is no RPC
37or message passing going on.
38
39If you need some form of RPC, you could use the L<AnyEvent::Fork::RPC>
40companion module, which adds simple RPC/job queueing to a process created
41by this module.
42
43And if you need some automatic process pool management on top of
44L<AnyEvent::Fork::RPC>, you can look at the L<AnyEvent::Fork::Pool>
45companion module.
46
47Or you can implement it yourself in whatever way you like: use some
48message-passing module such as L<AnyEvent::MP>, some pipe such as
49L<AnyEvent::ZeroMQ>, use L<AnyEvent::Handle> on both sides to send
50e.g. JSON or Storable messages, and so on.
51
52=head2 COMPARISON TO OTHER MODULES
53
54There is an abundance of modules on CPAN that do "something fork", such as
55L<Parallel::ForkManager>, L<AnyEvent::ForkManager>, L<AnyEvent::Worker>
56or L<AnyEvent::Subprocess>. There are modules that implement their own
57process management, such as L<AnyEvent::DBI>.
58
59The problems that all these modules try to solve are real, however, none
60of them (from what I have seen) tackle the very real problems of unwanted
61memory sharing, efficiency or not being able to use event processing, GUI
62toolkits or similar modules in the processes they create.
63
64This module doesn't try to replace any of them - instead it tries to solve
65the problem of creating processes with a minimum of fuss and overhead (and
66also luxury). Ideally, most of these would use AnyEvent::Fork internally,
67except they were written before AnyEvent:Fork was available, so obviously
68had to roll their own.
69
70=head2 PROBLEM STATEMENT
71
72There are two traditional ways to implement parallel processing on UNIX
73like operating systems - fork and process, and fork+exec and process. They
74have different advantages and disadvantages that I describe below,
75together with how this module tries to mitigate the disadvantages.
76
77=over 4
78
79=item Forking from a big process can be very slow.
80
81A 5GB process needs 0.05s to fork on my 3.6GHz amd64 GNU/Linux box. This
82overhead is often shared with exec (because you have to fork first), but
83in some circumstances (e.g. when vfork is used), fork+exec can be much
84faster.
85
86This module can help here by telling a small(er) helper process to fork,
87which is faster then forking the main process, and also uses vfork where
88possible. This gives the speed of vfork, with the flexibility of fork.
89
90=item Forking usually creates a copy-on-write copy of the parent
91process.
92
93For example, modules or data files that are loaded will not use additional
94memory after a fork. Exec'ing a new process, in contrast, means modules
95and data files might need to be loaded again, at extra CPU and memory
96cost.
97
98But when forking, you still create a copy of your data structures - if
99the program frees them and replaces them by new data, the child processes
100will retain the old version even if it isn't used, which can suddenly and
101unexpectedly increase memory usage when freeing memory.
102
103For example, L<Gtk2::CV> is an image viewer optimised for large
104directories (millions of pictures). It also forks subprocesses for
105thumbnail generation, which inherit the data structure that stores all
106file information. If the user changes the directory, it gets freed in
107the main process, leaving a copy in the thumbnailer processes. This can
108lead to many times the memory usage that would actually be required. The
109solution is to fork early (and being unable to dynamically generate more
110subprocesses or do this from a module)... or to use L<AnyEvent:Fork>.
111
112There is a trade-off between more sharing with fork (which can be good or
113bad), and no sharing with exec.
114
115This module allows the main program to do a controlled fork, and allows
116modules to exec processes safely at any time. When creating a custom
117process pool you can take advantage of data sharing via fork without
118risking to share large dynamic data structures that will blow up child
119memory usage.
120
121In other words, this module puts you into control over what is being
122shared and what isn't, at all times.
123
124=item Exec'ing a new perl process might be difficult.
125
126For example, it is not easy to find the correct path to the perl
127interpreter - C<$^X> might not be a perl interpreter at all. Worse, there
128might not even be a perl binary installed on the system.
129
130This module tries hard to identify the correct path to the perl
131interpreter. With a cooperative main program, exec'ing the interpreter
132might not even be necessary, but even without help from the main program,
133it will still work when used from a module.
134
135=item Exec'ing a new perl process might be slow, as all necessary modules
136have to be loaded from disk again, with no guarantees of success.
137
138Long running processes might run into problems when perl is upgraded
139and modules are no longer loadable because they refer to a different
140perl version, or parts of a distribution are newer than the ones already
141loaded.
142
143This module supports creating pre-initialised perl processes to be used as
144a template for new processes at a later time, e.g. for use in a process
145pool.
146
147=item Forking might be impossible when a program is running.
148
149For example, POSIX makes it almost impossible to fork from a
150multi-threaded program while doing anything useful in the child - in
151fact, if your perl program uses POSIX threads (even indirectly via
152e.g. L<IO::AIO> or L<threads>), you cannot call fork on the perl level
153anymore without risking memory corruption or worse on a number of
154operating systems.
155
156This module can safely fork helper processes at any time, by calling
157fork+exec in C, in a POSIX-compatible way (via L<Proc::FastSpawn>).
158
159=item Parallel processing with fork might be inconvenient or difficult
160to implement. Modules might not work in both parent and child.
161
162For example, when a program uses an event loop and creates watchers it
163becomes very hard to use the event loop from a child program, as the
164watchers already exist but are only meaningful in the parent. Worse, a
165module might want to use such a module, not knowing whether another module
166or the main program also does, leading to problems.
167
168Apart from event loops, graphical toolkits also commonly fall into the
169"unsafe module" category, or just about anything that communicates with
170the external world, such as network libraries and file I/O modules, which
171usually don't like being copied and then allowed to continue in two
172processes.
173
174With this module only the main program is allowed to create new processes
175by forking (because only the main program can know when it is still safe
176to do so) - all other processes are created via fork+exec, which makes it
177possible to use modules such as event loops or window interfaces safely.
178
179=back
180
181=head1 EXAMPLES
182
13 # create a single new process, tell it to run your worker function 183=head2 Create a single new process, tell it to run your worker function.
14 184
15 AnyEvent::Fork 185 AnyEvent::Fork
16 ->new 186 ->new
17 ->require ("MyModule") 187 ->require ("MyModule")
18 ->run ("MyModule::worker, sub { 188 ->run ("MyModule::worker, sub {
20 190
21 # now $master_filehandle is connected to the 191 # now $master_filehandle is connected to the
22 # $slave_filehandle in the new process. 192 # $slave_filehandle in the new process.
23 }); 193 });
24 194
25 # MyModule::worker might look like this 195C<MyModule> might look like this:
196
197 package MyModule;
198
26 sub MyModule::worker { 199 sub worker {
27 my ($slave_filehandle) = @_; 200 my ($slave_filehandle) = @_;
28 201
29 # now $slave_filehandle is connected to the $master_filehandle 202 # now $slave_filehandle is connected to the $master_filehandle
30 # in the original prorcess. have fun! 203 # in the original prorcess. have fun!
31 } 204 }
32 205
33 ##################################################################
34 # create a pool of server processes all accepting on the same socket 206=head2 Create a pool of server processes all accepting on the same socket.
35 207
36 # create listener socket 208 # create listener socket
37 my $listener = ...; 209 my $listener = ...;
38 210
39 # create a pool template, initialise it and give it the socket 211 # create a pool template, initialise it and give it the socket
51 } 223 }
52 224
53 # now do other things - maybe use the filehandle provided by run 225 # now do other things - maybe use the filehandle provided by run
54 # to wait for the processes to die. or whatever. 226 # to wait for the processes to die. or whatever.
55 227
56 # My::Server::run might look like this 228C<My::Server> might look like this:
57 sub My::Server::run { 229
230 package My::Server;
231
232 sub run {
58 my ($slave, $listener, $id) = @_; 233 my ($slave, $listener, $id) = @_;
59 234
60 close $slave; # we do not use the socket, so close it to save resources 235 close $slave; # we do not use the socket, so close it to save resources
61 236
62 # we could go ballistic and use e.g. AnyEvent here, or IO::AIO, 237 # we could go ballistic and use e.g. AnyEvent here, or IO::AIO,
64 while (my $socket = $listener->accept) { 239 while (my $socket = $listener->accept) {
65 # do sth. with new socket 240 # do sth. with new socket
66 } 241 }
67 } 242 }
68 243
69=head1 DESCRIPTION 244=head2 use AnyEvent::Fork as a faster fork+exec
70 245
71This module allows you to create new processes, without actually forking 246This runs C</bin/echo hi>, with standard output redirected to F</tmp/log>
72them from your current process (avoiding the problems of forking), but 247and standard error redirected to the communications socket. It is usually
73preserving most of the advantages of fork. 248faster than fork+exec, but still lets you prepare the environment.
74 249
75It can be used to create new worker processes or new independent 250 open my $output, ">/tmp/log" or die "$!";
76subprocesses for short- and long-running jobs, process pools (e.g. for use
77in pre-forked servers) but also to spawn new external processes (such as
78CGI scripts from a webserver), which can be faster (and more well behaved)
79than using fork+exec in big processes.
80 251
81Special care has been taken to make this module useful from other modules, 252 AnyEvent::Fork
82while still supporting specialised environments such as L<App::Staticperl> 253 ->new
83or L<PAR::Packer>. 254 ->eval ('
255 # compile a helper function for later use
256 sub run {
257 my ($fh, $output, @cmd) = @_;
84 258
85=head1 PROBLEM STATEMENT 259 # perl will clear close-on-exec on STDOUT/STDERR
260 open STDOUT, ">&", $output or die;
261 open STDERR, ">&", $fh or die;
86 262
87There are two ways to implement parallel processing on UNIX like operating 263 exec @cmd;
88systems - fork and process, and fork+exec and process. They have different 264 }
89advantages and disadvantages that I describe below, together with how this 265 ')
90module tries to mitigate the disadvantages. 266 ->send_fh ($output)
267 ->send_arg ("/bin/echo", "hi")
268 ->run ("run", my $cv = AE::cv);
91 269
92=over 4 270 my $stderr = $cv->recv;
93 271
94=item Forking from a big process can be very slow (a 5GB process needs 272=head2 For stingy users: put the worker code into a C<DATA> section.
950.05s to fork on my 3.6GHz amd64 GNU/Linux box for example). This overhead
96is often shared with exec (because you have to fork first), but in some
97circumstances (e.g. when vfork is used), fork+exec can be much faster.
98 273
99This module can help here by telling a small(er) helper process to fork, 274When you want to be stingy with files, you can put your code into the
100or fork+exec instead. 275C<DATA> section of your module (or program):
101 276
102=item Forking usually creates a copy-on-write copy of the parent 277 use AnyEvent::Fork;
103process. Memory (for example, modules or data files that have been
104will not take additional memory). When exec'ing a new process, modules
105and data files might need to be loaded again, at extra cpu and memory
106cost. Likewise when forking, all data structures are copied as well - if
107the program frees them and replaces them by new data, the child processes
108will retain the memory even if it isn't used.
109 278
110This module allows the main program to do a controlled fork, and allows 279 AnyEvent::Fork
111modules to exec processes safely at any time. When creating a custom 280 ->new
112process pool you can take advantage of data sharing via fork without 281 ->eval (do { local $/; <DATA> })
113risking to share large dynamic data structures that will blow up child 282 ->run ("doit", sub { ... });
114memory usage.
115 283
116=item Exec'ing a new perl process might be difficult and slow. For 284 __DATA__
117example, it is not easy to find the correct path to the perl interpreter,
118and all modules have to be loaded from disk again. Long running processes
119might run into problems when perl is upgraded for example.
120 285
121This module supports creating pre-initialised perl processes to be used 286 sub doit {
122as template, and also tries hard to identify the correct path to the perl 287 ... do something!
123interpreter. With a cooperative main program, exec'ing the interpreter 288 }
124might not even be necessary.
125 289
126=item Forking might be impossible when a program is running. For example, 290=head2 For stingy standalone programs: do not rely on external files at
127POSIX makes it almost impossible to fork from a multithreaded program and 291all.
128do anything useful in the child - strictly speaking, if your perl program
129uses posix threads (even indirectly via e.g. L<IO::AIO> or L<threads>),
130you cannot call fork on the perl level anymore, at all.
131 292
132This module can safely fork helper processes at any time, by caling 293For single-file scripts it can be inconvenient to rely on external
133fork+exec in C, in a POSIX-compatible way. 294files - even when using a C<DATA> section, you still need to C<exec> an
295external perl interpreter, which might not be available when using
296L<App::Staticperl>, L<Urlader> or L<PAR::Packer> for example.
134 297
135=item Parallel processing with fork might be inconvenient or difficult 298Two modules help here - L<AnyEvent::Fork::Early> forks a template process
136to implement. For example, when a program uses an event loop and creates 299for all further calls to C<new_exec>, and L<AnyEvent::Fork::Template>
137watchers it becomes very hard to use the event loop from a child 300forks the main program as a template process.
138program, as the watchers already exist but are only meaningful in the
139parent. Worse, a module might want to use such a system, not knowing
140whether another module or the main program also does, leading to problems.
141 301
142This module only lets the main program create pools by forking (because 302Here is how your main program should look like:
143only the main program can know when it is still safe to do so) - all other
144pools are created by fork+exec, after which such modules can again be
145loaded.
146 303
147=back 304 #! perl
305
306 # optional, as the very first thing.
307 # in case modules want to create their own processes.
308 use AnyEvent::Fork::Early;
309
310 # next, load all modules you need in your template process
311 use Example::My::Module
312 use Example::Whatever;
313
314 # next, put your run function definition and anything else you
315 # need, but do not use code outside of BEGIN blocks.
316 sub worker_run {
317 my ($fh, @args) = @_;
318 ...
319 }
320
321 # now preserve everything so far as AnyEvent::Fork object
322 # in $TEMPLATE.
323 use AnyEvent::Fork::Template;
324
325 # do not put code outside of BEGIN blocks until here
326
327 # now use the $TEMPLATE process in any way you like
328
329 # for example: create 10 worker processes
330 my @worker;
331 my $cv = AE::cv;
332 for (1..10) {
333 $cv->begin;
334 $TEMPLATE->fork->send_arg ($_)->run ("worker_run", sub {
335 push @worker, shift;
336 $cv->end;
337 });
338 }
339 $cv->recv;
148 340
149=head1 CONCEPTS 341=head1 CONCEPTS
150 342
151This module can create new processes either by executing a new perl 343This module can create new processes either by executing a new perl
152process, or by forking from an existing "template" process. 344process, or by forking from an existing "template" process.
345
346All these processes are called "child processes" (whether they are direct
347children or not), while the process that manages them is called the
348"parent process".
153 349
154Each such process comes with its own file handle that can be used to 350Each such process comes with its own file handle that can be used to
155communicate with it (it's actually a socket - one end in the new process, 351communicate with it (it's actually a socket - one end in the new process,
156one end in the main process), and among the things you can do in it are 352one end in the main process), and among the things you can do in it are
157load modules, fork new processes, send file handles to it, and execute 353load modules, fork new processes, send file handles to it, and execute
169needed the first time. Forking from this process shares the memory used 365needed the first time. Forking from this process shares the memory used
170for the perl interpreter with the new process, but loading modules takes 366for the perl interpreter with the new process, but loading modules takes
171time, and the memory is not shared with anything else. 367time, and the memory is not shared with anything else.
172 368
173This is ideal for when you only need one extra process of a kind, with the 369This is ideal for when you only need one extra process of a kind, with the
174option of starting and stipping it on demand. 370option of starting and stopping it on demand.
175 371
176Example: 372Example:
177 373
178 AnyEvent::Fork 374 AnyEvent::Fork
179 ->new 375 ->new
194modules you loaded) is shared between the processes, and each new process 390modules you loaded) is shared between the processes, and each new process
195consumes relatively little memory of its own. 391consumes relatively little memory of its own.
196 392
197The disadvantage of this approach is that you need to create a template 393The disadvantage of this approach is that you need to create a template
198process for the sole purpose of forking new processes from it, but if you 394process for the sole purpose of forking new processes from it, but if you
199only need a fixed number of proceses you can create them, and then destroy 395only need a fixed number of processes you can create them, and then destroy
200the template process. 396the template process.
201 397
202Example: 398Example:
203 399
204 my $template = AnyEvent::Fork->new->require ("Some::Module"); 400 my $template = AnyEvent::Fork->new->require ("Some::Module");
231 my ($fork_fh) = @_; 427 my ($fork_fh) = @_;
232 }); 428 });
233 429
234=back 430=back
235 431
236=head1 FUNCTIONS 432=head1 THE C<AnyEvent::Fork> CLASS
433
434This module exports nothing, and only implements a single class -
435C<AnyEvent::Fork>.
436
437There are two class constructors that both create new processes - C<new>
438and C<new_exec>. The C<fork> method creates a new process by forking an
439existing one and could be considered a third constructor.
440
441Most of the remaining methods deal with preparing the new process, by
442loading code, evaluating code and sending data to the new process. They
443usually return the process object, so you can chain method calls.
444
445If a process object is destroyed before calling its C<run> method, then
446the process simply exits. After C<run> is called, all responsibility is
447passed to the specified function.
448
449As long as there is any outstanding work to be done, process objects
450resist being destroyed, so there is no reason to store them unless you
451need them later - configure and forget works just fine.
237 452
238=over 4 453=over 4
239 454
240=cut 455=cut
241 456
242package AnyEvent::Fork; 457package AnyEvent::Fork;
243 458
244use common::sense; 459use common::sense;
245 460
246use Socket (); 461use Errno ();
247 462
248use AnyEvent; 463use AnyEvent;
249use AnyEvent::Fork::Util;
250use AnyEvent::Util (); 464use AnyEvent::Util ();
251 465
252our $VERSION = $AnyEvent::Fork::Util::VERSION; 466use IO::FDPass;
253 467
254our $PERL; # the path to the perl interpreter, deduces with various forms of magic 468our $VERSION = 1.2;
255
256=item my $pool = new AnyEvent::Fork key => value...
257
258Create a new process pool. The following named parameters are supported:
259
260=over 4
261
262=back
263
264=cut
265 469
266# the early fork template process 470# the early fork template process
267our $EARLY; 471our $EARLY;
268 472
269# the empty template process 473# the empty template process
270our $TEMPLATE; 474our $TEMPLATE;
271 475
476sub QUEUE() { 0 }
477sub FH() { 1 }
478sub WW() { 2 }
479sub PID() { 3 }
480sub CB() { 4 }
481
482sub _new {
483 my ($self, $fh, $pid) = @_;
484
485 AnyEvent::Util::fh_nonblocking $fh, 1;
486
487 $self = bless [
488 [], # write queue - strings or fd's
489 $fh,
490 undef, # AE watcher
491 $pid,
492 ], $self;
493
494 $self
495}
496
272sub _cmd { 497sub _cmd {
273 my $self = shift; 498 my $self = shift;
274 499
275 #TODO: maybe append the packet to any existing string command already in the queue
276
277 # ideally, we would want to use "a (w/a)*" as format string, but perl versions 500 # ideally, we would want to use "a (w/a)*" as format string, but perl
278 # from at least 5.8.9 to 5.16.3 are all buggy and can't unpack it. 501 # versions from at least 5.8.9 to 5.16.3 are all buggy and can't unpack
279 push @{ $self->[2] }, pack "N/a*", pack "(w/a*)*", @_; 502 # it.
503 push @{ $self->[QUEUE] }, pack "a L/a*", $_[0], $_[1];
280 504
281 $self->[3] ||= AE::io $self->[1], 1, sub { 505 $self->[WW] ||= AE::io $self->[FH], 1, sub {
506 do {
282 # send the next "thing" in the queue - either a reference to an fh, 507 # send the next "thing" in the queue - either a reference to an fh,
283 # or a plain string. 508 # or a plain string.
284 509
285 if (ref $self->[2][0]) { 510 if (ref $self->[QUEUE][0]) {
286 # send fh 511 # send fh
287 AnyEvent::Fork::Util::fd_send fileno $self->[1], fileno ${ $self->[2][0] } 512 unless (IO::FDPass::send fileno $self->[FH], fileno ${ $self->[QUEUE][0] }) {
513 return if $! == Errno::EAGAIN || $! == Errno::EWOULDBLOCK;
514 undef $self->[WW];
515 die "AnyEvent::Fork: file descriptor send failure: $!";
516 }
517
288 and shift @{ $self->[2] }; 518 shift @{ $self->[QUEUE] };
289 519
290 } else { 520 } else {
291 # send string 521 # send string
292 my $len = syswrite $self->[1], $self->[2][0] 522 my $len = syswrite $self->[FH], $self->[QUEUE][0];
523
524 unless ($len) {
525 return if $! == Errno::EAGAIN || $! == Errno::EWOULDBLOCK;
526 undef $self->[WW];
293 or do { undef $self->[3]; die "AnyEvent::Fork: command write failure: $!" }; 527 die "AnyEvent::Fork: command write failure: $!";
528 }
294 529
295 substr $self->[2][0], 0, $len, ""; 530 substr $self->[QUEUE][0], 0, $len, "";
296 shift @{ $self->[2] } unless length $self->[2][0]; 531 shift @{ $self->[QUEUE] } unless length $self->[QUEUE][0];
297 } 532 }
533 } while @{ $self->[QUEUE] };
298 534
299 unless (@{ $self->[2] }) { 535 # everything written
300 undef $self->[3]; 536 undef $self->[WW];
537
301 # invoke run callback 538 # invoke run callback, if any
539 if ($self->[CB]) {
302 $self->[0]->($self->[1]) if $self->[0]; 540 $self->[CB]->($self->[FH]);
541 @$self = ();
303 } 542 }
304 }; 543 };
305 544
306 () # make sure we don't leak the watcher 545 () # make sure we don't leak the watcher
307}
308
309sub _new {
310 my ($self, $fh) = @_;
311
312 AnyEvent::Util::fh_nonblocking $fh, 1;
313
314 $self = bless [
315 undef, # run callback
316 $fh,
317 [], # write queue - strings or fd's
318 undef, # AE watcher
319 ], $self;
320
321 $self
322} 546}
323 547
324# fork template from current process, used by AnyEvent::Fork::Early/Template 548# fork template from current process, used by AnyEvent::Fork::Early/Template
325sub _new_fork { 549sub _new_fork {
326 my ($fh, $slave) = AnyEvent::Util::portable_socketpair; 550 my ($fh, $slave) = AnyEvent::Util::portable_socketpair;
332 require AnyEvent::Fork::Serve; 556 require AnyEvent::Fork::Serve;
333 $AnyEvent::Fork::Serve::OWNER = $parent; 557 $AnyEvent::Fork::Serve::OWNER = $parent;
334 close $fh; 558 close $fh;
335 $0 = "$_[1] of $parent"; 559 $0 = "$_[1] of $parent";
336 AnyEvent::Fork::Serve::serve ($slave); 560 AnyEvent::Fork::Serve::serve ($slave);
337 AnyEvent::Fork::Util::_exit 0; 561 exit 0;
338 } elsif (!$pid) { 562 } elsif (!$pid) {
339 die "AnyEvent::Fork::Early/Template: unable to fork template process: $!"; 563 die "AnyEvent::Fork::Early/Template: unable to fork template process: $!";
340 } 564 }
341 565
342 AnyEvent::Fork->_new ($fh) 566 AnyEvent::Fork->_new ($fh, $pid)
343} 567}
344 568
345=item my $proc = new AnyEvent::Fork 569=item my $proc = new AnyEvent::Fork
346 570
347Create a new "empty" perl interpreter process and returns its process 571Create a new "empty" perl interpreter process and returns its process
348object for further manipulation. 572object for further manipulation.
349 573
350The new process is forked from a template process that is kept around 574The new process is forked from a template process that is kept around
351for this purpose. When it doesn't exist yet, it is created by a call to 575for this purpose. When it doesn't exist yet, it is created by a call to
352C<new_exec> and kept around for future calls. 576C<new_exec> first and then stays around for future calls.
353
354When the process object is destroyed, it will release the file handle
355that connects it with the new process. When the new process has not yet
356called C<run>, then the process will exit. Otherwise, what happens depends
357entirely on the code that is executed.
358 577
359=cut 578=cut
360 579
361sub new { 580sub new {
362 my $class = shift; 581 my $class = shift;
398reduces the amount of memory sharing that is possible, and is also slower. 617reduces the amount of memory sharing that is possible, and is also slower.
399 618
400You should use C<new> whenever possible, except when having a template 619You should use C<new> whenever possible, except when having a template
401process around is unacceptable. 620process around is unacceptable.
402 621
403The path to the perl interpreter is divined usign various methods - first 622The path to the perl interpreter is divined using various methods - first
404C<$^X> is investigated to see if the path ends with something that sounds 623C<$^X> is investigated to see if the path ends with something that looks
405as if it were the perl interpreter. Failing this, the module falls back to 624as if it were the perl interpreter. Failing this, the module falls back to
406using C<$Config::Config{perlpath}>. 625using C<$Config::Config{perlpath}>.
407 626
627The path to perl can also be overriden by setting the global variable
628C<$AnyEvent::Fork::PERL> - it's value will be used for all subsequent
629invocations.
630
408=cut 631=cut
632
633our $PERL;
409 634
410sub new_exec { 635sub new_exec {
411 my ($self) = @_; 636 my ($self) = @_;
412 637
413 return $EARLY->fork 638 return $EARLY->fork
414 if $EARLY; 639 if $EARLY;
415 640
641 unless (defined $PERL) {
416 # first find path of perl 642 # first find path of perl
417 my $perl = $; 643 my $perl = $^X;
418 644
419 # first we try $^X, but the path must be absolute (always on win32), and end in sth. 645 # first we try $^X, but the path must be absolute (always on win32), and end in sth.
420 # that looks like perl. this obviously only works for posix and win32 646 # that looks like perl. this obviously only works for posix and win32
421 unless ( 647 unless (
422 (AnyEvent::Fork::Util::WIN32 || $perl =~ m%^/%) 648 ($^O eq "MSWin32" || $perl =~ m%^/%)
423 && $perl =~ m%[/\\]perl(?:[0-9]+(\.[0-9]+)+)?(\.exe)?$%i 649 && $perl =~ m%[/\\]perl(?:[0-9]+(\.[0-9]+)+)?(\.exe)?$%i
424 ) { 650 ) {
425 # if it doesn't look perlish enough, try Config 651 # if it doesn't look perlish enough, try Config
426 require Config; 652 require Config;
427 $perl = $Config::Config{perlpath}; 653 $perl = $Config::Config{perlpath};
428 $perl =~ s/(?:\Q$Config::Config{_exe}\E)?$/$Config::Config{_exe}/; 654 $perl =~ s/(?:\Q$Config::Config{_exe}\E)?$/$Config::Config{_exe}/;
655 }
656
657 $PERL = $perl;
429 } 658 }
430 659
431 require Proc::FastSpawn; 660 require Proc::FastSpawn;
432 661
433 my ($fh, $slave) = AnyEvent::Util::portable_socketpair; 662 my ($fh, $slave) = AnyEvent::Util::portable_socketpair;
438 Proc::FastSpawn::fd_inherit (fileno $fh, 0); 667 Proc::FastSpawn::fd_inherit (fileno $fh, 0);
439 668
440 # quick. also doesn't work in win32. of course. what did you expect 669 # quick. also doesn't work in win32. of course. what did you expect
441 #local $ENV{PERL5LIB} = join ":", grep !ref, @INC; 670 #local $ENV{PERL5LIB} = join ":", grep !ref, @INC;
442 my %env = %ENV; 671 my %env = %ENV;
443 $env{PERL5LIB} = join +(AnyEvent::Fork::Util::WIN32 ? ";" : ":"), grep !ref, @INC; 672 $env{PERL5LIB} = join +($^O eq "MSWin32" ? ";" : ":"), grep !ref, @INC;
444 673
445 Proc::FastSpawn::spawn ( 674 my $pid = Proc::FastSpawn::spawn (
446 $perl, 675 $PERL,
447 ["perl", "-MAnyEvent::Fork::Serve", "-e", "AnyEvent::Fork::Serve::me", fileno $slave, $$], 676 ["perl", "-MAnyEvent::Fork::Serve", "-e", "AnyEvent::Fork::Serve::me", fileno $slave, $$],
448 [map "$_=$env{$_}", keys %env], 677 [map "$_=$env{$_}", keys %env],
449 ) or die "unable to spawn AnyEvent::Fork server: $!"; 678 ) or die "unable to spawn AnyEvent::Fork server: $!";
450 679
451 $self->_new ($fh) 680 $self->_new ($fh, $pid)
681}
682
683=item $pid = $proc->pid
684
685Returns the process id of the process I<iff it is a direct child of the
686process running AnyEvent::Fork>, and C<undef> otherwise. As a general
687rule (that you cannot rely upon), processes created via C<new_exec>,
688L<AnyEvent::Fork::Early> or L<AnyEvent::Fork::Template> are direct
689children, while all other processes are not.
690
691Or in other words, you do not normally have to take care of zombies for
692processes created via C<new>, but when in doubt, or zombies are a problem,
693you need to check whether a process is a diretc child by calling this
694method, and possibly creating a child watcher or reap it manually.
695
696=cut
697
698sub pid {
699 $_[0][PID]
452} 700}
453 701
454=item $proc = $proc->eval ($perlcode, @args) 702=item $proc = $proc->eval ($perlcode, @args)
455 703
456Evaluates the given C<$perlcode> as ... perl code, while setting C<@_> to 704Evaluates the given C<$perlcode> as ... Perl code, while setting C<@_> to
457the strings specified by C<@args>. 705the strings specified by C<@args>, in the "main" package.
458 706
459This call is meant to do any custom initialisation that might be required 707This call is meant to do any custom initialisation that might be required
460(for example, the C<require> method uses it). It's not supposed to be used 708(for example, the C<require> method uses it). It's not supposed to be used
461to completely take over the process, use C<run> for that. 709to completely take over the process, use C<run> for that.
462 710
463The code will usually be executed after this call returns, and there is no 711The code will usually be executed after this call returns, and there is no
464way to pass anything back to the calling process. Any evaluation errors 712way to pass anything back to the calling process. Any evaluation errors
465will be reported to stderr and cause the process to exit. 713will be reported to stderr and cause the process to exit.
466 714
715If you want to execute some code (that isn't in a module) to take over the
716process, you should compile a function via C<eval> first, and then call
717it via C<run>. This also gives you access to any arguments passed via the
718C<send_xxx> methods, such as file handles. See the L<use AnyEvent::Fork as
719a faster fork+exec> example to see it in action.
720
467Returns the process object for easy chaining of method calls. 721Returns the process object for easy chaining of method calls.
468 722
469=cut 723=cut
470 724
471sub eval { 725sub eval {
472 my ($self, $code, @args) = @_; 726 my ($self, $code, @args) = @_;
473 727
474 $self->_cmd (e => $code, @args); 728 $self->_cmd (e => pack "(w/a*)*", $code, @args);
475 729
476 $self 730 $self
477} 731}
478 732
479=item $proc = $proc->require ($module, ...) 733=item $proc = $proc->require ($module, ...)
496=item $proc = $proc->send_fh ($handle, ...) 750=item $proc = $proc->send_fh ($handle, ...)
497 751
498Send one or more file handles (I<not> file descriptors) to the process, 752Send one or more file handles (I<not> file descriptors) to the process,
499to prepare a call to C<run>. 753to prepare a call to C<run>.
500 754
501The process object keeps a reference to the handles until this is done, 755The process object keeps a reference to the handles until they have
502so you must not explicitly close the handles. This is most easily 756been passed over to the process, so you must not explicitly close the
503accomplished by simply not storing the file handles anywhere after passing 757handles. This is most easily accomplished by simply not storing the file
504them to this method. 758handles anywhere after passing them to this method - when AnyEvent::Fork
759is finished using them, perl will automatically close them.
505 760
506Returns the process object for easy chaining of method calls. 761Returns the process object for easy chaining of method calls.
507 762
508Example: pass an fh to a process, and release it without closing. it will 763Example: pass a file handle to a process, and release it without
509be closed automatically when it is no longer used. 764closing. It will be closed automatically when it is no longer used.
510 765
511 $proc->send_fh ($my_fh); 766 $proc->send_fh ($my_fh);
512 undef $my_fh; # free the reference if you want, but DO NOT CLOSE IT 767 undef $my_fh; # free the reference if you want, but DO NOT CLOSE IT
513 768
514=cut 769=cut
516sub send_fh { 771sub send_fh {
517 my ($self, @fh) = @_; 772 my ($self, @fh) = @_;
518 773
519 for my $fh (@fh) { 774 for my $fh (@fh) {
520 $self->_cmd ("h"); 775 $self->_cmd ("h");
521 push @{ $self->[2] }, \$fh; 776 push @{ $self->[QUEUE] }, \$fh;
522 } 777 }
523 778
524 $self 779 $self
525} 780}
526 781
527=item $proc = $proc->send_arg ($string, ...) 782=item $proc = $proc->send_arg ($string, ...)
528 783
529Send one or more argument strings to the process, to prepare a call to 784Send one or more argument strings to the process, to prepare a call to
530C<run>. The strings can be any octet string. 785C<run>. The strings can be any octet strings.
531 786
787The protocol is optimised to pass a moderate number of relatively short
788strings - while you can pass up to 4GB of data in one go, this is more
789meant to pass some ID information or other startup info, not big chunks of
790data.
791
532Returns the process object for easy chaining of emthod calls. 792Returns the process object for easy chaining of method calls.
533 793
534=cut 794=cut
535 795
536sub send_arg { 796sub send_arg {
537 my ($self, @arg) = @_; 797 my ($self, @arg) = @_;
538 798
539 $self->_cmd (a => @arg); 799 $self->_cmd (a => pack "(w/a*)*", @arg);
540 800
541 $self 801 $self
542} 802}
543 803
544=item $proc->run ($func, $cb->($fh)) 804=item $proc->run ($func, $cb->($fh))
545 805
546Enter the function specified by the fully qualified name in C<$func> in 806Enter the function specified by the function name in C<$func> in the
547the process. The function is called with the communication socket as first 807process. The function is called with the communication socket as first
548argument, followed by all file handles and string arguments sent earlier 808argument, followed by all file handles and string arguments sent earlier
549via C<send_fh> and C<send_arg> methods, in the order they were called. 809via C<send_fh> and C<send_arg> methods, in the order they were called.
550 810
551If the called function returns, the process exits.
552
553Preparing the process can take time - when the process is ready, the
554callback is invoked with the local communications socket as argument.
555
556The process object becomes unusable on return from this function. 811The process object becomes unusable on return from this function - any
812further method calls result in undefined behaviour.
813
814The function name should be fully qualified, but if it isn't, it will be
815looked up in the C<main> package.
816
817If the called function returns, doesn't exist, or any error occurs, the
818process exits.
819
820Preparing the process is done in the background - when all commands have
821been sent, the callback is invoked with the local communications socket
822as argument. At this point you can start using the socket in any way you
823like.
557 824
558If the communication socket isn't used, it should be closed on both sides, 825If the communication socket isn't used, it should be closed on both sides,
559to save on kernel memory. 826to save on kernel memory.
560 827
561The socket is non-blocking in the parent, and blocking in the newly 828The socket is non-blocking in the parent, and blocking in the newly
562created process. The close-on-exec flag is set on both. Even if not used 829created process. The close-on-exec flag is set in both.
830
563otherwise, the socket can be a good indicator for the existance of the 831Even if not used otherwise, the socket can be a good indicator for the
564process - if the other process exits, you get a readable event on it, 832existence of the process - if the other process exits, you get a readable
565because exiting the process closes the socket (if it didn't create any 833event on it, because exiting the process closes the socket (if it didn't
566children using fork). 834create any children using fork).
835
836=over 4
837
838=item Compatibility to L<AnyEvent::Fork::Remote>
839
840If you want to write code that works with both this module and
841L<AnyEvent::Fork::Remote>, you need to write your code so that it assumes
842there are two file handles for communications, which might not be unix
843domain sockets. The C<run> function should start like this:
844
845 sub run {
846 my ($rfh, @args) = @_; # @args is your normal arguments
847 my $wfh = fileno $rfh ? $rfh : *STDOUT;
848
849 # now use $rfh for reading and $wfh for writing
850 }
851
852This checks whether the passed file handle is, in fact, the process
853C<STDIN> handle. If it is, then the function was invoked visa
854L<AnyEvent::Fork::Remote>, so STDIN should be used for reading and
855C<STDOUT> should be used for writing.
856
857In all other cases, the function was called via this module, and there is
858only one file handle that should be sued for reading and writing.
859
860=back
567 861
568Example: create a template for a process pool, pass a few strings, some 862Example: create a template for a process pool, pass a few strings, some
569file handles, then fork, pass one more string, and run some code. 863file handles, then fork, pass one more string, and run some code.
570 864
571 my $pool = AnyEvent::Fork 865 my $pool = AnyEvent::Fork
579 ->send_arg ("str3") 873 ->send_arg ("str3")
580 ->run ("Some::function", sub { 874 ->run ("Some::function", sub {
581 my ($fh) = @_; 875 my ($fh) = @_;
582 876
583 # fh is nonblocking, but we trust that the OS can accept these 877 # fh is nonblocking, but we trust that the OS can accept these
584 # extra 3 octets anyway. 878 # few octets anyway.
585 syswrite $fh, "hi #$_\n"; 879 syswrite $fh, "hi #$_\n";
586 880
587 # $fh is being closed here, as we don't store it anywhere 881 # $fh is being closed here, as we don't store it anywhere
588 }); 882 });
589 } 883 }
591 # Some::function might look like this - all parameters passed before fork 885 # Some::function might look like this - all parameters passed before fork
592 # and after will be passed, in order, after the communications socket. 886 # and after will be passed, in order, after the communications socket.
593 sub Some::function { 887 sub Some::function {
594 my ($fh, $str1, $str2, $fh1, $fh2, $str3) = @_; 888 my ($fh, $str1, $str2, $fh1, $fh2, $str3) = @_;
595 889
596 print scalar <$fh>; # prints "hi 1\n" and "hi 2\n" 890 print scalar <$fh>; # prints "hi #1\n" and "hi #2\n" in any order
597 } 891 }
598 892
599=cut 893=cut
600 894
601sub run { 895sub run {
602 my ($self, $func, $cb) = @_; 896 my ($self, $func, $cb) = @_;
603 897
604 $self->[0] = $cb; 898 $self->[CB] = $cb;
605 $self->_cmd (r => $func); 899 $self->_cmd (r => $func);
606} 900}
901
902=back
903
904=head2 EXPERIMENTAL METHODS
905
906These methods might go away completely or change behaviour, at any time.
907
908=over 4
909
910=item $proc->to_fh ($cb->($fh)) # EXPERIMENTAL, MIGHT BE REMOVED
911
912Flushes all commands out to the process and then calls the callback with
913the communications socket.
914
915The process object becomes unusable on return from this function - any
916further method calls result in undefined behaviour.
917
918The point of this method is to give you a file handle that you can pass
919to another process. In that other process, you can call C<new_from_fh
920AnyEvent::Fork $fh> to create a new C<AnyEvent::Fork> object from it,
921thereby effectively passing a fork object to another process.
922
923=cut
924
925sub to_fh {
926 my ($self, $cb) = @_;
927
928 $self->[CB] = $cb;
929
930 unless ($self->[WW]) {
931 $self->[CB]->($self->[FH]);
932 @$self = ();
933 }
934}
935
936=item new_from_fh AnyEvent::Fork $fh # EXPERIMENTAL, MIGHT BE REMOVED
937
938Takes a file handle originally rceeived by the C<to_fh> method and creates
939a new C<AnyEvent:Fork> object. The child process itself will not change in
940any way, i.e. it will keep all the modifications done to it before calling
941C<to_fh>.
942
943The new object is very much like the original object, except that the
944C<pid> method will return C<undef> even if the process is a direct child.
945
946=cut
947
948sub new_from_fh {
949 my ($class, $fh) = @_;
950
951 $class->_new ($fh)
952}
953
954=back
955
956=head1 PERFORMANCE
957
958Now for some unscientific benchmark numbers (all done on an amd64
959GNU/Linux box). These are intended to give you an idea of the relative
960performance you can expect, they are not meant to be absolute performance
961numbers.
962
963OK, so, I ran a simple benchmark that creates a socket pair, forks, calls
964exit in the child and waits for the socket to close in the parent. I did
965load AnyEvent, EV and AnyEvent::Fork, for a total process size of 5100kB.
966
967 2079 new processes per second, using manual socketpair + fork
968
969Then I did the same thing, but instead of calling fork, I called
970AnyEvent::Fork->new->run ("CORE::exit") and then again waited for the
971socket from the child to close on exit. This does the same thing as manual
972socket pair + fork, except that what is forked is the template process
973(2440kB), and the socket needs to be passed to the server at the other end
974of the socket first.
975
976 2307 new processes per second, using AnyEvent::Fork->new
977
978And finally, using C<new_exec> instead C<new>, using vforks+execs to exec
979a new perl interpreter and compile the small server each time, I get:
980
981 479 vfork+execs per second, using AnyEvent::Fork->new_exec
982
983So how can C<< AnyEvent->new >> be faster than a standard fork, even
984though it uses the same operations, but adds a lot of overhead?
985
986The difference is simply the process size: forking the 5MB process takes
987so much longer than forking the 2.5MB template process that the extra
988overhead is canceled out.
989
990If the benchmark process grows, the normal fork becomes even slower:
991
992 1340 new processes, manual fork of a 20MB process
993 731 new processes, manual fork of a 200MB process
994 235 new processes, manual fork of a 2000MB process
995
996What that means (to me) is that I can use this module without having a bad
997conscience because of the extra overhead required to start new processes.
998
999=head1 TYPICAL PROBLEMS
1000
1001This section lists typical problems that remain. I hope by recognising
1002them, most can be avoided.
1003
1004=over 4
1005
1006=item leaked file descriptors for exec'ed processes
1007
1008POSIX systems inherit file descriptors by default when exec'ing a new
1009process. While perl itself laudably sets the close-on-exec flags on new
1010file handles, most C libraries don't care, and even if all cared, it's
1011often not possible to set the flag in a race-free manner.
1012
1013That means some file descriptors can leak through. And since it isn't
1014possible to know which file descriptors are "good" and "necessary" (or
1015even to know which file descriptors are open), there is no good way to
1016close the ones that might harm.
1017
1018As an example of what "harm" can be done consider a web server that
1019accepts connections and afterwards some module uses AnyEvent::Fork for the
1020first time, causing it to fork and exec a new process, which might inherit
1021the network socket. When the server closes the socket, it is still open
1022in the child (which doesn't even know that) and the client might conclude
1023that the connection is still fine.
1024
1025For the main program, there are multiple remedies available -
1026L<AnyEvent::Fork::Early> is one, creating a process early and not using
1027C<new_exec> is another, as in both cases, the first process can be exec'ed
1028well before many random file descriptors are open.
1029
1030In general, the solution for these kind of problems is to fix the
1031libraries or the code that leaks those file descriptors.
1032
1033Fortunately, most of these leaked descriptors do no harm, other than
1034sitting on some resources.
1035
1036=item leaked file descriptors for fork'ed processes
1037
1038Normally, L<AnyEvent::Fork> does start new processes by exec'ing them,
1039which closes file descriptors not marked for being inherited.
1040
1041However, L<AnyEvent::Fork::Early> and L<AnyEvent::Fork::Template> offer
1042a way to create these processes by forking, and this leaks more file
1043descriptors than exec'ing them, as there is no way to mark descriptors as
1044"close on fork".
1045
1046An example would be modules like L<EV>, L<IO::AIO> or L<Gtk2>. Both create
1047pipes for internal uses, and L<Gtk2> might open a connection to the X
1048server. L<EV> and L<IO::AIO> can deal with fork, but Gtk2 might have
1049trouble with a fork.
1050
1051The solution is to either not load these modules before use'ing
1052L<AnyEvent::Fork::Early> or L<AnyEvent::Fork::Template>, or to delay
1053initialising them, for example, by calling C<init Gtk2> manually.
1054
1055=item exiting calls object destructors
1056
1057This only applies to users of L<AnyEvent::Fork:Early> and
1058L<AnyEvent::Fork::Template>, or when initialising code creates objects
1059that reference external resources.
1060
1061When a process created by AnyEvent::Fork exits, it might do so by calling
1062exit, or simply letting perl reach the end of the program. At which point
1063Perl runs all destructors.
1064
1065Not all destructors are fork-safe - for example, an object that represents
1066the connection to an X display might tell the X server to free resources,
1067which is inconvenient when the "real" object in the parent still needs to
1068use them.
1069
1070This is obviously not a problem for L<AnyEvent::Fork::Early>, as you used
1071it as the very first thing, right?
1072
1073It is a problem for L<AnyEvent::Fork::Template> though - and the solution
1074is to not create objects with nontrivial destructors that might have an
1075effect outside of Perl.
607 1076
608=back 1077=back
609 1078
610=head1 PORTABILITY NOTES 1079=head1 PORTABILITY NOTES
611 1080
612Native win32 perls are somewhat supported (AnyEvent::Fork::Early is a nop, 1081Native win32 perls are somewhat supported (AnyEvent::Fork::Early is a nop,
613and ::Template is not going to work), and it cost a lot of blood and sweat 1082and ::Template is not going to work), and it cost a lot of blood and sweat
614to make it so, mostly due to the bloody broken perl that nobody seems to 1083to make it so, mostly due to the bloody broken perl that nobody seems to
615care about. The fork emulation is a bad joke - I have yet to see something 1084care about. The fork emulation is a bad joke - I have yet to see something
616useful that you cna do with it without running into memory corruption 1085useful that you can do with it without running into memory corruption
617issues or other braindamage. Hrrrr. 1086issues or other braindamage. Hrrrr.
618 1087
619Cygwin perl is not supported at the moment, as it should implement fd 1088Since fork is endlessly broken on win32 perls (it doesn't even remotely
620passing, but doesn't, and rolling my own is hard, as cygwin doesn't 1089work within it's documented limits) and quite obviously it's not getting
621support enough functionality to do it. 1090improved any time soon, the best way to proceed on windows would be to
1091always use C<new_exec> and thus never rely on perl's fork "emulation".
1092
1093Cygwin perl is not supported at the moment due to some hilarious
1094shortcomings of its API - see L<IO::FDPoll> for more details. If you never
1095use C<send_fh> and always use C<new_exec> to create processes, it should
1096work though.
1097
1098=head1 USING AnyEvent::Fork IN SUBPROCESSES
1099
1100AnyEvent::Fork itself cannot generally be used in subprocesses. As long as
1101only one process ever forks new processes, sharing the template processes
1102is possible (you could use a pipe as a lock by writing a byte into it to
1103unlock, and reading the byte to lock for example)
1104
1105To make concurrent calls possible after fork, you should get rid of the
1106template and early fork processes. AnyEvent::Fork will create a new
1107template process as needed.
1108
1109 undef $AnyEvent::Fork::EARLY;
1110 undef $AnyEvent::Fork::TEMPLATE;
1111
1112It doesn't matter whether you get rid of them in the parent or child after
1113a fork.
622 1114
623=head1 SEE ALSO 1115=head1 SEE ALSO
624 1116
625L<AnyEvent::Fork::Early> (to avoid executing a perl interpreter), 1117L<AnyEvent::Fork::Early>, to avoid executing a perl interpreter at all
1118(part of this distribution).
1119
626L<AnyEvent::Fork::Template> (to create a process by forking the main 1120L<AnyEvent::Fork::Template>, to create a process by forking the main
627program at a convenient time). 1121program at a convenient time (part of this distribution).
628 1122
629=head1 AUTHOR 1123L<AnyEvent::Fork::Remote>, for another way to create processes that is
1124mostly compatible to this module and modules building on top of it, but
1125works better with remote processes.
1126
1127L<AnyEvent::Fork::RPC>, for simple RPC to child processes (on CPAN).
1128
1129L<AnyEvent::Fork::Pool>, for simple worker process pool (on CPAN).
1130
1131=head1 AUTHOR AND CONTACT INFORMATION
630 1132
631 Marc Lehmann <schmorp@schmorp.de> 1133 Marc Lehmann <schmorp@schmorp.de>
632 http://home.schmorp.de/ 1134 http://software.schmorp.de/pkg/AnyEvent-Fork
633 1135
634=cut 1136=cut
635 1137
6361 11381
637 1139

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines