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.89 by root, Sun Oct 29 11:03:18 2006 UTC vs.
Revision 1.115 by root, Mon Sep 24 18:14:00 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
67using these functions on file descriptors that support nonblocking 68example sockets), using these functions on file descriptors that
68operation (again, sockets, pipes etc.) is very inefficient. Use an event 69support nonblocking operation (again, sockets, pipes etc.) is very
69loop for that (such as the L<Event|Event> module): IO::AIO will naturally 70inefficient. Use an event loop for that (such as the L<Event|Event>
70fit into such an event loop itself. 71module): IO::AIO will naturally fit into such an event loop itself.
71 72
72In this version, a number of threads are started that execute your 73In this version, a number of threads are started that execute your
73requests and signal their completion. You don't need thread support 74requests and signal their completion. You don't need thread support
74in perl, and the threads created by this module will not be visible 75in 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 76to perl. In the future, this module might make use of the native aio
… …
77not well-supported or restricted (GNU/Linux doesn't allow them on normal 78not well-supported or restricted (GNU/Linux doesn't allow them on normal
78files currently, for example), and they would only support aio_read and 79files currently, for example), and they would only support aio_read and
79aio_write, so the remaining functionality would have to be implemented 80aio_write, so the remaining functionality would have to be implemented
80using threads anyway. 81using threads anyway.
81 82
82Although the module will work with in the presence of other (Perl-) 83Although the module will work in the presence of other (Perl-) threads,
83threads, it is currently not reentrant in any way, so use appropriate 84it is currently not reentrant in any way, so use appropriate locking
84locking yourself, always call C<poll_cb> from within the same thread, or 85yourself, always call C<poll_cb> from within the same thread, or never
85never call C<poll_cb> (or other C<aio_> functions) recursively. 86call C<poll_cb> (or other C<aio_> functions) recursively.
86 87
87=head2 EXAMPLE 88=head2 EXAMPLE
88 89
89This is a simple example that uses the Event module and loads 90This is a simple example that uses the Event module and loads
90F</etc/passwd> asynchronously: 91F</etc/passwd> asynchronously:
… …
98 poll => 'r', 99 poll => 'r',
99 cb => \&IO::AIO::poll_cb); 100 cb => \&IO::AIO::poll_cb);
100 101
101 # queue the request to open /etc/passwd 102 # queue the request to open /etc/passwd
102 aio_open "/etc/passwd", O_RDONLY, 0, sub { 103 aio_open "/etc/passwd", O_RDONLY, 0, sub {
103 my $fh = $_[0] 104 my $fh = shift
104 or die "error while opening: $!"; 105 or die "error while opening: $!";
105 106
106 # stat'ing filehandles is generally non-blocking 107 # stat'ing filehandles is generally non-blocking
107 my $size = -s $fh; 108 my $size = -s $fh;
108 109
… …
188use strict 'vars'; 189use strict 'vars';
189 190
190use base 'Exporter'; 191use base 'Exporter';
191 192
192BEGIN { 193BEGIN {
193 our $VERSION = '2.1'; 194 our $VERSION = '2.41';
194 195
195 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat 196 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat
196 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 197 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink
197 aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move 198 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link
198 aio_copy aio_group aio_nop aio_mknod); 199 aio_move aio_copy aio_group aio_nop aio_mknod aio_load aio_rmtree aio_mkdir
200 aio_chown aio_chmod aio_utime aio_truncate);
199 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); 201 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block));
200 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 202 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
201 min_parallel max_parallel max_idle 203 min_parallel max_parallel max_idle
202 nreqs nready npending nthreads 204 nreqs nready npending nthreads
203 max_poll_time max_poll_reqs); 205 max_poll_time max_poll_reqs);
204 206
… …
269 aio_read $_[0], ..., sub { 271 aio_read $_[0], ..., sub {
270 ... 272 ...
271 }; 273 };
272 }; 274 };
273 275
276
274=item aioreq_nice $pri_adjust 277=item aioreq_nice $pri_adjust
275 278
276Similar to C<aioreq_pri>, but subtracts the given value from the current 279Similar to C<aioreq_pri>, but subtracts the given value from the current
277priority, so the effect is cumulative. 280priority, so the effect is cumulative.
281
278 282
279=item aio_open $pathname, $flags, $mode, $callback->($fh) 283=item aio_open $pathname, $flags, $mode, $callback->($fh)
280 284
281Asynchronously open or create a file and call the callback with a newly 285Asynchronously open or create a file and call the callback with a newly
282created filehandle for the file. 286created filehandle for the file.
… …
288list. They are the same as used by C<sysopen>. 292list. They are the same as used by C<sysopen>.
289 293
290Likewise, C<$mode> specifies the mode of the newly created file, if it 294Likewise, C<$mode> specifies the mode of the newly created file, if it
291didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>, 295didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>,
292except that it is mandatory (i.e. use C<0> if you don't create new files, 296except that it is mandatory (i.e. use C<0> if you don't create new files,
293and C<0666> or C<0777> if you do). 297and C<0666> or C<0777> if you do). Note that the C<$mode> will be modified
298by the umask in effect then the request is being executed, so better never
299change the umask.
294 300
295Example: 301Example:
296 302
297 aio_open "/etc/passwd", O_RDONLY, 0, sub { 303 aio_open "/etc/passwd", O_RDONLY, 0, sub {
298 if ($_[0]) { 304 if ($_[0]) {
… …
301 } else { 307 } else {
302 die "open failed: $!\n"; 308 die "open failed: $!\n";
303 } 309 }
304 }; 310 };
305 311
312
306=item aio_close $fh, $callback->($status) 313=item aio_close $fh, $callback->($status)
307 314
308Asynchronously close a file and call the callback with the result 315Asynchronously close a file and call the callback with the result
309code. I<WARNING:> although accepted, you should not pass in a perl 316code. I<WARNING:> although accepted, you should not pass in a perl
310filehandle here, as perl will likely close the file descriptor another 317filehandle here, as perl will likely close the file descriptor another
… …
312C<close> or just let filehandles go out of scope. 319C<close> or just let filehandles go out of scope.
313 320
314This is supposed to be a bug in the API, so that might change. It's 321This is supposed to be a bug in the API, so that might change. It's
315therefore best to avoid this function. 322therefore best to avoid this function.
316 323
324
317=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 325=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
318 326
319=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 327=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
320 328
321Reads or writes C<length> bytes from the specified C<fh> and C<offset> 329Reads or writes C<$length> bytes from the specified C<$fh> and C<$offset>
322into the scalar given by C<data> and offset C<dataoffset> and calls the 330into the scalar given by C<$data> and offset C<$dataoffset> and calls the
323callback without the actual number of bytes read (or -1 on error, just 331callback without the actual number of bytes read (or -1 on error, just
324like the syscall). 332like the syscall).
325 333
334If C<$offset> is undefined, then the current file descriptor offset will
335be used (and updated), otherwise the file descriptor offset will not be
336changed by these calls.
337
338If C<$length> is undefined in C<aio_write>, use the remaining length of C<$data>.
339
340If C<$dataoffset> is less than zero, it will be counted from the end of
341C<$data>.
342
326The C<$data> scalar I<MUST NOT> be modified in any way while the request 343The C<$data> scalar I<MUST NOT> be modified in any way while the request
327is outstanding. Modifying it can result in segfaults or WW3 (if the 344is outstanding. Modifying it can result in segfaults or World War III (if
328necessary/optional hardware is installed). 345the necessary/optional hardware is installed).
329 346
330Example: Read 15 bytes at offset 7 into scalar C<$buffer>, starting at 347Example: Read 15 bytes at offset 7 into scalar C<$buffer>, starting at
331offset C<0> within the scalar: 348offset C<0> within the scalar:
332 349
333 aio_read $fh, 7, 15, $buffer, 0, sub { 350 aio_read $fh, 7, 15, $buffer, 0, sub {
334 $_[0] > 0 or die "read error: $!"; 351 $_[0] > 0 or die "read error: $!";
335 print "read $_[0] bytes: <$buffer>\n"; 352 print "read $_[0] bytes: <$buffer>\n";
336 }; 353 };
354
337 355
338=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) 356=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
339 357
340Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts 358Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts
341reading at byte offset C<$in_offset>, and starts writing at the current 359reading at byte offset C<$in_offset>, and starts writing at the current
… …
355C<$in_fh> than are written, and there is no way to find out how many 373C<$in_fh> than are written, and there is no way to find out how many
356bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only 374bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only
357provides the number of bytes written to C<$out_fh>. Only if the result 375provides the number of bytes written to C<$out_fh>. Only if the result
358value equals C<$length> one can assume that C<$length> bytes have been 376value equals C<$length> one can assume that C<$length> bytes have been
359read. 377read.
378
360 379
361=item aio_readahead $fh,$offset,$length, $callback->($retval) 380=item aio_readahead $fh,$offset,$length, $callback->($retval)
362 381
363C<aio_readahead> populates the page cache with data from a file so that 382C<aio_readahead> populates the page cache with data from a file so that
364subsequent reads from that file will not block on disk I/O. The C<$offset> 383subsequent reads from that file will not block on disk I/O. The C<$offset>
… …
370file. The current file offset of the file is left unchanged. 389file. The current file offset of the file is left unchanged.
371 390
372If that syscall doesn't exist (likely if your OS isn't Linux) it will be 391If that syscall doesn't exist (likely if your OS isn't Linux) it will be
373emulated by simply reading the data, which would have a similar effect. 392emulated by simply reading the data, which would have a similar effect.
374 393
394
375=item aio_stat $fh_or_path, $callback->($status) 395=item aio_stat $fh_or_path, $callback->($status)
376 396
377=item aio_lstat $fh, $callback->($status) 397=item aio_lstat $fh, $callback->($status)
378 398
379Works like perl's C<stat> or C<lstat> in void context. The callback will 399Works like perl's C<stat> or C<lstat> in void context. The callback will
… …
392 aio_stat "/etc/passwd", sub { 412 aio_stat "/etc/passwd", sub {
393 $_[0] and die "stat failed: $!"; 413 $_[0] and die "stat failed: $!";
394 print "size is ", -s _, "\n"; 414 print "size is ", -s _, "\n";
395 }; 415 };
396 416
417
418=item aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
419
420Works like perl's C<utime> function (including the special case of $atime
421and $mtime being undef). Fractional times are supported if the underlying
422syscalls support them.
423
424When called with a pathname, uses utimes(2) if available, otherwise
425utime(2). If called on a file descriptor, uses futimes(2) if available,
426otherwise returns ENOSYS, so this is not portable.
427
428Examples:
429
430 # set atime and mtime to current time (basically touch(1)):
431 aio_utime "path", undef, undef;
432 # set atime to current time and mtime to beginning of the epoch:
433 aio_utime "path", time, undef; # undef==0
434
435
436=item aio_chown $fh_or_path, $uid, $gid, $callback->($status)
437
438Works like perl's C<chown> function, except that C<undef> for either $uid
439or $gid is being interpreted as "do not change" (but -1 can also be used).
440
441Examples:
442
443 # same as "chown root path" in the shell:
444 aio_chown "path", 0, -1;
445 # same as above:
446 aio_chown "path", 0, undef;
447
448
449=item aio_truncate $fh_or_path, $offset, $callback->($status)
450
451Works like truncate(2) or ftruncate(2).
452
453
454=item aio_chmod $fh_or_path, $mode, $callback->($status)
455
456Works like perl's C<chmod> function.
457
458
397=item aio_unlink $pathname, $callback->($status) 459=item aio_unlink $pathname, $callback->($status)
398 460
399Asynchronously unlink (delete) a file and call the callback with the 461Asynchronously unlink (delete) a file and call the callback with the
400result code. 462result code.
401 463
464
402=item aio_mknod $path, $mode, $dev, $callback->($status) 465=item aio_mknod $path, $mode, $dev, $callback->($status)
403 466
404[EXPERIMENTAL] 467[EXPERIMENTAL]
405 468
406Asynchronously create a device node (or fifo). See mknod(2). 469Asynchronously create a device node (or fifo). See mknod(2).
407 470
408The only (POSIX-) portable way of calling this function is: 471The only (POSIX-) portable way of calling this function is:
409 472
410 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ... 473 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ...
474
411 475
412=item aio_link $srcpath, $dstpath, $callback->($status) 476=item aio_link $srcpath, $dstpath, $callback->($status)
413 477
414Asynchronously create a new link to the existing object at C<$srcpath> at 478Asynchronously create a new link to the existing object at C<$srcpath> at
415the path C<$dstpath> and call the callback with the result code. 479the path C<$dstpath> and call the callback with the result code.
416 480
481
417=item aio_symlink $srcpath, $dstpath, $callback->($status) 482=item aio_symlink $srcpath, $dstpath, $callback->($status)
418 483
419Asynchronously create a new symbolic link to the existing object at C<$srcpath> at 484Asynchronously create a new symbolic link to the existing object at C<$srcpath> at
420the path C<$dstpath> and call the callback with the result code. 485the path C<$dstpath> and call the callback with the result code.
421 486
487
488=item aio_readlink $path, $callback->($link)
489
490Asynchronously read the symlink specified by C<$path> and pass it to
491the callback. If an error occurs, nothing or undef gets passed to the
492callback.
493
494
422=item aio_rename $srcpath, $dstpath, $callback->($status) 495=item aio_rename $srcpath, $dstpath, $callback->($status)
423 496
424Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 497Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
425rename(2) and call the callback with the result code. 498rename(2) and call the callback with the result code.
426 499
500
501=item aio_mkdir $pathname, $mode, $callback->($status)
502
503Asynchronously mkdir (create) a directory and call the callback with
504the result code. C<$mode> will be modified by the umask at the time the
505request is executed, so do not change your umask.
506
507
427=item aio_rmdir $pathname, $callback->($status) 508=item aio_rmdir $pathname, $callback->($status)
428 509
429Asynchronously rmdir (delete) a directory and call the callback with the 510Asynchronously rmdir (delete) a directory and call the callback with the
430result code. 511result code.
512
431 513
432=item aio_readdir $pathname, $callback->($entries) 514=item aio_readdir $pathname, $callback->($entries)
433 515
434Unlike the POSIX call of the same name, C<aio_readdir> reads an entire 516Unlike the POSIX call of the same name, C<aio_readdir> reads an entire
435directory (i.e. opendir + readdir + closedir). The entries will not be 517directory (i.e. opendir + readdir + closedir). The entries will not be
436sorted, and will B<NOT> include the C<.> and C<..> entries. 518sorted, and will B<NOT> include the C<.> and C<..> entries.
437 519
438The callback a single argument which is either C<undef> or an array-ref 520The callback a single argument which is either C<undef> or an array-ref
439with the filenames. 521with the filenames.
522
523
524=item aio_load $path, $data, $callback->($status)
525
526This is a composite request that tries to fully load the given file into
527memory. Status is the same as with aio_read.
528
529=cut
530
531sub aio_load($$;$) {
532 aio_block {
533 my ($path, undef, $cb) = @_;
534 my $data = \$_[1];
535
536 my $pri = aioreq_pri;
537 my $grp = aio_group $cb;
538
539 aioreq_pri $pri;
540 add $grp aio_open $path, O_RDONLY, 0, sub {
541 my $fh = shift
542 or return $grp->result (-1);
543
544 aioreq_pri $pri;
545 add $grp aio_read $fh, 0, (-s $fh), $$data, 0, sub {
546 $grp->result ($_[0]);
547 };
548 };
549
550 $grp
551 }
552}
440 553
441=item aio_copy $srcpath, $dstpath, $callback->($status) 554=item aio_copy $srcpath, $dstpath, $callback->($status)
442 555
443Try to copy the I<file> (directories not supported as either source or 556Try to copy the I<file> (directories not supported as either source or
444destination) from C<$srcpath> to C<$dstpath> and call the callback with 557destination) from C<$srcpath> to C<$dstpath> and call the callback with
… …
454errors are being ignored. 567errors are being ignored.
455 568
456=cut 569=cut
457 570
458sub aio_copy($$;$) { 571sub aio_copy($$;$) {
572 aio_block {
459 my ($src, $dst, $cb) = @_; 573 my ($src, $dst, $cb) = @_;
460 574
461 my $pri = aioreq_pri; 575 my $pri = aioreq_pri;
462 my $grp = aio_group $cb; 576 my $grp = aio_group $cb;
463 577
464 aioreq_pri $pri; 578 aioreq_pri $pri;
465 add $grp aio_open $src, O_RDONLY, 0, sub { 579 add $grp aio_open $src, O_RDONLY, 0, sub {
466 if (my $src_fh = $_[0]) { 580 if (my $src_fh = $_[0]) {
467 my @stat = stat $src_fh; 581 my @stat = stat $src_fh;
468 582
469 aioreq_pri $pri; 583 aioreq_pri $pri;
470 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { 584 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
471 if (my $dst_fh = $_[0]) { 585 if (my $dst_fh = $_[0]) {
472 aioreq_pri $pri; 586 aioreq_pri $pri;
473 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub { 587 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
474 if ($_[0] == $stat[7]) { 588 if ($_[0] == $stat[7]) {
475 $grp->result (0); 589 $grp->result (0);
476 close $src_fh; 590 close $src_fh;
477 591
478 # those should not normally block. should. should. 592 # those should not normally block. should. should.
479 utime $stat[8], $stat[9], $dst; 593 utime $stat[8], $stat[9], $dst;
480 chmod $stat[2] & 07777, $dst_fh; 594 chmod $stat[2] & 07777, $dst_fh;
481 chown $stat[4], $stat[5], $dst_fh; 595 chown $stat[4], $stat[5], $dst_fh;
482 close $dst_fh; 596 close $dst_fh;
483 } else { 597 } else {
484 $grp->result (-1); 598 $grp->result (-1);
485 close $src_fh; 599 close $src_fh;
486 close $dst_fh; 600 close $dst_fh;
487 601
488 aioreq $pri; 602 aioreq $pri;
489 add $grp aio_unlink $dst; 603 add $grp aio_unlink $dst;
604 }
490 } 605 };
606 } else {
607 $grp->result (-1);
491 }; 608 }
492 } else {
493 $grp->result (-1);
494 } 609 },
610
611 } else {
612 $grp->result (-1);
495 }, 613 }
496
497 } else {
498 $grp->result (-1);
499 } 614 };
615
616 $grp
500 }; 617 }
501
502 $grp
503} 618}
504 619
505=item aio_move $srcpath, $dstpath, $callback->($status) 620=item aio_move $srcpath, $dstpath, $callback->($status)
506 621
507Try to move the I<file> (directories not supported as either source or 622Try to move the I<file> (directories not supported as either source or
… …
513that is successful, unlinking the C<$srcpath>. 628that is successful, unlinking the C<$srcpath>.
514 629
515=cut 630=cut
516 631
517sub aio_move($$;$) { 632sub aio_move($$;$) {
633 aio_block {
518 my ($src, $dst, $cb) = @_; 634 my ($src, $dst, $cb) = @_;
519 635
520 my $pri = aioreq_pri; 636 my $pri = aioreq_pri;
521 my $grp = aio_group $cb; 637 my $grp = aio_group $cb;
522 638
523 aioreq_pri $pri; 639 aioreq_pri $pri;
524 add $grp aio_rename $src, $dst, sub { 640 add $grp aio_rename $src, $dst, sub {
525 if ($_[0] && $! == EXDEV) { 641 if ($_[0] && $! == EXDEV) {
526 aioreq_pri $pri; 642 aioreq_pri $pri;
527 add $grp aio_copy $src, $dst, sub { 643 add $grp aio_copy $src, $dst, sub {
644 $grp->result ($_[0]);
645
646 if (!$_[0]) {
647 aioreq_pri $pri;
648 add $grp aio_unlink $src;
649 }
650 };
651 } else {
528 $grp->result ($_[0]); 652 $grp->result ($_[0]);
529
530 if (!$_[0]) {
531 aioreq_pri $pri;
532 add $grp aio_unlink $src;
533 }
534 }; 653 }
535 } else {
536 $grp->result ($_[0]);
537 } 654 };
655
656 $grp
538 }; 657 }
539
540 $grp
541} 658}
542 659
543=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) 660=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
544 661
545Scans a directory (similar to C<aio_readdir>) but additionally tries to 662Scans a directory (similar to C<aio_readdir>) but additionally tries to
… …
592as those tend to return 0 or 1 as link counts, which disables the 709as those tend to return 0 or 1 as link counts, which disables the
593directory counting heuristic. 710directory counting heuristic.
594 711
595=cut 712=cut
596 713
597sub aio_scandir($$$) { 714sub aio_scandir($$;$) {
715 aio_block {
598 my ($path, $maxreq, $cb) = @_; 716 my ($path, $maxreq, $cb) = @_;
599 717
600 my $pri = aioreq_pri; 718 my $pri = aioreq_pri;
601 719
602 my $grp = aio_group $cb; 720 my $grp = aio_group $cb;
603 721
604 $maxreq = 4 if $maxreq <= 0; 722 $maxreq = 4 if $maxreq <= 0;
605 723
606 # stat once 724 # stat once
607 aioreq_pri $pri;
608 add $grp aio_stat $path, sub {
609 return $grp->result () if $_[0];
610 my $now = time;
611 my $hash1 = join ":", (stat _)[0,1,3,7,9];
612
613 # read the directory entries
614 aioreq_pri $pri; 725 aioreq_pri $pri;
615 add $grp aio_readdir $path, sub { 726 add $grp aio_stat $path, sub {
616 my $entries = shift
617 or return $grp->result (); 727 return $grp->result () if $_[0];
728 my $now = time;
729 my $hash1 = join ":", (stat _)[0,1,3,7,9];
618 730
619 # stat the dir another time 731 # read the directory entries
620 aioreq_pri $pri; 732 aioreq_pri $pri;
733 add $grp aio_readdir $path, sub {
734 my $entries = shift
735 or return $grp->result ();
736
737 # stat the dir another time
738 aioreq_pri $pri;
621 add $grp aio_stat $path, sub { 739 add $grp aio_stat $path, sub {
622 my $hash2 = join ":", (stat _)[0,1,3,7,9]; 740 my $hash2 = join ":", (stat _)[0,1,3,7,9];
623 741
624 my $ndirs; 742 my $ndirs;
625 743
626 # take the slow route if anything looks fishy 744 # take the slow route if anything looks fishy
627 if ($hash1 ne $hash2 or (stat _)[9] == $now) { 745 if ($hash1 ne $hash2 or (stat _)[9] == $now) {
628 $ndirs = -1; 746 $ndirs = -1;
629 } else { 747 } else {
630 # if nlink == 2, we are finished 748 # if nlink == 2, we are finished
631 # on non-posix-fs's, we rely on nlink < 2 749 # on non-posix-fs's, we rely on nlink < 2
632 $ndirs = (stat _)[3] - 2 750 $ndirs = (stat _)[3] - 2
633 or return $grp->result ([], $entries); 751 or return $grp->result ([], $entries);
634 } 752 }
635 753
636 # sort into likely dirs and likely nondirs 754 # sort into likely dirs and likely nondirs
637 # dirs == files without ".", short entries first 755 # dirs == files without ".", short entries first
638 $entries = [map $_->[0], 756 $entries = [map $_->[0],
639 sort { $b->[1] cmp $a->[1] } 757 sort { $b->[1] cmp $a->[1] }
640 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length], 758 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length],
641 @$entries]; 759 @$entries];
642 760
643 my (@dirs, @nondirs); 761 my (@dirs, @nondirs);
644 762
645 my $statgrp = add $grp aio_group sub { 763 my $statgrp = add $grp aio_group sub {
646 $grp->result (\@dirs, \@nondirs); 764 $grp->result (\@dirs, \@nondirs);
647 }; 765 };
648 766
649 limit $statgrp $maxreq; 767 limit $statgrp $maxreq;
650 feed $statgrp sub { 768 feed $statgrp sub {
651 return unless @$entries; 769 return unless @$entries;
652 my $entry = pop @$entries; 770 my $entry = pop @$entries;
653 771
654 aioreq_pri $pri; 772 aioreq_pri $pri;
655 add $statgrp aio_stat "$path/$entry/.", sub { 773 add $statgrp aio_stat "$path/$entry/.", sub {
656 if ($_[0] < 0) { 774 if ($_[0] < 0) {
657 push @nondirs, $entry; 775 push @nondirs, $entry;
658 } else { 776 } else {
659 # need to check for real directory 777 # need to check for real directory
660 aioreq_pri $pri; 778 aioreq_pri $pri;
661 add $statgrp aio_lstat "$path/$entry", sub { 779 add $statgrp aio_lstat "$path/$entry", sub {
662 if (-d _) { 780 if (-d _) {
663 push @dirs, $entry; 781 push @dirs, $entry;
664 782
665 unless (--$ndirs) { 783 unless (--$ndirs) {
666 push @nondirs, @$entries; 784 push @nondirs, @$entries;
667 feed $statgrp; 785 feed $statgrp;
786 }
787 } else {
788 push @nondirs, $entry;
668 } 789 }
669 } else {
670 push @nondirs, $entry;
671 } 790 }
672 } 791 }
673 } 792 };
674 }; 793 };
675 }; 794 };
676 }; 795 };
677 }; 796 };
797
798 $grp
678 }; 799 }
800}
679 801
802=item aio_rmtree $path, $callback->($status)
803
804Delete a directory tree starting (and including) C<$path>, return the
805status of the final C<rmdir> only. This is a composite request that
806uses C<aio_scandir> to recurse into and rmdir directories, and unlink
807everything else.
808
809=cut
810
811sub aio_rmtree;
812sub aio_rmtree($;$) {
813 aio_block {
814 my ($path, $cb) = @_;
815
816 my $pri = aioreq_pri;
817 my $grp = aio_group $cb;
818
819 aioreq_pri $pri;
820 add $grp aio_scandir $path, 0, sub {
821 my ($dirs, $nondirs) = @_;
822
823 my $dirgrp = aio_group sub {
824 add $grp aio_rmdir $path, sub {
825 $grp->result ($_[0]);
826 };
827 };
828
829 (aioreq_pri $pri), add $dirgrp aio_rmtree "$path/$_" for @$dirs;
830 (aioreq_pri $pri), add $dirgrp aio_unlink "$path/$_" for @$nondirs;
831
832 add $grp $dirgrp;
833 };
834
680 $grp 835 $grp
836 }
681} 837}
682 838
683=item aio_fsync $fh, $callback->($status) 839=item aio_fsync $fh, $callback->($status)
684 840
685Asynchronously call fsync on the given filehandle and call the callback 841Asynchronously call fsync on the given filehandle and call the callback
… …
964 poll => 'r', nice => 1, 1120 poll => 'r', nice => 1,
965 cb => &IO::AIO::poll_cb); 1121 cb => &IO::AIO::poll_cb);
966 1122
967=item IO::AIO::poll_wait 1123=item IO::AIO::poll_wait
968 1124
1125If there are any outstanding requests and none of them in the result
969Wait till the result filehandle becomes ready for reading (simply does a 1126phase, wait till the result filehandle becomes ready for reading (simply
970C<select> on the filehandle. This is useful if you want to synchronously 1127does a C<select> on the filehandle. This is useful if you want to
971wait for some requests to finish). 1128synchronously wait for some requests to finish).
972 1129
973See C<nreqs> for an example. 1130See C<nreqs> for an example.
974 1131
975=item IO::AIO::poll 1132=item IO::AIO::poll
976 1133
977Waits until some requests have been handled. 1134Waits until some requests have been handled.
978 1135
1136Returns the number of requests processed, but is otherwise strictly
979Strictly equivalent to: 1137equivalent to:
980 1138
981 IO::AIO::poll_wait, IO::AIO::poll_cb 1139 IO::AIO::poll_wait, IO::AIO::poll_cb
982 if IO::AIO::nreqs;
983 1140
984=item IO::AIO::flush 1141=item IO::AIO::flush
985 1142
986Wait till all outstanding AIO requests have been handled. 1143Wait till all outstanding AIO requests have been handled.
987 1144
988Strictly equivalent to: 1145Strictly equivalent to:
989 1146
990 IO::AIO::poll_wait, IO::AIO::poll_cb 1147 IO::AIO::poll_wait, IO::AIO::poll_cb
991 while IO::AIO::nreqs; 1148 while IO::AIO::nreqs;
992 1149
1150=back
1151
993=head3 CONTROLLING THE NUMBER OF THREADS 1152=head3 CONTROLLING THE NUMBER OF THREADS
1153
1154=over
994 1155
995=item IO::AIO::min_parallel $nthreads 1156=item IO::AIO::min_parallel $nthreads
996 1157
997Set the minimum number of AIO threads to C<$nthreads>. The current 1158Set the minimum number of AIO threads to C<$nthreads>. The current
998default is C<8>, which means eight asynchronous operations can execute 1159default is C<8>, which means eight asynchronous operations can execute
… …
1046This is a very bad function to use in interactive programs because it 1207This is a very bad function to use in interactive programs because it
1047blocks, and a bad way to reduce concurrency because it is inexact: Better 1208blocks, and a bad way to reduce concurrency because it is inexact: Better
1048use an C<aio_group> together with a feed callback. 1209use an C<aio_group> together with a feed callback.
1049 1210
1050Sets the maximum number of outstanding requests to C<$nreqs>. If you 1211Sets the maximum number of outstanding requests to C<$nreqs>. If you
1051to queue up more than this number of requests, the next call to the 1212do queue up more than this number of requests, the next call to the
1052C<poll_cb> (and C<poll_some> and other functions calling C<poll_cb>) 1213C<poll_cb> (and C<poll_some> and other functions calling C<poll_cb>)
1053function will block until the limit is no longer exceeded. 1214function will block until the limit is no longer exceeded.
1054 1215
1055The default value is very large, so there is no practical limit on the 1216The default value is very large, so there is no practical limit on the
1056number of outstanding requests. 1217number of outstanding requests.
1057 1218
1058You can still queue as many requests as you want. Therefore, 1219You can still queue as many requests as you want. Therefore,
1059C<max_oustsanding> is mainly useful in simple scripts (with low values) or 1220C<max_oustsanding> is mainly useful in simple scripts (with low values) or
1060as a stop gap to shield against fatal memory overflow (with large values). 1221as a stop gap to shield against fatal memory overflow (with large values).
1061 1222
1223=back
1224
1062=head3 STATISTICAL INFORMATION 1225=head3 STATISTICAL INFORMATION
1226
1227=over
1063 1228
1064=item IO::AIO::nreqs 1229=item IO::AIO::nreqs
1065 1230
1066Returns the number of requests currently in the ready, execute or pending 1231Returns the number of requests currently in the ready, execute or pending
1067states (i.e. for which their callback has not been invoked yet). 1232states (i.e. for which their callback has not been invoked yet).
… …
1101 *$sym 1266 *$sym
1102} 1267}
1103 1268
1104min_parallel 8; 1269min_parallel 8;
1105 1270
1106END { 1271END { flush }
1107 min_parallel 1;
1108 flush;
1109};
1110 1272
11111; 12731;
1112 1274
1113=head2 FORK BEHAVIOUR 1275=head2 FORK BEHAVIOUR
1114 1276
… …
1134bytes of memory. In addition, stat requests need a stat buffer (possibly 1296bytes of memory. In addition, stat requests need a stat buffer (possibly
1135a few hundred bytes), readdir requires a result buffer and so on. Perl 1297a few hundred bytes), readdir requires a result buffer and so on. Perl
1136scalars and other data passed into aio requests will also be locked and 1298scalars and other data passed into aio requests will also be locked and
1137will consume memory till the request has entered the done state. 1299will consume memory till the request has entered the done state.
1138 1300
1139This is now awfully much, so queuing lots of requests is not usually a 1301This is not awfully much, so queuing lots of requests is not usually a
1140problem. 1302problem.
1141 1303
1142Per-thread usage: 1304Per-thread usage:
1143 1305
1144In the execution phase, some aio requests require more memory for 1306In the execution phase, some aio requests require more memory for

Diff Legend

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