--- IO-AIO/AIO.pm 2014/01/24 23:46:16 1.244 +++ IO-AIO/AIO.pm 2016/05/21 04:43:31 1.261 @@ -96,7 +96,7 @@ print $contents; # exit event loop and program - EV::unloop; + EV::break; }; }; @@ -104,7 +104,7 @@ # check for sockets etc. etc. # process events as long as there are some: - EV::loop; + EV::run; =head1 REQUEST ANATOMY AND LIFETIME @@ -169,13 +169,13 @@ use base 'Exporter'; BEGIN { - our $VERSION = '4.19'; + our $VERSION = 4.34; our @AIO_REQ = qw(aio_sendfile aio_seek aio_read aio_write aio_open aio_close aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir aio_readdirx - aio_scandir aio_symlink aio_readlink aio_realpath aio_sync - aio_fsync aio_syncfs aio_fdatasync aio_sync_file_range aio_allocate - aio_pathsync aio_readahead aio_fiemap + aio_scandir aio_symlink aio_readlink aio_realpath aio_fcntl aio_ioctl + aio_sync aio_fsync aio_syncfs aio_fdatasync aio_sync_file_range + aio_pathsync aio_readahead aio_fiemap aio_allocate aio_rename aio_link aio_move aio_copy aio_group aio_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown aio_chmod aio_utime aio_truncate @@ -229,7 +229,7 @@ aio_link $srcpath, $dstpath, $callback->($status) aio_symlink $srcpath, $dstpath, $callback->($status) aio_readlink $pathname, $callback->($link) - aio_realpath $pathname, $callback->($link) + aio_realpath $pathname, $callback->($path) aio_rename $srcpath, $dstpath, $callback->($status) aio_mkdir $pathname, $mode, $callback->($status) aio_rmdir $pathname, $callback->($status) @@ -242,6 +242,8 @@ aio_copy $srcpath, $dstpath, $callback->($status) aio_move $srcpath, $dstpath, $callback->($status) aio_rmtree $pathname, $callback->($status) + aio_fcntl $fh, $cmd, $arg, $callback->($status) + aio_ioctl $fh, $request, $buf, $callback->($status) aio_sync $callback->($status) aio_syncfs $fh, $callback->($status) aio_fsync $fh, $callback->($status) @@ -396,7 +398,7 @@ C, C, C, C, C, C, C, C, C, C, C, -C, C and C. +C, C, C, C, and C. =item aio_close $fh, $callback->($status) @@ -524,8 +526,8 @@ (off-set+length). C does not read beyond the end of the file. The current file offset of the file is left unchanged. -If that syscall doesn't exist (likely if your OS isn't Linux) it will be -emulated by simply reading the data, which would have a similar effect. +If that syscall doesn't exist (likely if your kernel isn't Linux) it will +be emulated by simply reading the data, which would have a similar effect. =item aio_stat $fh_or_path, $callback->($status) @@ -628,8 +630,9 @@ 0x0000f15f ecryptfs 0x00414a53 efs 0x0000137d ext - 0x0000ef53 ext2/ext3 + 0x0000ef53 ext2/ext3/ext4 0x0000ef51 ext2 + 0xf2f52010 f2fs 0x00004006 fat 0x65735546 fuseblk 0x65735543 fusectl @@ -638,6 +641,7 @@ 0x47504653 gpfs 0x00004244 hfs 0xf995e849 hpfs + 0x00c0ffee hostfs 0x958458f6 hugetlbfs 0x2bad1dea inotifyfs 0x00009660 isofs @@ -662,6 +666,7 @@ 0x00009fa0 proc 0x6165676c pstorefs 0x0000002f qnx4 + 0x68191122 qnx6 0x858458f6 ramfs 0x52654973 reiserfs 0x00007275 romfs @@ -724,12 +729,16 @@ =item aio_allocate $fh, $mode, $offset, $len, $callback->($status) -Allocates or freed disk space according to the C<$mode> argument. See the -linux C docuemntation for details. +Allocates or frees disk space according to the C<$mode> argument. See the +linux C documentation for details. -C<$mode> can currently be C<0> or C -to allocate space, or C, to deallocate a file range. +C<$mode> is usually C<0> or C to allocate +space, or C, +to deallocate a file range. + +IO::AIO also supports C, to remove a range +(without leaving a hole) and C, to zero a range (see +your L manpage). The file system block size used by C is presumably the C returned by C. @@ -1222,6 +1231,25 @@ $grp } +=item aio_fcntl $fh, $cmd, $arg, $callback->($status) + +=item aio_ioctl $fh, $request, $buf, $callback->($status) + +These work just like the C and C built-in functions, except +they execute asynchronously and pass the return value to the callback. + +Both calls can be used for a lot of things, some of which make more sense +to run asynchronously in their own thread, while some others make less +sense. For example, calls that block waiting for external events, such +as locking, will also lock down an I/O thread while it is waiting, which +can deadlock the whole I/O system. At the same time, there might be no +alternative to using a thread to wait. + +So in general, you should only use these calls for things that do +(filesystem) I/O, not for things that wait for other events (network, +other processes), although if you are careful and know what you are doing, +you still can. + =item aio_sync $callback->($status) Asynchronously call sync and call the callback when finished. @@ -1502,9 +1530,9 @@ }; }; -That C is a request and not a normal function shows that creating -an IO::AIO::WD object is itself a potentially blocking operation, which is -why it is done asynchronously. +The fact that C is a request and not a normal function shows that +creating an IO::AIO::WD object is itself a potentially blocking operation, +which is why it is done asynchronously. To stat the directory obtained with C above, one could write either of the following three request calls: @@ -1557,9 +1585,6 @@ C callback, as future requests using the value will fail in the expected way. -If this call isn't available because your OS lacks it or it couldn't be -detected, it will be emulated by calling C instead. - =item IO::AIO::CWD This is a compiletime constant (object) that represents the process @@ -1936,7 +1961,7 @@ blocks, and a bad way to reduce concurrency because it is inexact: Better use an C together with a feed callback. -It's main use is in scripts without an event loop - when you want to stat +Its main use is in scripts without an event loop - when you want to stat a lot of files, you can write somehting like this: IO::AIO::max_outstanding 32; @@ -1986,8 +2011,10 @@ =head3 MISCELLANEOUS FUNCTIONS -IO::AIO implements some functions that might be useful, but are not -asynchronous. +IO::AIO implements some functions that are useful when you want to use +some "Advanced I/O" function not available to in Perl, without going the +"Asynchronous I/O" route. Many of these have an asynchronous C +counterpart. =over 4 @@ -2056,13 +2083,20 @@ C<$prot> is a combination of C, C, C and/or C, -C<$flags> can be a combination of C or -C, or a number of system-specific flags (when -not available, the are defined as 0): C -(which is set to C if your system only provides this -constant), C, C, -C, C or -C +C<$flags> can be a combination of +C or +C, +or a number of system-specific flags (when not available, the are C<0>): +C (which is set to C if your system only provides this constant), +C, +C, +C, +C, +C, +C, +C, +C or +C. If C<$fh> is C, then a file descriptor of C<-1> is passed. @@ -2115,7 +2149,7 @@ =item IO::AIO::tee $r_fh, $w_fh, $length, $flags -Calls the GNU/Linux C syscall, see it's manpage and the +Calls the GNU/Linux C syscall, see its manpage and the description for C above for details. =item $actual_size = IO::AIO::pipesize $r_fh[, $new_size] @@ -2125,6 +2159,26 @@ C<-1>/C everywhere else. If anybody knows how to influence pipe buffer size on other systems, drop me a note. +=item ($rfh, $wfh) = IO::AIO::pipe2 [$flags] + +This is a direct interface to the Linux L system call. If +C<$flags> is missing or C<0>, then this should be the same as a call to +perl's built-in C function and create a new pipe, and works on +systems that lack the pipe2 syscall. On win32, this case invokes C<_pipe +(..., 4096, O_BINARY)>. + +If C<$flags> is non-zero, it tries to invoke the pipe2 system call with +the given flags (Linux 2.6.27, glibc 2.9). + +On success, the read and write file handles are returned. + +On error, nothing will be returned. If the pipe2 syscall is missing and +C<$flags> is non-zero, fails with C. + +Please refer to L for more info on the C<$flags>, but at the +time of this writing, C, C and +C (Linux 3.4, for packet-based pipes) were supported. + =back =cut