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.86 by root, Sat Oct 28 23:32:29 2006 UTC vs.
Revision 1.100 by root, Sun Jan 7 21:36:58 2007 UTC

… …
5=head1 SYNOPSIS 5=head1 SYNOPSIS
6 6
7 use IO::AIO; 7 use IO::AIO;
8 8
9 aio_open "/etc/passwd", O_RDONLY, 0, sub { 9 aio_open "/etc/passwd", O_RDONLY, 0, sub {
10 my ($fh) = @_; 10 my $fh = shift
11 or die "/etc/passwd: $!";
11 ... 12 ...
12 }; 13 };
13 14
14 aio_unlink "/tmp/file", sub { }; 15 aio_unlink "/tmp/file", sub { };
15 16
… …
61etc.), but can also be used to easily do operations in parallel that are 62etc.), 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 63normally 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 64on a RAID volume or over NFS when you do a number of stat operations
64concurrently. 65concurrently.
65 66
66While this works on all types of file descriptors (for example sockets), 67While most of this works on all types of file descriptors (for example
67using these functions on file descriptors that support nonblocking 68sockets), using these functions on file descriptors that support
68operation (again, sockets, pipes etc.) is very inefficient. Use an event 69nonblocking operation (again, sockets, pipes etc.) is very inefficient or
70might not work (aio_read fails on sockets/pipes/fifos). Use an event loop
69loop for that (such as the L<Event|Event> module): IO::AIO will naturally 71for that (such as the L<Event|Event> module): IO::AIO will naturally fit
70fit into such an event loop itself. 72into such an event loop itself.
71 73
72In this version, a number of threads are started that execute your 74In this version, a number of threads are started that execute your
73requests and signal their completion. You don't need thread support 75requests and signal their completion. You don't need thread support
74in perl, and the threads created by this module will not be visible 76in perl, and the threads created by this module will not be visible
75to perl. In the future, this module might make use of the native aio 77to perl. In the future, this module might make use of the native aio
… …
98 poll => 'r', 100 poll => 'r',
99 cb => \&IO::AIO::poll_cb); 101 cb => \&IO::AIO::poll_cb);
100 102
101 # queue the request to open /etc/passwd 103 # queue the request to open /etc/passwd
102 aio_open "/etc/passwd", O_RDONLY, 0, sub { 104 aio_open "/etc/passwd", O_RDONLY, 0, sub {
103 my $fh = $_[0] 105 my $fh = shift
104 or die "error while opening: $!"; 106 or die "error while opening: $!";
105 107
106 # stat'ing filehandles is generally non-blocking 108 # stat'ing filehandles is generally non-blocking
107 my $size = -s $fh; 109 my $size = -s $fh;
108 110
… …
176Request has reached the end of its lifetime and holds no resources anymore 178Request has reached the end of its lifetime and holds no resources anymore
177(except possibly for the Perl object, but its connection to the actual 179(except possibly for the Perl object, but its connection to the actual
178aio request is severed and calling its methods will either do nothing or 180aio request is severed and calling its methods will either do nothing or
179result in a runtime error). 181result in a runtime error).
180 182
183=back
184
181=cut 185=cut
182 186
183package IO::AIO; 187package IO::AIO;
184 188
185no warnings; 189no warnings;
186use strict 'vars'; 190use strict 'vars';
187 191
188use base 'Exporter'; 192use base 'Exporter';
189 193
190BEGIN { 194BEGIN {
191 our $VERSION = '2.1'; 195 our $VERSION = '2.32';
192 196
193 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat 197 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat
194 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 198 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink
195 aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move 199 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link
196 aio_copy aio_group aio_nop aio_mknod); 200 aio_move aio_copy aio_group aio_nop aio_mknod aio_load aio_rmtree);
197 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); 201 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block));
198 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 202 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
199 min_parallel max_parallel max_idle 203 min_parallel max_parallel max_idle
200 nreqs nready npending nthreads 204 nreqs nready npending nthreads
201 max_poll_time max_poll_reqs); 205 max_poll_time max_poll_reqs);
202 206
… …
206 XSLoader::load ("IO::AIO", $VERSION); 210 XSLoader::load ("IO::AIO", $VERSION);
207} 211}
208 212
209=head1 FUNCTIONS 213=head1 FUNCTIONS
210 214
211=head2 AIO FUNCTIONS 215=head2 AIO REQUEST FUNCTIONS
212 216
213All the C<aio_*> calls are more or less thin wrappers around the syscall 217All the C<aio_*> calls are more or less thin wrappers around the syscall
214with the same name (sans C<aio_>). The arguments are similar or identical, 218with the same name (sans C<aio_>). The arguments are similar or identical,
215and they all accept an additional (and optional) C<$callback> argument 219and they all accept an additional (and optional) C<$callback> argument
216which must be a code reference. This code reference will get called with 220which must be a code reference. This code reference will get called with
… …
219syscall has been executed asynchronously. 223syscall has been executed asynchronously.
220 224
221All functions expecting a filehandle keep a copy of the filehandle 225All functions expecting a filehandle keep a copy of the filehandle
222internally until the request has finished. 226internally until the request has finished.
223 227
224All requests return objects of type L<IO::AIO::REQ> that allow further 228All functions return request objects of type L<IO::AIO::REQ> that allow
225manipulation of those requests while they are in-flight. 229further manipulation of those requests while they are in-flight.
226 230
227The pathnames you pass to these routines I<must> be absolute and 231The pathnames you pass to these routines I<must> be absolute and
228encoded in byte form. The reason for the former is that at the time the 232encoded as octets. The reason for the former is that at the time the
229request is being executed, the current working directory could have 233request is being executed, the current working directory could have
230changed. Alternatively, you can make sure that you never change the 234changed. Alternatively, you can make sure that you never change the
231current working directory. 235current working directory anywhere in the program and then use relative
236paths.
232 237
233To encode pathnames to byte form, either make sure you either: a) 238To encode pathnames as octets, either make sure you either: a) always pass
234always pass in filenames you got from outside (command line, readdir 239in filenames you got from outside (command line, readdir etc.) without
235etc.), b) are ASCII or ISO 8859-1, c) use the Encode module and encode 240tinkering, b) are ASCII or ISO 8859-1, c) use the Encode module and encode
236your pathnames to the locale (or other) encoding in effect in the user 241your pathnames to the locale (or other) encoding in effect in the user
237environment, d) use Glib::filename_from_unicode on unicode filenames or e) 242environment, d) use Glib::filename_from_unicode on unicode filenames or e)
238use something else. 243use something else to ensure your scalar has the correct contents.
244
245This works, btw. independent of the internal UTF-8 bit, which IO::AIO
246handles correctly wether it is set or not.
239 247
240=over 4 248=over 4
241 249
242=item $prev_pri = aioreq_pri [$pri] 250=item $prev_pri = aioreq_pri [$pri]
243 251
… …
266 }; 274 };
267 275
268=item aioreq_nice $pri_adjust 276=item aioreq_nice $pri_adjust
269 277
270Similar to C<aioreq_pri>, but subtracts the given value from the current 278Similar to C<aioreq_pri>, but subtracts the given value from the current
271priority, so effects are cumulative. 279priority, so the effect is cumulative.
272 280
273=item aio_open $pathname, $flags, $mode, $callback->($fh) 281=item aio_open $pathname, $flags, $mode, $callback->($fh)
274 282
275Asynchronously open or create a file and call the callback with a newly 283Asynchronously open or create a file and call the callback with a newly
276created filehandle for the file. 284created filehandle for the file.
… …
411=item aio_symlink $srcpath, $dstpath, $callback->($status) 419=item aio_symlink $srcpath, $dstpath, $callback->($status)
412 420
413Asynchronously create a new symbolic link to the existing object at C<$srcpath> at 421Asynchronously create a new symbolic link to the existing object at C<$srcpath> at
414the path C<$dstpath> and call the callback with the result code. 422the path C<$dstpath> and call the callback with the result code.
415 423
424=item aio_readlink $path, $callback->($link)
425
426Asynchronously read the symlink specified by C<$path> and pass it to
427the callback. If an error occurs, nothing or undef gets passed to the
428callback.
429
416=item aio_rename $srcpath, $dstpath, $callback->($status) 430=item aio_rename $srcpath, $dstpath, $callback->($status)
417 431
418Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 432Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
419rename(2) and call the callback with the result code. 433rename(2) and call the callback with the result code.
420 434
… …
429directory (i.e. opendir + readdir + closedir). The entries will not be 443directory (i.e. opendir + readdir + closedir). The entries will not be
430sorted, and will B<NOT> include the C<.> and C<..> entries. 444sorted, and will B<NOT> include the C<.> and C<..> entries.
431 445
432The callback a single argument which is either C<undef> or an array-ref 446The callback a single argument which is either C<undef> or an array-ref
433with the filenames. 447with the filenames.
448
449=item aio_load $path, $data, $callback->($status)
450
451This is a composite request that tries to fully load the given file into
452memory. Status is the same as with aio_read.
453
454=cut
455
456sub aio_load($$;$) {
457 aio_block {
458 my ($path, undef, $cb) = @_;
459 my $data = \$_[1];
460
461 my $pri = aioreq_pri;
462 my $grp = aio_group $cb;
463
464 aioreq_pri $pri;
465 add $grp aio_open $path, O_RDONLY, 0, sub {
466 my ($fh) = @_
467 or return $grp->result (-1);
468
469 aioreq_pri $pri;
470 add $grp aio_read $fh, 0, (-s $fh), $$data, 0, sub {
471 $grp->result ($_[0]);
472 };
473 };
474
475 $grp
476 }
477}
434 478
435=item aio_copy $srcpath, $dstpath, $callback->($status) 479=item aio_copy $srcpath, $dstpath, $callback->($status)
436 480
437Try to copy the I<file> (directories not supported as either source or 481Try to copy the I<file> (directories not supported as either source or
438destination) from C<$srcpath> to C<$dstpath> and call the callback with 482destination) from C<$srcpath> to C<$dstpath> and call the callback with
… …
448errors are being ignored. 492errors are being ignored.
449 493
450=cut 494=cut
451 495
452sub aio_copy($$;$) { 496sub aio_copy($$;$) {
497 aio_block {
453 my ($src, $dst, $cb) = @_; 498 my ($src, $dst, $cb) = @_;
454 499
455 my $pri = aioreq_pri; 500 my $pri = aioreq_pri;
456 my $grp = aio_group $cb; 501 my $grp = aio_group $cb;
457 502
458 aioreq_pri $pri; 503 aioreq_pri $pri;
459 add $grp aio_open $src, O_RDONLY, 0, sub { 504 add $grp aio_open $src, O_RDONLY, 0, sub {
460 if (my $src_fh = $_[0]) { 505 if (my $src_fh = $_[0]) {
461 my @stat = stat $src_fh; 506 my @stat = stat $src_fh;
462 507
463 aioreq_pri $pri; 508 aioreq_pri $pri;
464 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { 509 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
465 if (my $dst_fh = $_[0]) { 510 if (my $dst_fh = $_[0]) {
466 aioreq_pri $pri; 511 aioreq_pri $pri;
467 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub { 512 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
468 if ($_[0] == $stat[7]) { 513 if ($_[0] == $stat[7]) {
469 $grp->result (0); 514 $grp->result (0);
470 close $src_fh; 515 close $src_fh;
471 516
472 # those should not normally block. should. should. 517 # those should not normally block. should. should.
473 utime $stat[8], $stat[9], $dst; 518 utime $stat[8], $stat[9], $dst;
474 chmod $stat[2] & 07777, $dst_fh; 519 chmod $stat[2] & 07777, $dst_fh;
475 chown $stat[4], $stat[5], $dst_fh; 520 chown $stat[4], $stat[5], $dst_fh;
476 close $dst_fh; 521 close $dst_fh;
477 } else { 522 } else {
478 $grp->result (-1); 523 $grp->result (-1);
479 close $src_fh; 524 close $src_fh;
480 close $dst_fh; 525 close $dst_fh;
481 526
482 aioreq $pri; 527 aioreq $pri;
483 add $grp aio_unlink $dst; 528 add $grp aio_unlink $dst;
529 }
484 } 530 };
531 } else {
532 $grp->result (-1);
485 }; 533 }
486 } else {
487 $grp->result (-1);
488 } 534 },
535
536 } else {
537 $grp->result (-1);
489 }, 538 }
490
491 } else {
492 $grp->result (-1);
493 } 539 };
540
541 $grp
494 }; 542 }
495
496 $grp
497} 543}
498 544
499=item aio_move $srcpath, $dstpath, $callback->($status) 545=item aio_move $srcpath, $dstpath, $callback->($status)
500 546
501Try to move the I<file> (directories not supported as either source or 547Try to move the I<file> (directories not supported as either source or
… …
507that is successful, unlinking the C<$srcpath>. 553that is successful, unlinking the C<$srcpath>.
508 554
509=cut 555=cut
510 556
511sub aio_move($$;$) { 557sub aio_move($$;$) {
558 aio_block {
512 my ($src, $dst, $cb) = @_; 559 my ($src, $dst, $cb) = @_;
513 560
514 my $pri = aioreq_pri; 561 my $pri = aioreq_pri;
515 my $grp = aio_group $cb; 562 my $grp = aio_group $cb;
516 563
517 aioreq_pri $pri; 564 aioreq_pri $pri;
518 add $grp aio_rename $src, $dst, sub { 565 add $grp aio_rename $src, $dst, sub {
519 if ($_[0] && $! == EXDEV) { 566 if ($_[0] && $! == EXDEV) {
520 aioreq_pri $pri; 567 aioreq_pri $pri;
521 add $grp aio_copy $src, $dst, sub { 568 add $grp aio_copy $src, $dst, sub {
569 $grp->result ($_[0]);
570
571 if (!$_[0]) {
572 aioreq_pri $pri;
573 add $grp aio_unlink $src;
574 }
575 };
576 } else {
522 $grp->result ($_[0]); 577 $grp->result ($_[0]);
523
524 if (!$_[0]) {
525 aioreq_pri $pri;
526 add $grp aio_unlink $src;
527 }
528 }; 578 }
529 } else {
530 $grp->result ($_[0]);
531 } 579 };
580
581 $grp
532 }; 582 }
533
534 $grp
535} 583}
536 584
537=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) 585=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
538 586
539Scans a directory (similar to C<aio_readdir>) but additionally tries to 587Scans a directory (similar to C<aio_readdir>) but additionally tries to
… …
586as those tend to return 0 or 1 as link counts, which disables the 634as those tend to return 0 or 1 as link counts, which disables the
587directory counting heuristic. 635directory counting heuristic.
588 636
589=cut 637=cut
590 638
591sub aio_scandir($$$) { 639sub aio_scandir($$;$) {
640 aio_block {
592 my ($path, $maxreq, $cb) = @_; 641 my ($path, $maxreq, $cb) = @_;
593 642
594 my $pri = aioreq_pri; 643 my $pri = aioreq_pri;
595 644
596 my $grp = aio_group $cb; 645 my $grp = aio_group $cb;
597 646
598 $maxreq = 4 if $maxreq <= 0; 647 $maxreq = 4 if $maxreq <= 0;
599 648
600 # stat once 649 # stat once
601 aioreq_pri $pri;
602 add $grp aio_stat $path, sub {
603 return $grp->result () if $_[0];
604 my $now = time;
605 my $hash1 = join ":", (stat _)[0,1,3,7,9];
606
607 # read the directory entries
608 aioreq_pri $pri; 650 aioreq_pri $pri;
609 add $grp aio_readdir $path, sub { 651 add $grp aio_stat $path, sub {
610 my $entries = shift
611 or return $grp->result (); 652 return $grp->result () if $_[0];
653 my $now = time;
654 my $hash1 = join ":", (stat _)[0,1,3,7,9];
612 655
613 # stat the dir another time 656 # read the directory entries
614 aioreq_pri $pri; 657 aioreq_pri $pri;
658 add $grp aio_readdir $path, sub {
659 my $entries = shift
660 or return $grp->result ();
661
662 # stat the dir another time
663 aioreq_pri $pri;
615 add $grp aio_stat $path, sub { 664 add $grp aio_stat $path, sub {
616 my $hash2 = join ":", (stat _)[0,1,3,7,9]; 665 my $hash2 = join ":", (stat _)[0,1,3,7,9];
617 666
618 my $ndirs; 667 my $ndirs;
619 668
620 # take the slow route if anything looks fishy 669 # take the slow route if anything looks fishy
621 if ($hash1 ne $hash2 or (stat _)[9] == $now) { 670 if ($hash1 ne $hash2 or (stat _)[9] == $now) {
622 $ndirs = -1; 671 $ndirs = -1;
623 } else { 672 } else {
624 # if nlink == 2, we are finished 673 # if nlink == 2, we are finished
625 # on non-posix-fs's, we rely on nlink < 2 674 # on non-posix-fs's, we rely on nlink < 2
626 $ndirs = (stat _)[3] - 2 675 $ndirs = (stat _)[3] - 2
627 or return $grp->result ([], $entries); 676 or return $grp->result ([], $entries);
628 } 677 }
629 678
630 # sort into likely dirs and likely nondirs 679 # sort into likely dirs and likely nondirs
631 # dirs == files without ".", short entries first 680 # dirs == files without ".", short entries first
632 $entries = [map $_->[0], 681 $entries = [map $_->[0],
633 sort { $b->[1] cmp $a->[1] } 682 sort { $b->[1] cmp $a->[1] }
634 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length], 683 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length],
635 @$entries]; 684 @$entries];
636 685
637 my (@dirs, @nondirs); 686 my (@dirs, @nondirs);
638 687
639 my $statgrp = add $grp aio_group sub { 688 my $statgrp = add $grp aio_group sub {
640 $grp->result (\@dirs, \@nondirs); 689 $grp->result (\@dirs, \@nondirs);
641 }; 690 };
642 691
643 limit $statgrp $maxreq; 692 limit $statgrp $maxreq;
644 feed $statgrp sub { 693 feed $statgrp sub {
645 return unless @$entries; 694 return unless @$entries;
646 my $entry = pop @$entries; 695 my $entry = pop @$entries;
647 696
648 aioreq_pri $pri; 697 aioreq_pri $pri;
649 add $statgrp aio_stat "$path/$entry/.", sub { 698 add $statgrp aio_stat "$path/$entry/.", sub {
650 if ($_[0] < 0) { 699 if ($_[0] < 0) {
651 push @nondirs, $entry; 700 push @nondirs, $entry;
652 } else { 701 } else {
653 # need to check for real directory 702 # need to check for real directory
654 aioreq_pri $pri; 703 aioreq_pri $pri;
655 add $statgrp aio_lstat "$path/$entry", sub { 704 add $statgrp aio_lstat "$path/$entry", sub {
656 if (-d _) { 705 if (-d _) {
657 push @dirs, $entry; 706 push @dirs, $entry;
658 707
659 unless (--$ndirs) { 708 unless (--$ndirs) {
660 push @nondirs, @$entries; 709 push @nondirs, @$entries;
661 feed $statgrp; 710 feed $statgrp;
711 }
712 } else {
713 push @nondirs, $entry;
662 } 714 }
663 } else {
664 push @nondirs, $entry;
665 } 715 }
666 } 716 }
667 } 717 };
668 }; 718 };
669 }; 719 };
670 }; 720 };
671 }; 721 };
722
723 $grp
672 }; 724 }
725}
673 726
727=item aio_rmtree $path, $callback->($status)
728
729Delete a directory tree starting (and including) C<$path>, return the
730status of the final C<rmdir> only. This is a composite request that
731uses C<aio_scandir> to recurse into and rmdir directories, and unlink
732everything else.
733
734=cut
735
736sub aio_rmtree;
737sub aio_rmtree($;$) {
738 aio_block {
739 my ($path, $cb) = @_;
740
741 my $pri = aioreq_pri;
742 my $grp = aio_group $cb;
743
744 aioreq_pri $pri;
745 add $grp aio_scandir $path, 0, sub {
746 my ($dirs, $nondirs) = @_;
747
748 my $dirgrp = aio_group sub {
749 add $grp aio_rmdir $path, sub {
750 $grp->result ($_[0]);
751 };
752 };
753
754 (aioreq_pri $pri), add $dirgrp aio_rmtree "$path/$_" for @$dirs;
755 (aioreq_pri $pri), add $dirgrp aio_unlink "$path/$_" for @$nondirs;
756
757 add $grp $dirgrp;
758 };
759
674 $grp 760 $grp
761 }
675} 762}
676 763
677=item aio_fsync $fh, $callback->($status) 764=item aio_fsync $fh, $callback->($status)
678 765
679Asynchronously call fsync on the given filehandle and call the callback 766Asynchronously call fsync on the given filehandle and call the callback
… …
933that are being processed by C<IO::AIO::poll_cb> in one call, respectively 1020that 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 1021the maximum amount of time (default C<0>, meaning infinity) spent in
935C<IO::AIO::poll_cb> to process requests (more correctly the mininum amount 1022C<IO::AIO::poll_cb> to process requests (more correctly the mininum amount
936of time C<poll_cb> is allowed to use). 1023of time C<poll_cb> is allowed to use).
937 1024
1025Setting C<max_poll_time> to a non-zero value creates an overhead of one
1026syscall per request processed, which is not normally a problem unless your
1027callbacks are really really fast or your OS is really really slow (I am
1028not mentioning Solaris here). Using C<max_poll_reqs> incurs no overhead.
1029
938Setting these is useful if you want to ensure some level of 1030Setting these is useful if you want to ensure some level of
939interactiveness when perl is not fast enough to process all requests in 1031interactiveness when perl is not fast enough to process all requests in
940time. 1032time.
941 1033
942For interactive programs, values such as C<0.01> to C<0.1> should be fine. 1034For interactive programs, values such as C<0.01> to C<0.1> should be fine.
943 1035
944Example: Install an Event watcher that automatically calls 1036Example: Install an Event watcher that automatically calls
945IO::AIO::poll_some with low priority, to ensure that other parts of the 1037IO::AIO::poll_cb with low priority, to ensure that other parts of the
946program get the CPU sometimes even under high AIO load. 1038program get the CPU sometimes even under high AIO load.
947 1039
948 # try not to spend much more than 0.1s in poll_cb 1040 # try not to spend much more than 0.1s in poll_cb
949 IO::AIO::max_poll_time 0.1; 1041 IO::AIO::max_poll_time 0.1;
950 1042
… …
953 poll => 'r', nice => 1, 1045 poll => 'r', nice => 1,
954 cb => &IO::AIO::poll_cb); 1046 cb => &IO::AIO::poll_cb);
955 1047
956=item IO::AIO::poll_wait 1048=item IO::AIO::poll_wait
957 1049
1050If there are any outstanding requests and none of them in the result
958Wait till the result filehandle becomes ready for reading (simply does a 1051phase, wait till the result filehandle becomes ready for reading (simply
959C<select> on the filehandle. This is useful if you want to synchronously 1052does a C<select> on the filehandle. This is useful if you want to
960wait for some requests to finish). 1053synchronously wait for some requests to finish).
961 1054
962See C<nreqs> for an example. 1055See C<nreqs> for an example.
963 1056
964=item IO::AIO::poll 1057=item IO::AIO::poll
965 1058
966Waits until some requests have been handled. 1059Waits until some requests have been handled.
967 1060
1061Returns the number of requests processed, but is otherwise strictly
968Strictly equivalent to: 1062equivalent to:
969 1063
970 IO::AIO::poll_wait, IO::AIO::poll_cb 1064 IO::AIO::poll_wait, IO::AIO::poll_cb
971 if IO::AIO::nreqs;
972 1065
973=item IO::AIO::flush 1066=item IO::AIO::flush
974 1067
975Wait till all outstanding AIO requests have been handled. 1068Wait till all outstanding AIO requests have been handled.
976 1069
… …
1090 *$sym 1183 *$sym
1091} 1184}
1092 1185
1093min_parallel 8; 1186min_parallel 8;
1094 1187
1095END { 1188END { flush }
1096 min_parallel 1;
1097 flush;
1098};
1099 1189
11001; 11901;
1101 1191
1102=head2 FORK BEHAVIOUR 1192=head2 FORK BEHAVIOUR
1103 1193

Diff Legend

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