… | |
… | |
25 | my $req = aio_unlink "/tmp/file", sub { }; |
25 | my $req = aio_unlink "/tmp/file", sub { }; |
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 | |
|
|
31 | # AnyEvent integration (EV, Event, Glib, Tk, POE, urxvt, pureperl...) |
|
|
32 | use AnyEvent::AIO; |
|
|
33 | |
|
|
34 | # EV integration |
|
|
35 | my $aio_w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb; |
|
|
36 | |
|
|
37 | # Event integration |
|
|
38 | Event->io (fd => IO::AIO::poll_fileno, |
|
|
39 | poll => 'r', |
|
|
40 | cb => \&IO::AIO::poll_cb); |
|
|
41 | |
|
|
42 | # Glib/Gtk2 integration |
|
|
43 | add_watch Glib::IO IO::AIO::poll_fileno, |
|
|
44 | in => sub { IO::AIO::poll_cb; 1 }; |
|
|
45 | |
|
|
46 | # Tk integration |
|
|
47 | Tk::Event::IO->fileevent (IO::AIO::poll_fileno, "", |
|
|
48 | readable => \&IO::AIO::poll_cb); |
|
|
49 | |
|
|
50 | # Danga::Socket integration |
|
|
51 | Danga::Socket->AddOtherFds (IO::AIO::poll_fileno => |
|
|
52 | \&IO::AIO::poll_cb); |
|
|
53 | |
30 | |
54 | =head1 DESCRIPTION |
31 | =head1 DESCRIPTION |
55 | |
32 | |
56 | This module implements asynchronous I/O using whatever means your |
33 | This module implements asynchronous I/O using whatever means your |
57 | operating system supports. It is implemented as an interface to C<libeio> |
34 | operating system supports. It is implemented as an interface to C<libeio> |
… | |
… | |
191 | use common::sense; |
168 | use common::sense; |
192 | |
169 | |
193 | use base 'Exporter'; |
170 | use base 'Exporter'; |
194 | |
171 | |
195 | BEGIN { |
172 | BEGIN { |
196 | our $VERSION = '3.3'; |
173 | our $VERSION = '3.6'; |
197 | |
174 | |
198 | our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close |
175 | our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close |
199 | aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir aio_readdirx |
176 | aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir aio_readdirx |
200 | aio_scandir aio_symlink aio_readlink aio_sync aio_fsync |
177 | aio_scandir aio_symlink aio_readlink aio_sync aio_fsync |
201 | aio_fdatasync aio_sync_file_range aio_pathsync aio_readahead |
178 | aio_fdatasync aio_sync_file_range aio_pathsync aio_readahead |
202 | aio_rename aio_link aio_move aio_copy aio_group |
179 | aio_rename aio_link aio_move aio_copy aio_group |
203 | aio_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown |
180 | aio_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown |
204 | aio_chmod aio_utime aio_truncate); |
181 | aio_chmod aio_utime aio_truncate |
|
|
182 | aio_msync aio_mtouch aio_statvfs); |
205 | |
183 | |
206 | our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); |
184 | our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); |
207 | our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush |
185 | our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush |
208 | min_parallel max_parallel max_idle |
186 | min_parallel max_parallel max_idle |
209 | nreqs nready npending nthreads |
187 | nreqs nready npending nthreads |
… | |
… | |
217 | require XSLoader; |
195 | require XSLoader; |
218 | XSLoader::load ("IO::AIO", $VERSION); |
196 | XSLoader::load ("IO::AIO", $VERSION); |
219 | } |
197 | } |
220 | |
198 | |
221 | =head1 FUNCTIONS |
199 | =head1 FUNCTIONS |
|
|
200 | |
|
|
201 | =head2 QUICK OVERVIEW |
|
|
202 | |
|
|
203 | This section simply lists the prototypes of the most important functions |
|
|
204 | for quick reference. See the following sections for function-by-function |
|
|
205 | documentation. |
|
|
206 | |
|
|
207 | aio_open $pathname, $flags, $mode, $callback->($fh) |
|
|
208 | aio_close $fh, $callback->($status) |
|
|
209 | aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) |
|
|
210 | aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) |
|
|
211 | aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) |
|
|
212 | aio_readahead $fh,$offset,$length, $callback->($retval) |
|
|
213 | aio_stat $fh_or_path, $callback->($status) |
|
|
214 | aio_lstat $fh, $callback->($status) |
|
|
215 | aio_statvfs $fh_or_path, $callback->($statvfs) |
|
|
216 | aio_utime $fh_or_path, $atime, $mtime, $callback->($status) |
|
|
217 | aio_chown $fh_or_path, $uid, $gid, $callback->($status) |
|
|
218 | aio_truncate $fh_or_path, $offset, $callback->($status) |
|
|
219 | aio_chmod $fh_or_path, $mode, $callback->($status) |
|
|
220 | aio_unlink $pathname, $callback->($status) |
|
|
221 | aio_mknod $path, $mode, $dev, $callback->($status) |
|
|
222 | aio_link $srcpath, $dstpath, $callback->($status) |
|
|
223 | aio_symlink $srcpath, $dstpath, $callback->($status) |
|
|
224 | aio_readlink $path, $callback->($link) |
|
|
225 | aio_rename $srcpath, $dstpath, $callback->($status) |
|
|
226 | aio_mkdir $pathname, $mode, $callback->($status) |
|
|
227 | aio_rmdir $pathname, $callback->($status) |
|
|
228 | aio_readdir $pathname, $callback->($entries) |
|
|
229 | aio_readdirx $pathname, $flags, $callback->($entries, $flags) |
|
|
230 | IO::AIO::READDIR_DENTS IO::AIO::READDIR_DIRS_FIRST |
|
|
231 | IO::AIO::READDIR_STAT_ORDER IO::AIO::READDIR_FOUND_UNKNOWN |
|
|
232 | aio_load $path, $data, $callback->($status) |
|
|
233 | aio_copy $srcpath, $dstpath, $callback->($status) |
|
|
234 | aio_move $srcpath, $dstpath, $callback->($status) |
|
|
235 | aio_scandir $path, $maxreq, $callback->($dirs, $nondirs) |
|
|
236 | aio_rmtree $path, $callback->($status) |
|
|
237 | aio_sync $callback->($status) |
|
|
238 | aio_fsync $fh, $callback->($status) |
|
|
239 | aio_fdatasync $fh, $callback->($status) |
|
|
240 | aio_sync_file_range $fh, $offset, $nbytes, $flags, $callback->($status) |
|
|
241 | aio_pathsync $path, $callback->($status) |
|
|
242 | aio_msync $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status) |
|
|
243 | aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status) |
|
|
244 | aio_group $callback->(...) |
|
|
245 | aio_nop $callback->() |
|
|
246 | |
|
|
247 | $prev_pri = aioreq_pri [$pri] |
|
|
248 | aioreq_nice $pri_adjust |
|
|
249 | |
|
|
250 | IO::AIO::poll_wait |
|
|
251 | IO::AIO::poll_cb |
|
|
252 | IO::AIO::poll |
|
|
253 | IO::AIO::flush |
|
|
254 | IO::AIO::max_poll_reqs $nreqs |
|
|
255 | IO::AIO::max_poll_time $seconds |
|
|
256 | IO::AIO::min_parallel $nthreads |
|
|
257 | IO::AIO::max_parallel $nthreads |
|
|
258 | IO::AIO::max_idle $nthreads |
|
|
259 | IO::AIO::max_outstanding $maxreqs |
|
|
260 | IO::AIO::nreqs |
|
|
261 | IO::AIO::nready |
|
|
262 | IO::AIO::npending |
|
|
263 | |
|
|
264 | IO::AIO::sendfile $ofh, $ifh, $offset, $count |
|
|
265 | IO::AIO::fadvise $fh, $offset, $len, $advice |
|
|
266 | IO::AIO::mlockall $flags |
|
|
267 | IO::AIO::munlockall |
222 | |
268 | |
223 | =head2 AIO REQUEST FUNCTIONS |
269 | =head2 AIO REQUEST FUNCTIONS |
224 | |
270 | |
225 | All the C<aio_*> calls are more or less thin wrappers around the syscall |
271 | All the C<aio_*> calls are more or less thin wrappers around the syscall |
226 | with the same name (sans C<aio_>). The arguments are similar or identical, |
272 | with the same name (sans C<aio_>). The arguments are similar or identical, |
… | |
… | |
378 | than one C<aio_sendfile> per C<$out_fh>, as they will interfere with each |
424 | than one C<aio_sendfile> per C<$out_fh>, as they will interfere with each |
379 | other. |
425 | other. |
380 | |
426 | |
381 | This call tries to make use of a native C<sendfile> syscall to provide |
427 | This call tries to make use of a native C<sendfile> syscall to provide |
382 | zero-copy operation. For this to work, C<$out_fh> should refer to a |
428 | zero-copy operation. For this to work, C<$out_fh> should refer to a |
383 | socket, and C<$in_fh> should refer to mmap'able file. |
429 | socket, and C<$in_fh> should refer to an mmap'able file. |
384 | |
430 | |
385 | If the native sendfile call fails or is not implemented, it will be |
431 | If a native sendfile cannot be found or it fails with C<ENOSYS>, |
|
|
432 | C<ENOTSUP>, C<EOPNOTSUPP>, C<EAFNOSUPPORT>, C<EPROTOTYPE> or C<ENOTSOCK>, |
386 | emulated, so you can call C<aio_sendfile> on any type of filehandle |
433 | it will be emulated, so you can call C<aio_sendfile> on any type of |
387 | regardless of the limitations of the operating system. |
434 | filehandle regardless of the limitations of the operating system. |
388 | |
435 | |
389 | Please note, however, that C<aio_sendfile> can read more bytes from |
436 | Please note, however, that C<aio_sendfile> can read more bytes from |
390 | C<$in_fh> than are written, and there is no way to find out how many |
437 | C<$in_fh> than are written, and there is no way to find out how many |
391 | bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only |
438 | bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only |
392 | provides the number of bytes written to C<$out_fh>. Only if the result |
439 | provides the number of bytes written to C<$out_fh>. Only if the result |
… | |
… | |
430 | $_[0] and die "stat failed: $!"; |
477 | $_[0] and die "stat failed: $!"; |
431 | print "size is ", -s _, "\n"; |
478 | print "size is ", -s _, "\n"; |
432 | }; |
479 | }; |
433 | |
480 | |
434 | |
481 | |
|
|
482 | =item aio_statvfs $fh_or_path, $callback->($statvfs) |
|
|
483 | |
|
|
484 | Works like the POSIX C<statvfs> or C<fstatvfs> syscalls, depending on |
|
|
485 | whether a file handle or path was passed. |
|
|
486 | |
|
|
487 | On success, the callback is passed a hash reference with the following |
|
|
488 | members: C<bsize>, C<frsize>, C<blocks>, C<bfree>, C<bavail>, C<files>, |
|
|
489 | C<ffree>, C<favail>, C<fsid>, C<flag> and C<namemax>. On failure, C<undef> |
|
|
490 | is passed. |
|
|
491 | |
|
|
492 | The following POSIX IO::AIO::ST_* constants are defined: C<ST_RDONLY> and |
|
|
493 | C<ST_NOSUID>. |
|
|
494 | |
|
|
495 | The following non-POSIX IO::AIO::ST_* flag masks are defined to |
|
|
496 | their correct value when available, or to C<0> on systems that do |
|
|
497 | not support them: C<ST_NODEV>, C<ST_NOEXEC>, C<ST_SYNCHRONOUS>, |
|
|
498 | C<ST_MANDLOCK>, C<ST_WRITE>, C<ST_APPEND>, C<ST_IMMUTABLE>, C<ST_NOATIME>, |
|
|
499 | C<ST_NODIRATIME> and C<ST_RELATIME>. |
|
|
500 | |
|
|
501 | Example: stat C</wd> and dump out the data if successful. |
|
|
502 | |
|
|
503 | aio_statvfs "/wd", sub { |
|
|
504 | my $f = $_[0] |
|
|
505 | or die "statvfs: $!"; |
|
|
506 | |
|
|
507 | use Data::Dumper; |
|
|
508 | say Dumper $f; |
|
|
509 | }; |
|
|
510 | |
|
|
511 | # result: |
|
|
512 | { |
|
|
513 | bsize => 1024, |
|
|
514 | bfree => 4333064312, |
|
|
515 | blocks => 10253828096, |
|
|
516 | files => 2050765568, |
|
|
517 | flag => 4096, |
|
|
518 | favail => 2042092649, |
|
|
519 | bavail => 4333064312, |
|
|
520 | ffree => 2042092649, |
|
|
521 | namemax => 255, |
|
|
522 | frsize => 1024, |
|
|
523 | fsid => 1810 |
|
|
524 | } |
|
|
525 | |
|
|
526 | |
435 | =item aio_utime $fh_or_path, $atime, $mtime, $callback->($status) |
527 | =item aio_utime $fh_or_path, $atime, $mtime, $callback->($status) |
436 | |
528 | |
437 | Works like perl's C<utime> function (including the special case of $atime |
529 | Works like perl's C<utime> function (including the special case of $atime |
438 | and $mtime being undef). Fractional times are supported if the underlying |
530 | and $mtime being undef). Fractional times are supported if the underlying |
439 | syscalls support them. |
531 | syscalls support them. |
… | |
… | |
634 | |
726 | |
635 | =item aio_copy $srcpath, $dstpath, $callback->($status) |
727 | =item aio_copy $srcpath, $dstpath, $callback->($status) |
636 | |
728 | |
637 | Try to copy the I<file> (directories not supported as either source or |
729 | Try to copy the I<file> (directories not supported as either source or |
638 | destination) from C<$srcpath> to C<$dstpath> and call the callback with |
730 | destination) from C<$srcpath> to C<$dstpath> and call the callback with |
639 | the C<0> (error) or C<-1> ok. |
731 | a status of C<0> (ok) or C<-1> (error, see C<$!>). |
640 | |
732 | |
641 | This is a composite request that creates the destination file with |
733 | This is a composite request that creates the destination file with |
642 | mode 0200 and copies the contents of the source file into it using |
734 | mode 0200 and copies the contents of the source file into it using |
643 | C<aio_sendfile>, followed by restoring atime, mtime, access mode and |
735 | C<aio_sendfile>, followed by restoring atime, mtime, access mode and |
644 | uid/gid, in that order. |
736 | uid/gid, in that order. |
… | |
… | |
656 | my $grp = aio_group $cb; |
748 | my $grp = aio_group $cb; |
657 | |
749 | |
658 | aioreq_pri $pri; |
750 | aioreq_pri $pri; |
659 | add $grp aio_open $src, O_RDONLY, 0, sub { |
751 | add $grp aio_open $src, O_RDONLY, 0, sub { |
660 | if (my $src_fh = $_[0]) { |
752 | if (my $src_fh = $_[0]) { |
661 | my @stat = stat $src_fh; # hmm, might bock over nfs? |
753 | my @stat = stat $src_fh; # hmm, might block over nfs? |
662 | |
754 | |
663 | aioreq_pri $pri; |
755 | aioreq_pri $pri; |
664 | add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { |
756 | add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { |
665 | if (my $dst_fh = $_[0]) { |
757 | if (my $dst_fh = $_[0]) { |
666 | aioreq_pri $pri; |
758 | aioreq_pri $pri; |
… | |
… | |
713 | |
805 | |
714 | =item aio_move $srcpath, $dstpath, $callback->($status) |
806 | =item aio_move $srcpath, $dstpath, $callback->($status) |
715 | |
807 | |
716 | Try to move the I<file> (directories not supported as either source or |
808 | Try to move the I<file> (directories not supported as either source or |
717 | destination) from C<$srcpath> to C<$dstpath> and call the callback with |
809 | destination) from C<$srcpath> to C<$dstpath> and call the callback with |
718 | the C<0> (error) or C<-1> ok. |
810 | a status of C<0> (ok) or C<-1> (error, see C<$!>). |
719 | |
811 | |
720 | This is a composite request that tries to rename(2) the file first; if |
812 | This is a composite request that tries to rename(2) the file first; if |
721 | rename fails with C<EXDEV>, it copies the file with C<aio_copy> and, if |
813 | rename fails with C<EXDEV>, it copies the file with C<aio_copy> and, if |
722 | that is successful, unlinks the C<$srcpath>. |
814 | that is successful, unlinks the C<$srcpath>. |
723 | |
815 | |
… | |
… | |
989 | }; |
1081 | }; |
990 | |
1082 | |
991 | $grp |
1083 | $grp |
992 | } |
1084 | } |
993 | |
1085 | |
|
|
1086 | =item aio_msync $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status) |
|
|
1087 | |
|
|
1088 | This is a rather advanced IO::AIO call, which only works on mmap(2)ed |
|
|
1089 | scalars (see the C<IO::AIO::mmap> function, although it also works on data |
|
|
1090 | scalars managed by the L<Sys::Mmap> or L<Mmap> modules, note that the |
|
|
1091 | scalar must only be modified in-place while an aio operation is pending on |
|
|
1092 | it). |
|
|
1093 | |
|
|
1094 | It calls the C<msync> function of your OS, if available, with the memory |
|
|
1095 | area starting at C<$offset> in the string and ending C<$length> bytes |
|
|
1096 | later. If C<$length> is negative, counts from the end, and if C<$length> |
|
|
1097 | is C<undef>, then it goes till the end of the string. The flags can be |
|
|
1098 | a combination of C<IO::AIO::MS_ASYNC>, C<IO::AIO::MS_INVALIDATE> and |
|
|
1099 | C<IO::AIO::MS_SYNC>. |
|
|
1100 | |
|
|
1101 | =item aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0, $callback->($status) |
|
|
1102 | |
|
|
1103 | This is a rather advanced IO::AIO call, which works best on mmap(2)ed |
|
|
1104 | scalars. |
|
|
1105 | |
|
|
1106 | It touches (reads or writes) all memory pages in the specified |
|
|
1107 | range inside the scalar. All caveats and parameters are the same |
|
|
1108 | as for C<aio_msync>, above, except for flags, which must be either |
|
|
1109 | C<0> (which reads all pages and ensures they are instantiated) or |
|
|
1110 | C<IO::AIO::MT_MODIFY>, which modifies the memory page s(by reading and |
|
|
1111 | writing an octet from it, which dirties the page). |
|
|
1112 | |
994 | =item aio_group $callback->(...) |
1113 | =item aio_group $callback->(...) |
995 | |
1114 | |
996 | This is a very special aio request: Instead of doing something, it is a |
1115 | This is a very special aio request: Instead of doing something, it is a |
997 | container for other aio requests, which is useful if you want to bundle |
1116 | container for other aio requests, which is useful if you want to bundle |
998 | many requests into a single, composite, request with a definite callback |
1117 | many requests into a single, composite, request with a definite callback |
… | |
… | |
1133 | =item $grp->cancel_subs |
1252 | =item $grp->cancel_subs |
1134 | |
1253 | |
1135 | Cancel all subrequests and clears any feeder, but not the group request |
1254 | Cancel all subrequests and clears any feeder, but not the group request |
1136 | itself. Useful when you queued a lot of events but got a result early. |
1255 | itself. Useful when you queued a lot of events but got a result early. |
1137 | |
1256 | |
|
|
1257 | The group request will finish normally (you cannot add requests to the |
|
|
1258 | group). |
|
|
1259 | |
1138 | =item $grp->result (...) |
1260 | =item $grp->result (...) |
1139 | |
1261 | |
1140 | Set the result value(s) that will be passed to the group callback when all |
1262 | Set the result value(s) that will be passed to the group callback when all |
1141 | subrequests have finished and set the groups errno to the current value |
1263 | subrequests have finished and set the groups errno to the current value |
1142 | of errno (just like calling C<errno> without an error number). By default, |
1264 | of errno (just like calling C<errno> without an error number). By default, |
… | |
… | |
1236 | |
1358 | |
1237 | Event->io (fd => IO::AIO::poll_fileno, |
1359 | Event->io (fd => IO::AIO::poll_fileno, |
1238 | poll => 'r', async => 1, |
1360 | poll => 'r', async => 1, |
1239 | cb => \&IO::AIO::poll_cb); |
1361 | cb => \&IO::AIO::poll_cb); |
1240 | |
1362 | |
|
|
1363 | =item IO::AIO::poll_wait |
|
|
1364 | |
|
|
1365 | If there are any outstanding requests and none of them in the result |
|
|
1366 | phase, wait till the result filehandle becomes ready for reading (simply |
|
|
1367 | does a C<select> on the filehandle. This is useful if you want to |
|
|
1368 | synchronously wait for some requests to finish). |
|
|
1369 | |
|
|
1370 | See C<nreqs> for an example. |
|
|
1371 | |
|
|
1372 | =item IO::AIO::poll |
|
|
1373 | |
|
|
1374 | Waits until some requests have been handled. |
|
|
1375 | |
|
|
1376 | Returns the number of requests processed, but is otherwise strictly |
|
|
1377 | equivalent to: |
|
|
1378 | |
|
|
1379 | IO::AIO::poll_wait, IO::AIO::poll_cb |
|
|
1380 | |
|
|
1381 | =item IO::AIO::flush |
|
|
1382 | |
|
|
1383 | Wait till all outstanding AIO requests have been handled. |
|
|
1384 | |
|
|
1385 | Strictly equivalent to: |
|
|
1386 | |
|
|
1387 | IO::AIO::poll_wait, IO::AIO::poll_cb |
|
|
1388 | while IO::AIO::nreqs; |
|
|
1389 | |
1241 | =item IO::AIO::max_poll_reqs $nreqs |
1390 | =item IO::AIO::max_poll_reqs $nreqs |
1242 | |
1391 | |
1243 | =item IO::AIO::max_poll_time $seconds |
1392 | =item IO::AIO::max_poll_time $seconds |
1244 | |
1393 | |
1245 | These set the maximum number of requests (default C<0>, meaning infinity) |
1394 | These set the maximum number of requests (default C<0>, meaning infinity) |
… | |
… | |
1269 | # use a low priority so other tasks have priority |
1418 | # use a low priority so other tasks have priority |
1270 | Event->io (fd => IO::AIO::poll_fileno, |
1419 | Event->io (fd => IO::AIO::poll_fileno, |
1271 | poll => 'r', nice => 1, |
1420 | poll => 'r', nice => 1, |
1272 | cb => &IO::AIO::poll_cb); |
1421 | cb => &IO::AIO::poll_cb); |
1273 | |
1422 | |
1274 | =item IO::AIO::poll_wait |
|
|
1275 | |
|
|
1276 | If there are any outstanding requests and none of them in the result |
|
|
1277 | phase, wait till the result filehandle becomes ready for reading (simply |
|
|
1278 | does a C<select> on the filehandle. This is useful if you want to |
|
|
1279 | synchronously wait for some requests to finish). |
|
|
1280 | |
|
|
1281 | See C<nreqs> for an example. |
|
|
1282 | |
|
|
1283 | =item IO::AIO::poll |
|
|
1284 | |
|
|
1285 | Waits until some requests have been handled. |
|
|
1286 | |
|
|
1287 | Returns the number of requests processed, but is otherwise strictly |
|
|
1288 | equivalent to: |
|
|
1289 | |
|
|
1290 | IO::AIO::poll_wait, IO::AIO::poll_cb |
|
|
1291 | |
|
|
1292 | =item IO::AIO::flush |
|
|
1293 | |
|
|
1294 | Wait till all outstanding AIO requests have been handled. |
|
|
1295 | |
|
|
1296 | Strictly equivalent to: |
|
|
1297 | |
|
|
1298 | IO::AIO::poll_wait, IO::AIO::poll_cb |
|
|
1299 | while IO::AIO::nreqs; |
|
|
1300 | |
|
|
1301 | =back |
1423 | =back |
1302 | |
1424 | |
1303 | =head3 CONTROLLING THE NUMBER OF THREADS |
1425 | =head3 CONTROLLING THE NUMBER OF THREADS |
1304 | |
1426 | |
1305 | =over |
1427 | =over |
… | |
… | |
1424 | C<IO::AIO::FADV_WILLNEED>, C<IO::AIO::FADV_DONTNEED>. |
1546 | C<IO::AIO::FADV_WILLNEED>, C<IO::AIO::FADV_DONTNEED>. |
1425 | |
1547 | |
1426 | On systems that do not implement C<posix_fadvise>, this function returns |
1548 | On systems that do not implement C<posix_fadvise>, this function returns |
1427 | ENOSYS, otherwise the return value of C<posix_fadvise>. |
1549 | ENOSYS, otherwise the return value of C<posix_fadvise>. |
1428 | |
1550 | |
|
|
1551 | =item IO::AIO::mmap $scalar, $length, $prot, $flags, $fh[, $offset] |
|
|
1552 | |
|
|
1553 | Memory-maps a file (or anonymous memory range) and attaches it to the |
|
|
1554 | given C<$scalar>, which will act like a string scalar. |
|
|
1555 | |
|
|
1556 | The only operations allowed on the scalar are C<substr>/C<vec> that don't |
|
|
1557 | change the string length, and most read-only operations such as copying it |
|
|
1558 | or searching it with regexes and so on. |
|
|
1559 | |
|
|
1560 | Anything else is unsafe and will, at best, result in memory leaks. |
|
|
1561 | |
|
|
1562 | The memory map associated with the C<$scalar> is automatically removed |
|
|
1563 | when the C<$scalar> is destroyed, or when the C<IO::AIO::mmap> or |
|
|
1564 | C<IO::AIO::munmap> functions are called. |
|
|
1565 | |
|
|
1566 | This calls the C<mmap>(2) function internally. See your system's manual |
|
|
1567 | page for details on the C<$length>, C<$prot> and C<$flags> parameters. |
|
|
1568 | |
|
|
1569 | The C<$length> must be larger than zero and smaller than the actual |
|
|
1570 | filesize. |
|
|
1571 | |
|
|
1572 | C<$prot> is a combination of C<IO::AIO::PROT_NONE>, C<IO::AIO::PROT_EXEC>, |
|
|
1573 | C<IO::AIO::PROT_READ> and/or C<IO::AIO::PROT_WRITE>, |
|
|
1574 | |
|
|
1575 | C<$flags> can be a combination of C<IO::AIO::MAP_SHARED> or |
|
|
1576 | C<IO::AIO::MAP_PRIVATE>, or a number of system-specific flags (when |
|
|
1577 | not available, the are defined as 0): C<IO::AIO::MAP_ANONYMOUS> |
|
|
1578 | (which is set to C<MAP_ANON> if your system only provides this |
|
|
1579 | constant), C<IO::AIO::MAP_HUGETLB>, C<IO::AIO::MAP_LOCKED>, |
|
|
1580 | C<IO::AIO::MAP_NORESERVE>, C<IO::AIO::MAP_POPULATE> or |
|
|
1581 | C<IO::AIO::MAP_NONBLOCK> |
|
|
1582 | |
|
|
1583 | If C<$fh> is C<undef>, then a file descriptor of C<-1> is passed. |
|
|
1584 | |
|
|
1585 | Example: |
|
|
1586 | |
|
|
1587 | use Digest::MD5; |
|
|
1588 | use IO::AIO; |
|
|
1589 | |
|
|
1590 | open my $fh, "<verybigfile" |
|
|
1591 | or die "$!"; |
|
|
1592 | |
|
|
1593 | IO::AIO::mmap my $data, -s $fh, IO::AIO::PROT_READ, IO::AIO::MAP_SHARED, $fh |
|
|
1594 | or die "verybigfile: $!"; |
|
|
1595 | |
|
|
1596 | my $fast_md5 = md5 $data; |
|
|
1597 | |
|
|
1598 | =item IO::AIO::munmap $scalar |
|
|
1599 | |
|
|
1600 | Removes a previous mmap and undefines the C<$scalar>. |
|
|
1601 | |
|
|
1602 | =item IO::AIO::mlockall $flags |
|
|
1603 | |
|
|
1604 | Calls the C<mlockall> function with the given C<$flags> (a combination of |
|
|
1605 | C<IO::AIO::MCL_CURRENT> and C<IO::AIO::MCL__FUTURE>). |
|
|
1606 | |
|
|
1607 | On systems that do not implement C<mlockall>, this function returns |
|
|
1608 | ENOSYS, otherwise the return value of C<mlockall>. |
|
|
1609 | |
|
|
1610 | =item IO::AIO::munlockall |
|
|
1611 | |
|
|
1612 | Calls the C<munlockall> function. |
|
|
1613 | |
|
|
1614 | On systems that do not implement C<munlockall>, this function returns |
|
|
1615 | ENOSYS, otherwise the return value of C<munlockall>. |
|
|
1616 | |
1429 | =back |
1617 | =back |
1430 | |
1618 | |
1431 | =cut |
1619 | =cut |
1432 | |
1620 | |
1433 | min_parallel 8; |
1621 | min_parallel 8; |
1434 | |
1622 | |
1435 | END { flush } |
1623 | END { flush } |
1436 | |
1624 | |
1437 | 1; |
1625 | 1; |
|
|
1626 | |
|
|
1627 | =head1 EVENT LOOP INTEGRATION |
|
|
1628 | |
|
|
1629 | It is recommended to use L<AnyEvent::AIO> to integrate IO::AIO |
|
|
1630 | automatically into many event loops: |
|
|
1631 | |
|
|
1632 | # AnyEvent integration (EV, Event, Glib, Tk, POE, urxvt, pureperl...) |
|
|
1633 | use AnyEvent::AIO; |
|
|
1634 | |
|
|
1635 | You can also integrate IO::AIO manually into many event loops, here are |
|
|
1636 | some examples of how to do this: |
|
|
1637 | |
|
|
1638 | # EV integration |
|
|
1639 | my $aio_w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb; |
|
|
1640 | |
|
|
1641 | # Event integration |
|
|
1642 | Event->io (fd => IO::AIO::poll_fileno, |
|
|
1643 | poll => 'r', |
|
|
1644 | cb => \&IO::AIO::poll_cb); |
|
|
1645 | |
|
|
1646 | # Glib/Gtk2 integration |
|
|
1647 | add_watch Glib::IO IO::AIO::poll_fileno, |
|
|
1648 | in => sub { IO::AIO::poll_cb; 1 }; |
|
|
1649 | |
|
|
1650 | # Tk integration |
|
|
1651 | Tk::Event::IO->fileevent (IO::AIO::poll_fileno, "", |
|
|
1652 | readable => \&IO::AIO::poll_cb); |
|
|
1653 | |
|
|
1654 | # Danga::Socket integration |
|
|
1655 | Danga::Socket->AddOtherFds (IO::AIO::poll_fileno => |
|
|
1656 | \&IO::AIO::poll_cb); |
1438 | |
1657 | |
1439 | =head2 FORK BEHAVIOUR |
1658 | =head2 FORK BEHAVIOUR |
1440 | |
1659 | |
1441 | This module should do "the right thing" when the process using it forks: |
1660 | This module should do "the right thing" when the process using it forks: |
1442 | |
1661 | |