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.119 by root, Sun Dec 2 20:54:33 2007 UTC vs.
Revision 1.122 by root, Sat Apr 26 12:00:23 2008 UTC

… …
194use strict 'vars'; 194use strict 'vars';
195 195
196use base 'Exporter'; 196use base 'Exporter';
197 197
198BEGIN { 198BEGIN {
199 our $VERSION = '2.6'; 199 our $VERSION = '2.62';
200 200
201 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat 201 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close
202 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 202 aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir
203 aio_readlink aio_sync aio_fsync aio_fdatasync aio_readahead aio_rename aio_link 203 aio_scandir aio_symlink aio_readlink aio_sync aio_fsync
204 aio_fdatasync aio_pathsync aio_readahead
205 aio_rename aio_link aio_move aio_copy aio_group
204 aio_move aio_copy aio_group aio_nop aio_mknod aio_load aio_rmtree aio_mkdir 206 aio_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown
205 aio_chown aio_chmod aio_utime aio_truncate); 207 aio_chmod aio_utime aio_truncate);
208
206 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block)); 209 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block));
207 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 210 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
208 min_parallel max_parallel max_idle 211 min_parallel max_parallel max_idle
209 nreqs nready npending nthreads 212 nreqs nready npending nthreads
210 max_poll_time max_poll_reqs); 213 max_poll_time max_poll_reqs);
… …
319 322
320Asynchronously close a file and call the callback with the result 323Asynchronously close a file and call the callback with the result
321code. 324code.
322 325
323Unfortunately, you can't do this to perl. Perl I<insists> very strongly on 326Unfortunately, you can't do this to perl. Perl I<insists> very strongly on
324closing the file descriptor associated with the filehandle itself. Here is 327closing the file descriptor associated with the filehandle itself.
325what aio_close will try:
326 328
327 1. dup()licate the fd 329Therefore, C<aio_close> will not close the filehandle - instead it will
328 2. asynchronously close() the duplicated fd 330use dup2 to overwrite the file descriptor with the write-end of a pipe
329 3. dup()licate the fd once more 331(the pipe fd will be created on demand and will be cached).
330 4. let perl close() the filehandle
331 5. asynchronously close the duplicated fd
332 332
333The idea is that the first close() flushes stuff to disk that closing an 333Or in other words: the file descriptor will be closed, but it will not be
334fd will flush, so when perl closes the fd, nothing much will need to be 334free for reuse until the perl filehandle is closed.
335flushed. The second async. close() will then flush stuff to disk that
336closing the last fd to the file will flush.
337
338Just FYI, SuSv3 has this to say on close:
339
340 All outstanding record locks owned by the process on the file
341 associated with the file descriptor shall be removed.
342
343 If fildes refers to a socket, close() shall cause the socket to be
344 destroyed. ... close() shall block for up to the current linger
345 interval until all data is transmitted.
346 [this actually sounds like a specification bug, but who knows]
347
348And at least Linux additionally actually flushes stuff on every close,
349even when the file itself is still open.
350
351Sounds enourmously inefficient and complicated? Yes... please show me how
352to nuke perl's fd out of existence...
353 335
354=cut 336=cut
355
356sub aio_close($;$) {
357 aio_block {
358 my ($fh, $cb) = @_;
359
360 my $pri = aioreq_pri;
361 my $grp = aio_group $cb;
362
363 my $fd = fileno $fh;
364
365 defined $fd or Carp::croak "aio_close called with fd-less filehandle";
366
367 # if the dups fail we will simply get EBADF
368 my $fd2 = _dup $fd;
369 aioreq_pri $pri;
370 add $grp _aio_close $fd2, sub {
371 my $fd2 = _dup $fd;
372 close $fh;
373 aioreq_pri $pri;
374 add $grp _aio_close $fd2, sub {
375 $grp->result ($_[0]);
376 };
377 };
378
379 $grp
380 }
381}
382
383 337
384=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 338=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
385 339
386=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 340=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
387 341
… …
650 604
651 # those should not normally block. should. should. 605 # those should not normally block. should. should.
652 utime $stat[8], $stat[9], $dst; 606 utime $stat[8], $stat[9], $dst;
653 chmod $stat[2] & 07777, $dst_fh; 607 chmod $stat[2] & 07777, $dst_fh;
654 chown $stat[4], $stat[5], $dst_fh; 608 chown $stat[4], $stat[5], $dst_fh;
609
610 aioreq_pri $pri;
655 close $dst_fh; 611 add $grp aio_close $dst_fh;
656 } else { 612 } else {
657 $grp->result (-1); 613 $grp->result (-1);
658 close $src_fh; 614 close $src_fh;
659 close $dst_fh; 615 close $dst_fh;
660 616
… …
910callback with the fdatasync result code. 866callback with the fdatasync result code.
911 867
912If this call isn't available because your OS lacks it or it couldn't be 868If this call isn't available because your OS lacks it or it couldn't be
913detected, it will be emulated by calling C<fsync> instead. 869detected, it will be emulated by calling C<fsync> instead.
914 870
871=item aio_pathsync $path, $callback->($status)
872
873This request tries to open, fsync and close the given path. This is a
874composite request intended tosync directories after directory operations
875(E.g. rename). This might not work on all operating systems or have any
876specific effect, but usually it makes sure that directory changes get
877written to disc. It works for anything that can be opened for read-only,
878not just directories.
879
880Passes C<0> when everything went ok, and C<-1> on error.
881
882=cut
883
884sub aio_pathsync($;$) {
885 aio_block {
886 my ($path, $cb) = @_;
887
888 my $pri = aioreq_pri;
889 my $grp = aio_group $cb;
890
891 aioreq_pri $pri;
892 add $grp aio_open $path, O_RDONLY, 0, sub {
893 my ($fh) = @_;
894 if ($fh) {
895 aioreq_pri $pri;
896 add $grp aio_fsync $fh, sub {
897 $grp->result ($_[0]);
898
899 aioreq_pri $pri;
900 add $grp aio_close $fh;
901 };
902 } else {
903 $grp->result (-1);
904 }
905 };
906
907 $grp
908 }
909}
910
915=item aio_group $callback->(...) 911=item aio_group $callback->(...)
916 912
917This is a very special aio request: Instead of doing something, it is a 913This is a very special aio request: Instead of doing something, it is a
918container for other aio requests, which is useful if you want to bundle 914container for other aio requests, which is useful if you want to bundle
919many requests into a single, composite, request with a definite callback 915many requests into a single, composite, request with a definite callback
… …
1055itself. Useful when you queued a lot of events but got a result early. 1051itself. Useful when you queued a lot of events but got a result early.
1056 1052
1057=item $grp->result (...) 1053=item $grp->result (...)
1058 1054
1059Set the result value(s) that will be passed to the group callback when all 1055Set the result value(s) that will be passed to the group callback when all
1060subrequests have finished and set thre groups errno to the current value 1056subrequests have finished and set the groups errno to the current value
1061of errno (just like calling C<errno> without an error number). By default, 1057of errno (just like calling C<errno> without an error number). By default,
1062no argument will be passed and errno is zero. 1058no argument will be passed and errno is zero.
1063 1059
1064=item $grp->errno ([$errno]) 1060=item $grp->errno ([$errno])
1065 1061

Diff Legend

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