ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/IO-AIO/AIO.pm
(Generate patch)

Comparing IO-AIO/AIO.pm (file contents):
Revision 1.86 by root, Sat Oct 28 23:32:29 2006 UTC vs.
Revision 1.107 by root, Fri Jun 1 05:52:59 2007 UTC

… …
5=head1 SYNOPSIS 5=head1 SYNOPSIS
6 6
7 use IO::AIO; 7 use IO::AIO;
8 8
9 aio_open "/etc/passwd", O_RDONLY, 0, sub { 9 aio_open "/etc/passwd", O_RDONLY, 0, sub {
10 my ($fh) = @_; 10 my $fh = shift
11 or die "/etc/passwd: $!";
11 ... 12 ...
12 }; 13 };
13 14
14 aio_unlink "/tmp/file", sub { }; 15 aio_unlink "/tmp/file", sub { };
15 16
… …
61etc.), but can also be used to easily do operations in parallel that are 62etc.), but can also be used to easily do operations in parallel that are
62normally done sequentially, e.g. stat'ing many files, which is much faster 63normally done sequentially, e.g. stat'ing many files, which is much faster
63on a RAID volume or over NFS when you do a number of stat operations 64on a RAID volume or over NFS when you do a number of stat operations
64concurrently. 65concurrently.
65 66
66While this works on all types of file descriptors (for example sockets), 67While most of this works on all types of file descriptors (for example
67using these functions on file descriptors that support nonblocking 68sockets), using these functions on file descriptors that support
68operation (again, sockets, pipes etc.) is very inefficient. Use an event 69nonblocking operation (again, sockets, pipes etc.) is very inefficient or
70might not work (aio_read fails on sockets/pipes/fifos). Use an event loop
69loop for that (such as the L<Event|Event> module): IO::AIO will naturally 71for that (such as the L<Event|Event> module): IO::AIO will naturally fit
70fit into such an event loop itself. 72into such an event loop itself.
71 73
72In this version, a number of threads are started that execute your 74In this version, a number of threads are started that execute your
73requests and signal their completion. You don't need thread support 75requests and signal their completion. You don't need thread support
74in perl, and the threads created by this module will not be visible 76in perl, and the threads created by this module will not be visible
75to perl. In the future, this module might make use of the native aio 77to perl. In the future, this module might make use of the native aio
… …
98 poll => 'r', 100 poll => 'r',
99 cb => \&IO::AIO::poll_cb); 101 cb => \&IO::AIO::poll_cb);
100 102
101 # queue the request to open /etc/passwd 103 # queue the request to open /etc/passwd
102 aio_open "/etc/passwd", O_RDONLY, 0, sub { 104 aio_open "/etc/passwd", O_RDONLY, 0, sub {
103 my $fh = $_[0] 105 my $fh = shift
104 or die "error while opening: $!"; 106 or die "error while opening: $!";
105 107
106 # stat'ing filehandles is generally non-blocking 108 # stat'ing filehandles is generally non-blocking
107 my $size = -s $fh; 109 my $size = -s $fh;
108 110
… …
176Request has reached the end of its lifetime and holds no resources anymore 178Request has reached the end of its lifetime and holds no resources anymore
177(except possibly for the Perl object, but its connection to the actual 179(except possibly for the Perl object, but its connection to the actual
178aio request is severed and calling its methods will either do nothing or 180aio request is severed and calling its methods will either do nothing or
179result in a runtime error). 181result in a runtime error).
180 182
183=back
184
181=cut 185=cut
182 186
183package IO::AIO; 187package IO::AIO;
184 188
185no warnings; 189no warnings;
186use strict 'vars'; 190use strict 'vars';
187 191
188use base 'Exporter'; 192use base 'Exporter';
189 193
190BEGIN { 194BEGIN {
191 our $VERSION = '2.1'; 195 our $VERSION = '2.4';
192 196
193 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat 197 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat
194 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 198 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink
195 aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move 199 aio_readlink aio_fsync aio_fdatasync aio_readahead aio_rename aio_link
200 aio_move aio_copy aio_group aio_nop aio_mknod aio_load aio_rmtree aio_mkdir
196 aio_copy aio_group aio_nop aio_mknod); 201 aio_chown aio_chmod aio_utime);
197 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); 202 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block));
198 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 203 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
199 min_parallel max_parallel max_idle 204 min_parallel max_parallel max_idle
200 nreqs nready npending nthreads 205 nreqs nready npending nthreads
201 max_poll_time max_poll_reqs); 206 max_poll_time max_poll_reqs);
202 207
… …
206 XSLoader::load ("IO::AIO", $VERSION); 211 XSLoader::load ("IO::AIO", $VERSION);
207} 212}
208 213
209=head1 FUNCTIONS 214=head1 FUNCTIONS
210 215
211=head2 AIO FUNCTIONS 216=head2 AIO REQUEST FUNCTIONS
212 217
213All the C<aio_*> calls are more or less thin wrappers around the syscall 218All the C<aio_*> calls are more or less thin wrappers around the syscall
214with the same name (sans C<aio_>). The arguments are similar or identical, 219with the same name (sans C<aio_>). The arguments are similar or identical,
215and they all accept an additional (and optional) C<$callback> argument 220and they all accept an additional (and optional) C<$callback> argument
216which must be a code reference. This code reference will get called with 221which must be a code reference. This code reference will get called with
… …
219syscall has been executed asynchronously. 224syscall has been executed asynchronously.
220 225
221All functions expecting a filehandle keep a copy of the filehandle 226All functions expecting a filehandle keep a copy of the filehandle
222internally until the request has finished. 227internally until the request has finished.
223 228
224All requests return objects of type L<IO::AIO::REQ> that allow further 229All functions return request objects of type L<IO::AIO::REQ> that allow
225manipulation of those requests while they are in-flight. 230further manipulation of those requests while they are in-flight.
226 231
227The pathnames you pass to these routines I<must> be absolute and 232The pathnames you pass to these routines I<must> be absolute and
228encoded in byte form. The reason for the former is that at the time the 233encoded as octets. The reason for the former is that at the time the
229request is being executed, the current working directory could have 234request is being executed, the current working directory could have
230changed. Alternatively, you can make sure that you never change the 235changed. Alternatively, you can make sure that you never change the
231current working directory. 236current working directory anywhere in the program and then use relative
237paths.
232 238
233To encode pathnames to byte form, either make sure you either: a) 239To encode pathnames as octets, either make sure you either: a) always pass
234always pass in filenames you got from outside (command line, readdir 240in filenames you got from outside (command line, readdir etc.) without
235etc.), b) are ASCII or ISO 8859-1, c) use the Encode module and encode 241tinkering, b) are ASCII or ISO 8859-1, c) use the Encode module and encode
236your pathnames to the locale (or other) encoding in effect in the user 242your pathnames to the locale (or other) encoding in effect in the user
237environment, d) use Glib::filename_from_unicode on unicode filenames or e) 243environment, d) use Glib::filename_from_unicode on unicode filenames or e)
238use something else. 244use something else to ensure your scalar has the correct contents.
245
246This works, btw. independent of the internal UTF-8 bit, which IO::AIO
247handles correctly wether it is set or not.
239 248
240=over 4 249=over 4
241 250
242=item $prev_pri = aioreq_pri [$pri] 251=item $prev_pri = aioreq_pri [$pri]
243 252
… …
263 aio_read $_[0], ..., sub { 272 aio_read $_[0], ..., sub {
264 ... 273 ...
265 }; 274 };
266 }; 275 };
267 276
277
268=item aioreq_nice $pri_adjust 278=item aioreq_nice $pri_adjust
269 279
270Similar to C<aioreq_pri>, but subtracts the given value from the current 280Similar to C<aioreq_pri>, but subtracts the given value from the current
271priority, so effects are cumulative. 281priority, so the effect is cumulative.
282
272 283
273=item aio_open $pathname, $flags, $mode, $callback->($fh) 284=item aio_open $pathname, $flags, $mode, $callback->($fh)
274 285
275Asynchronously open or create a file and call the callback with a newly 286Asynchronously open or create a file and call the callback with a newly
276created filehandle for the file. 287created filehandle for the file.
… …
282list. They are the same as used by C<sysopen>. 293list. They are the same as used by C<sysopen>.
283 294
284Likewise, C<$mode> specifies the mode of the newly created file, if it 295Likewise, C<$mode> specifies the mode of the newly created file, if it
285didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>, 296didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>,
286except that it is mandatory (i.e. use C<0> if you don't create new files, 297except that it is mandatory (i.e. use C<0> if you don't create new files,
287and C<0666> or C<0777> if you do). 298and C<0666> or C<0777> if you do). Note that the C<$mode> will be modified
299by the umask in effect then the request is being executed, so better never
300change the umask.
288 301
289Example: 302Example:
290 303
291 aio_open "/etc/passwd", O_RDONLY, 0, sub { 304 aio_open "/etc/passwd", O_RDONLY, 0, sub {
292 if ($_[0]) { 305 if ($_[0]) {
… …
295 } else { 308 } else {
296 die "open failed: $!\n"; 309 die "open failed: $!\n";
297 } 310 }
298 }; 311 };
299 312
313
300=item aio_close $fh, $callback->($status) 314=item aio_close $fh, $callback->($status)
301 315
302Asynchronously close a file and call the callback with the result 316Asynchronously close a file and call the callback with the result
303code. I<WARNING:> although accepted, you should not pass in a perl 317code. I<WARNING:> although accepted, you should not pass in a perl
304filehandle here, as perl will likely close the file descriptor another 318filehandle here, as perl will likely close the file descriptor another
… …
306C<close> or just let filehandles go out of scope. 320C<close> or just let filehandles go out of scope.
307 321
308This is supposed to be a bug in the API, so that might change. It's 322This is supposed to be a bug in the API, so that might change. It's
309therefore best to avoid this function. 323therefore best to avoid this function.
310 324
325
311=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 326=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
312 327
313=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 328=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
314 329
315Reads or writes C<length> bytes from the specified C<fh> and C<offset> 330Reads or writes C<length> bytes from the specified C<fh> and C<offset>
… …
326 341
327 aio_read $fh, 7, 15, $buffer, 0, sub { 342 aio_read $fh, 7, 15, $buffer, 0, sub {
328 $_[0] > 0 or die "read error: $!"; 343 $_[0] > 0 or die "read error: $!";
329 print "read $_[0] bytes: <$buffer>\n"; 344 print "read $_[0] bytes: <$buffer>\n";
330 }; 345 };
346
331 347
332=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) 348=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
333 349
334Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts 350Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts
335reading at byte offset C<$in_offset>, and starts writing at the current 351reading at byte offset C<$in_offset>, and starts writing at the current
… …
349C<$in_fh> than are written, and there is no way to find out how many 365C<$in_fh> than are written, and there is no way to find out how many
350bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only 366bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only
351provides the number of bytes written to C<$out_fh>. Only if the result 367provides the number of bytes written to C<$out_fh>. Only if the result
352value equals C<$length> one can assume that C<$length> bytes have been 368value equals C<$length> one can assume that C<$length> bytes have been
353read. 369read.
370
354 371
355=item aio_readahead $fh,$offset,$length, $callback->($retval) 372=item aio_readahead $fh,$offset,$length, $callback->($retval)
356 373
357C<aio_readahead> populates the page cache with data from a file so that 374C<aio_readahead> populates the page cache with data from a file so that
358subsequent reads from that file will not block on disk I/O. The C<$offset> 375subsequent reads from that file will not block on disk I/O. The C<$offset>
… …
364file. The current file offset of the file is left unchanged. 381file. The current file offset of the file is left unchanged.
365 382
366If that syscall doesn't exist (likely if your OS isn't Linux) it will be 383If that syscall doesn't exist (likely if your OS isn't Linux) it will be
367emulated by simply reading the data, which would have a similar effect. 384emulated by simply reading the data, which would have a similar effect.
368 385
386
369=item aio_stat $fh_or_path, $callback->($status) 387=item aio_stat $fh_or_path, $callback->($status)
370 388
371=item aio_lstat $fh, $callback->($status) 389=item aio_lstat $fh, $callback->($status)
372 390
373Works like perl's C<stat> or C<lstat> in void context. The callback will 391Works like perl's C<stat> or C<lstat> in void context. The callback will
… …
386 aio_stat "/etc/passwd", sub { 404 aio_stat "/etc/passwd", sub {
387 $_[0] and die "stat failed: $!"; 405 $_[0] and die "stat failed: $!";
388 print "size is ", -s _, "\n"; 406 print "size is ", -s _, "\n";
389 }; 407 };
390 408
409
410=item aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
411
412Works like perl's C<utime> function (including the special case of $atime
413and $mtime being undef). Fractional times are supported if the underlying
414syscalls support them.
415
416When called with a pathname, uses utimes(2) if available, otherwise
417utime(2). If called on a file descriptor, uses futimes(2) if available,
418otherwise returns ENOSYS, so this is not portable.
419
420Examples:
421
422 # set atime and mtime to current time (basically touch(1)):
423 aio_utime "path", undef, undef;
424 # set atime to current time and mtime to beginning of the epoch:
425 aio_utime "path", time, undef; # undef==0
426
427
428=item aio_chown $fh_or_path, $uid, $gid, $callback->($status)
429
430Works like perl's C<chown> function, except that C<undef> for either $uid
431or $gid is being interpreted as "do not change" (but -1 can also be used).
432
433Examples:
434
435 # same as "chown root path" in the shell:
436 aio_chown "path", 0, -1;
437 # same as above:
438 aio_chown "path", 0, undef;
439
440
441=item aio_chmod $fh_or_path, $mode, $callback->($status)
442
443Works like perl's C<chmod> function.
444
445
391=item aio_unlink $pathname, $callback->($status) 446=item aio_unlink $pathname, $callback->($status)
392 447
393Asynchronously unlink (delete) a file and call the callback with the 448Asynchronously unlink (delete) a file and call the callback with the
394result code. 449result code.
395 450
451
396=item aio_mknod $path, $mode, $dev, $callback->($status) 452=item aio_mknod $path, $mode, $dev, $callback->($status)
397 453
398[EXPERIMENTAL] 454[EXPERIMENTAL]
399 455
400Asynchronously create a device node (or fifo). See mknod(2). 456Asynchronously create a device node (or fifo). See mknod(2).
401 457
402The only (POSIX-) portable way of calling this function is: 458The only (POSIX-) portable way of calling this function is:
403 459
404 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ... 460 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ...
461
405 462
406=item aio_link $srcpath, $dstpath, $callback->($status) 463=item aio_link $srcpath, $dstpath, $callback->($status)
407 464
408Asynchronously create a new link to the existing object at C<$srcpath> at 465Asynchronously create a new link to the existing object at C<$srcpath> at
409the path C<$dstpath> and call the callback with the result code. 466the path C<$dstpath> and call the callback with the result code.
410 467
468
411=item aio_symlink $srcpath, $dstpath, $callback->($status) 469=item aio_symlink $srcpath, $dstpath, $callback->($status)
412 470
413Asynchronously create a new symbolic link to the existing object at C<$srcpath> at 471Asynchronously create a new symbolic link to the existing object at C<$srcpath> at
414the path C<$dstpath> and call the callback with the result code. 472the path C<$dstpath> and call the callback with the result code.
415 473
474
475=item aio_readlink $path, $callback->($link)
476
477Asynchronously read the symlink specified by C<$path> and pass it to
478the callback. If an error occurs, nothing or undef gets passed to the
479callback.
480
481
416=item aio_rename $srcpath, $dstpath, $callback->($status) 482=item aio_rename $srcpath, $dstpath, $callback->($status)
417 483
418Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 484Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
419rename(2) and call the callback with the result code. 485rename(2) and call the callback with the result code.
420 486
487
488=item aio_mkdir $pathname, $mode, $callback->($status)
489
490Asynchronously mkdir (create) a directory and call the callback with
491the result code. C<$mode> will be modified by the umask at the time the
492request is executed, so do not change your umask.
493
494
421=item aio_rmdir $pathname, $callback->($status) 495=item aio_rmdir $pathname, $callback->($status)
422 496
423Asynchronously rmdir (delete) a directory and call the callback with the 497Asynchronously rmdir (delete) a directory and call the callback with the
424result code. 498result code.
499
425 500
426=item aio_readdir $pathname, $callback->($entries) 501=item aio_readdir $pathname, $callback->($entries)
427 502
428Unlike the POSIX call of the same name, C<aio_readdir> reads an entire 503Unlike the POSIX call of the same name, C<aio_readdir> reads an entire
429directory (i.e. opendir + readdir + closedir). The entries will not be 504directory (i.e. opendir + readdir + closedir). The entries will not be
430sorted, and will B<NOT> include the C<.> and C<..> entries. 505sorted, and will B<NOT> include the C<.> and C<..> entries.
431 506
432The callback a single argument which is either C<undef> or an array-ref 507The callback a single argument which is either C<undef> or an array-ref
433with the filenames. 508with the filenames.
509
510
511=item aio_load $path, $data, $callback->($status)
512
513This is a composite request that tries to fully load the given file into
514memory. Status is the same as with aio_read.
515
516=cut
517
518sub aio_load($$;$) {
519 aio_block {
520 my ($path, undef, $cb) = @_;
521 my $data = \$_[1];
522
523 my $pri = aioreq_pri;
524 my $grp = aio_group $cb;
525
526 aioreq_pri $pri;
527 add $grp aio_open $path, O_RDONLY, 0, sub {
528 my $fh = shift
529 or return $grp->result (-1);
530
531 aioreq_pri $pri;
532 add $grp aio_read $fh, 0, (-s $fh), $$data, 0, sub {
533 $grp->result ($_[0]);
534 };
535 };
536
537 $grp
538 }
539}
434 540
435=item aio_copy $srcpath, $dstpath, $callback->($status) 541=item aio_copy $srcpath, $dstpath, $callback->($status)
436 542
437Try to copy the I<file> (directories not supported as either source or 543Try to copy the I<file> (directories not supported as either source or
438destination) from C<$srcpath> to C<$dstpath> and call the callback with 544destination) from C<$srcpath> to C<$dstpath> and call the callback with
… …
448errors are being ignored. 554errors are being ignored.
449 555
450=cut 556=cut
451 557
452sub aio_copy($$;$) { 558sub aio_copy($$;$) {
559 aio_block {
453 my ($src, $dst, $cb) = @_; 560 my ($src, $dst, $cb) = @_;
454 561
455 my $pri = aioreq_pri; 562 my $pri = aioreq_pri;
456 my $grp = aio_group $cb; 563 my $grp = aio_group $cb;
457 564
458 aioreq_pri $pri; 565 aioreq_pri $pri;
459 add $grp aio_open $src, O_RDONLY, 0, sub { 566 add $grp aio_open $src, O_RDONLY, 0, sub {
460 if (my $src_fh = $_[0]) { 567 if (my $src_fh = $_[0]) {
461 my @stat = stat $src_fh; 568 my @stat = stat $src_fh;
462 569
463 aioreq_pri $pri; 570 aioreq_pri $pri;
464 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { 571 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
465 if (my $dst_fh = $_[0]) { 572 if (my $dst_fh = $_[0]) {
466 aioreq_pri $pri; 573 aioreq_pri $pri;
467 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub { 574 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
468 if ($_[0] == $stat[7]) { 575 if ($_[0] == $stat[7]) {
469 $grp->result (0); 576 $grp->result (0);
470 close $src_fh; 577 close $src_fh;
471 578
472 # those should not normally block. should. should. 579 # those should not normally block. should. should.
473 utime $stat[8], $stat[9], $dst; 580 utime $stat[8], $stat[9], $dst;
474 chmod $stat[2] & 07777, $dst_fh; 581 chmod $stat[2] & 07777, $dst_fh;
475 chown $stat[4], $stat[5], $dst_fh; 582 chown $stat[4], $stat[5], $dst_fh;
476 close $dst_fh; 583 close $dst_fh;
477 } else { 584 } else {
478 $grp->result (-1); 585 $grp->result (-1);
479 close $src_fh; 586 close $src_fh;
480 close $dst_fh; 587 close $dst_fh;
481 588
482 aioreq $pri; 589 aioreq $pri;
483 add $grp aio_unlink $dst; 590 add $grp aio_unlink $dst;
591 }
484 } 592 };
593 } else {
594 $grp->result (-1);
485 }; 595 }
486 } else {
487 $grp->result (-1);
488 } 596 },
597
598 } else {
599 $grp->result (-1);
489 }, 600 }
490
491 } else {
492 $grp->result (-1);
493 } 601 };
602
603 $grp
494 }; 604 }
495
496 $grp
497} 605}
498 606
499=item aio_move $srcpath, $dstpath, $callback->($status) 607=item aio_move $srcpath, $dstpath, $callback->($status)
500 608
501Try to move the I<file> (directories not supported as either source or 609Try to move the I<file> (directories not supported as either source or
… …
507that is successful, unlinking the C<$srcpath>. 615that is successful, unlinking the C<$srcpath>.
508 616
509=cut 617=cut
510 618
511sub aio_move($$;$) { 619sub aio_move($$;$) {
620 aio_block {
512 my ($src, $dst, $cb) = @_; 621 my ($src, $dst, $cb) = @_;
513 622
514 my $pri = aioreq_pri; 623 my $pri = aioreq_pri;
515 my $grp = aio_group $cb; 624 my $grp = aio_group $cb;
516 625
517 aioreq_pri $pri; 626 aioreq_pri $pri;
518 add $grp aio_rename $src, $dst, sub { 627 add $grp aio_rename $src, $dst, sub {
519 if ($_[0] && $! == EXDEV) { 628 if ($_[0] && $! == EXDEV) {
520 aioreq_pri $pri; 629 aioreq_pri $pri;
521 add $grp aio_copy $src, $dst, sub { 630 add $grp aio_copy $src, $dst, sub {
631 $grp->result ($_[0]);
632
633 if (!$_[0]) {
634 aioreq_pri $pri;
635 add $grp aio_unlink $src;
636 }
637 };
638 } else {
522 $grp->result ($_[0]); 639 $grp->result ($_[0]);
523
524 if (!$_[0]) {
525 aioreq_pri $pri;
526 add $grp aio_unlink $src;
527 }
528 }; 640 }
529 } else {
530 $grp->result ($_[0]);
531 } 641 };
642
643 $grp
532 }; 644 }
533
534 $grp
535} 645}
536 646
537=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) 647=item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
538 648
539Scans a directory (similar to C<aio_readdir>) but additionally tries to 649Scans a directory (similar to C<aio_readdir>) but additionally tries to
… …
586as those tend to return 0 or 1 as link counts, which disables the 696as those tend to return 0 or 1 as link counts, which disables the
587directory counting heuristic. 697directory counting heuristic.
588 698
589=cut 699=cut
590 700
591sub aio_scandir($$$) { 701sub aio_scandir($$;$) {
702 aio_block {
592 my ($path, $maxreq, $cb) = @_; 703 my ($path, $maxreq, $cb) = @_;
593 704
594 my $pri = aioreq_pri; 705 my $pri = aioreq_pri;
595 706
596 my $grp = aio_group $cb; 707 my $grp = aio_group $cb;
597 708
598 $maxreq = 4 if $maxreq <= 0; 709 $maxreq = 4 if $maxreq <= 0;
599 710
600 # stat once 711 # stat once
601 aioreq_pri $pri;
602 add $grp aio_stat $path, sub {
603 return $grp->result () if $_[0];
604 my $now = time;
605 my $hash1 = join ":", (stat _)[0,1,3,7,9];
606
607 # read the directory entries
608 aioreq_pri $pri; 712 aioreq_pri $pri;
609 add $grp aio_readdir $path, sub { 713 add $grp aio_stat $path, sub {
610 my $entries = shift
611 or return $grp->result (); 714 return $grp->result () if $_[0];
715 my $now = time;
716 my $hash1 = join ":", (stat _)[0,1,3,7,9];
612 717
613 # stat the dir another time 718 # read the directory entries
614 aioreq_pri $pri; 719 aioreq_pri $pri;
720 add $grp aio_readdir $path, sub {
721 my $entries = shift
722 or return $grp->result ();
723
724 # stat the dir another time
725 aioreq_pri $pri;
615 add $grp aio_stat $path, sub { 726 add $grp aio_stat $path, sub {
616 my $hash2 = join ":", (stat _)[0,1,3,7,9]; 727 my $hash2 = join ":", (stat _)[0,1,3,7,9];
617 728
618 my $ndirs; 729 my $ndirs;
619 730
620 # take the slow route if anything looks fishy 731 # take the slow route if anything looks fishy
621 if ($hash1 ne $hash2 or (stat _)[9] == $now) { 732 if ($hash1 ne $hash2 or (stat _)[9] == $now) {
622 $ndirs = -1; 733 $ndirs = -1;
623 } else { 734 } else {
624 # if nlink == 2, we are finished 735 # if nlink == 2, we are finished
625 # on non-posix-fs's, we rely on nlink < 2 736 # on non-posix-fs's, we rely on nlink < 2
626 $ndirs = (stat _)[3] - 2 737 $ndirs = (stat _)[3] - 2
627 or return $grp->result ([], $entries); 738 or return $grp->result ([], $entries);
628 } 739 }
629 740
630 # sort into likely dirs and likely nondirs 741 # sort into likely dirs and likely nondirs
631 # dirs == files without ".", short entries first 742 # dirs == files without ".", short entries first
632 $entries = [map $_->[0], 743 $entries = [map $_->[0],
633 sort { $b->[1] cmp $a->[1] } 744 sort { $b->[1] cmp $a->[1] }
634 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length], 745 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length],
635 @$entries]; 746 @$entries];
636 747
637 my (@dirs, @nondirs); 748 my (@dirs, @nondirs);
638 749
639 my $statgrp = add $grp aio_group sub { 750 my $statgrp = add $grp aio_group sub {
640 $grp->result (\@dirs, \@nondirs); 751 $grp->result (\@dirs, \@nondirs);
641 }; 752 };
642 753
643 limit $statgrp $maxreq; 754 limit $statgrp $maxreq;
644 feed $statgrp sub { 755 feed $statgrp sub {
645 return unless @$entries; 756 return unless @$entries;
646 my $entry = pop @$entries; 757 my $entry = pop @$entries;
647 758
648 aioreq_pri $pri; 759 aioreq_pri $pri;
649 add $statgrp aio_stat "$path/$entry/.", sub { 760 add $statgrp aio_stat "$path/$entry/.", sub {
650 if ($_[0] < 0) { 761 if ($_[0] < 0) {
651 push @nondirs, $entry; 762 push @nondirs, $entry;
652 } else { 763 } else {
653 # need to check for real directory 764 # need to check for real directory
654 aioreq_pri $pri; 765 aioreq_pri $pri;
655 add $statgrp aio_lstat "$path/$entry", sub { 766 add $statgrp aio_lstat "$path/$entry", sub {
656 if (-d _) { 767 if (-d _) {
657 push @dirs, $entry; 768 push @dirs, $entry;
658 769
659 unless (--$ndirs) { 770 unless (--$ndirs) {
660 push @nondirs, @$entries; 771 push @nondirs, @$entries;
661 feed $statgrp; 772 feed $statgrp;
773 }
774 } else {
775 push @nondirs, $entry;
662 } 776 }
663 } else {
664 push @nondirs, $entry;
665 } 777 }
666 } 778 }
667 } 779 };
668 }; 780 };
669 }; 781 };
670 }; 782 };
671 }; 783 };
784
785 $grp
672 }; 786 }
787}
673 788
789=item aio_rmtree $path, $callback->($status)
790
791Delete a directory tree starting (and including) C<$path>, return the
792status of the final C<rmdir> only. This is a composite request that
793uses C<aio_scandir> to recurse into and rmdir directories, and unlink
794everything else.
795
796=cut
797
798sub aio_rmtree;
799sub aio_rmtree($;$) {
800 aio_block {
801 my ($path, $cb) = @_;
802
803 my $pri = aioreq_pri;
804 my $grp = aio_group $cb;
805
806 aioreq_pri $pri;
807 add $grp aio_scandir $path, 0, sub {
808 my ($dirs, $nondirs) = @_;
809
810 my $dirgrp = aio_group sub {
811 add $grp aio_rmdir $path, sub {
812 $grp->result ($_[0]);
813 };
814 };
815
816 (aioreq_pri $pri), add $dirgrp aio_rmtree "$path/$_" for @$dirs;
817 (aioreq_pri $pri), add $dirgrp aio_unlink "$path/$_" for @$nondirs;
818
819 add $grp $dirgrp;
820 };
821
674 $grp 822 $grp
823 }
675} 824}
676 825
677=item aio_fsync $fh, $callback->($status) 826=item aio_fsync $fh, $callback->($status)
678 827
679Asynchronously call fsync on the given filehandle and call the callback 828Asynchronously call fsync on the given filehandle and call the callback
… …
933that are being processed by C<IO::AIO::poll_cb> in one call, respectively 1082that are being processed by C<IO::AIO::poll_cb> in one call, respectively
934the maximum amount of time (default C<0>, meaning infinity) spent in 1083the maximum amount of time (default C<0>, meaning infinity) spent in
935C<IO::AIO::poll_cb> to process requests (more correctly the mininum amount 1084C<IO::AIO::poll_cb> to process requests (more correctly the mininum amount
936of time C<poll_cb> is allowed to use). 1085of time C<poll_cb> is allowed to use).
937 1086
1087Setting C<max_poll_time> to a non-zero value creates an overhead of one
1088syscall per request processed, which is not normally a problem unless your
1089callbacks are really really fast or your OS is really really slow (I am
1090not mentioning Solaris here). Using C<max_poll_reqs> incurs no overhead.
1091
938Setting these is useful if you want to ensure some level of 1092Setting these is useful if you want to ensure some level of
939interactiveness when perl is not fast enough to process all requests in 1093interactiveness when perl is not fast enough to process all requests in
940time. 1094time.
941 1095
942For interactive programs, values such as C<0.01> to C<0.1> should be fine. 1096For interactive programs, values such as C<0.01> to C<0.1> should be fine.
943 1097
944Example: Install an Event watcher that automatically calls 1098Example: Install an Event watcher that automatically calls
945IO::AIO::poll_some with low priority, to ensure that other parts of the 1099IO::AIO::poll_cb with low priority, to ensure that other parts of the
946program get the CPU sometimes even under high AIO load. 1100program get the CPU sometimes even under high AIO load.
947 1101
948 # try not to spend much more than 0.1s in poll_cb 1102 # try not to spend much more than 0.1s in poll_cb
949 IO::AIO::max_poll_time 0.1; 1103 IO::AIO::max_poll_time 0.1;
950 1104
… …
953 poll => 'r', nice => 1, 1107 poll => 'r', nice => 1,
954 cb => &IO::AIO::poll_cb); 1108 cb => &IO::AIO::poll_cb);
955 1109
956=item IO::AIO::poll_wait 1110=item IO::AIO::poll_wait
957 1111
1112If there are any outstanding requests and none of them in the result
958Wait till the result filehandle becomes ready for reading (simply does a 1113phase, wait till the result filehandle becomes ready for reading (simply
959C<select> on the filehandle. This is useful if you want to synchronously 1114does a C<select> on the filehandle. This is useful if you want to
960wait for some requests to finish). 1115synchronously wait for some requests to finish).
961 1116
962See C<nreqs> for an example. 1117See C<nreqs> for an example.
963 1118
964=item IO::AIO::poll 1119=item IO::AIO::poll
965 1120
966Waits until some requests have been handled. 1121Waits until some requests have been handled.
967 1122
1123Returns the number of requests processed, but is otherwise strictly
968Strictly equivalent to: 1124equivalent to:
969 1125
970 IO::AIO::poll_wait, IO::AIO::poll_cb 1126 IO::AIO::poll_wait, IO::AIO::poll_cb
971 if IO::AIO::nreqs;
972 1127
973=item IO::AIO::flush 1128=item IO::AIO::flush
974 1129
975Wait till all outstanding AIO requests have been handled. 1130Wait till all outstanding AIO requests have been handled.
976 1131
977Strictly equivalent to: 1132Strictly equivalent to:
978 1133
979 IO::AIO::poll_wait, IO::AIO::poll_cb 1134 IO::AIO::poll_wait, IO::AIO::poll_cb
980 while IO::AIO::nreqs; 1135 while IO::AIO::nreqs;
981 1136
1137=back
1138
982=head3 CONTROLLING THE NUMBER OF THREADS 1139=head3 CONTROLLING THE NUMBER OF THREADS
1140
1141=over
983 1142
984=item IO::AIO::min_parallel $nthreads 1143=item IO::AIO::min_parallel $nthreads
985 1144
986Set the minimum number of AIO threads to C<$nthreads>. The current 1145Set the minimum number of AIO threads to C<$nthreads>. The current
987default is C<8>, which means eight asynchronous operations can execute 1146default is C<8>, which means eight asynchronous operations can execute
… …
1046 1205
1047You can still queue as many requests as you want. Therefore, 1206You can still queue as many requests as you want. Therefore,
1048C<max_oustsanding> is mainly useful in simple scripts (with low values) or 1207C<max_oustsanding> is mainly useful in simple scripts (with low values) or
1049as a stop gap to shield against fatal memory overflow (with large values). 1208as a stop gap to shield against fatal memory overflow (with large values).
1050 1209
1210=back
1211
1051=head3 STATISTICAL INFORMATION 1212=head3 STATISTICAL INFORMATION
1213
1214=over
1052 1215
1053=item IO::AIO::nreqs 1216=item IO::AIO::nreqs
1054 1217
1055Returns the number of requests currently in the ready, execute or pending 1218Returns the number of requests currently in the ready, execute or pending
1056states (i.e. for which their callback has not been invoked yet). 1219states (i.e. for which their callback has not been invoked yet).
… …
1090 *$sym 1253 *$sym
1091} 1254}
1092 1255
1093min_parallel 8; 1256min_parallel 8;
1094 1257
1095END { 1258END { flush }
1096 min_parallel 1;
1097 flush;
1098};
1099 1259
11001; 12601;
1101 1261
1102=head2 FORK BEHAVIOUR 1262=head2 FORK BEHAVIOUR
1103 1263

Diff Legend

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