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.91 by root, Mon Oct 30 23:30:29 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 most of this works on all types of file descriptors (for example 67While most of this works on all types of file descriptors (for
67sockets), using these functions on file descriptors that support 68example sockets), using these functions on file descriptors that
68nonblocking operation (again, sockets, pipes etc.) is very inefficient or 69support nonblocking operation (again, sockets, pipes etc.) is very
69might not work (aio_read fails on sockets/pipes/fifos). Use an event loop 70inefficient. Use an event loop for that (such as the L<Event|Event>
70for that (such as the L<Event|Event> module): IO::AIO will naturally fit 71module): IO::AIO will naturally fit into such an event loop itself.
71into such an event loop itself.
72 72
73In this version, a number of threads are started that execute your 73In this version, a number of threads are started that execute your
74requests and signal their completion. You don't need thread support 74requests and signal their completion. You don't need thread support
75in 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
76to 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
… …
78not 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
79files currently, for example), and they would only support aio_read and 79files currently, for example), and they would only support aio_read and
80aio_write, so the remaining functionality would have to be implemented 80aio_write, so the remaining functionality would have to be implemented
81using threads anyway. 81using threads anyway.
82 82
83Although the module will work with in the presence of other (Perl-) 83Although the module will work in the presence of other (Perl-) threads,
84threads, it is currently not reentrant in any way, so use appropriate 84it is currently not reentrant in any way, so use appropriate locking
85locking 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
86never call C<poll_cb> (or other C<aio_> functions) recursively. 86call C<poll_cb> (or other C<aio_> functions) recursively.
87 87
88=head2 EXAMPLE 88=head2 EXAMPLE
89 89
90This is a simple example that uses the Event module and loads 90This is a simple example that uses the Event module and loads
91F</etc/passwd> asynchronously: 91F</etc/passwd> asynchronously:
… …
99 poll => 'r', 99 poll => 'r',
100 cb => \&IO::AIO::poll_cb); 100 cb => \&IO::AIO::poll_cb);
101 101
102 # queue the request to open /etc/passwd 102 # queue the request to open /etc/passwd
103 aio_open "/etc/passwd", O_RDONLY, 0, sub { 103 aio_open "/etc/passwd", O_RDONLY, 0, sub {
104 my $fh = $_[0] 104 my $fh = shift
105 or die "error while opening: $!"; 105 or die "error while opening: $!";
106 106
107 # stat'ing filehandles is generally non-blocking 107 # stat'ing filehandles is generally non-blocking
108 my $size = -s $fh; 108 my $size = -s $fh;
109 109
… …
189use strict 'vars'; 189use strict 'vars';
190 190
191use base 'Exporter'; 191use base 'Exporter';
192 192
193BEGIN { 193BEGIN {
194 our $VERSION = '2.2'; 194 our $VERSION = '2.41';
195 195
196 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
197 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
198 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link 198 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link
199 aio_move 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);
200 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); 201 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block));
201 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 202 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
202 min_parallel max_parallel max_idle 203 min_parallel max_parallel max_idle
203 nreqs nready npending nthreads 204 nreqs nready npending nthreads
204 max_poll_time max_poll_reqs); 205 max_poll_time max_poll_reqs);
205 206
… …
270 aio_read $_[0], ..., sub { 271 aio_read $_[0], ..., sub {
271 ... 272 ...
272 }; 273 };
273 }; 274 };
274 275
276
275=item aioreq_nice $pri_adjust 277=item aioreq_nice $pri_adjust
276 278
277Similar 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
278priority, so the effect is cumulative. 280priority, so the effect is cumulative.
281
279 282
280=item aio_open $pathname, $flags, $mode, $callback->($fh) 283=item aio_open $pathname, $flags, $mode, $callback->($fh)
281 284
282Asynchronously 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
283created filehandle for the file. 286created filehandle for the file.
… …
289list. They are the same as used by C<sysopen>. 292list. They are the same as used by C<sysopen>.
290 293
291Likewise, 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
292didn'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>,
293except 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,
294and 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.
295 300
296Example: 301Example:
297 302
298 aio_open "/etc/passwd", O_RDONLY, 0, sub { 303 aio_open "/etc/passwd", O_RDONLY, 0, sub {
299 if ($_[0]) { 304 if ($_[0]) {
… …
302 } else { 307 } else {
303 die "open failed: $!\n"; 308 die "open failed: $!\n";
304 } 309 }
305 }; 310 };
306 311
312
307=item aio_close $fh, $callback->($status) 313=item aio_close $fh, $callback->($status)
308 314
309Asynchronously close a file and call the callback with the result 315Asynchronously close a file and call the callback with the result
310code. I<WARNING:> although accepted, you should not pass in a perl 316code. I<WARNING:> although accepted, you should not pass in a perl
311filehandle here, as perl will likely close the file descriptor another 317filehandle here, as perl will likely close the file descriptor another
… …
313C<close> or just let filehandles go out of scope. 319C<close> or just let filehandles go out of scope.
314 320
315This 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
316therefore best to avoid this function. 322therefore best to avoid this function.
317 323
324
318=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 325=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
319 326
320=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 327=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
321 328
322Reads 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>
323into 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
324callback 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
325like the syscall). 332like the syscall).
326 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
327The 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
328is outstanding. Modifying it can result in segfaults or WW3 (if the 344is outstanding. Modifying it can result in segfaults or World War III (if
329necessary/optional hardware is installed). 345the necessary/optional hardware is installed).
330 346
331Example: 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
332offset C<0> within the scalar: 348offset C<0> within the scalar:
333 349
334 aio_read $fh, 7, 15, $buffer, 0, sub { 350 aio_read $fh, 7, 15, $buffer, 0, sub {
335 $_[0] > 0 or die "read error: $!"; 351 $_[0] > 0 or die "read error: $!";
336 print "read $_[0] bytes: <$buffer>\n"; 352 print "read $_[0] bytes: <$buffer>\n";
337 }; 353 };
354
338 355
339=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)
340 357
341Tries 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
342reading 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
… …
356C<$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
357bytes 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
358provides 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
359value 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
360read. 377read.
378
361 379
362=item aio_readahead $fh,$offset,$length, $callback->($retval) 380=item aio_readahead $fh,$offset,$length, $callback->($retval)
363 381
364C<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
365subsequent 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>
… …
371file. The current file offset of the file is left unchanged. 389file. The current file offset of the file is left unchanged.
372 390
373If 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
374emulated by simply reading the data, which would have a similar effect. 392emulated by simply reading the data, which would have a similar effect.
375 393
394
376=item aio_stat $fh_or_path, $callback->($status) 395=item aio_stat $fh_or_path, $callback->($status)
377 396
378=item aio_lstat $fh, $callback->($status) 397=item aio_lstat $fh, $callback->($status)
379 398
380Works 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
… …
393 aio_stat "/etc/passwd", sub { 412 aio_stat "/etc/passwd", sub {
394 $_[0] and die "stat failed: $!"; 413 $_[0] and die "stat failed: $!";
395 print "size is ", -s _, "\n"; 414 print "size is ", -s _, "\n";
396 }; 415 };
397 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
398=item aio_unlink $pathname, $callback->($status) 459=item aio_unlink $pathname, $callback->($status)
399 460
400Asynchronously unlink (delete) a file and call the callback with the 461Asynchronously unlink (delete) a file and call the callback with the
401result code. 462result code.
402 463
464
403=item aio_mknod $path, $mode, $dev, $callback->($status) 465=item aio_mknod $path, $mode, $dev, $callback->($status)
404 466
405[EXPERIMENTAL] 467[EXPERIMENTAL]
406 468
407Asynchronously create a device node (or fifo). See mknod(2). 469Asynchronously create a device node (or fifo). See mknod(2).
408 470
409The only (POSIX-) portable way of calling this function is: 471The only (POSIX-) portable way of calling this function is:
410 472
411 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ... 473 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ...
474
412 475
413=item aio_link $srcpath, $dstpath, $callback->($status) 476=item aio_link $srcpath, $dstpath, $callback->($status)
414 477
415Asynchronously 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
416the path C<$dstpath> and call the callback with the result code. 479the path C<$dstpath> and call the callback with the result code.
417 480
481
418=item aio_symlink $srcpath, $dstpath, $callback->($status) 482=item aio_symlink $srcpath, $dstpath, $callback->($status)
419 483
420Asynchronously 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
421the path C<$dstpath> and call the callback with the result code. 485the path C<$dstpath> and call the callback with the result code.
486
422 487
423=item aio_readlink $path, $callback->($link) 488=item aio_readlink $path, $callback->($link)
424 489
425Asynchronously read the symlink specified by C<$path> and pass it to 490Asynchronously read the symlink specified by C<$path> and pass it to
426the callback. If an error occurs, nothing or undef gets passed to the 491the callback. If an error occurs, nothing or undef gets passed to the
427callback. 492callback.
428 493
494
429=item aio_rename $srcpath, $dstpath, $callback->($status) 495=item aio_rename $srcpath, $dstpath, $callback->($status)
430 496
431Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 497Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
432rename(2) and call the callback with the result code. 498rename(2) and call the callback with the result code.
433 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
434=item aio_rmdir $pathname, $callback->($status) 508=item aio_rmdir $pathname, $callback->($status)
435 509
436Asynchronously rmdir (delete) a directory and call the callback with the 510Asynchronously rmdir (delete) a directory and call the callback with the
437result code. 511result code.
512
438 513
439=item aio_readdir $pathname, $callback->($entries) 514=item aio_readdir $pathname, $callback->($entries)
440 515
441Unlike 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
442directory (i.e. opendir + readdir + closedir). The entries will not be 517directory (i.e. opendir + readdir + closedir). The entries will not be
443sorted, and will B<NOT> include the C<.> and C<..> entries. 518sorted, and will B<NOT> include the C<.> and C<..> entries.
444 519
445The 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
446with 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}
447 553
448=item aio_copy $srcpath, $dstpath, $callback->($status) 554=item aio_copy $srcpath, $dstpath, $callback->($status)
449 555
450Try 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
451destination) from C<$srcpath> to C<$dstpath> and call the callback with 557destination) from C<$srcpath> to C<$dstpath> and call the callback with
… …
461errors are being ignored. 567errors are being ignored.
462 568
463=cut 569=cut
464 570
465sub aio_copy($$;$) { 571sub aio_copy($$;$) {
572 aio_block {
466 my ($src, $dst, $cb) = @_; 573 my ($src, $dst, $cb) = @_;
467 574
468 my $pri = aioreq_pri; 575 my $pri = aioreq_pri;
469 my $grp = aio_group $cb; 576 my $grp = aio_group $cb;
470 577
471 aioreq_pri $pri; 578 aioreq_pri $pri;
472 add $grp aio_open $src, O_RDONLY, 0, sub { 579 add $grp aio_open $src, O_RDONLY, 0, sub {
473 if (my $src_fh = $_[0]) { 580 if (my $src_fh = $_[0]) {
474 my @stat = stat $src_fh; 581 my @stat = stat $src_fh;
475 582
476 aioreq_pri $pri; 583 aioreq_pri $pri;
477 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 {
478 if (my $dst_fh = $_[0]) { 585 if (my $dst_fh = $_[0]) {
479 aioreq_pri $pri; 586 aioreq_pri $pri;
480 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 {
481 if ($_[0] == $stat[7]) { 588 if ($_[0] == $stat[7]) {
482 $grp->result (0); 589 $grp->result (0);
483 close $src_fh; 590 close $src_fh;
484 591
485 # those should not normally block. should. should. 592 # those should not normally block. should. should.
486 utime $stat[8], $stat[9], $dst; 593 utime $stat[8], $stat[9], $dst;
487 chmod $stat[2] & 07777, $dst_fh; 594 chmod $stat[2] & 07777, $dst_fh;
488 chown $stat[4], $stat[5], $dst_fh; 595 chown $stat[4], $stat[5], $dst_fh;
489 close $dst_fh; 596 close $dst_fh;
490 } else { 597 } else {
491 $grp->result (-1); 598 $grp->result (-1);
492 close $src_fh; 599 close $src_fh;
493 close $dst_fh; 600 close $dst_fh;
494 601
495 aioreq $pri; 602 aioreq $pri;
496 add $grp aio_unlink $dst; 603 add $grp aio_unlink $dst;
604 }
497 } 605 };
606 } else {
607 $grp->result (-1);
498 }; 608 }
499 } else {
500 $grp->result (-1);
501 } 609 },
610
611 } else {
612 $grp->result (-1);
502 }, 613 }
503
504 } else {
505 $grp->result (-1);
506 } 614 };
615
616 $grp
507 }; 617 }
508
509 $grp
510} 618}
511 619
512=item aio_move $srcpath, $dstpath, $callback->($status) 620=item aio_move $srcpath, $dstpath, $callback->($status)
513 621
514Try 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
… …
520that is successful, unlinking the C<$srcpath>. 628that is successful, unlinking the C<$srcpath>.
521 629
522=cut 630=cut
523 631
524sub aio_move($$;$) { 632sub aio_move($$;$) {
633 aio_block {
525 my ($src, $dst, $cb) = @_; 634 my ($src, $dst, $cb) = @_;
526 635
527 my $pri = aioreq_pri; 636 my $pri = aioreq_pri;
528 my $grp = aio_group $cb; 637 my $grp = aio_group $cb;
529 638
530 aioreq_pri $pri; 639 aioreq_pri $pri;
531 add $grp aio_rename $src, $dst, sub { 640 add $grp aio_rename $src, $dst, sub {
532 if ($_[0] && $! == EXDEV) { 641 if ($_[0] && $! == EXDEV) {
533 aioreq_pri $pri; 642 aioreq_pri $pri;
534 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 {
535 $grp->result ($_[0]); 652 $grp->result ($_[0]);
536
537 if (!$_[0]) {
538 aioreq_pri $pri;
539 add $grp aio_unlink $src;
540 }
541 }; 653 }
542 } else {
543 $grp->result ($_[0]);
544 } 654 };
655
656 $grp
545 }; 657 }
546
547 $grp
548} 658}
549 659
550=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) 660=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
551 661
552Scans a directory (similar to C<aio_readdir>) but additionally tries to 662Scans a directory (similar to C<aio_readdir>) but additionally tries to
… …
599as 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
600directory counting heuristic. 710directory counting heuristic.
601 711
602=cut 712=cut
603 713
604sub aio_scandir($$$) { 714sub aio_scandir($$;$) {
715 aio_block {
605 my ($path, $maxreq, $cb) = @_; 716 my ($path, $maxreq, $cb) = @_;
606 717
607 my $pri = aioreq_pri; 718 my $pri = aioreq_pri;
608 719
609 my $grp = aio_group $cb; 720 my $grp = aio_group $cb;
610 721
611 $maxreq = 4 if $maxreq <= 0; 722 $maxreq = 4 if $maxreq <= 0;
612 723
613 # stat once 724 # stat once
614 aioreq_pri $pri;
615 add $grp aio_stat $path, sub {
616 return $grp->result () if $_[0];
617 my $now = time;
618 my $hash1 = join ":", (stat _)[0,1,3,7,9];
619
620 # read the directory entries
621 aioreq_pri $pri; 725 aioreq_pri $pri;
622 add $grp aio_readdir $path, sub { 726 add $grp aio_stat $path, sub {
623 my $entries = shift
624 or return $grp->result (); 727 return $grp->result () if $_[0];
728 my $now = time;
729 my $hash1 = join ":", (stat _)[0,1,3,7,9];
625 730
626 # stat the dir another time 731 # read the directory entries
627 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;
628 add $grp aio_stat $path, sub { 739 add $grp aio_stat $path, sub {
629 my $hash2 = join ":", (stat _)[0,1,3,7,9]; 740 my $hash2 = join ":", (stat _)[0,1,3,7,9];
630 741
631 my $ndirs; 742 my $ndirs;
632 743
633 # take the slow route if anything looks fishy 744 # take the slow route if anything looks fishy
634 if ($hash1 ne $hash2 or (stat _)[9] == $now) { 745 if ($hash1 ne $hash2 or (stat _)[9] == $now) {
635 $ndirs = -1; 746 $ndirs = -1;
636 } else { 747 } else {
637 # if nlink == 2, we are finished 748 # if nlink == 2, we are finished
638 # on non-posix-fs's, we rely on nlink < 2 749 # on non-posix-fs's, we rely on nlink < 2
639 $ndirs = (stat _)[3] - 2 750 $ndirs = (stat _)[3] - 2
640 or return $grp->result ([], $entries); 751 or return $grp->result ([], $entries);
641 } 752 }
642 753
643 # sort into likely dirs and likely nondirs 754 # sort into likely dirs and likely nondirs
644 # dirs == files without ".", short entries first 755 # dirs == files without ".", short entries first
645 $entries = [map $_->[0], 756 $entries = [map $_->[0],
646 sort { $b->[1] cmp $a->[1] } 757 sort { $b->[1] cmp $a->[1] }
647 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length], 758 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length],
648 @$entries]; 759 @$entries];
649 760
650 my (@dirs, @nondirs); 761 my (@dirs, @nondirs);
651 762
652 my $statgrp = add $grp aio_group sub { 763 my $statgrp = add $grp aio_group sub {
653 $grp->result (\@dirs, \@nondirs); 764 $grp->result (\@dirs, \@nondirs);
654 }; 765 };
655 766
656 limit $statgrp $maxreq; 767 limit $statgrp $maxreq;
657 feed $statgrp sub { 768 feed $statgrp sub {
658 return unless @$entries; 769 return unless @$entries;
659 my $entry = pop @$entries; 770 my $entry = pop @$entries;
660 771
661 aioreq_pri $pri; 772 aioreq_pri $pri;
662 add $statgrp aio_stat "$path/$entry/.", sub { 773 add $statgrp aio_stat "$path/$entry/.", sub {
663 if ($_[0] < 0) { 774 if ($_[0] < 0) {
664 push @nondirs, $entry; 775 push @nondirs, $entry;
665 } else { 776 } else {
666 # need to check for real directory 777 # need to check for real directory
667 aioreq_pri $pri; 778 aioreq_pri $pri;
668 add $statgrp aio_lstat "$path/$entry", sub { 779 add $statgrp aio_lstat "$path/$entry", sub {
669 if (-d _) { 780 if (-d _) {
670 push @dirs, $entry; 781 push @dirs, $entry;
671 782
672 unless (--$ndirs) { 783 unless (--$ndirs) {
673 push @nondirs, @$entries; 784 push @nondirs, @$entries;
674 feed $statgrp; 785 feed $statgrp;
786 }
787 } else {
788 push @nondirs, $entry;
675 } 789 }
676 } else {
677 push @nondirs, $entry;
678 } 790 }
679 } 791 }
680 } 792 };
681 }; 793 };
682 }; 794 };
683 }; 795 };
684 }; 796 };
797
798 $grp
685 }; 799 }
800}
686 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
687 $grp 835 $grp
836 }
688} 837}
689 838
690=item aio_fsync $fh, $callback->($status) 839=item aio_fsync $fh, $callback->($status)
691 840
692Asynchronously call fsync on the given filehandle and call the callback 841Asynchronously call fsync on the given filehandle and call the callback
… …
971 poll => 'r', nice => 1, 1120 poll => 'r', nice => 1,
972 cb => &IO::AIO::poll_cb); 1121 cb => &IO::AIO::poll_cb);
973 1122
974=item IO::AIO::poll_wait 1123=item IO::AIO::poll_wait
975 1124
1125If there are any outstanding requests and none of them in the result
976Wait till the result filehandle becomes ready for reading (simply does a 1126phase, wait till the result filehandle becomes ready for reading (simply
977C<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
978wait for some requests to finish). 1128synchronously wait for some requests to finish).
979 1129
980See C<nreqs> for an example. 1130See C<nreqs> for an example.
981 1131
982=item IO::AIO::poll 1132=item IO::AIO::poll
983 1133
984Waits until some requests have been handled. 1134Waits until some requests have been handled.
985 1135
1136Returns the number of requests processed, but is otherwise strictly
986Strictly equivalent to: 1137equivalent to:
987 1138
988 IO::AIO::poll_wait, IO::AIO::poll_cb 1139 IO::AIO::poll_wait, IO::AIO::poll_cb
989 if IO::AIO::nreqs;
990 1140
991=item IO::AIO::flush 1141=item IO::AIO::flush
992 1142
993Wait till all outstanding AIO requests have been handled. 1143Wait till all outstanding AIO requests have been handled.
994 1144
995Strictly equivalent to: 1145Strictly equivalent to:
996 1146
997 IO::AIO::poll_wait, IO::AIO::poll_cb 1147 IO::AIO::poll_wait, IO::AIO::poll_cb
998 while IO::AIO::nreqs; 1148 while IO::AIO::nreqs;
999 1149
1150=back
1151
1000=head3 CONTROLLING THE NUMBER OF THREADS 1152=head3 CONTROLLING THE NUMBER OF THREADS
1153
1154=over
1001 1155
1002=item IO::AIO::min_parallel $nthreads 1156=item IO::AIO::min_parallel $nthreads
1003 1157
1004Set the minimum number of AIO threads to C<$nthreads>. The current 1158Set the minimum number of AIO threads to C<$nthreads>. The current
1005default is C<8>, which means eight asynchronous operations can execute 1159default is C<8>, which means eight asynchronous operations can execute
… …
1053This 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
1054blocks, 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
1055use an C<aio_group> together with a feed callback. 1209use an C<aio_group> together with a feed callback.
1056 1210
1057Sets the maximum number of outstanding requests to C<$nreqs>. If you 1211Sets the maximum number of outstanding requests to C<$nreqs>. If you
1058to 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
1059C<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>)
1060function will block until the limit is no longer exceeded. 1214function will block until the limit is no longer exceeded.
1061 1215
1062The 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
1063number of outstanding requests. 1217number of outstanding requests.
1064 1218
1065You can still queue as many requests as you want. Therefore, 1219You can still queue as many requests as you want. Therefore,
1066C<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
1067as 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).
1068 1222
1223=back
1224
1069=head3 STATISTICAL INFORMATION 1225=head3 STATISTICAL INFORMATION
1226
1227=over
1070 1228
1071=item IO::AIO::nreqs 1229=item IO::AIO::nreqs
1072 1230
1073Returns the number of requests currently in the ready, execute or pending 1231Returns the number of requests currently in the ready, execute or pending
1074states (i.e. for which their callback has not been invoked yet). 1232states (i.e. for which their callback has not been invoked yet).
… …
1108 *$sym 1266 *$sym
1109} 1267}
1110 1268
1111min_parallel 8; 1269min_parallel 8;
1112 1270
1113END { 1271END { flush }
1114 min_parallel 1;
1115 flush;
1116};
1117 1272
11181; 12731;
1119 1274
1120=head2 FORK BEHAVIOUR 1275=head2 FORK BEHAVIOUR
1121 1276
… …
1141bytes of memory. In addition, stat requests need a stat buffer (possibly 1296bytes of memory. In addition, stat requests need a stat buffer (possibly
1142a 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
1143scalars 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
1144will consume memory till the request has entered the done state. 1299will consume memory till the request has entered the done state.
1145 1300
1146This 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
1147problem. 1302problem.
1148 1303
1149Per-thread usage: 1304Per-thread usage:
1150 1305
1151In 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