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

Comparing IO-AIO/AIO.pm (file contents):
Revision 1.80 by root, Thu Oct 26 16:28:33 2006 UTC vs.
Revision 1.86 by root, Sat Oct 28 23:32:29 2006 UTC

… …
50 50
51=head1 DESCRIPTION 51=head1 DESCRIPTION
52 52
53This module implements asynchronous I/O using whatever means your 53This module implements asynchronous I/O using whatever means your
54operating system supports. 54operating system supports.
55
56Asynchronous means that operations that can normally block your program
57(e.g. reading from disk) will be done asynchronously: the operation
58will still block, but you can do something else in the meantime. This
59is extremely useful for programs that need to stay interactive even
60when doing heavy I/O (GUI programs, high performance network servers
61etc.), but can also be used to easily do operations in parallel that are
62normally done sequentially, e.g. stat'ing many files, which is much faster
63on a RAID volume or over NFS when you do a number of stat operations
64concurrently.
65
66While this works on all types of file descriptors (for example sockets),
67using these functions on file descriptors that support nonblocking
68operation (again, sockets, pipes etc.) is very inefficient. Use an event
69loop for that (such as the L<Event|Event> module): IO::AIO will naturally
70fit into such an event loop itself.
55 71
56In this version, a number of threads are started that execute your 72In this version, a number of threads are started that execute your
57requests and signal their completion. You don't need thread support 73requests and signal their completion. You don't need thread support
58in perl, and the threads created by this module will not be visible 74in perl, and the threads created by this module will not be visible
59to perl. In the future, this module might make use of the native aio 75to perl. In the future, this module might make use of the native aio
60functions available on many operating systems. However, they are often 76functions available on many operating systems. However, they are often
61not well-supported or restricted (Linux doesn't allow them on normal 77not well-supported or restricted (GNU/Linux doesn't allow them on normal
62files currently, for example), and they would only support aio_read and 78files currently, for example), and they would only support aio_read and
63aio_write, so the remaining functionality would have to be implemented 79aio_write, so the remaining functionality would have to be implemented
64using threads anyway. 80using threads anyway.
65 81
66Although the module will work with in the presence of other (Perl-) 82Although the module will work with in the presence of other (Perl-)
67threads, it is currently not reentrant in any way, so use appropriate 83threads, it is currently not reentrant in any way, so use appropriate
68locking yourself, always call C<poll_cb> from within the same thread, or 84locking yourself, always call C<poll_cb> from within the same thread, or
69never call C<poll_cb> (or other C<aio_> functions) recursively. 85never call C<poll_cb> (or other C<aio_> functions) recursively.
70 86
87=head2 EXAMPLE
88
89This is a simple example that uses the Event module and loads
90F</etc/passwd> asynchronously:
91
92 use Fcntl;
93 use Event;
94 use IO::AIO;
95
96 # register the IO::AIO callback with Event
97 Event->io (fd => IO::AIO::poll_fileno,
98 poll => 'r',
99 cb => \&IO::AIO::poll_cb);
100
101 # queue the request to open /etc/passwd
102 aio_open "/etc/passwd", O_RDONLY, 0, sub {
103 my $fh = $_[0]
104 or die "error while opening: $!";
105
106 # stat'ing filehandles is generally non-blocking
107 my $size = -s $fh;
108
109 # queue a request to read the file
110 my $contents;
111 aio_read $fh, 0, $size, $contents, 0, sub {
112 $_[0] == $size
113 or die "short read: $!";
114
115 close $fh;
116
117 # file contents now in $contents
118 print $contents;
119
120 # exit event loop and program
121 Event::unloop;
122 };
123 };
124
125 # possibly queue up other requests, or open GUI windows,
126 # check for sockets etc. etc.
127
128 # process events as long as there are some:
129 Event::loop;
130
71=head1 REQUEST ANATOMY AND LIFETIME 131=head1 REQUEST ANATOMY AND LIFETIME
72 132
73Every C<aio_*> function creates a request. which is a C data structure not 133Every C<aio_*> function creates a request. which is a C data structure not
74directly visible to Perl. 134directly visible to Perl.
75 135
… …
126use strict 'vars'; 186use strict 'vars';
127 187
128use base 'Exporter'; 188use base 'Exporter';
129 189
130BEGIN { 190BEGIN {
131 our $VERSION = '2.0'; 191 our $VERSION = '2.1';
132 192
133 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat 193 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat
134 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 194 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink
135 aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move 195 aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move
136 aio_group aio_nop); 196 aio_copy aio_group aio_nop aio_mknod);
137 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); 197 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice));
138 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 198 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
139 min_parallel max_parallel nreqs nready npending); 199 min_parallel max_parallel max_idle
200 nreqs nready npending nthreads
201 max_poll_time max_poll_reqs);
140 202
141 @IO::AIO::GRP::ISA = 'IO::AIO::REQ'; 203 @IO::AIO::GRP::ISA = 'IO::AIO::REQ';
142 204
143 require XSLoader; 205 require XSLoader;
144 XSLoader::load ("IO::AIO", $VERSION); 206 XSLoader::load ("IO::AIO", $VERSION);
… …
264 326
265 aio_read $fh, 7, 15, $buffer, 0, sub { 327 aio_read $fh, 7, 15, $buffer, 0, sub {
266 $_[0] > 0 or die "read error: $!"; 328 $_[0] > 0 or die "read error: $!";
267 print "read $_[0] bytes: <$buffer>\n"; 329 print "read $_[0] bytes: <$buffer>\n";
268 }; 330 };
269
270=item aio_move $srcpath, $dstpath, $callback->($status)
271
272Try to move the I<file> (directories not supported as either source or
273destination) from C<$srcpath> to C<$dstpath> and call the callback with
274the C<0> (error) or C<-1> ok.
275
276This is a composite request that tries to rename(2) the file first. If
277rename files with C<EXDEV>, it creates the destination file with mode 0200
278and copies the contents of the source file into it using C<aio_sendfile>,
279followed by restoring atime, mtime, access mode and uid/gid, in that
280order, and unlinking the C<$srcpath>.
281
282If an error occurs, the partial destination file will be unlinked, if
283possible, except when setting atime, mtime, access mode and uid/gid, where
284errors are being ignored.
285
286=cut
287
288sub aio_move($$$) {
289 my ($src, $dst, $cb) = @_;
290
291 my $pri = aioreq_pri;
292 my $grp = aio_group $cb;
293
294 aioreq_pri $pri;
295 add $grp aio_rename $src, $dst, sub {
296 if ($_[0] && $! == EXDEV) {
297 aioreq_pri $pri;
298 add $grp aio_open $src, O_RDONLY, 0, sub {
299 if (my $src_fh = $_[0]) {
300 my @stat = stat $src_fh;
301
302 aioreq_pri $pri;
303 add $grp aio_open $dst, O_WRONLY, 0200, sub {
304 if (my $dst_fh = $_[0]) {
305 aioreq_pri $pri;
306 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
307 close $src_fh;
308
309 if ($_[0] == $stat[7]) {
310 utime $stat[8], $stat[9], $dst;
311 chmod $stat[2] & 07777, $dst_fh;
312 chown $stat[4], $stat[5], $dst_fh;
313 close $dst_fh;
314
315 aioreq_pri $pri;
316 add $grp aio_unlink $src, sub {
317 $grp->result ($_[0]);
318 };
319 } else {
320 my $errno = $!;
321 aioreq_pri $pri;
322 add $grp aio_unlink $dst, sub {
323 $! = $errno;
324 $grp->result (-1);
325 };
326 }
327 };
328 } else {
329 $grp->result (-1);
330 }
331 },
332
333 } else {
334 $grp->result (-1);
335 }
336 };
337 } else {
338 $grp->result ($_[0]);
339 }
340 };
341
342 $grp
343}
344 331
345=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) 332=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
346 333
347Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts 334Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts
348reading at byte offset C<$in_offset>, and starts writing at the current 335reading at byte offset C<$in_offset>, and starts writing at the current
… …
404=item aio_unlink $pathname, $callback->($status) 391=item aio_unlink $pathname, $callback->($status)
405 392
406Asynchronously unlink (delete) a file and call the callback with the 393Asynchronously unlink (delete) a file and call the callback with the
407result code. 394result code.
408 395
396=item aio_mknod $path, $mode, $dev, $callback->($status)
397
398[EXPERIMENTAL]
399
400Asynchronously create a device node (or fifo). See mknod(2).
401
402The only (POSIX-) portable way of calling this function is:
403
404 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ...
405
409=item aio_link $srcpath, $dstpath, $callback->($status) 406=item aio_link $srcpath, $dstpath, $callback->($status)
410 407
411Asynchronously create a new link to the existing object at C<$srcpath> at 408Asynchronously create a new link to the existing object at C<$srcpath> at
412the path C<$dstpath> and call the callback with the result code. 409the path C<$dstpath> and call the callback with the result code.
413 410
… …
432directory (i.e. opendir + readdir + closedir). The entries will not be 429directory (i.e. opendir + readdir + closedir). The entries will not be
433sorted, and will B<NOT> include the C<.> and C<..> entries. 430sorted, and will B<NOT> include the C<.> and C<..> entries.
434 431
435The callback a single argument which is either C<undef> or an array-ref 432The callback a single argument which is either C<undef> or an array-ref
436with the filenames. 433with the filenames.
434
435=item aio_copy $srcpath, $dstpath, $callback->($status)
436
437Try to copy the I<file> (directories not supported as either source or
438destination) from C<$srcpath> to C<$dstpath> and call the callback with
439the C<0> (error) or C<-1> ok.
440
441This is a composite request that it creates the destination file with
442mode 0200 and copies the contents of the source file into it using
443C<aio_sendfile>, followed by restoring atime, mtime, access mode and
444uid/gid, in that order.
445
446If an error occurs, the partial destination file will be unlinked, if
447possible, except when setting atime, mtime, access mode and uid/gid, where
448errors are being ignored.
449
450=cut
451
452sub aio_copy($$;$) {
453 my ($src, $dst, $cb) = @_;
454
455 my $pri = aioreq_pri;
456 my $grp = aio_group $cb;
457
458 aioreq_pri $pri;
459 add $grp aio_open $src, O_RDONLY, 0, sub {
460 if (my $src_fh = $_[0]) {
461 my @stat = stat $src_fh;
462
463 aioreq_pri $pri;
464 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
465 if (my $dst_fh = $_[0]) {
466 aioreq_pri $pri;
467 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
468 if ($_[0] == $stat[7]) {
469 $grp->result (0);
470 close $src_fh;
471
472 # those should not normally block. should. should.
473 utime $stat[8], $stat[9], $dst;
474 chmod $stat[2] & 07777, $dst_fh;
475 chown $stat[4], $stat[5], $dst_fh;
476 close $dst_fh;
477 } else {
478 $grp->result (-1);
479 close $src_fh;
480 close $dst_fh;
481
482 aioreq $pri;
483 add $grp aio_unlink $dst;
484 }
485 };
486 } else {
487 $grp->result (-1);
488 }
489 },
490
491 } else {
492 $grp->result (-1);
493 }
494 };
495
496 $grp
497}
498
499=item aio_move $srcpath, $dstpath, $callback->($status)
500
501Try to move the I<file> (directories not supported as either source or
502destination) from C<$srcpath> to C<$dstpath> and call the callback with
503the C<0> (error) or C<-1> ok.
504
505This is a composite request that tries to rename(2) the file first. If
506rename files with C<EXDEV>, it copies the file with C<aio_copy> and, if
507that is successful, unlinking the C<$srcpath>.
508
509=cut
510
511sub aio_move($$;$) {
512 my ($src, $dst, $cb) = @_;
513
514 my $pri = aioreq_pri;
515 my $grp = aio_group $cb;
516
517 aioreq_pri $pri;
518 add $grp aio_rename $src, $dst, sub {
519 if ($_[0] && $! == EXDEV) {
520 aioreq_pri $pri;
521 add $grp aio_copy $src, $dst, sub {
522 $grp->result ($_[0]);
523
524 if (!$_[0]) {
525 aioreq_pri $pri;
526 add $grp aio_unlink $src;
527 }
528 };
529 } else {
530 $grp->result ($_[0]);
531 }
532 };
533
534 $grp
535}
437 536
438=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) 537=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
439 538
440Scans a directory (similar to C<aio_readdir>) but additionally tries to 539Scans a directory (similar to C<aio_readdir>) but additionally tries to
441efficiently separate the entries of directory C<$path> into two sets of 540efficiently separate the entries of directory C<$path> into two sets of
… …
443recurse into (everything else, including symlinks to directories). 542recurse into (everything else, including symlinks to directories).
444 543
445C<aio_scandir> is a composite request that creates of many sub requests_ 544C<aio_scandir> is a composite request that creates of many sub requests_
446C<$maxreq> specifies the maximum number of outstanding aio requests that 545C<$maxreq> specifies the maximum number of outstanding aio requests that
447this function generates. If it is C<< <= 0 >>, then a suitable default 546this function generates. If it is C<< <= 0 >>, then a suitable default
448will be chosen (currently 6). 547will be chosen (currently 4).
449 548
450On error, the callback is called without arguments, otherwise it receives 549On error, the callback is called without arguments, otherwise it receives
451two array-refs with path-relative entry names. 550two array-refs with path-relative entry names.
452 551
453Example: 552Example:
… …
494 593
495 my $pri = aioreq_pri; 594 my $pri = aioreq_pri;
496 595
497 my $grp = aio_group $cb; 596 my $grp = aio_group $cb;
498 597
499 $maxreq = 6 if $maxreq <= 0; 598 $maxreq = 4 if $maxreq <= 0;
500 599
501 # stat once 600 # stat once
502 aioreq_pri $pri; 601 aioreq_pri $pri;
503 add $grp aio_stat $path, sub { 602 add $grp aio_stat $path, sub {
504 return $grp->result () if $_[0]; 603 return $grp->result () if $_[0];
… …
794 893
795=back 894=back
796 895
797=head2 SUPPORT FUNCTIONS 896=head2 SUPPORT FUNCTIONS
798 897
898=head3 EVENT PROCESSING AND EVENT LOOP INTEGRATION
899
799=over 4 900=over 4
800 901
801=item $fileno = IO::AIO::poll_fileno 902=item $fileno = IO::AIO::poll_fileno
802 903
803Return the I<request result pipe file descriptor>. This filehandle must be 904Return the I<request result pipe file descriptor>. This filehandle must be
… …
807 908
808See C<poll_cb> for an example. 909See C<poll_cb> for an example.
809 910
810=item IO::AIO::poll_cb 911=item IO::AIO::poll_cb
811 912
812Process all outstanding events on the result pipe. You have to call this 913Process some outstanding events on the result pipe. You have to call this
813regularly. Returns the number of events processed. Returns immediately 914regularly. Returns the number of events processed. Returns immediately
814when no events are outstanding. 915when no events are outstanding. The amount of events processed depends on
916the settings of C<IO::AIO::max_poll_req> and C<IO::AIO::max_poll_time>.
815 917
816If not all requests were processed for whatever reason, the filehandle 918If not all requests were processed for whatever reason, the filehandle
817will still be ready when C<poll_cb> returns. 919will still be ready when C<poll_cb> returns.
818 920
819Example: Install an Event watcher that automatically calls 921Example: Install an Event watcher that automatically calls
… …
821 923
822 Event->io (fd => IO::AIO::poll_fileno, 924 Event->io (fd => IO::AIO::poll_fileno,
823 poll => 'r', async => 1, 925 poll => 'r', async => 1,
824 cb => \&IO::AIO::poll_cb); 926 cb => \&IO::AIO::poll_cb);
825 927
826=item IO::AIO::poll_some $max_requests 928=item IO::AIO::max_poll_reqs $nreqs
827 929
828Similar to C<poll_cb>, but only processes up to C<$max_requests> requests 930=item IO::AIO::max_poll_time $seconds
829at a time.
830 931
831Useful if you want to ensure some level of interactiveness when perl is 932These set the maximum number of requests (default C<0>, meaning infinity)
832not fast enough to process all requests in time. 933that are being processed by C<IO::AIO::poll_cb> in one call, respectively
934the maximum amount of time (default C<0>, meaning infinity) spent in
935C<IO::AIO::poll_cb> to process requests (more correctly the mininum amount
936of time C<poll_cb> is allowed to use).
937
938Setting these is useful if you want to ensure some level of
939interactiveness when perl is not fast enough to process all requests in
940time.
941
942For interactive programs, values such as C<0.01> to C<0.1> should be fine.
833 943
834Example: Install an Event watcher that automatically calls 944Example: Install an Event watcher that automatically calls
835IO::AIO::poll_some with low priority, to ensure that other parts of the 945IO::AIO::poll_some with low priority, to ensure that other parts of the
836program get the CPU sometimes even under high AIO load. 946program get the CPU sometimes even under high AIO load.
837 947
948 # try not to spend much more than 0.1s in poll_cb
949 IO::AIO::max_poll_time 0.1;
950
951 # use a low priority so other tasks have priority
838 Event->io (fd => IO::AIO::poll_fileno, 952 Event->io (fd => IO::AIO::poll_fileno,
839 poll => 'r', nice => 1, 953 poll => 'r', nice => 1,
840 cb => sub { IO::AIO::poll_some 256 }); 954 cb => &IO::AIO::poll_cb);
841 955
842=item IO::AIO::poll_wait 956=item IO::AIO::poll_wait
843 957
844Wait till the result filehandle becomes ready for reading (simply does a 958Wait till the result filehandle becomes ready for reading (simply does a
845C<select> on the filehandle. This is useful if you want to synchronously wait 959C<select> on the filehandle. This is useful if you want to synchronously
846for some requests to finish). 960wait for some requests to finish).
847 961
848See C<nreqs> for an example. 962See C<nreqs> for an example.
849 963
964=item IO::AIO::poll
965
966Waits until some requests have been handled.
967
968Strictly equivalent to:
969
970 IO::AIO::poll_wait, IO::AIO::poll_cb
971 if IO::AIO::nreqs;
972
850=item IO::AIO::nreqs 973=item IO::AIO::flush
851 974
852Returns the number of requests currently in the ready, execute or pending 975Wait till all outstanding AIO requests have been handled.
853states (i.e. for which their callback has not been invoked yet).
854 976
855Example: wait till there are no outstanding requests anymore: 977Strictly equivalent to:
856 978
857 IO::AIO::poll_wait, IO::AIO::poll_cb 979 IO::AIO::poll_wait, IO::AIO::poll_cb
858 while IO::AIO::nreqs; 980 while IO::AIO::nreqs;
859 981
860=item IO::AIO::nready 982=head3 CONTROLLING THE NUMBER OF THREADS
861
862Returns the number of requests currently in the ready state (not yet
863executed).
864
865=item IO::AIO::npending
866
867Returns the number of requests currently in the pending state (executed,
868but not yet processed by poll_cb).
869
870=item IO::AIO::flush
871
872Wait till all outstanding AIO requests have been handled.
873
874Strictly equivalent to:
875
876 IO::AIO::poll_wait, IO::AIO::poll_cb
877 while IO::AIO::nreqs;
878
879=item IO::AIO::poll
880
881Waits until some requests have been handled.
882
883Strictly equivalent to:
884
885 IO::AIO::poll_wait, IO::AIO::poll_cb
886 if IO::AIO::nreqs;
887 983
888=item IO::AIO::min_parallel $nthreads 984=item IO::AIO::min_parallel $nthreads
889 985
890Set the minimum number of AIO threads to C<$nthreads>. The current 986Set the minimum number of AIO threads to C<$nthreads>. The current
891default is C<8>, which means eight asynchronous operations can execute 987default is C<8>, which means eight asynchronous operations can execute
892concurrently at any one time (the number of outstanding requests, 988concurrently at any one time (the number of outstanding requests,
893however, is unlimited). 989however, is unlimited).
894 990
895IO::AIO starts threads only on demand, when an AIO request is queued and 991IO::AIO starts threads only on demand, when an AIO request is queued and
896no free thread exists. 992no free thread exists. Please note that queueing up a hundred requests can
993create demand for a hundred threads, even if it turns out that everything
994is in the cache and could have been processed faster by a single thread.
897 995
898It is recommended to keep the number of threads relatively low, as some 996It is recommended to keep the number of threads relatively low, as some
899Linux kernel versions will scale negatively with the number of threads 997Linux kernel versions will scale negatively with the number of threads
900(higher parallelity => MUCH higher latency). With current Linux 2.6 998(higher parallelity => MUCH higher latency). With current Linux 2.6
901versions, 4-32 threads should be fine. 999versions, 4-32 threads should be fine.
… …
915This module automatically runs C<max_parallel 0> at program end, to ensure 1013This module automatically runs C<max_parallel 0> at program end, to ensure
916that all threads are killed and that there are no outstanding requests. 1014that all threads are killed and that there are no outstanding requests.
917 1015
918Under normal circumstances you don't need to call this function. 1016Under normal circumstances you don't need to call this function.
919 1017
1018=item IO::AIO::max_idle $nthreads
1019
1020Limit the number of threads (default: 4) that are allowed to idle (i.e.,
1021threads that did not get a request to process within 10 seconds). That
1022means if a thread becomes idle while C<$nthreads> other threads are also
1023idle, it will free its resources and exit.
1024
1025This is useful when you allow a large number of threads (e.g. 100 or 1000)
1026to allow for extremely high load situations, but want to free resources
1027under normal circumstances (1000 threads can easily consume 30MB of RAM).
1028
1029The default is probably ok in most situations, especially if thread
1030creation is fast. If thread creation is very slow on your system you might
1031want to use larger values.
1032
920=item $oldmaxreqs = IO::AIO::max_outstanding $maxreqs 1033=item $oldmaxreqs = IO::AIO::max_outstanding $maxreqs
921 1034
922This is a very bad function to use in interactive programs because it 1035This is a very bad function to use in interactive programs because it
923blocks, and a bad way to reduce concurrency because it is inexact: Better 1036blocks, and a bad way to reduce concurrency because it is inexact: Better
924use an C<aio_group> together with a feed callback. 1037use an C<aio_group> together with a feed callback.
… …
933 1046
934You can still queue as many requests as you want. Therefore, 1047You can still queue as many requests as you want. Therefore,
935C<max_oustsanding> is mainly useful in simple scripts (with low values) or 1048C<max_oustsanding> is mainly useful in simple scripts (with low values) or
936as a stop gap to shield against fatal memory overflow (with large values). 1049as a stop gap to shield against fatal memory overflow (with large values).
937 1050
1051=head3 STATISTICAL INFORMATION
1052
1053=item IO::AIO::nreqs
1054
1055Returns the number of requests currently in the ready, execute or pending
1056states (i.e. for which their callback has not been invoked yet).
1057
1058Example: wait till there are no outstanding requests anymore:
1059
1060 IO::AIO::poll_wait, IO::AIO::poll_cb
1061 while IO::AIO::nreqs;
1062
1063=item IO::AIO::nready
1064
1065Returns the number of requests currently in the ready state (not yet
1066executed).
1067
1068=item IO::AIO::npending
1069
1070Returns the number of requests currently in the pending state (executed,
1071but not yet processed by poll_cb).
1072
938=back 1073=back
939 1074
940=cut 1075=cut
941 1076
942# support function to convert a fd into a perl filehandle 1077# support function to convert a fd into a perl filehandle
… …
956} 1091}
957 1092
958min_parallel 8; 1093min_parallel 8;
959 1094
960END { 1095END {
961 max_parallel 0; 1096 min_parallel 1;
962} 1097 flush;
1098};
963 1099
9641; 11001;
965 1101
966=head2 FORK BEHAVIOUR 1102=head2 FORK BEHAVIOUR
967 1103

Diff Legend

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