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.94 by root, Wed Nov 8 02:01:02 2006 UTC vs.
Revision 1.107 by root, Fri Jun 1 05:52:59 2007 UTC

… …
190use strict 'vars'; 190use strict 'vars';
191 191
192use base 'Exporter'; 192use base 'Exporter';
193 193
194BEGIN { 194BEGIN {
195 our $VERSION = '2.2'; 195 our $VERSION = '2.4';
196 196
197 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
198 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
199 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link 199 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link
200 aio_move aio_copy aio_group aio_nop aio_mknod); 200 aio_move aio_copy aio_group aio_nop aio_mknod aio_load aio_rmtree aio_mkdir
201 aio_chown aio_chmod aio_utime);
201 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); 202 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block));
202 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 203 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
203 min_parallel max_parallel max_idle 204 min_parallel max_parallel max_idle
204 nreqs nready npending nthreads 205 nreqs nready npending nthreads
205 max_poll_time max_poll_reqs); 206 max_poll_time max_poll_reqs);
206 207
… …
271 aio_read $_[0], ..., sub { 272 aio_read $_[0], ..., sub {
272 ... 273 ...
273 }; 274 };
274 }; 275 };
275 276
277
276=item aioreq_nice $pri_adjust 278=item aioreq_nice $pri_adjust
277 279
278Similar to C<aioreq_pri>, but subtracts the given value from the current 280Similar to C<aioreq_pri>, but subtracts the given value from the current
279priority, so the effect is cumulative. 281priority, so the effect is cumulative.
282
280 283
281=item aio_open $pathname, $flags, $mode, $callback->($fh) 284=item aio_open $pathname, $flags, $mode, $callback->($fh)
282 285
283Asynchronously open or create a file and call the callback with a newly 286Asynchronously open or create a file and call the callback with a newly
284created filehandle for the file. 287created filehandle for the file.
… …
290list. They are the same as used by C<sysopen>. 293list. They are the same as used by C<sysopen>.
291 294
292Likewise, C<$mode> specifies the mode of the newly created file, if it 295Likewise, C<$mode> specifies the mode of the newly created file, if it
293didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>, 296didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>,
294except that it is mandatory (i.e. use C<0> if you don't create new files, 297except that it is mandatory (i.e. use C<0> if you don't create new files,
295and C<0666> or C<0777> if you do). 298and C<0666> or C<0777> if you do). Note that the C<$mode> will be modified
299by the umask in effect then the request is being executed, so better never
300change the umask.
296 301
297Example: 302Example:
298 303
299 aio_open "/etc/passwd", O_RDONLY, 0, sub { 304 aio_open "/etc/passwd", O_RDONLY, 0, sub {
300 if ($_[0]) { 305 if ($_[0]) {
… …
303 } else { 308 } else {
304 die "open failed: $!\n"; 309 die "open failed: $!\n";
305 } 310 }
306 }; 311 };
307 312
313
308=item aio_close $fh, $callback->($status) 314=item aio_close $fh, $callback->($status)
309 315
310Asynchronously close a file and call the callback with the result 316Asynchronously close a file and call the callback with the result
311code. I<WARNING:> although accepted, you should not pass in a perl 317code. I<WARNING:> although accepted, you should not pass in a perl
312filehandle here, as perl will likely close the file descriptor another 318filehandle here, as perl will likely close the file descriptor another
… …
314C<close> or just let filehandles go out of scope. 320C<close> or just let filehandles go out of scope.
315 321
316This is supposed to be a bug in the API, so that might change. It's 322This is supposed to be a bug in the API, so that might change. It's
317therefore best to avoid this function. 323therefore best to avoid this function.
318 324
325
319=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 326=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
320 327
321=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 328=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
322 329
323Reads or writes C<length> bytes from the specified C<fh> and C<offset> 330Reads or writes C<length> bytes from the specified C<fh> and C<offset>
… …
334 341
335 aio_read $fh, 7, 15, $buffer, 0, sub { 342 aio_read $fh, 7, 15, $buffer, 0, sub {
336 $_[0] > 0 or die "read error: $!"; 343 $_[0] > 0 or die "read error: $!";
337 print "read $_[0] bytes: <$buffer>\n"; 344 print "read $_[0] bytes: <$buffer>\n";
338 }; 345 };
346
339 347
340=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) 348=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
341 349
342Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts 350Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts
343reading at byte offset C<$in_offset>, and starts writing at the current 351reading at byte offset C<$in_offset>, and starts writing at the current
… …
357C<$in_fh> than are written, and there is no way to find out how many 365C<$in_fh> than are written, and there is no way to find out how many
358bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only 366bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only
359provides the number of bytes written to C<$out_fh>. Only if the result 367provides the number of bytes written to C<$out_fh>. Only if the result
360value equals C<$length> one can assume that C<$length> bytes have been 368value equals C<$length> one can assume that C<$length> bytes have been
361read. 369read.
370
362 371
363=item aio_readahead $fh,$offset,$length, $callback->($retval) 372=item aio_readahead $fh,$offset,$length, $callback->($retval)
364 373
365C<aio_readahead> populates the page cache with data from a file so that 374C<aio_readahead> populates the page cache with data from a file so that
366subsequent reads from that file will not block on disk I/O. The C<$offset> 375subsequent reads from that file will not block on disk I/O. The C<$offset>
… …
372file. The current file offset of the file is left unchanged. 381file. The current file offset of the file is left unchanged.
373 382
374If that syscall doesn't exist (likely if your OS isn't Linux) it will be 383If that syscall doesn't exist (likely if your OS isn't Linux) it will be
375emulated by simply reading the data, which would have a similar effect. 384emulated by simply reading the data, which would have a similar effect.
376 385
386
377=item aio_stat $fh_or_path, $callback->($status) 387=item aio_stat $fh_or_path, $callback->($status)
378 388
379=item aio_lstat $fh, $callback->($status) 389=item aio_lstat $fh, $callback->($status)
380 390
381Works like perl's C<stat> or C<lstat> in void context. The callback will 391Works like perl's C<stat> or C<lstat> in void context. The callback will
… …
394 aio_stat "/etc/passwd", sub { 404 aio_stat "/etc/passwd", sub {
395 $_[0] and die "stat failed: $!"; 405 $_[0] and die "stat failed: $!";
396 print "size is ", -s _, "\n"; 406 print "size is ", -s _, "\n";
397 }; 407 };
398 408
409
410=item aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
411
412Works like perl's C<utime> function (including the special case of $atime
413and $mtime being undef). Fractional times are supported if the underlying
414syscalls support them.
415
416When called with a pathname, uses utimes(2) if available, otherwise
417utime(2). If called on a file descriptor, uses futimes(2) if available,
418otherwise returns ENOSYS, so this is not portable.
419
420Examples:
421
422 # set atime and mtime to current time (basically touch(1)):
423 aio_utime "path", undef, undef;
424 # set atime to current time and mtime to beginning of the epoch:
425 aio_utime "path", time, undef; # undef==0
426
427
428=item aio_chown $fh_or_path, $uid, $gid, $callback->($status)
429
430Works like perl's C<chown> function, except that C<undef> for either $uid
431or $gid is being interpreted as "do not change" (but -1 can also be used).
432
433Examples:
434
435 # same as "chown root path" in the shell:
436 aio_chown "path", 0, -1;
437 # same as above:
438 aio_chown "path", 0, undef;
439
440
441=item aio_chmod $fh_or_path, $mode, $callback->($status)
442
443Works like perl's C<chmod> function.
444
445
399=item aio_unlink $pathname, $callback->($status) 446=item aio_unlink $pathname, $callback->($status)
400 447
401Asynchronously unlink (delete) a file and call the callback with the 448Asynchronously unlink (delete) a file and call the callback with the
402result code. 449result code.
403 450
451
404=item aio_mknod $path, $mode, $dev, $callback->($status) 452=item aio_mknod $path, $mode, $dev, $callback->($status)
405 453
406[EXPERIMENTAL] 454[EXPERIMENTAL]
407 455
408Asynchronously create a device node (or fifo). See mknod(2). 456Asynchronously create a device node (or fifo). See mknod(2).
409 457
410The only (POSIX-) portable way of calling this function is: 458The only (POSIX-) portable way of calling this function is:
411 459
412 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ... 460 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ...
461
413 462
414=item aio_link $srcpath, $dstpath, $callback->($status) 463=item aio_link $srcpath, $dstpath, $callback->($status)
415 464
416Asynchronously create a new link to the existing object at C<$srcpath> at 465Asynchronously create a new link to the existing object at C<$srcpath> at
417the path C<$dstpath> and call the callback with the result code. 466the path C<$dstpath> and call the callback with the result code.
418 467
468
419=item aio_symlink $srcpath, $dstpath, $callback->($status) 469=item aio_symlink $srcpath, $dstpath, $callback->($status)
420 470
421Asynchronously create a new symbolic link to the existing object at C<$srcpath> at 471Asynchronously create a new symbolic link to the existing object at C<$srcpath> at
422the path C<$dstpath> and call the callback with the result code. 472the path C<$dstpath> and call the callback with the result code.
473
423 474
424=item aio_readlink $path, $callback->($link) 475=item aio_readlink $path, $callback->($link)
425 476
426Asynchronously read the symlink specified by C<$path> and pass it to 477Asynchronously read the symlink specified by C<$path> and pass it to
427the callback. If an error occurs, nothing or undef gets passed to the 478the callback. If an error occurs, nothing or undef gets passed to the
428callback. 479callback.
429 480
481
430=item aio_rename $srcpath, $dstpath, $callback->($status) 482=item aio_rename $srcpath, $dstpath, $callback->($status)
431 483
432Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 484Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
433rename(2) and call the callback with the result code. 485rename(2) and call the callback with the result code.
434 486
487
488=item aio_mkdir $pathname, $mode, $callback->($status)
489
490Asynchronously mkdir (create) a directory and call the callback with
491the result code. C<$mode> will be modified by the umask at the time the
492request is executed, so do not change your umask.
493
494
435=item aio_rmdir $pathname, $callback->($status) 495=item aio_rmdir $pathname, $callback->($status)
436 496
437Asynchronously rmdir (delete) a directory and call the callback with the 497Asynchronously rmdir (delete) a directory and call the callback with the
438result code. 498result code.
499
439 500
440=item aio_readdir $pathname, $callback->($entries) 501=item aio_readdir $pathname, $callback->($entries)
441 502
442Unlike the POSIX call of the same name, C<aio_readdir> reads an entire 503Unlike the POSIX call of the same name, C<aio_readdir> reads an entire
443directory (i.e. opendir + readdir + closedir). The entries will not be 504directory (i.e. opendir + readdir + closedir). The entries will not be
444sorted, and will B<NOT> include the C<.> and C<..> entries. 505sorted, and will B<NOT> include the C<.> and C<..> entries.
445 506
446The callback a single argument which is either C<undef> or an array-ref 507The callback a single argument which is either C<undef> or an array-ref
447with the filenames. 508with the filenames.
509
510
511=item aio_load $path, $data, $callback->($status)
512
513This is a composite request that tries to fully load the given file into
514memory. Status is the same as with aio_read.
515
516=cut
517
518sub aio_load($$;$) {
519 aio_block {
520 my ($path, undef, $cb) = @_;
521 my $data = \$_[1];
522
523 my $pri = aioreq_pri;
524 my $grp = aio_group $cb;
525
526 aioreq_pri $pri;
527 add $grp aio_open $path, O_RDONLY, 0, sub {
528 my $fh = shift
529 or return $grp->result (-1);
530
531 aioreq_pri $pri;
532 add $grp aio_read $fh, 0, (-s $fh), $$data, 0, sub {
533 $grp->result ($_[0]);
534 };
535 };
536
537 $grp
538 }
539}
448 540
449=item aio_copy $srcpath, $dstpath, $callback->($status) 541=item aio_copy $srcpath, $dstpath, $callback->($status)
450 542
451Try to copy the I<file> (directories not supported as either source or 543Try to copy the I<file> (directories not supported as either source or
452destination) from C<$srcpath> to C<$dstpath> and call the callback with 544destination) from C<$srcpath> to C<$dstpath> and call the callback with
… …
462errors are being ignored. 554errors are being ignored.
463 555
464=cut 556=cut
465 557
466sub aio_copy($$;$) { 558sub aio_copy($$;$) {
559 aio_block {
467 my ($src, $dst, $cb) = @_; 560 my ($src, $dst, $cb) = @_;
468 561
469 my $pri = aioreq_pri; 562 my $pri = aioreq_pri;
470 my $grp = aio_group $cb; 563 my $grp = aio_group $cb;
471 564
472 aioreq_pri $pri; 565 aioreq_pri $pri;
473 add $grp aio_open $src, O_RDONLY, 0, sub { 566 add $grp aio_open $src, O_RDONLY, 0, sub {
474 if (my $src_fh = $_[0]) { 567 if (my $src_fh = $_[0]) {
475 my @stat = stat $src_fh; 568 my @stat = stat $src_fh;
476 569
477 aioreq_pri $pri; 570 aioreq_pri $pri;
478 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { 571 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
479 if (my $dst_fh = $_[0]) { 572 if (my $dst_fh = $_[0]) {
480 aioreq_pri $pri; 573 aioreq_pri $pri;
481 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub { 574 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
482 if ($_[0] == $stat[7]) { 575 if ($_[0] == $stat[7]) {
483 $grp->result (0); 576 $grp->result (0);
484 close $src_fh; 577 close $src_fh;
485 578
486 # those should not normally block. should. should. 579 # those should not normally block. should. should.
487 utime $stat[8], $stat[9], $dst; 580 utime $stat[8], $stat[9], $dst;
488 chmod $stat[2] & 07777, $dst_fh; 581 chmod $stat[2] & 07777, $dst_fh;
489 chown $stat[4], $stat[5], $dst_fh; 582 chown $stat[4], $stat[5], $dst_fh;
490 close $dst_fh; 583 close $dst_fh;
491 } else { 584 } else {
492 $grp->result (-1); 585 $grp->result (-1);
493 close $src_fh; 586 close $src_fh;
494 close $dst_fh; 587 close $dst_fh;
495 588
496 aioreq $pri; 589 aioreq $pri;
497 add $grp aio_unlink $dst; 590 add $grp aio_unlink $dst;
591 }
498 } 592 };
593 } else {
594 $grp->result (-1);
499 }; 595 }
500 } else {
501 $grp->result (-1);
502 } 596 },
597
598 } else {
599 $grp->result (-1);
503 }, 600 }
504
505 } else {
506 $grp->result (-1);
507 } 601 };
602
603 $grp
508 }; 604 }
509
510 $grp
511} 605}
512 606
513=item aio_move $srcpath, $dstpath, $callback->($status) 607=item aio_move $srcpath, $dstpath, $callback->($status)
514 608
515Try to move the I<file> (directories not supported as either source or 609Try to move the I<file> (directories not supported as either source or
… …
521that is successful, unlinking the C<$srcpath>. 615that is successful, unlinking the C<$srcpath>.
522 616
523=cut 617=cut
524 618
525sub aio_move($$;$) { 619sub aio_move($$;$) {
620 aio_block {
526 my ($src, $dst, $cb) = @_; 621 my ($src, $dst, $cb) = @_;
527 622
528 my $pri = aioreq_pri; 623 my $pri = aioreq_pri;
529 my $grp = aio_group $cb; 624 my $grp = aio_group $cb;
530 625
531 aioreq_pri $pri; 626 aioreq_pri $pri;
532 add $grp aio_rename $src, $dst, sub { 627 add $grp aio_rename $src, $dst, sub {
533 if ($_[0] && $! == EXDEV) { 628 if ($_[0] && $! == EXDEV) {
534 aioreq_pri $pri; 629 aioreq_pri $pri;
535 add $grp aio_copy $src, $dst, sub { 630 add $grp aio_copy $src, $dst, sub {
631 $grp->result ($_[0]);
632
633 if (!$_[0]) {
634 aioreq_pri $pri;
635 add $grp aio_unlink $src;
636 }
637 };
638 } else {
536 $grp->result ($_[0]); 639 $grp->result ($_[0]);
537
538 if (!$_[0]) {
539 aioreq_pri $pri;
540 add $grp aio_unlink $src;
541 }
542 }; 640 }
543 } else {
544 $grp->result ($_[0]);
545 } 641 };
642
643 $grp
546 }; 644 }
547
548 $grp
549} 645}
550 646
551=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) 647=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
552 648
553Scans a directory (similar to C<aio_readdir>) but additionally tries to 649Scans a directory (similar to C<aio_readdir>) but additionally tries to
… …
600as those tend to return 0 or 1 as link counts, which disables the 696as those tend to return 0 or 1 as link counts, which disables the
601directory counting heuristic. 697directory counting heuristic.
602 698
603=cut 699=cut
604 700
605sub aio_scandir($$$) { 701sub aio_scandir($$;$) {
702 aio_block {
606 my ($path, $maxreq, $cb) = @_; 703 my ($path, $maxreq, $cb) = @_;
607 704
608 my $pri = aioreq_pri; 705 my $pri = aioreq_pri;
609 706
610 my $grp = aio_group $cb; 707 my $grp = aio_group $cb;
611 708
612 $maxreq = 4 if $maxreq <= 0; 709 $maxreq = 4 if $maxreq <= 0;
613 710
614 # stat once 711 # stat once
615 aioreq_pri $pri;
616 add $grp aio_stat $path, sub {
617 return $grp->result () if $_[0];
618 my $now = time;
619 my $hash1 = join ":", (stat _)[0,1,3,7,9];
620
621 # read the directory entries
622 aioreq_pri $pri; 712 aioreq_pri $pri;
623 add $grp aio_readdir $path, sub { 713 add $grp aio_stat $path, sub {
624 my $entries = shift
625 or return $grp->result (); 714 return $grp->result () if $_[0];
715 my $now = time;
716 my $hash1 = join ":", (stat _)[0,1,3,7,9];
626 717
627 # stat the dir another time 718 # read the directory entries
628 aioreq_pri $pri; 719 aioreq_pri $pri;
720 add $grp aio_readdir $path, sub {
721 my $entries = shift
722 or return $grp->result ();
723
724 # stat the dir another time
725 aioreq_pri $pri;
629 add $grp aio_stat $path, sub { 726 add $grp aio_stat $path, sub {
630 my $hash2 = join ":", (stat _)[0,1,3,7,9]; 727 my $hash2 = join ":", (stat _)[0,1,3,7,9];
631 728
632 my $ndirs; 729 my $ndirs;
633 730
634 # take the slow route if anything looks fishy 731 # take the slow route if anything looks fishy
635 if ($hash1 ne $hash2 or (stat _)[9] == $now) { 732 if ($hash1 ne $hash2 or (stat _)[9] == $now) {
636 $ndirs = -1; 733 $ndirs = -1;
637 } else { 734 } else {
638 # if nlink == 2, we are finished 735 # if nlink == 2, we are finished
639 # on non-posix-fs's, we rely on nlink < 2 736 # on non-posix-fs's, we rely on nlink < 2
640 $ndirs = (stat _)[3] - 2 737 $ndirs = (stat _)[3] - 2
641 or return $grp->result ([], $entries); 738 or return $grp->result ([], $entries);
642 } 739 }
643 740
644 # sort into likely dirs and likely nondirs 741 # sort into likely dirs and likely nondirs
645 # dirs == files without ".", short entries first 742 # dirs == files without ".", short entries first
646 $entries = [map $_->[0], 743 $entries = [map $_->[0],
647 sort { $b->[1] cmp $a->[1] } 744 sort { $b->[1] cmp $a->[1] }
648 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length], 745 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length],
649 @$entries]; 746 @$entries];
650 747
651 my (@dirs, @nondirs); 748 my (@dirs, @nondirs);
652 749
653 my $statgrp = add $grp aio_group sub { 750 my $statgrp = add $grp aio_group sub {
654 $grp->result (\@dirs, \@nondirs); 751 $grp->result (\@dirs, \@nondirs);
655 }; 752 };
656 753
657 limit $statgrp $maxreq; 754 limit $statgrp $maxreq;
658 feed $statgrp sub { 755 feed $statgrp sub {
659 return unless @$entries; 756 return unless @$entries;
660 my $entry = pop @$entries; 757 my $entry = pop @$entries;
661 758
662 aioreq_pri $pri; 759 aioreq_pri $pri;
663 add $statgrp aio_stat "$path/$entry/.", sub { 760 add $statgrp aio_stat "$path/$entry/.", sub {
664 if ($_[0] < 0) { 761 if ($_[0] < 0) {
665 push @nondirs, $entry; 762 push @nondirs, $entry;
666 } else { 763 } else {
667 # need to check for real directory 764 # need to check for real directory
668 aioreq_pri $pri; 765 aioreq_pri $pri;
669 add $statgrp aio_lstat "$path/$entry", sub { 766 add $statgrp aio_lstat "$path/$entry", sub {
670 if (-d _) { 767 if (-d _) {
671 push @dirs, $entry; 768 push @dirs, $entry;
672 769
673 unless (--$ndirs) { 770 unless (--$ndirs) {
674 push @nondirs, @$entries; 771 push @nondirs, @$entries;
675 feed $statgrp; 772 feed $statgrp;
773 }
774 } else {
775 push @nondirs, $entry;
676 } 776 }
677 } else {
678 push @nondirs, $entry;
679 } 777 }
680 } 778 }
681 } 779 };
682 }; 780 };
683 }; 781 };
684 }; 782 };
685 }; 783 };
784
785 $grp
686 }; 786 }
787}
687 788
789=item aio_rmtree $path, $callback->($status)
790
791Delete a directory tree starting (and including) C<$path>, return the
792status of the final C<rmdir> only. This is a composite request that
793uses C<aio_scandir> to recurse into and rmdir directories, and unlink
794everything else.
795
796=cut
797
798sub aio_rmtree;
799sub aio_rmtree($;$) {
800 aio_block {
801 my ($path, $cb) = @_;
802
803 my $pri = aioreq_pri;
804 my $grp = aio_group $cb;
805
806 aioreq_pri $pri;
807 add $grp aio_scandir $path, 0, sub {
808 my ($dirs, $nondirs) = @_;
809
810 my $dirgrp = aio_group sub {
811 add $grp aio_rmdir $path, sub {
812 $grp->result ($_[0]);
813 };
814 };
815
816 (aioreq_pri $pri), add $dirgrp aio_rmtree "$path/$_" for @$dirs;
817 (aioreq_pri $pri), add $dirgrp aio_unlink "$path/$_" for @$nondirs;
818
819 add $grp $dirgrp;
820 };
821
688 $grp 822 $grp
823 }
689} 824}
690 825
691=item aio_fsync $fh, $callback->($status) 826=item aio_fsync $fh, $callback->($status)
692 827
693Asynchronously call fsync on the given filehandle and call the callback 828Asynchronously call fsync on the given filehandle and call the callback
… …
997Strictly equivalent to: 1132Strictly equivalent to:
998 1133
999 IO::AIO::poll_wait, IO::AIO::poll_cb 1134 IO::AIO::poll_wait, IO::AIO::poll_cb
1000 while IO::AIO::nreqs; 1135 while IO::AIO::nreqs;
1001 1136
1137=back
1138
1002=head3 CONTROLLING THE NUMBER OF THREADS 1139=head3 CONTROLLING THE NUMBER OF THREADS
1140
1141=over
1003 1142
1004=item IO::AIO::min_parallel $nthreads 1143=item IO::AIO::min_parallel $nthreads
1005 1144
1006Set the minimum number of AIO threads to C<$nthreads>. The current 1145Set the minimum number of AIO threads to C<$nthreads>. The current
1007default is C<8>, which means eight asynchronous operations can execute 1146default is C<8>, which means eight asynchronous operations can execute
… …
1066 1205
1067You can still queue as many requests as you want. Therefore, 1206You can still queue as many requests as you want. Therefore,
1068C<max_oustsanding> is mainly useful in simple scripts (with low values) or 1207C<max_oustsanding> is mainly useful in simple scripts (with low values) or
1069as a stop gap to shield against fatal memory overflow (with large values). 1208as a stop gap to shield against fatal memory overflow (with large values).
1070 1209
1210=back
1211
1071=head3 STATISTICAL INFORMATION 1212=head3 STATISTICAL INFORMATION
1213
1214=over
1072 1215
1073=item IO::AIO::nreqs 1216=item IO::AIO::nreqs
1074 1217
1075Returns the number of requests currently in the ready, execute or pending 1218Returns the number of requests currently in the ready, execute or pending
1076states (i.e. for which their callback has not been invoked yet). 1219states (i.e. for which their callback has not been invoked yet).
… …
1110 *$sym 1253 *$sym
1111} 1254}
1112 1255
1113min_parallel 8; 1256min_parallel 8;
1114 1257
1115END { 1258END { flush }
1116 min_parallel 1;
1117 flush;
1118};
1119 1259
11201; 12601;
1121 1261
1122=head2 FORK BEHAVIOUR 1262=head2 FORK BEHAVIOUR
1123 1263

Diff Legend

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