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.116 by root, Wed Oct 3 21:27:51 2007 UTC vs.
Revision 1.120 by root, Sun Dec 2 21:51:36 2007 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 31 # AnyEvent integration (EV, Event, Glib, Tk, urxvt, pureperl...)
32 open my $fh, "<&=" . IO::AIO::poll_fileno or die "$!"; 32 open my $fh, "<&=" . IO::AIO::poll_fileno or die "$!";
33 my $w = AnyEvent->io (fh => $fh, poll => 'r', cb => sub { IO::AIO::poll_cb }); 33 my $w = AnyEvent->io (fh => $fh, poll => 'r', cb => sub { IO::AIO::poll_cb });
34
35 # EV integration
36 my $w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
34 37
35 # Event integration 38 # Event integration
36 Event->io (fd => IO::AIO::poll_fileno, 39 Event->io (fd => IO::AIO::poll_fileno,
37 poll => 'r', 40 poll => 'r',
38 cb => \&IO::AIO::poll_cb); 41 cb => \&IO::AIO::poll_cb);
… …
183 186
184=cut 187=cut
185 188
186package IO::AIO; 189package IO::AIO;
187 190
191use Carp ();
192
188no warnings; 193no warnings;
189use strict 'vars'; 194use strict 'vars';
190 195
191use base 'Exporter'; 196use base 'Exporter';
192 197
193BEGIN { 198BEGIN {
194 our $VERSION = '2.5'; 199 our $VERSION = '2.6';
195 200
196 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
197 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 202 aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir
198 aio_readlink 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
199 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
200 aio_chown aio_chmod aio_utime aio_truncate); 207 aio_chmod aio_utime aio_truncate);
208
201 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block)); 209 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice aio_block));
202 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 210 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
203 min_parallel max_parallel max_idle 211 min_parallel max_parallel max_idle
204 nreqs nready npending nthreads 212 nreqs nready npending nthreads
205 max_poll_time max_poll_reqs); 213 max_poll_time max_poll_reqs);
… …
313=item aio_close $fh, $callback->($status) 321=item aio_close $fh, $callback->($status)
314 322
315Asynchronously close a file and call the callback with the result 323Asynchronously close a file and call the callback with the result
316code. 324code.
317 325
318Unlike the other functions operating on files, this function uses the 326Unfortunately, you can't do this to perl. Perl I<insists> very strongly on
319PerlIO layer to close the filehandle. The reason is that the PerlIO API 327closing the file descriptor associated with the filehandle itself. Here is
320insists on closing the underlying fd itself, no matter what, and doesn't 328what aio_close will try:
321allow modifications to the fd. Unfortunately, it is not clear that you can
322call PerlIO from different threads (actually, its quite clear that this
323won't work in some cases), so while it likely works perfectly with simple
324file handles (such as the ones created by C<aio_open>) it might fail in
325interesting ways for others.
326 329
327Having said that, aio_close tries to clean up the filehandle as much as 330 1. dup()licate the fd
328possible before handing it to an io thread, and generally does work. 331 2. asynchronously close() the duplicated fd
332 3. dup()licate the fd once more
333 4. let perl close() the filehandle
334 5. asynchronously close the duplicated fd
335
336The idea is that the first close() flushes stuff to disk that closing an
337fd will flush, so when perl closes the fd, nothing much will need to be
338flushed. The second async. close() will then flush stuff to disk that
339closing the last fd to the file will flush.
340
341Just FYI, SuSv3 has this to say on close:
342
343 All outstanding record locks owned by the process on the file
344 associated with the file descriptor shall be removed.
345
346 If fildes refers to a socket, close() shall cause the socket to be
347 destroyed. ... close() shall block for up to the current linger
348 interval until all data is transmitted.
349 [this actually sounds like a specification bug, but who knows]
350
351And at least Linux additionally actually flushes stuff on every close,
352even when the file itself is still open.
353
354Sounds enourmously inefficient and complicated? Yes... please show me how
355to nuke perl's fd out of existence...
356
357=cut
358
359sub aio_close($;$) {
360 aio_block {
361 my ($fh, $cb) = @_;
362
363 my $pri = aioreq_pri;
364 my $grp = aio_group $cb;
365
366 my $fd = fileno $fh;
367
368 defined $fd or Carp::croak "aio_close called with fd-less filehandle";
369
370 # if the dups fail we will simply get EBADF
371 my $fd2 = _dup $fd;
372 aioreq_pri $pri;
373 add $grp _aio_close $fd2, sub {
374 my $fd2 = _dup $fd;
375 close $fh;
376 aioreq_pri $pri;
377 add $grp _aio_close $fd2, sub {
378 $grp->result ($_[0]);
379 };
380 };
381
382 $grp
383 }
384}
329 385
330 386
331=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 387=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
332 388
333=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 389=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
… …
597 653
598 # those should not normally block. should. should. 654 # those should not normally block. should. should.
599 utime $stat[8], $stat[9], $dst; 655 utime $stat[8], $stat[9], $dst;
600 chmod $stat[2] & 07777, $dst_fh; 656 chmod $stat[2] & 07777, $dst_fh;
601 chown $stat[4], $stat[5], $dst_fh; 657 chown $stat[4], $stat[5], $dst_fh;
658
659 aioreq_pri $pri;
602 close $dst_fh; 660 add $grp aio_close $dst_fh;
603 } else { 661 } else {
604 $grp->result (-1); 662 $grp->result (-1);
605 close $src_fh; 663 close $src_fh;
606 close $dst_fh; 664 close $dst_fh;
607 665
… …
840 898
841 $grp 899 $grp
842 } 900 }
843} 901}
844 902
903=item aio_sync $callback->($status)
904
905Asynchronously call sync and call the callback when finished.
906
845=item aio_fsync $fh, $callback->($status) 907=item aio_fsync $fh, $callback->($status)
846 908
847Asynchronously call fsync on the given filehandle and call the callback 909Asynchronously call fsync on the given filehandle and call the callback
848with the fsync result code. 910with the fsync result code.
849 911
… …
852Asynchronously call fdatasync on the given filehandle and call the 914Asynchronously call fdatasync on the given filehandle and call the
853callback with the fdatasync result code. 915callback with the fdatasync result code.
854 916
855If this call isn't available because your OS lacks it or it couldn't be 917If this call isn't available because your OS lacks it or it couldn't be
856detected, it will be emulated by calling C<fsync> instead. 918detected, it will be emulated by calling C<fsync> instead.
919
920=item aio_pathsync $path, $callback->($status)
921
922This request tries to open, fsync and close the given path. This is a
923composite request intended tosync directories after directory operations
924(E.g. rename). This might not work on all operating systems or have any
925specific effect, but usually it makes sure that directory changes get
926written to disc. It works for anything that can be opened for read-only,
927not just directories.
928
929Passes C<0> when everything went ok, and C<-1> on error.
930
931=cut
932
933sub aio_pathsync($;$) {
934 aio_block {
935 my ($path, $cb) = @_;
936
937 my $pri = aioreq_pri;
938 my $grp = aio_group $cb;
939
940 aioreq_pri $pri;
941 add $grp aio_open $path, O_RDONLY, 0, sub {
942 my ($fh) = @_;
943 if ($fh) {
944 aioreq_pri $pri;
945 add $grp aio_fsync $fh, sub {
946 $grp->result ($_[0]);
947
948 aioreq_pri $pri;
949 add $grp aio_close $fh;
950 };
951 } else {
952 $grp->result (-1);
953 }
954 };
955
956 $grp
957 }
958}
857 959
858=item aio_group $callback->(...) 960=item aio_group $callback->(...)
859 961
860This is a very special aio request: Instead of doing something, it is a 962This is a very special aio request: Instead of doing something, it is a
861container for other aio requests, which is useful if you want to bundle 963container for other aio requests, which is useful if you want to bundle
… …
998itself. Useful when you queued a lot of events but got a result early. 1100itself. Useful when you queued a lot of events but got a result early.
999 1101
1000=item $grp->result (...) 1102=item $grp->result (...)
1001 1103
1002Set the result value(s) that will be passed to the group callback when all 1104Set the result value(s) that will be passed to the group callback when all
1003subrequests have finished and set thre groups errno to the current value 1105subrequests have finished and set the groups errno to the current value
1004of errno (just like calling C<errno> without an error number). By default, 1106of errno (just like calling C<errno> without an error number). By default,
1005no argument will be passed and errno is zero. 1107no argument will be passed and errno is zero.
1006 1108
1007=item $grp->errno ([$errno]) 1109=item $grp->errno ([$errno])
1008 1110

Diff Legend

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