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.105 by root, Sun Mar 25 00:20:27 2007 UTC vs.
Revision 1.125 by root, Sat May 10 22:47:34 2008 UTC

… …
26 $req->cancel; # cancel request if still in queue 26 $req->cancel; # cancel request if still in queue
27 27
28 my $grp = aio_group sub { print "all stats done\n" }; 28 my $grp = aio_group sub { print "all stats done\n" };
29 add $grp aio_stat "..." for ...; 29 add $grp aio_stat "..." for ...;
30 30
31 # AnyEvent integration (EV, Event, Glib, Tk, POE, urxvt, pureperl...)
32 use AnyEvent::AIO;
33
31 # AnyEvent integration 34 # EV integration
32 open my $fh, "<&=" . IO::AIO::poll_fileno or die "$!"; 35 my $w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
33 my $w = AnyEvent->io (fh => $fh, poll => 'r', cb => sub { IO::AIO::poll_cb });
34 36
35 # Event integration 37 # Event integration
36 Event->io (fd => IO::AIO::poll_fileno, 38 Event->io (fd => IO::AIO::poll_fileno,
37 poll => 'r', 39 poll => 'r',
38 cb => \&IO::AIO::poll_cb); 40 cb => \&IO::AIO::poll_cb);
… …
62etc.), but can also be used to easily do operations in parallel that are 64etc.), but can also be used to easily do operations in parallel that are
63normally done sequentially, e.g. stat'ing many files, which is much faster 65normally done sequentially, e.g. stat'ing many files, which is much faster
64on a RAID volume or over NFS when you do a number of stat operations 66on a RAID volume or over NFS when you do a number of stat operations
65concurrently. 67concurrently.
66 68
67While most of this works on all types of file descriptors (for example 69While most of this works on all types of file descriptors (for
68sockets), using these functions on file descriptors that support 70example sockets), using these functions on file descriptors that
69nonblocking operation (again, sockets, pipes etc.) is very inefficient or 71support nonblocking operation (again, sockets, pipes etc.) is very
70might not work (aio_read fails on sockets/pipes/fifos). Use an event loop 72inefficient. Use an event loop for that (such as the L<Event|Event>
71for that (such as the L<Event|Event> module): IO::AIO will naturally fit 73module): IO::AIO will naturally fit into such an event loop itself.
72into such an event loop itself.
73 74
74In this version, a number of threads are started that execute your 75In this version, a number of threads are started that execute your
75requests and signal their completion. You don't need thread support 76requests and signal their completion. You don't need thread support
76in perl, and the threads created by this module will not be visible 77in perl, and the threads created by this module will not be visible
77to perl. In the future, this module might make use of the native aio 78to perl. In the future, this module might make use of the native aio
… …
79not well-supported or restricted (GNU/Linux doesn't allow them on normal 80not well-supported or restricted (GNU/Linux doesn't allow them on normal
80files currently, for example), and they would only support aio_read and 81files currently, for example), and they would only support aio_read and
81aio_write, so the remaining functionality would have to be implemented 82aio_write, so the remaining functionality would have to be implemented
82using threads anyway. 83using threads anyway.
83 84
84Although the module will work with in the presence of other (Perl-) 85Although the module will work in the presence of other (Perl-) threads,
85threads, it is currently not reentrant in any way, so use appropriate 86it is currently not reentrant in any way, so use appropriate locking
86locking yourself, always call C<poll_cb> from within the same thread, or 87yourself, always call C<poll_cb> from within the same thread, or never
87never call C<poll_cb> (or other C<aio_> functions) recursively. 88call C<poll_cb> (or other C<aio_> functions) recursively.
88 89
89=head2 EXAMPLE 90=head2 EXAMPLE
90 91
91This is a simple example that uses the Event module and loads 92This is a simple example that uses the Event module and loads
92F</etc/passwd> asynchronously: 93F</etc/passwd> asynchronously:
… …
184 185
185=cut 186=cut
186 187
187package IO::AIO; 188package IO::AIO;
188 189
190use Carp ();
191
189no warnings; 192no warnings;
190use strict 'vars'; 193use strict 'vars';
191 194
192use base 'Exporter'; 195use base 'Exporter';
193 196
194BEGIN { 197BEGIN {
195 our $VERSION = '2.33'; 198 our $VERSION = '3.0';
196 199
197 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat 200 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close
198 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 201 aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir
199 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link 202 aio_scandir aio_symlink aio_readlink aio_sync aio_fsync
203 aio_fdatasync aio_pathsync aio_readahead
204 aio_rename aio_link aio_move aio_copy aio_group
200 aio_move aio_copy aio_group aio_nop aio_mknod aio_load aio_rmtree aio_mkdir); 205 aio_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown
206 aio_chmod aio_utime aio_truncate);
207
201 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block)); 208 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice));
202 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 209 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
203 min_parallel max_parallel max_idle 210 min_parallel max_parallel max_idle
204 nreqs nready npending nthreads 211 nreqs nready npending nthreads
205 max_poll_time max_poll_reqs); 212 max_poll_time max_poll_reqs);
206 213
… …
271 aio_read $_[0], ..., sub { 278 aio_read $_[0], ..., sub {
272 ... 279 ...
273 }; 280 };
274 }; 281 };
275 282
283
276=item aioreq_nice $pri_adjust 284=item aioreq_nice $pri_adjust
277 285
278Similar to C<aioreq_pri>, but subtracts the given value from the current 286Similar to C<aioreq_pri>, but subtracts the given value from the current
279priority, so the effect is cumulative. 287priority, so the effect is cumulative.
288
280 289
281=item aio_open $pathname, $flags, $mode, $callback->($fh) 290=item aio_open $pathname, $flags, $mode, $callback->($fh)
282 291
283Asynchronously open or create a file and call the callback with a newly 292Asynchronously open or create a file and call the callback with a newly
284created filehandle for the file. 293created filehandle for the file.
… …
305 } else { 314 } else {
306 die "open failed: $!\n"; 315 die "open failed: $!\n";
307 } 316 }
308 }; 317 };
309 318
319
310=item aio_close $fh, $callback->($status) 320=item aio_close $fh, $callback->($status)
311 321
312Asynchronously close a file and call the callback with the result 322Asynchronously close a file and call the callback with the result
313code. I<WARNING:> although accepted, you should not pass in a perl 323code.
314filehandle here, as perl will likely close the file descriptor another
315time when the filehandle is destroyed. Normally, you can safely call perls
316C<close> or just let filehandles go out of scope.
317 324
318This is supposed to be a bug in the API, so that might change. It's 325Unfortunately, you can't do this to perl. Perl I<insists> very strongly on
319therefore best to avoid this function. 326closing the file descriptor associated with the filehandle itself.
327
328Therefore, C<aio_close> will not close the filehandle - instead it will
329use dup2 to overwrite the file descriptor with the write-end of a pipe
330(the pipe fd will be created on demand and will be cached).
331
332Or in other words: the file descriptor will be closed, but it will not be
333free for reuse until the perl filehandle is closed.
334
335=cut
320 336
321=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 337=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
322 338
323=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 339=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
324 340
325Reads or writes C<length> bytes from the specified C<fh> and C<offset> 341Reads or writes C<$length> bytes from the specified C<$fh> and C<$offset>
326into the scalar given by C<data> and offset C<dataoffset> and calls the 342into the scalar given by C<$data> and offset C<$dataoffset> and calls the
327callback without the actual number of bytes read (or -1 on error, just 343callback without the actual number of bytes read (or -1 on error, just
328like the syscall). 344like the syscall).
329 345
346If C<$offset> is undefined, then the current file descriptor offset will
347be used (and updated), otherwise the file descriptor offset will not be
348changed by these calls.
349
350If C<$length> is undefined in C<aio_write>, use the remaining length of C<$data>.
351
352If C<$dataoffset> is less than zero, it will be counted from the end of
353C<$data>.
354
330The C<$data> scalar I<MUST NOT> be modified in any way while the request 355The C<$data> scalar I<MUST NOT> be modified in any way while the request
331is outstanding. Modifying it can result in segfaults or WW3 (if the 356is outstanding. Modifying it can result in segfaults or World War III (if
332necessary/optional hardware is installed). 357the necessary/optional hardware is installed).
333 358
334Example: Read 15 bytes at offset 7 into scalar C<$buffer>, starting at 359Example: Read 15 bytes at offset 7 into scalar C<$buffer>, starting at
335offset C<0> within the scalar: 360offset C<0> within the scalar:
336 361
337 aio_read $fh, 7, 15, $buffer, 0, sub { 362 aio_read $fh, 7, 15, $buffer, 0, sub {
338 $_[0] > 0 or die "read error: $!"; 363 $_[0] > 0 or die "read error: $!";
339 print "read $_[0] bytes: <$buffer>\n"; 364 print "read $_[0] bytes: <$buffer>\n";
340 }; 365 };
366
341 367
342=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) 368=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
343 369
344Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts 370Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts
345reading at byte offset C<$in_offset>, and starts writing at the current 371reading at byte offset C<$in_offset>, and starts writing at the current
… …
359C<$in_fh> than are written, and there is no way to find out how many 385C<$in_fh> than are written, and there is no way to find out how many
360bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only 386bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only
361provides the number of bytes written to C<$out_fh>. Only if the result 387provides the number of bytes written to C<$out_fh>. Only if the result
362value equals C<$length> one can assume that C<$length> bytes have been 388value equals C<$length> one can assume that C<$length> bytes have been
363read. 389read.
390
364 391
365=item aio_readahead $fh,$offset,$length, $callback->($retval) 392=item aio_readahead $fh,$offset,$length, $callback->($retval)
366 393
367C<aio_readahead> populates the page cache with data from a file so that 394C<aio_readahead> populates the page cache with data from a file so that
368subsequent reads from that file will not block on disk I/O. The C<$offset> 395subsequent reads from that file will not block on disk I/O. The C<$offset>
… …
374file. The current file offset of the file is left unchanged. 401file. The current file offset of the file is left unchanged.
375 402
376If that syscall doesn't exist (likely if your OS isn't Linux) it will be 403If that syscall doesn't exist (likely if your OS isn't Linux) it will be
377emulated by simply reading the data, which would have a similar effect. 404emulated by simply reading the data, which would have a similar effect.
378 405
406
379=item aio_stat $fh_or_path, $callback->($status) 407=item aio_stat $fh_or_path, $callback->($status)
380 408
381=item aio_lstat $fh, $callback->($status) 409=item aio_lstat $fh, $callback->($status)
382 410
383Works like perl's C<stat> or C<lstat> in void context. The callback will 411Works like perl's C<stat> or C<lstat> in void context. The callback will
… …
396 aio_stat "/etc/passwd", sub { 424 aio_stat "/etc/passwd", sub {
397 $_[0] and die "stat failed: $!"; 425 $_[0] and die "stat failed: $!";
398 print "size is ", -s _, "\n"; 426 print "size is ", -s _, "\n";
399 }; 427 };
400 428
429
430=item aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
431
432Works like perl's C<utime> function (including the special case of $atime
433and $mtime being undef). Fractional times are supported if the underlying
434syscalls support them.
435
436When called with a pathname, uses utimes(2) if available, otherwise
437utime(2). If called on a file descriptor, uses futimes(2) if available,
438otherwise returns ENOSYS, so this is not portable.
439
440Examples:
441
442 # set atime and mtime to current time (basically touch(1)):
443 aio_utime "path", undef, undef;
444 # set atime to current time and mtime to beginning of the epoch:
445 aio_utime "path", time, undef; # undef==0
446
447
448=item aio_chown $fh_or_path, $uid, $gid, $callback->($status)
449
450Works like perl's C<chown> function, except that C<undef> for either $uid
451or $gid is being interpreted as "do not change" (but -1 can also be used).
452
453Examples:
454
455 # same as "chown root path" in the shell:
456 aio_chown "path", 0, -1;
457 # same as above:
458 aio_chown "path", 0, undef;
459
460
461=item aio_truncate $fh_or_path, $offset, $callback->($status)
462
463Works like truncate(2) or ftruncate(2).
464
465
466=item aio_chmod $fh_or_path, $mode, $callback->($status)
467
468Works like perl's C<chmod> function.
469
470
401=item aio_unlink $pathname, $callback->($status) 471=item aio_unlink $pathname, $callback->($status)
402 472
403Asynchronously unlink (delete) a file and call the callback with the 473Asynchronously unlink (delete) a file and call the callback with the
404result code. 474result code.
405 475
476
406=item aio_mknod $path, $mode, $dev, $callback->($status) 477=item aio_mknod $path, $mode, $dev, $callback->($status)
407 478
408[EXPERIMENTAL] 479[EXPERIMENTAL]
409 480
410Asynchronously create a device node (or fifo). See mknod(2). 481Asynchronously create a device node (or fifo). See mknod(2).
411 482
412The only (POSIX-) portable way of calling this function is: 483The only (POSIX-) portable way of calling this function is:
413 484
414 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ... 485 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ...
486
415 487
416=item aio_link $srcpath, $dstpath, $callback->($status) 488=item aio_link $srcpath, $dstpath, $callback->($status)
417 489
418Asynchronously create a new link to the existing object at C<$srcpath> at 490Asynchronously create a new link to the existing object at C<$srcpath> at
419the path C<$dstpath> and call the callback with the result code. 491the path C<$dstpath> and call the callback with the result code.
420 492
493
421=item aio_symlink $srcpath, $dstpath, $callback->($status) 494=item aio_symlink $srcpath, $dstpath, $callback->($status)
422 495
423Asynchronously create a new symbolic link to the existing object at C<$srcpath> at 496Asynchronously create a new symbolic link to the existing object at C<$srcpath> at
424the path C<$dstpath> and call the callback with the result code. 497the path C<$dstpath> and call the callback with the result code.
498
425 499
426=item aio_readlink $path, $callback->($link) 500=item aio_readlink $path, $callback->($link)
427 501
428Asynchronously read the symlink specified by C<$path> and pass it to 502Asynchronously read the symlink specified by C<$path> and pass it to
429the callback. If an error occurs, nothing or undef gets passed to the 503the callback. If an error occurs, nothing or undef gets passed to the
430callback. 504callback.
431 505
506
432=item aio_rename $srcpath, $dstpath, $callback->($status) 507=item aio_rename $srcpath, $dstpath, $callback->($status)
433 508
434Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 509Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
435rename(2) and call the callback with the result code. 510rename(2) and call the callback with the result code.
511
436 512
437=item aio_mkdir $pathname, $mode, $callback->($status) 513=item aio_mkdir $pathname, $mode, $callback->($status)
438 514
439Asynchronously mkdir (create) a directory and call the callback with 515Asynchronously mkdir (create) a directory and call the callback with
440the result code. C<$mode> will be modified by the umask at the time the 516the result code. C<$mode> will be modified by the umask at the time the
441request is executed, so do not change your umask. 517request is executed, so do not change your umask.
442 518
519
443=item aio_rmdir $pathname, $callback->($status) 520=item aio_rmdir $pathname, $callback->($status)
444 521
445Asynchronously rmdir (delete) a directory and call the callback with the 522Asynchronously rmdir (delete) a directory and call the callback with the
446result code. 523result code.
524
447 525
448=item aio_readdir $pathname, $callback->($entries) 526=item aio_readdir $pathname, $callback->($entries)
449 527
450Unlike the POSIX call of the same name, C<aio_readdir> reads an entire 528Unlike the POSIX call of the same name, C<aio_readdir> reads an entire
451directory (i.e. opendir + readdir + closedir). The entries will not be 529directory (i.e. opendir + readdir + closedir). The entries will not be
452sorted, and will B<NOT> include the C<.> and C<..> entries. 530sorted, and will B<NOT> include the C<.> and C<..> entries.
453 531
454The callback a single argument which is either C<undef> or an array-ref 532The callback a single argument which is either C<undef> or an array-ref
455with the filenames. 533with the filenames.
456 534
535
457=item aio_load $path, $data, $callback->($status) 536=item aio_load $path, $data, $callback->($status)
458 537
459This is a composite request that tries to fully load the given file into 538This is a composite request that tries to fully load the given file into
460memory. Status is the same as with aio_read. 539memory. Status is the same as with aio_read.
461 540
462=cut 541=cut
463 542
464sub aio_load($$;$) { 543sub aio_load($$;$) {
465 aio_block {
466 my ($path, undef, $cb) = @_; 544 my ($path, undef, $cb) = @_;
467 my $data = \$_[1]; 545 my $data = \$_[1];
468 546
469 my $pri = aioreq_pri; 547 my $pri = aioreq_pri;
470 my $grp = aio_group $cb; 548 my $grp = aio_group $cb;
549
550 aioreq_pri $pri;
551 add $grp aio_open $path, O_RDONLY, 0, sub {
552 my $fh = shift
553 or return $grp->result (-1);
471 554
472 aioreq_pri $pri; 555 aioreq_pri $pri;
473 add $grp aio_open $path, O_RDONLY, 0, sub {
474 my $fh = shift
475 or return $grp->result (-1);
476
477 aioreq_pri $pri;
478 add $grp aio_read $fh, 0, (-s $fh), $$data, 0, sub { 556 add $grp aio_read $fh, 0, (-s $fh), $$data, 0, sub {
479 $grp->result ($_[0]); 557 $grp->result ($_[0]);
480 };
481 }; 558 };
482
483 $grp
484 } 559 };
560
561 $grp
485} 562}
486 563
487=item aio_copy $srcpath, $dstpath, $callback->($status) 564=item aio_copy $srcpath, $dstpath, $callback->($status)
488 565
489Try to copy the I<file> (directories not supported as either source or 566Try to copy the I<file> (directories not supported as either source or
… …
500errors are being ignored. 577errors are being ignored.
501 578
502=cut 579=cut
503 580
504sub aio_copy($$;$) { 581sub aio_copy($$;$) {
505 aio_block {
506 my ($src, $dst, $cb) = @_; 582 my ($src, $dst, $cb) = @_;
507 583
508 my $pri = aioreq_pri; 584 my $pri = aioreq_pri;
509 my $grp = aio_group $cb; 585 my $grp = aio_group $cb;
510 586
511 aioreq_pri $pri; 587 aioreq_pri $pri;
512 add $grp aio_open $src, O_RDONLY, 0, sub { 588 add $grp aio_open $src, O_RDONLY, 0, sub {
513 if (my $src_fh = $_[0]) { 589 if (my $src_fh = $_[0]) {
514 my @stat = stat $src_fh; 590 my @stat = stat $src_fh;
515 591
516 aioreq_pri $pri; 592 aioreq_pri $pri;
517 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { 593 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
518 if (my $dst_fh = $_[0]) { 594 if (my $dst_fh = $_[0]) {
519 aioreq_pri $pri; 595 aioreq_pri $pri;
520 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub { 596 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
521 if ($_[0] == $stat[7]) { 597 if ($_[0] == $stat[7]) {
522 $grp->result (0); 598 $grp->result (0);
523 close $src_fh; 599 close $src_fh;
524 600
525 # those should not normally block. should. should. 601 # those should not normally block. should. should.
526 utime $stat[8], $stat[9], $dst; 602 utime $stat[8], $stat[9], $dst;
527 chmod $stat[2] & 07777, $dst_fh; 603 chmod $stat[2] & 07777, $dst_fh;
528 chown $stat[4], $stat[5], $dst_fh; 604 chown $stat[4], $stat[5], $dst_fh;
605
606 aioreq_pri $pri;
529 close $dst_fh; 607 add $grp aio_close $dst_fh;
530 } else { 608 } else {
531 $grp->result (-1); 609 $grp->result (-1);
532 close $src_fh; 610 close $src_fh;
533 close $dst_fh; 611 close $dst_fh;
534 612
535 aioreq $pri; 613 aioreq $pri;
536 add $grp aio_unlink $dst; 614 add $grp aio_unlink $dst;
537 }
538 }; 615 }
539 } else {
540 $grp->result (-1);
541 } 616 };
617 } else {
618 $grp->result (-1);
542 }, 619 }
543
544 } else {
545 $grp->result (-1);
546 } 620 },
621
622 } else {
623 $grp->result (-1);
547 }; 624 }
548
549 $grp
550 } 625 };
626
627 $grp
551} 628}
552 629
553=item aio_move $srcpath, $dstpath, $callback->($status) 630=item aio_move $srcpath, $dstpath, $callback->($status)
554 631
555Try to move the I<file> (directories not supported as either source or 632Try to move the I<file> (directories not supported as either source or
… …
561that is successful, unlinking the C<$srcpath>. 638that is successful, unlinking the C<$srcpath>.
562 639
563=cut 640=cut
564 641
565sub aio_move($$;$) { 642sub aio_move($$;$) {
566 aio_block {
567 my ($src, $dst, $cb) = @_; 643 my ($src, $dst, $cb) = @_;
568 644
569 my $pri = aioreq_pri; 645 my $pri = aioreq_pri;
570 my $grp = aio_group $cb; 646 my $grp = aio_group $cb;
571 647
572 aioreq_pri $pri; 648 aioreq_pri $pri;
573 add $grp aio_rename $src, $dst, sub { 649 add $grp aio_rename $src, $dst, sub {
574 if ($_[0] && $! == EXDEV) { 650 if ($_[0] && $! == EXDEV) {
575 aioreq_pri $pri; 651 aioreq_pri $pri;
576 add $grp aio_copy $src, $dst, sub { 652 add $grp aio_copy $src, $dst, sub {
577 $grp->result ($_[0]);
578
579 if (!$_[0]) {
580 aioreq_pri $pri;
581 add $grp aio_unlink $src;
582 }
583 };
584 } else {
585 $grp->result ($_[0]); 653 $grp->result ($_[0]);
654
655 if (!$_[0]) {
656 aioreq_pri $pri;
657 add $grp aio_unlink $src;
658 }
586 } 659 };
660 } else {
661 $grp->result ($_[0]);
587 }; 662 }
588
589 $grp
590 } 663 };
664
665 $grp
591} 666}
592 667
593=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) 668=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
594 669
595Scans a directory (similar to C<aio_readdir>) but additionally tries to 670Scans a directory (similar to C<aio_readdir>) but additionally tries to
… …
643directory counting heuristic. 718directory counting heuristic.
644 719
645=cut 720=cut
646 721
647sub aio_scandir($$;$) { 722sub aio_scandir($$;$) {
648 aio_block {
649 my ($path, $maxreq, $cb) = @_; 723 my ($path, $maxreq, $cb) = @_;
650 724
651 my $pri = aioreq_pri; 725 my $pri = aioreq_pri;
652 726
653 my $grp = aio_group $cb; 727 my $grp = aio_group $cb;
654 728
655 $maxreq = 4 if $maxreq <= 0; 729 $maxreq = 4 if $maxreq <= 0;
656 730
657 # stat once 731 # stat once
732 aioreq_pri $pri;
733 add $grp aio_stat $path, sub {
734 return $grp->result () if $_[0];
735 my $now = time;
736 my $hash1 = join ":", (stat _)[0,1,3,7,9];
737
738 # read the directory entries
658 aioreq_pri $pri; 739 aioreq_pri $pri;
659 add $grp aio_stat $path, sub { 740 add $grp aio_readdir $path, sub {
741 my $entries = shift
660 return $grp->result () if $_[0]; 742 or return $grp->result ();
661 my $now = time;
662 my $hash1 = join ":", (stat _)[0,1,3,7,9];
663 743
664 # read the directory entries 744 # stat the dir another time
665 aioreq_pri $pri; 745 aioreq_pri $pri;
666 add $grp aio_readdir $path, sub {
667 my $entries = shift
668 or return $grp->result ();
669
670 # stat the dir another time
671 aioreq_pri $pri;
672 add $grp aio_stat $path, sub { 746 add $grp aio_stat $path, sub {
673 my $hash2 = join ":", (stat _)[0,1,3,7,9]; 747 my $hash2 = join ":", (stat _)[0,1,3,7,9];
674 748
675 my $ndirs; 749 my $ndirs;
676 750
677 # take the slow route if anything looks fishy 751 # take the slow route if anything looks fishy
678 if ($hash1 ne $hash2 or (stat _)[9] == $now) { 752 if ($hash1 ne $hash2 or (stat _)[9] == $now) {
679 $ndirs = -1; 753 $ndirs = -1;
680 } else { 754 } else {
681 # if nlink == 2, we are finished 755 # if nlink == 2, we are finished
682 # on non-posix-fs's, we rely on nlink < 2 756 # on non-posix-fs's, we rely on nlink < 2
683 $ndirs = (stat _)[3] - 2 757 $ndirs = (stat _)[3] - 2
684 or return $grp->result ([], $entries); 758 or return $grp->result ([], $entries);
685 } 759 }
686 760
687 # sort into likely dirs and likely nondirs 761 # sort into likely dirs and likely nondirs
688 # dirs == files without ".", short entries first 762 # dirs == files without ".", short entries first
689 $entries = [map $_->[0], 763 $entries = [map $_->[0],
690 sort { $b->[1] cmp $a->[1] } 764 sort { $b->[1] cmp $a->[1] }
691 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length], 765 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length],
692 @$entries]; 766 @$entries];
693 767
694 my (@dirs, @nondirs); 768 my (@dirs, @nondirs);
695 769
696 my $statgrp = add $grp aio_group sub { 770 my $statgrp = add $grp aio_group sub {
697 $grp->result (\@dirs, \@nondirs); 771 $grp->result (\@dirs, \@nondirs);
698 }; 772 };
699 773
700 limit $statgrp $maxreq; 774 limit $statgrp $maxreq;
701 feed $statgrp sub { 775 feed $statgrp sub {
702 return unless @$entries; 776 return unless @$entries;
703 my $entry = pop @$entries; 777 my $entry = pop @$entries;
704 778
705 aioreq_pri $pri; 779 aioreq_pri $pri;
706 add $statgrp aio_stat "$path/$entry/.", sub { 780 add $statgrp aio_stat "$path/$entry/.", sub {
707 if ($_[0] < 0) { 781 if ($_[0] < 0) {
708 push @nondirs, $entry; 782 push @nondirs, $entry;
709 } else { 783 } else {
710 # need to check for real directory 784 # need to check for real directory
711 aioreq_pri $pri; 785 aioreq_pri $pri;
712 add $statgrp aio_lstat "$path/$entry", sub { 786 add $statgrp aio_lstat "$path/$entry", sub {
713 if (-d _) { 787 if (-d _) {
714 push @dirs, $entry; 788 push @dirs, $entry;
715 789
716 unless (--$ndirs) { 790 unless (--$ndirs) {
717 push @nondirs, @$entries; 791 push @nondirs, @$entries;
718 feed $statgrp; 792 feed $statgrp;
719 }
720 } else {
721 push @nondirs, $entry;
722 } 793 }
794 } else {
795 push @nondirs, $entry;
723 } 796 }
724 } 797 }
725 }; 798 }
726 }; 799 };
727 }; 800 };
728 }; 801 };
729 }; 802 };
730
731 $grp
732 } 803 };
804
805 $grp
733} 806}
734 807
735=item aio_rmtree $path, $callback->($status) 808=item aio_rmtree $path, $callback->($status)
736 809
737Delete a directory tree starting (and including) C<$path>, return the 810Delete a directory tree starting (and including) C<$path>, return the
… …
741 814
742=cut 815=cut
743 816
744sub aio_rmtree; 817sub aio_rmtree;
745sub aio_rmtree($;$) { 818sub aio_rmtree($;$) {
746 aio_block {
747 my ($path, $cb) = @_; 819 my ($path, $cb) = @_;
748 820
749 my $pri = aioreq_pri; 821 my $pri = aioreq_pri;
750 my $grp = aio_group $cb; 822 my $grp = aio_group $cb;
751 823
752 aioreq_pri $pri; 824 aioreq_pri $pri;
753 add $grp aio_scandir $path, 0, sub { 825 add $grp aio_scandir $path, 0, sub {
754 my ($dirs, $nondirs) = @_; 826 my ($dirs, $nondirs) = @_;
755 827
756 my $dirgrp = aio_group sub { 828 my $dirgrp = aio_group sub {
757 add $grp aio_rmdir $path, sub { 829 add $grp aio_rmdir $path, sub {
758 $grp->result ($_[0]); 830 $grp->result ($_[0]);
759 };
760 }; 831 };
761
762 (aioreq_pri $pri), add $dirgrp aio_rmtree "$path/$_" for @$dirs;
763 (aioreq_pri $pri), add $dirgrp aio_unlink "$path/$_" for @$nondirs;
764
765 add $grp $dirgrp;
766 }; 832 };
767 833
768 $grp 834 (aioreq_pri $pri), add $dirgrp aio_rmtree "$path/$_" for @$dirs;
835 (aioreq_pri $pri), add $dirgrp aio_unlink "$path/$_" for @$nondirs;
836
837 add $grp $dirgrp;
769 } 838 };
839
840 $grp
770} 841}
842
843=item aio_sync $callback->($status)
844
845Asynchronously call sync and call the callback when finished.
771 846
772=item aio_fsync $fh, $callback->($status) 847=item aio_fsync $fh, $callback->($status)
773 848
774Asynchronously call fsync on the given filehandle and call the callback 849Asynchronously call fsync on the given filehandle and call the callback
775with the fsync result code. 850with the fsync result code.
… …
779Asynchronously call fdatasync on the given filehandle and call the 854Asynchronously call fdatasync on the given filehandle and call the
780callback with the fdatasync result code. 855callback with the fdatasync result code.
781 856
782If this call isn't available because your OS lacks it or it couldn't be 857If this call isn't available because your OS lacks it or it couldn't be
783detected, it will be emulated by calling C<fsync> instead. 858detected, it will be emulated by calling C<fsync> instead.
859
860=item aio_pathsync $path, $callback->($status)
861
862This request tries to open, fsync and close the given path. This is a
863composite request intended tosync directories after directory operations
864(E.g. rename). This might not work on all operating systems or have any
865specific effect, but usually it makes sure that directory changes get
866written to disc. It works for anything that can be opened for read-only,
867not just directories.
868
869Passes C<0> when everything went ok, and C<-1> on error.
870
871=cut
872
873sub aio_pathsync($;$) {
874 my ($path, $cb) = @_;
875
876 my $pri = aioreq_pri;
877 my $grp = aio_group $cb;
878
879 aioreq_pri $pri;
880 add $grp aio_open $path, O_RDONLY, 0, sub {
881 my ($fh) = @_;
882 if ($fh) {
883 aioreq_pri $pri;
884 add $grp aio_fsync $fh, sub {
885 $grp->result ($_[0]);
886
887 aioreq_pri $pri;
888 add $grp aio_close $fh;
889 };
890 } else {
891 $grp->result (-1);
892 }
893 };
894
895 $grp
896}
784 897
785=item aio_group $callback->(...) 898=item aio_group $callback->(...)
786 899
787This is a very special aio request: Instead of doing something, it is a 900This is a very special aio request: Instead of doing something, it is a
788container for other aio requests, which is useful if you want to bundle 901container for other aio requests, which is useful if you want to bundle
… …
925itself. Useful when you queued a lot of events but got a result early. 1038itself. Useful when you queued a lot of events but got a result early.
926 1039
927=item $grp->result (...) 1040=item $grp->result (...)
928 1041
929Set the result value(s) that will be passed to the group callback when all 1042Set the result value(s) that will be passed to the group callback when all
930subrequests have finished and set thre groups errno to the current value 1043subrequests have finished and set the groups errno to the current value
931of errno (just like calling C<errno> without an error number). By default, 1044of errno (just like calling C<errno> without an error number). By default,
932no argument will be passed and errno is zero. 1045no argument will be passed and errno is zero.
933 1046
934=item $grp->errno ([$errno]) 1047=item $grp->errno ([$errno])
935 1048
… …
1133 1246
1134The default is probably ok in most situations, especially if thread 1247The default is probably ok in most situations, especially if thread
1135creation is fast. If thread creation is very slow on your system you might 1248creation is fast. If thread creation is very slow on your system you might
1136want to use larger values. 1249want to use larger values.
1137 1250
1138=item $oldmaxreqs = IO::AIO::max_outstanding $maxreqs 1251=item IO::AIO::max_outstanding $maxreqs
1139 1252
1140This is a very bad function to use in interactive programs because it 1253This is a very bad function to use in interactive programs because it
1141blocks, and a bad way to reduce concurrency because it is inexact: Better 1254blocks, and a bad way to reduce concurrency because it is inexact: Better
1142use an C<aio_group> together with a feed callback. 1255use an C<aio_group> together with a feed callback.
1143 1256
1144Sets the maximum number of outstanding requests to C<$nreqs>. If you 1257Sets the maximum number of outstanding requests to C<$nreqs>. If you
1145to queue up more than this number of requests, the next call to the 1258do queue up more than this number of requests, the next call to the
1146C<poll_cb> (and C<poll_some> and other functions calling C<poll_cb>) 1259C<poll_cb> (and C<poll_some> and other functions calling C<poll_cb>)
1147function will block until the limit is no longer exceeded. 1260function will block until the limit is no longer exceeded.
1148 1261
1149The default value is very large, so there is no practical limit on the 1262The default value is very large, so there is no practical limit on the
1150number of outstanding requests. 1263number of outstanding requests.
1151 1264
1152You can still queue as many requests as you want. Therefore, 1265You can still queue as many requests as you want. Therefore,
1153C<max_oustsanding> is mainly useful in simple scripts (with low values) or 1266C<max_outstanding> is mainly useful in simple scripts (with low values) or
1154as a stop gap to shield against fatal memory overflow (with large values). 1267as a stop gap to shield against fatal memory overflow (with large values).
1155 1268
1156=back 1269=back
1157 1270
1158=head3 STATISTICAL INFORMATION 1271=head3 STATISTICAL INFORMATION
… …
1180but not yet processed by poll_cb). 1293but not yet processed by poll_cb).
1181 1294
1182=back 1295=back
1183 1296
1184=cut 1297=cut
1185
1186# support function to convert a fd into a perl filehandle
1187sub _fd2fh {
1188 return undef if $_[0] < 0;
1189
1190 # try to generate nice filehandles
1191 my $sym = "IO::AIO::fd#$_[0]";
1192 local *$sym;
1193
1194 open *$sym, "+<&=$_[0]" # usually works under any unix
1195 or open *$sym, "<&=$_[0]" # cygwin needs this
1196 or open *$sym, ">&=$_[0]" # or this
1197 or return undef;
1198
1199 *$sym
1200}
1201 1298
1202min_parallel 8; 1299min_parallel 8;
1203 1300
1204END { flush } 1301END { flush }
1205 1302
… …
1229bytes of memory. In addition, stat requests need a stat buffer (possibly 1326bytes of memory. In addition, stat requests need a stat buffer (possibly
1230a few hundred bytes), readdir requires a result buffer and so on. Perl 1327a few hundred bytes), readdir requires a result buffer and so on. Perl
1231scalars and other data passed into aio requests will also be locked and 1328scalars and other data passed into aio requests will also be locked and
1232will consume memory till the request has entered the done state. 1329will consume memory till the request has entered the done state.
1233 1330
1234This is now awfully much, so queuing lots of requests is not usually a 1331This is not awfully much, so queuing lots of requests is not usually a
1235problem. 1332problem.
1236 1333
1237Per-thread usage: 1334Per-thread usage:
1238 1335
1239In the execution phase, some aio requests require more memory for 1336In the execution phase, some aio requests require more memory for
… …
1244 1341
1245Known bugs will be fixed in the next release. 1342Known bugs will be fixed in the next release.
1246 1343
1247=head1 SEE ALSO 1344=head1 SEE ALSO
1248 1345
1249L<Coro::AIO>. 1346L<AnyEvent::AIO> for easy integration into event loops, L<Coro::AIO> for a
1347more natural syntax.
1250 1348
1251=head1 AUTHOR 1349=head1 AUTHOR
1252 1350
1253 Marc Lehmann <schmorp@schmorp.de> 1351 Marc Lehmann <schmorp@schmorp.de>
1254 http://home.schmorp.de/ 1352 http://home.schmorp.de/

Diff Legend

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