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.89 by root, Sun Oct 29 11:03:18 2006 UTC vs.
Revision 1.149 by root, Sat Jun 6 18:19:35 2009 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
25 $req->cancel; # cancel request if still in queue 26 $req->cancel; # cancel request if still in queue
26 27
27 my $grp = aio_group sub { print "all stats done\n" }; 28 my $grp = aio_group sub { print "all stats done\n" };
28 add $grp aio_stat "..." for ...; 29 add $grp aio_stat "..." for ...;
29 30
31 # AnyEvent integration (EV, Event, Glib, Tk, POE, urxvt, pureperl...)
32 use AnyEvent::AIO;
33
30 # AnyEvent integration 34 # EV integration
31 open my $fh, "<&=" . IO::AIO::poll_fileno or die "$!"; 35 my $w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
32 my $w = AnyEvent->io (fh => $fh, poll => 'r', cb => sub { IO::AIO::poll_cb });
33 36
34 # Event integration 37 # Event integration
35 Event->io (fd => IO::AIO::poll_fileno, 38 Event->io (fd => IO::AIO::poll_fileno,
36 poll => 'r', 39 poll => 'r',
37 cb => \&IO::AIO::poll_cb); 40 cb => \&IO::AIO::poll_cb);
61etc.), but can also be used to easily do operations in parallel that are 64etc.), 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 65normally 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 66on a RAID volume or over NFS when you do a number of stat operations
64concurrently. 67concurrently.
65 68
66While this works on all types of file descriptors (for example sockets), 69While most of this works on all types of file descriptors (for
67using these functions on file descriptors that support nonblocking 70example sockets), using these functions on file descriptors that
68operation (again, sockets, pipes etc.) is very inefficient. Use an event 71support nonblocking operation (again, sockets, pipes etc.) is very
69loop for that (such as the L<Event|Event> module): IO::AIO will naturally 72inefficient. Use an event loop for that (such as the L<Event|Event>
70fit into such an event loop itself. 73module): IO::AIO will naturally fit into such an event loop itself.
71 74
72In this version, a number of threads are started that execute your 75In this version, a number of threads are started that execute your
73requests and signal their completion. You don't need thread support 76requests and signal their completion. You don't need thread support
74in perl, and the threads created by this module will not be visible 77in 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 78to perl. In the future, this module might make use of the native aio
77not well-supported or restricted (GNU/Linux doesn't allow them on normal 80not well-supported or restricted (GNU/Linux doesn't allow them on normal
78files currently, for example), and they would only support aio_read and 81files currently, for example), and they would only support aio_read and
79aio_write, so the remaining functionality would have to be implemented 82aio_write, so the remaining functionality would have to be implemented
80using threads anyway. 83using threads anyway.
81 84
82Although the module will work with in the presence of other (Perl-) 85Although the module will work in the presence of other (Perl-) threads,
83threads, it is currently not reentrant in any way, so use appropriate 86it is currently not reentrant in any way, so use appropriate locking
84locking yourself, always call C<poll_cb> from within the same thread, or 87yourself, always call C<poll_cb> from within the same thread, or never
85never call C<poll_cb> (or other C<aio_> functions) recursively. 88call C<poll_cb> (or other C<aio_> functions) recursively.
86 89
87=head2 EXAMPLE 90=head2 EXAMPLE
88 91
89This is a simple example that uses the Event module and loads 92This is a simple example that uses the Event module and loads
90F</etc/passwd> asynchronously: 93F</etc/passwd> asynchronously:
98 poll => 'r', 101 poll => 'r',
99 cb => \&IO::AIO::poll_cb); 102 cb => \&IO::AIO::poll_cb);
100 103
101 # queue the request to open /etc/passwd 104 # queue the request to open /etc/passwd
102 aio_open "/etc/passwd", O_RDONLY, 0, sub { 105 aio_open "/etc/passwd", O_RDONLY, 0, sub {
103 my $fh = $_[0] 106 my $fh = shift
104 or die "error while opening: $!"; 107 or die "error while opening: $!";
105 108
106 # stat'ing filehandles is generally non-blocking 109 # stat'ing filehandles is generally non-blocking
107 my $size = -s $fh; 110 my $size = -s $fh;
108 111
182 185
183=cut 186=cut
184 187
185package IO::AIO; 188package IO::AIO;
186 189
190use Carp ();
191
187no warnings; 192no warnings;
188use strict 'vars'; 193use strict 'vars';
189 194
190use base 'Exporter'; 195use base 'Exporter';
191 196
192BEGIN { 197BEGIN {
193 our $VERSION = '2.1'; 198 our $VERSION = '3.2';
194 199
195 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close aio_stat 200 our @AIO_REQ = qw(aio_sendfile aio_read aio_write aio_open aio_close
196 aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink 201 aio_stat aio_lstat aio_unlink aio_rmdir aio_readdir aio_readdirx
197 aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move 202 aio_scandir aio_symlink aio_readlink aio_sync aio_fsync
198 aio_copy aio_group aio_nop aio_mknod); 203 aio_fdatasync aio_sync_file_range aio_pathsync aio_readahead
204 aio_rename aio_link aio_move aio_copy aio_group
205 aio_nop aio_mknod aio_load aio_rmtree aio_mkdir aio_chown
206 aio_chmod aio_utime aio_truncate);
207
199 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice)); 208 our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice));
200 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush 209 our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
201 min_parallel max_parallel max_idle 210 min_parallel max_parallel max_idle
202 nreqs nready npending nthreads 211 nreqs nready npending nthreads
203 max_poll_time max_poll_reqs); 212 max_poll_time max_poll_reqs);
204 213
214 push @AIO_REQ, qw(aio_busy); # not exported
215
205 @IO::AIO::GRP::ISA = 'IO::AIO::REQ'; 216 @IO::AIO::GRP::ISA = 'IO::AIO::REQ';
206 217
207 require XSLoader; 218 require XSLoader;
208 XSLoader::load ("IO::AIO", $VERSION); 219 XSLoader::load ("IO::AIO", $VERSION);
209} 220}
215All the C<aio_*> calls are more or less thin wrappers around the syscall 226All the C<aio_*> calls are more or less thin wrappers around the syscall
216with the same name (sans C<aio_>). The arguments are similar or identical, 227with the same name (sans C<aio_>). The arguments are similar or identical,
217and they all accept an additional (and optional) C<$callback> argument 228and they all accept an additional (and optional) C<$callback> argument
218which must be a code reference. This code reference will get called with 229which must be a code reference. This code reference will get called with
219the syscall return code (e.g. most syscalls return C<-1> on error, unlike 230the syscall return code (e.g. most syscalls return C<-1> on error, unlike
220perl, which usually delivers "false") as it's sole argument when the given 231perl, which usually delivers "false") as its sole argument after the given
221syscall has been executed asynchronously. 232syscall has been executed asynchronously.
222 233
223All functions expecting a filehandle keep a copy of the filehandle 234All functions expecting a filehandle keep a copy of the filehandle
224internally until the request has finished. 235internally until the request has finished.
225 236
239your pathnames to the locale (or other) encoding in effect in the user 250your pathnames to the locale (or other) encoding in effect in the user
240environment, d) use Glib::filename_from_unicode on unicode filenames or e) 251environment, d) use Glib::filename_from_unicode on unicode filenames or e)
241use something else to ensure your scalar has the correct contents. 252use something else to ensure your scalar has the correct contents.
242 253
243This works, btw. independent of the internal UTF-8 bit, which IO::AIO 254This works, btw. independent of the internal UTF-8 bit, which IO::AIO
244handles correctly wether it is set or not. 255handles correctly whether it is set or not.
245 256
246=over 4 257=over 4
247 258
248=item $prev_pri = aioreq_pri [$pri] 259=item $prev_pri = aioreq_pri [$pri]
249 260
269 aio_read $_[0], ..., sub { 280 aio_read $_[0], ..., sub {
270 ... 281 ...
271 }; 282 };
272 }; 283 };
273 284
285
274=item aioreq_nice $pri_adjust 286=item aioreq_nice $pri_adjust
275 287
276Similar to C<aioreq_pri>, but subtracts the given value from the current 288Similar to C<aioreq_pri>, but subtracts the given value from the current
277priority, so the effect is cumulative. 289priority, so the effect is cumulative.
290
278 291
279=item aio_open $pathname, $flags, $mode, $callback->($fh) 292=item aio_open $pathname, $flags, $mode, $callback->($fh)
280 293
281Asynchronously open or create a file and call the callback with a newly 294Asynchronously open or create a file and call the callback with a newly
282created filehandle for the file. 295created filehandle for the file.
288list. They are the same as used by C<sysopen>. 301list. They are the same as used by C<sysopen>.
289 302
290Likewise, C<$mode> specifies the mode of the newly created file, if it 303Likewise, C<$mode> specifies the mode of the newly created file, if it
291didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>, 304didn't exist and C<O_CREAT> has been given, just like perl's C<sysopen>,
292except that it is mandatory (i.e. use C<0> if you don't create new files, 305except that it is mandatory (i.e. use C<0> if you don't create new files,
293and C<0666> or C<0777> if you do). 306and C<0666> or C<0777> if you do). Note that the C<$mode> will be modified
307by the umask in effect then the request is being executed, so better never
308change the umask.
294 309
295Example: 310Example:
296 311
297 aio_open "/etc/passwd", O_RDONLY, 0, sub { 312 aio_open "/etc/passwd", O_RDONLY, 0, sub {
298 if ($_[0]) { 313 if ($_[0]) {
301 } else { 316 } else {
302 die "open failed: $!\n"; 317 die "open failed: $!\n";
303 } 318 }
304 }; 319 };
305 320
321
306=item aio_close $fh, $callback->($status) 322=item aio_close $fh, $callback->($status)
307 323
308Asynchronously close a file and call the callback with the result 324Asynchronously close a file and call the callback with the result
309code. I<WARNING:> although accepted, you should not pass in a perl 325code.
310filehandle here, as perl will likely close the file descriptor another
311time when the filehandle is destroyed. Normally, you can safely call perls
312C<close> or just let filehandles go out of scope.
313 326
314This is supposed to be a bug in the API, so that might change. It's 327Unfortunately, you can't do this to perl. Perl I<insists> very strongly on
315therefore best to avoid this function. 328closing the file descriptor associated with the filehandle itself.
329
330Therefore, C<aio_close> will not close the filehandle - instead it will
331use dup2 to overwrite the file descriptor with the write-end of a pipe
332(the pipe fd will be created on demand and will be cached).
333
334Or in other words: the file descriptor will be closed, but it will not be
335free for reuse until the perl filehandle is closed.
336
337=cut
316 338
317=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 339=item aio_read $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
318 340
319=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval) 341=item aio_write $fh,$offset,$length, $data,$dataoffset, $callback->($retval)
320 342
321Reads or writes C<length> bytes from the specified C<fh> and C<offset> 343Reads or writes C<$length> bytes from or to the specified C<$fh> and
322into the scalar given by C<data> and offset C<dataoffset> and calls the 344C<$offset> into the scalar given by C<$data> and offset C<$dataoffset>
323callback without the actual number of bytes read (or -1 on error, just 345and calls the callback without the actual number of bytes read (or -1 on
324like the syscall). 346error, just like the syscall).
347
348C<aio_read> will, like C<sysread>, shrink or grow the C<$data> scalar to
349offset plus the actual number of bytes read.
350
351If C<$offset> is undefined, then the current file descriptor offset will
352be used (and updated), otherwise the file descriptor offset will not be
353changed by these calls.
354
355If C<$length> is undefined in C<aio_write>, use the remaining length of
356C<$data>.
357
358If C<$dataoffset> is less than zero, it will be counted from the end of
359C<$data>.
325 360
326The C<$data> scalar I<MUST NOT> be modified in any way while the request 361The C<$data> scalar I<MUST NOT> be modified in any way while the request
327is outstanding. Modifying it can result in segfaults or WW3 (if the 362is outstanding. Modifying it can result in segfaults or World War III (if
328necessary/optional hardware is installed). 363the necessary/optional hardware is installed).
329 364
330Example: Read 15 bytes at offset 7 into scalar C<$buffer>, starting at 365Example: Read 15 bytes at offset 7 into scalar C<$buffer>, starting at
331offset C<0> within the scalar: 366offset C<0> within the scalar:
332 367
333 aio_read $fh, 7, 15, $buffer, 0, sub { 368 aio_read $fh, 7, 15, $buffer, 0, sub {
334 $_[0] > 0 or die "read error: $!"; 369 $_[0] > 0 or die "read error: $!";
335 print "read $_[0] bytes: <$buffer>\n"; 370 print "read $_[0] bytes: <$buffer>\n";
336 }; 371 };
372
337 373
338=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval) 374=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback->($retval)
339 375
340Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts 376Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts
341reading at byte offset C<$in_offset>, and starts writing at the current 377reading at byte offset C<$in_offset>, and starts writing at the current
355C<$in_fh> than are written, and there is no way to find out how many 391C<$in_fh> than are written, and there is no way to find out how many
356bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only 392bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only
357provides the number of bytes written to C<$out_fh>. Only if the result 393provides the number of bytes written to C<$out_fh>. Only if the result
358value equals C<$length> one can assume that C<$length> bytes have been 394value equals C<$length> one can assume that C<$length> bytes have been
359read. 395read.
396
360 397
361=item aio_readahead $fh,$offset,$length, $callback->($retval) 398=item aio_readahead $fh,$offset,$length, $callback->($retval)
362 399
363C<aio_readahead> populates the page cache with data from a file so that 400C<aio_readahead> populates the page cache with data from a file so that
364subsequent reads from that file will not block on disk I/O. The C<$offset> 401subsequent reads from that file will not block on disk I/O. The C<$offset>
370file. The current file offset of the file is left unchanged. 407file. The current file offset of the file is left unchanged.
371 408
372If that syscall doesn't exist (likely if your OS isn't Linux) it will be 409If that syscall doesn't exist (likely if your OS isn't Linux) it will be
373emulated by simply reading the data, which would have a similar effect. 410emulated by simply reading the data, which would have a similar effect.
374 411
412
375=item aio_stat $fh_or_path, $callback->($status) 413=item aio_stat $fh_or_path, $callback->($status)
376 414
377=item aio_lstat $fh, $callback->($status) 415=item aio_lstat $fh, $callback->($status)
378 416
379Works like perl's C<stat> or C<lstat> in void context. The callback will 417Works like perl's C<stat> or C<lstat> in void context. The callback will
392 aio_stat "/etc/passwd", sub { 430 aio_stat "/etc/passwd", sub {
393 $_[0] and die "stat failed: $!"; 431 $_[0] and die "stat failed: $!";
394 print "size is ", -s _, "\n"; 432 print "size is ", -s _, "\n";
395 }; 433 };
396 434
435
436=item aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
437
438Works like perl's C<utime> function (including the special case of $atime
439and $mtime being undef). Fractional times are supported if the underlying
440syscalls support them.
441
442When called with a pathname, uses utimes(2) if available, otherwise
443utime(2). If called on a file descriptor, uses futimes(2) if available,
444otherwise returns ENOSYS, so this is not portable.
445
446Examples:
447
448 # set atime and mtime to current time (basically touch(1)):
449 aio_utime "path", undef, undef;
450 # set atime to current time and mtime to beginning of the epoch:
451 aio_utime "path", time, undef; # undef==0
452
453
454=item aio_chown $fh_or_path, $uid, $gid, $callback->($status)
455
456Works like perl's C<chown> function, except that C<undef> for either $uid
457or $gid is being interpreted as "do not change" (but -1 can also be used).
458
459Examples:
460
461 # same as "chown root path" in the shell:
462 aio_chown "path", 0, -1;
463 # same as above:
464 aio_chown "path", 0, undef;
465
466
467=item aio_truncate $fh_or_path, $offset, $callback->($status)
468
469Works like truncate(2) or ftruncate(2).
470
471
472=item aio_chmod $fh_or_path, $mode, $callback->($status)
473
474Works like perl's C<chmod> function.
475
476
397=item aio_unlink $pathname, $callback->($status) 477=item aio_unlink $pathname, $callback->($status)
398 478
399Asynchronously unlink (delete) a file and call the callback with the 479Asynchronously unlink (delete) a file and call the callback with the
400result code. 480result code.
401 481
482
402=item aio_mknod $path, $mode, $dev, $callback->($status) 483=item aio_mknod $path, $mode, $dev, $callback->($status)
403 484
404[EXPERIMENTAL] 485[EXPERIMENTAL]
405 486
406Asynchronously create a device node (or fifo). See mknod(2). 487Asynchronously create a device node (or fifo). See mknod(2).
407 488
408The only (POSIX-) portable way of calling this function is: 489The only (POSIX-) portable way of calling this function is:
409 490
410 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ... 491 aio_mknod $path, IO::AIO::S_IFIFO | $mode, 0, sub { ...
492
411 493
412=item aio_link $srcpath, $dstpath, $callback->($status) 494=item aio_link $srcpath, $dstpath, $callback->($status)
413 495
414Asynchronously create a new link to the existing object at C<$srcpath> at 496Asynchronously create a new link to the existing object at C<$srcpath> at
415the path C<$dstpath> and call the callback with the result code. 497the path C<$dstpath> and call the callback with the result code.
416 498
499
417=item aio_symlink $srcpath, $dstpath, $callback->($status) 500=item aio_symlink $srcpath, $dstpath, $callback->($status)
418 501
419Asynchronously create a new symbolic link to the existing object at C<$srcpath> at 502Asynchronously create a new symbolic link to the existing object at C<$srcpath> at
420the path C<$dstpath> and call the callback with the result code. 503the path C<$dstpath> and call the callback with the result code.
421 504
505
506=item aio_readlink $path, $callback->($link)
507
508Asynchronously read the symlink specified by C<$path> and pass it to
509the callback. If an error occurs, nothing or undef gets passed to the
510callback.
511
512
422=item aio_rename $srcpath, $dstpath, $callback->($status) 513=item aio_rename $srcpath, $dstpath, $callback->($status)
423 514
424Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as 515Asynchronously rename the object at C<$srcpath> to C<$dstpath>, just as
425rename(2) and call the callback with the result code. 516rename(2) and call the callback with the result code.
426 517
518
519=item aio_mkdir $pathname, $mode, $callback->($status)
520
521Asynchronously mkdir (create) a directory and call the callback with
522the result code. C<$mode> will be modified by the umask at the time the
523request is executed, so do not change your umask.
524
525
427=item aio_rmdir $pathname, $callback->($status) 526=item aio_rmdir $pathname, $callback->($status)
428 527
429Asynchronously rmdir (delete) a directory and call the callback with the 528Asynchronously rmdir (delete) a directory and call the callback with the
430result code. 529result code.
530
431 531
432=item aio_readdir $pathname, $callback->($entries) 532=item aio_readdir $pathname, $callback->($entries)
433 533
434Unlike the POSIX call of the same name, C<aio_readdir> reads an entire 534Unlike the POSIX call of the same name, C<aio_readdir> reads an entire
435directory (i.e. opendir + readdir + closedir). The entries will not be 535directory (i.e. opendir + readdir + closedir). The entries will not be
436sorted, and will B<NOT> include the C<.> and C<..> entries. 536sorted, and will B<NOT> include the C<.> and C<..> entries.
437 537
438The callback a single argument which is either C<undef> or an array-ref 538The callback is passed a single argument which is either C<undef> or an
439with the filenames. 539array-ref with the filenames.
540
541
542=item aio_readdirx $pathname, $flags, $callback->($entries, $flags)
543
544Quite similar to C<aio_readdir>, but the C<$flags> argument allows to tune
545behaviour and output format. In case of an error, C<$entries> will be
546C<undef>.
547
548The flags are a combination of the following constants, ORed together (the
549flags will also be passed to the callback, possibly modified):
550
551=over 4
552
553=item AIO::READDIR_DENTS
554
555When this flag is off, then the callback gets an arrayref with of names
556only (as with C<aio_readdir>), otherwise it gets an arrayref with
557C<[$name, $inode, $type]> arrayrefs, each describing a single directory
558entry in more detail.
559
560C<$name> is the name of the entry.
561
562C<$inode> is the inode number (which might not be exact on systems with 64
563bit inode numbers and 32 bit perls). On systems that do not deliver the
564inode information, this will always be zero.
565
566C<$type> is one of the C<AIO::DT_xxx> constants:
567
568C<AIO::DT_UNKNOWN>, C<AIO::DT_FIFO>, C<AIO::DT_CHR>, C<AIO::DT_DIR>,
569C<AIO::DT_BLK>, C<AIO::DT_REG>, C<AIO::DT_LNK>, C<AIO::DT_SOCK>,
570C<AIO::DT_WHT>.
571
572C<AIO::DT_UNKNOWN> means just that: readdir does not know. If you need to
573know, you have to run stat yourself. Also, for speed reasons, the C<$type>
574scalars are read-only: you can not modify them.
575
576=item AIO::READDIR_DIRS_FIRST
577
578When this flag is set, then the names will be returned in an order where
579likely directories come first. This is useful when you need to quickly
580find directories, or you want to find all directories while avoiding to
581stat() each entry.
582
583If the system returns type information in readdir, then this is used
584to find directories directly. Otherwise, likely directories are files
585beginning with ".", or otherwise files with no dots, of which files with
586short names are tried first.
587
588=item AIO::READDIR_STAT_ORDER
589
590When this flag is set, then the names will be returned in an order
591suitable for stat()'ing each one. That is, when you plan to stat()
592all files in the given directory, then the returned order will likely
593be fastest.
594
595If both this flag and IO::READDIR_DIRS_FIRST are specified, then the
596likely dirs come first, resulting in a less optimal stat order.
597
598=item AIO::READDIR_FOUND_UNKNOWN
599
600This flag should not be set when calling C<aio_readdirx>. Instead, it
601is being set by C<aio_readdirx>, when any of the C<$type>'s found were
602C<AIO::DT_UNKNOWN>. The absense of this flag therefore indicates that all
603C<$type>'s are known, which can be used to speed up some algorithms.
604
605=back
606
607
608=item aio_load $path, $data, $callback->($status)
609
610This is a composite request that tries to fully load the given file into
611memory. Status is the same as with aio_read.
612
613=cut
614
615sub aio_load($$;$) {
616 my ($path, undef, $cb) = @_;
617 my $data = \$_[1];
618
619 my $pri = aioreq_pri;
620 my $grp = aio_group $cb;
621
622 aioreq_pri $pri;
623 add $grp aio_open $path, O_RDONLY, 0, sub {
624 my $fh = shift
625 or return $grp->result (-1);
626
627 aioreq_pri $pri;
628 add $grp aio_read $fh, 0, (-s $fh), $$data, 0, sub {
629 $grp->result ($_[0]);
630 };
631 };
632
633 $grp
634}
440 635
441=item aio_copy $srcpath, $dstpath, $callback->($status) 636=item aio_copy $srcpath, $dstpath, $callback->($status)
442 637
443Try to copy the I<file> (directories not supported as either source or 638Try to copy the I<file> (directories not supported as either source or
444destination) from C<$srcpath> to C<$dstpath> and call the callback with 639destination) from C<$srcpath> to C<$dstpath> and call the callback with
445the C<0> (error) or C<-1> ok. 640the C<0> (error) or C<-1> ok.
446 641
447This is a composite request that it creates the destination file with 642This is a composite request that creates the destination file with
448mode 0200 and copies the contents of the source file into it using 643mode 0200 and copies the contents of the source file into it using
449C<aio_sendfile>, followed by restoring atime, mtime, access mode and 644C<aio_sendfile>, followed by restoring atime, mtime, access mode and
450uid/gid, in that order. 645uid/gid, in that order.
451 646
452If an error occurs, the partial destination file will be unlinked, if 647If an error occurs, the partial destination file will be unlinked, if
462 my $grp = aio_group $cb; 657 my $grp = aio_group $cb;
463 658
464 aioreq_pri $pri; 659 aioreq_pri $pri;
465 add $grp aio_open $src, O_RDONLY, 0, sub { 660 add $grp aio_open $src, O_RDONLY, 0, sub {
466 if (my $src_fh = $_[0]) { 661 if (my $src_fh = $_[0]) {
467 my @stat = stat $src_fh; 662 my @stat = stat $src_fh; # hmm, might bock over nfs?
468 663
469 aioreq_pri $pri; 664 aioreq_pri $pri;
470 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub { 665 add $grp aio_open $dst, O_CREAT | O_WRONLY | O_TRUNC, 0200, sub {
471 if (my $dst_fh = $_[0]) { 666 if (my $dst_fh = $_[0]) {
472 aioreq_pri $pri; 667 aioreq_pri $pri;
473 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub { 668 add $grp aio_sendfile $dst_fh, $src_fh, 0, $stat[7], sub {
474 if ($_[0] == $stat[7]) { 669 if ($_[0] == $stat[7]) {
475 $grp->result (0); 670 $grp->result (0);
476 close $src_fh; 671 close $src_fh;
477 672
478 # those should not normally block. should. should. 673 my $ch = sub {
674 aioreq_pri $pri;
675 add $grp aio_chmod $dst_fh, $stat[2] & 07777, sub {
676 aioreq_pri $pri;
677 add $grp aio_chown $dst_fh, $stat[4], $stat[5], sub {
678 aioreq_pri $pri;
679 add $grp aio_close $dst_fh;
680 }
681 };
682 };
683
684 aioreq_pri $pri;
685 add $grp aio_utime $dst_fh, $stat[8], $stat[9], sub {
686 if ($_[0] < 0 && $! == ENOSYS) {
687 aioreq_pri $pri;
479 utime $stat[8], $stat[9], $dst; 688 add $grp aio_utime $dst, $stat[8], $stat[9], $ch;
480 chmod $stat[2] & 07777, $dst_fh; 689 } else {
481 chown $stat[4], $stat[5], $dst_fh; 690 $ch->();
691 }
482 close $dst_fh; 692 };
483 } else { 693 } else {
484 $grp->result (-1); 694 $grp->result (-1);
485 close $src_fh; 695 close $src_fh;
486 close $dst_fh; 696 close $dst_fh;
487 697
506 716
507Try to move the I<file> (directories not supported as either source or 717Try to move the I<file> (directories not supported as either source or
508destination) from C<$srcpath> to C<$dstpath> and call the callback with 718destination) from C<$srcpath> to C<$dstpath> and call the callback with
509the C<0> (error) or C<-1> ok. 719the C<0> (error) or C<-1> ok.
510 720
511This is a composite request that tries to rename(2) the file first. If 721This is a composite request that tries to rename(2) the file first; if
512rename files with C<EXDEV>, it copies the file with C<aio_copy> and, if 722rename fails with C<EXDEV>, it copies the file with C<aio_copy> and, if
513that is successful, unlinking the C<$srcpath>. 723that is successful, unlinks the C<$srcpath>.
514 724
515=cut 725=cut
516 726
517sub aio_move($$;$) { 727sub aio_move($$;$) {
518 my ($src, $dst, $cb) = @_; 728 my ($src, $dst, $cb) = @_;
565 775
566Implementation notes. 776Implementation notes.
567 777
568The C<aio_readdir> cannot be avoided, but C<stat()>'ing every entry can. 778The C<aio_readdir> cannot be avoided, but C<stat()>'ing every entry can.
569 779
780If readdir returns file type information, then this is used directly to
781find directories.
782
570After reading the directory, the modification time, size etc. of the 783Otherwise, after reading the directory, the modification time, size etc.
571directory before and after the readdir is checked, and if they match (and 784of the directory before and after the readdir is checked, and if they
572isn't the current time), the link count will be used to decide how many 785match (and isn't the current time), the link count will be used to decide
573entries are directories (if >= 2). Otherwise, no knowledge of the number 786how many entries are directories (if >= 2). Otherwise, no knowledge of the
574of subdirectories will be assumed. 787number of subdirectories will be assumed.
575 788
576Then entries will be sorted into likely directories (everything without 789Then entries will be sorted into likely directories a non-initial dot
577a non-initial dot currently) and likely non-directories (everything 790currently) and likely non-directories (see C<aio_readdirx>). Then every
578else). Then every entry plus an appended C</.> will be C<stat>'ed, 791entry plus an appended C</.> will be C<stat>'ed, likely directories first,
579likely directories first. If that succeeds, it assumes that the entry 792in order of their inode numbers. If that succeeds, it assumes that the
580is a directory or a symlink to directory (which will be checked 793entry is a directory or a symlink to directory (which will be checked
581seperately). This is often faster than stat'ing the entry itself because 794seperately). This is often faster than stat'ing the entry itself because
582filesystems might detect the type of the entry without reading the inode 795filesystems might detect the type of the entry without reading the inode
583data (e.g. ext2fs filetype feature). 796data (e.g. ext2fs filetype feature), even on systems that cannot return
797the filetype information on readdir.
584 798
585If the known number of directories (link count - 2) has been reached, the 799If the known number of directories (link count - 2) has been reached, the
586rest of the entries is assumed to be non-directories. 800rest of the entries is assumed to be non-directories.
587 801
588This only works with certainty on POSIX (= UNIX) filesystems, which 802This only works with certainty on POSIX (= UNIX) filesystems, which
592as those tend to return 0 or 1 as link counts, which disables the 806as those tend to return 0 or 1 as link counts, which disables the
593directory counting heuristic. 807directory counting heuristic.
594 808
595=cut 809=cut
596 810
597sub aio_scandir($$$) { 811sub aio_scandir($$;$) {
598 my ($path, $maxreq, $cb) = @_; 812 my ($path, $maxreq, $cb) = @_;
599 813
600 my $pri = aioreq_pri; 814 my $pri = aioreq_pri;
601 815
602 my $grp = aio_group $cb; 816 my $grp = aio_group $cb;
610 my $now = time; 824 my $now = time;
611 my $hash1 = join ":", (stat _)[0,1,3,7,9]; 825 my $hash1 = join ":", (stat _)[0,1,3,7,9];
612 826
613 # read the directory entries 827 # read the directory entries
614 aioreq_pri $pri; 828 aioreq_pri $pri;
615 add $grp aio_readdir $path, sub { 829 add $grp aio_readdirx $path, READDIR_DIRS_FIRST, sub {
616 my $entries = shift 830 my $entries = shift
617 or return $grp->result (); 831 or return $grp->result ();
618 832
619 # stat the dir another time 833 # stat the dir another time
620 aioreq_pri $pri; 834 aioreq_pri $pri;
630 # if nlink == 2, we are finished 844 # if nlink == 2, we are finished
631 # on non-posix-fs's, we rely on nlink < 2 845 # on non-posix-fs's, we rely on nlink < 2
632 $ndirs = (stat _)[3] - 2 846 $ndirs = (stat _)[3] - 2
633 or return $grp->result ([], $entries); 847 or return $grp->result ([], $entries);
634 } 848 }
635
636 # sort into likely dirs and likely nondirs
637 # dirs == files without ".", short entries first
638 $entries = [map $_->[0],
639 sort { $b->[1] cmp $a->[1] }
640 map [$_, sprintf "%s%04d", (/.\./ ? "1" : "0"), length],
641 @$entries];
642 849
643 my (@dirs, @nondirs); 850 my (@dirs, @nondirs);
644 851
645 my $statgrp = add $grp aio_group sub { 852 my $statgrp = add $grp aio_group sub {
646 $grp->result (\@dirs, \@nondirs); 853 $grp->result (\@dirs, \@nondirs);
678 }; 885 };
679 886
680 $grp 887 $grp
681} 888}
682 889
890=item aio_rmtree $path, $callback->($status)
891
892Delete a directory tree starting (and including) C<$path>, return the
893status of the final C<rmdir> only. This is a composite request that
894uses C<aio_scandir> to recurse into and rmdir directories, and unlink
895everything else.
896
897=cut
898
899sub aio_rmtree;
900sub aio_rmtree($;$) {
901 my ($path, $cb) = @_;
902
903 my $pri = aioreq_pri;
904 my $grp = aio_group $cb;
905
906 aioreq_pri $pri;
907 add $grp aio_scandir $path, 0, sub {
908 my ($dirs, $nondirs) = @_;
909
910 my $dirgrp = aio_group sub {
911 add $grp aio_rmdir $path, sub {
912 $grp->result ($_[0]);
913 };
914 };
915
916 (aioreq_pri $pri), add $dirgrp aio_rmtree "$path/$_" for @$dirs;
917 (aioreq_pri $pri), add $dirgrp aio_unlink "$path/$_" for @$nondirs;
918
919 add $grp $dirgrp;
920 };
921
922 $grp
923}
924
925=item aio_sync $callback->($status)
926
927Asynchronously call sync and call the callback when finished.
928
683=item aio_fsync $fh, $callback->($status) 929=item aio_fsync $fh, $callback->($status)
684 930
685Asynchronously call fsync on the given filehandle and call the callback 931Asynchronously call fsync on the given filehandle and call the callback
686with the fsync result code. 932with the fsync result code.
687 933
690Asynchronously call fdatasync on the given filehandle and call the 936Asynchronously call fdatasync on the given filehandle and call the
691callback with the fdatasync result code. 937callback with the fdatasync result code.
692 938
693If this call isn't available because your OS lacks it or it couldn't be 939If this call isn't available because your OS lacks it or it couldn't be
694detected, it will be emulated by calling C<fsync> instead. 940detected, it will be emulated by calling C<fsync> instead.
941
942=item aio_sync_file_range $fh, $offset, $nbytes, $flags, $callback->($status)
943
944Sync the data portion of the file specified by C<$offset> and C<$length>
945to disk (but NOT the metadata), by calling the Linux-specific
946sync_file_range call. If sync_file_range is not available or it returns
947ENOSYS, then fdatasync or fsync is being substituted.
948
949C<$flags> can be a combination of C<IO::AIO::SYNC_FILE_RANGE_WAIT_BEFORE>,
950C<IO::AIO::SYNC_FILE_RANGE_WRITE> and
951C<IO::AIO::SYNC_FILE_RANGE_WAIT_AFTER>: refer to the sync_file_range
952manpage for details.
953
954=item aio_pathsync $path, $callback->($status)
955
956This request tries to open, fsync and close the given path. This is a
957composite request intended to sync directories after directory operations
958(E.g. rename). This might not work on all operating systems or have any
959specific effect, but usually it makes sure that directory changes get
960written to disc. It works for anything that can be opened for read-only,
961not just directories.
962
963Passes C<0> when everything went ok, and C<-1> on error.
964
965=cut
966
967sub aio_pathsync($;$) {
968 my ($path, $cb) = @_;
969
970 my $pri = aioreq_pri;
971 my $grp = aio_group $cb;
972
973 aioreq_pri $pri;
974 add $grp aio_open $path, O_RDONLY, 0, sub {
975 my ($fh) = @_;
976 if ($fh) {
977 aioreq_pri $pri;
978 add $grp aio_fsync $fh, sub {
979 $grp->result ($_[0]);
980
981 aioreq_pri $pri;
982 add $grp aio_close $fh;
983 };
984 } else {
985 $grp->result (-1);
986 }
987 };
988
989 $grp
990}
695 991
696=item aio_group $callback->(...) 992=item aio_group $callback->(...)
697 993
698This is a very special aio request: Instead of doing something, it is a 994This is a very special aio request: Instead of doing something, it is a
699container for other aio requests, which is useful if you want to bundle 995container for other aio requests, which is useful if you want to bundle
811Their lifetime, simplified, looks like this: when they are empty, they 1107Their lifetime, simplified, looks like this: when they are empty, they
812will finish very quickly. If they contain only requests that are in the 1108will finish very quickly. If they contain only requests that are in the
813C<done> state, they will also finish. Otherwise they will continue to 1109C<done> state, they will also finish. Otherwise they will continue to
814exist. 1110exist.
815 1111
816That means after creating a group you have some time to add requests. And 1112That means after creating a group you have some time to add requests
817in the callbacks of those requests, you can add further requests to the 1113(precisely before the callback has been invoked, which is only done within
818group. And only when all those requests have finished will the the group 1114the C<poll_cb>). And in the callbacks of those requests, you can add
819itself finish. 1115further requests to the group. And only when all those requests have
1116finished will the the group itself finish.
820 1117
821=over 4 1118=over 4
822 1119
823=item add $grp ... 1120=item add $grp ...
824 1121
836itself. Useful when you queued a lot of events but got a result early. 1133itself. Useful when you queued a lot of events but got a result early.
837 1134
838=item $grp->result (...) 1135=item $grp->result (...)
839 1136
840Set the result value(s) that will be passed to the group callback when all 1137Set the result value(s) that will be passed to the group callback when all
841subrequests have finished and set thre groups errno to the current value 1138subrequests have finished and set the groups errno to the current value
842of errno (just like calling C<errno> without an error number). By default, 1139of errno (just like calling C<errno> without an error number). By default,
843no argument will be passed and errno is zero. 1140no argument will be passed and errno is zero.
844 1141
845=item $grp->errno ([$errno]) 1142=item $grp->errno ([$errno])
846 1143
857=item feed $grp $callback->($grp) 1154=item feed $grp $callback->($grp)
858 1155
859Sets a feeder/generator on this group: every group can have an attached 1156Sets a feeder/generator on this group: every group can have an attached
860generator that generates requests if idle. The idea behind this is that, 1157generator that generates requests if idle. The idea behind this is that,
861although you could just queue as many requests as you want in a group, 1158although you could just queue as many requests as you want in a group,
862this might starve other requests for a potentially long time. For 1159this might starve other requests for a potentially long time. For example,
863example, C<aio_scandir> might generate hundreds of thousands C<aio_stat> 1160C<aio_scandir> might generate hundreds of thousands C<aio_stat> requests,
864requests, delaying any later requests for a long time. 1161delaying any later requests for a long time.
865 1162
866To avoid this, and allow incremental generation of requests, you can 1163To avoid this, and allow incremental generation of requests, you can
867instead a group and set a feeder on it that generates those requests. The 1164instead a group and set a feeder on it that generates those requests. The
868feed callback will be called whenever there are few enough (see C<limit>, 1165feed callback will be called whenever there are few enough (see C<limit>,
869below) requests active in the group itself and is expected to queue more 1166below) requests active in the group itself and is expected to queue more
873not impose any limits). 1170not impose any limits).
874 1171
875If the feed does not queue more requests when called, it will be 1172If the feed does not queue more requests when called, it will be
876automatically removed from the group. 1173automatically removed from the group.
877 1174
878If the feed limit is C<0>, it will be set to C<2> automatically. 1175If the feed limit is C<0> when this method is called, it will be set to
1176C<2> automatically.
879 1177
880Example: 1178Example:
881 1179
882 # stat all files in @files, but only ever use four aio requests concurrently: 1180 # stat all files in @files, but only ever use four aio requests concurrently:
883 1181
895Sets the feeder limit for the group: The feeder will be called whenever 1193Sets the feeder limit for the group: The feeder will be called whenever
896the group contains less than this many requests. 1194the group contains less than this many requests.
897 1195
898Setting the limit to C<0> will pause the feeding process. 1196Setting the limit to C<0> will pause the feeding process.
899 1197
1198The default value for the limit is C<0>, but note that setting a feeder
1199automatically bumps it up to C<2>.
1200
900=back 1201=back
901 1202
902=head2 SUPPORT FUNCTIONS 1203=head2 SUPPORT FUNCTIONS
903 1204
904=head3 EVENT PROCESSING AND EVENT LOOP INTEGRATION 1205=head3 EVENT PROCESSING AND EVENT LOOP INTEGRATION
915See C<poll_cb> for an example. 1216See C<poll_cb> for an example.
916 1217
917=item IO::AIO::poll_cb 1218=item IO::AIO::poll_cb
918 1219
919Process some outstanding events on the result pipe. You have to call this 1220Process some outstanding events on the result pipe. You have to call this
920regularly. Returns the number of events processed. Returns immediately 1221regularly. Returns C<0> if all events could be processed, or C<-1> if it
1222returned earlier for whatever reason. Returns immediately when no events
921when no events are outstanding. The amount of events processed depends on 1223are outstanding. The amount of events processed depends on the settings of
922the settings of C<IO::AIO::max_poll_req> and C<IO::AIO::max_poll_time>. 1224C<IO::AIO::max_poll_req> and C<IO::AIO::max_poll_time>.
923 1225
924If not all requests were processed for whatever reason, the filehandle 1226If not all requests were processed for whatever reason, the filehandle
925will still be ready when C<poll_cb> returns. 1227will still be ready when C<poll_cb> returns, so normally you don't have to
1228do anything special to have it called later.
926 1229
927Example: Install an Event watcher that automatically calls 1230Example: Install an Event watcher that automatically calls
928IO::AIO::poll_cb with high priority: 1231IO::AIO::poll_cb with high priority:
929 1232
930 Event->io (fd => IO::AIO::poll_fileno, 1233 Event->io (fd => IO::AIO::poll_fileno,
964 poll => 'r', nice => 1, 1267 poll => 'r', nice => 1,
965 cb => &IO::AIO::poll_cb); 1268 cb => &IO::AIO::poll_cb);
966 1269
967=item IO::AIO::poll_wait 1270=item IO::AIO::poll_wait
968 1271
1272If there are any outstanding requests and none of them in the result
969Wait till the result filehandle becomes ready for reading (simply does a 1273phase, wait till the result filehandle becomes ready for reading (simply
970C<select> on the filehandle. This is useful if you want to synchronously 1274does a C<select> on the filehandle. This is useful if you want to
971wait for some requests to finish). 1275synchronously wait for some requests to finish).
972 1276
973See C<nreqs> for an example. 1277See C<nreqs> for an example.
974 1278
975=item IO::AIO::poll 1279=item IO::AIO::poll
976 1280
977Waits until some requests have been handled. 1281Waits until some requests have been handled.
978 1282
1283Returns the number of requests processed, but is otherwise strictly
979Strictly equivalent to: 1284equivalent to:
980 1285
981 IO::AIO::poll_wait, IO::AIO::poll_cb 1286 IO::AIO::poll_wait, IO::AIO::poll_cb
982 if IO::AIO::nreqs;
983 1287
984=item IO::AIO::flush 1288=item IO::AIO::flush
985 1289
986Wait till all outstanding AIO requests have been handled. 1290Wait till all outstanding AIO requests have been handled.
987 1291
988Strictly equivalent to: 1292Strictly equivalent to:
989 1293
990 IO::AIO::poll_wait, IO::AIO::poll_cb 1294 IO::AIO::poll_wait, IO::AIO::poll_cb
991 while IO::AIO::nreqs; 1295 while IO::AIO::nreqs;
992 1296
1297=back
1298
993=head3 CONTROLLING THE NUMBER OF THREADS 1299=head3 CONTROLLING THE NUMBER OF THREADS
1300
1301=over
994 1302
995=item IO::AIO::min_parallel $nthreads 1303=item IO::AIO::min_parallel $nthreads
996 1304
997Set the minimum number of AIO threads to C<$nthreads>. The current 1305Set the minimum number of AIO threads to C<$nthreads>. The current
998default is C<8>, which means eight asynchronous operations can execute 1306default is C<8>, which means eight asynchronous operations can execute
1039 1347
1040The default is probably ok in most situations, especially if thread 1348The default is probably ok in most situations, especially if thread
1041creation is fast. If thread creation is very slow on your system you might 1349creation is fast. If thread creation is very slow on your system you might
1042want to use larger values. 1350want to use larger values.
1043 1351
1044=item $oldmaxreqs = IO::AIO::max_outstanding $maxreqs 1352=item IO::AIO::max_outstanding $maxreqs
1045 1353
1046This is a very bad function to use in interactive programs because it 1354This is a very bad function to use in interactive programs because it
1047blocks, and a bad way to reduce concurrency because it is inexact: Better 1355blocks, and a bad way to reduce concurrency because it is inexact: Better
1048use an C<aio_group> together with a feed callback. 1356use an C<aio_group> together with a feed callback.
1049 1357
1050Sets the maximum number of outstanding requests to C<$nreqs>. If you 1358Sets the maximum number of outstanding requests to C<$nreqs>. If you
1051to queue up more than this number of requests, the next call to the 1359do queue up more than this number of requests, the next call to the
1052C<poll_cb> (and C<poll_some> and other functions calling C<poll_cb>) 1360C<poll_cb> (and C<poll_some> and other functions calling C<poll_cb>)
1053function will block until the limit is no longer exceeded. 1361function will block until the limit is no longer exceeded.
1054 1362
1055The default value is very large, so there is no practical limit on the 1363The default value is very large, so there is no practical limit on the
1056number of outstanding requests. 1364number of outstanding requests.
1057 1365
1058You can still queue as many requests as you want. Therefore, 1366You can still queue as many requests as you want. Therefore,
1059C<max_oustsanding> is mainly useful in simple scripts (with low values) or 1367C<max_outstanding> is mainly useful in simple scripts (with low values) or
1060as a stop gap to shield against fatal memory overflow (with large values). 1368as a stop gap to shield against fatal memory overflow (with large values).
1061 1369
1370=back
1371
1062=head3 STATISTICAL INFORMATION 1372=head3 STATISTICAL INFORMATION
1373
1374=over
1063 1375
1064=item IO::AIO::nreqs 1376=item IO::AIO::nreqs
1065 1377
1066Returns the number of requests currently in the ready, execute or pending 1378Returns the number of requests currently in the ready, execute or pending
1067states (i.e. for which their callback has not been invoked yet). 1379states (i.e. for which their callback has not been invoked yet).
1083 1395
1084=back 1396=back
1085 1397
1086=cut 1398=cut
1087 1399
1088# support function to convert a fd into a perl filehandle
1089sub _fd2fh {
1090 return undef if $_[0] < 0;
1091
1092 # try to generate nice filehandles
1093 my $sym = "IO::AIO::fd#$_[0]";
1094 local *$sym;
1095
1096 open *$sym, "+<&=$_[0]" # usually works under any unix
1097 or open *$sym, "<&=$_[0]" # cygwin needs this
1098 or open *$sym, ">&=$_[0]" # or this
1099 or return undef;
1100
1101 *$sym
1102}
1103
1104min_parallel 8; 1400min_parallel 8;
1105 1401
1106END { 1402END { flush }
1107 min_parallel 1;
1108 flush;
1109};
1110 1403
11111; 14041;
1112 1405
1113=head2 FORK BEHAVIOUR 1406=head2 FORK BEHAVIOUR
1114 1407
1134bytes of memory. In addition, stat requests need a stat buffer (possibly 1427bytes of memory. In addition, stat requests need a stat buffer (possibly
1135a few hundred bytes), readdir requires a result buffer and so on. Perl 1428a few hundred bytes), readdir requires a result buffer and so on. Perl
1136scalars and other data passed into aio requests will also be locked and 1429scalars and other data passed into aio requests will also be locked and
1137will consume memory till the request has entered the done state. 1430will consume memory till the request has entered the done state.
1138 1431
1139This is now awfully much, so queuing lots of requests is not usually a 1432This is not awfully much, so queuing lots of requests is not usually a
1140problem. 1433problem.
1141 1434
1142Per-thread usage: 1435Per-thread usage:
1143 1436
1144In the execution phase, some aio requests require more memory for 1437In the execution phase, some aio requests require more memory for
1149 1442
1150Known bugs will be fixed in the next release. 1443Known bugs will be fixed in the next release.
1151 1444
1152=head1 SEE ALSO 1445=head1 SEE ALSO
1153 1446
1154L<Coro::AIO>. 1447L<AnyEvent::AIO> for easy integration into event loops, L<Coro::AIO> for a
1448more natural syntax.
1155 1449
1156=head1 AUTHOR 1450=head1 AUTHOR
1157 1451
1158 Marc Lehmann <schmorp@schmorp.de> 1452 Marc Lehmann <schmorp@schmorp.de>
1159 http://home.schmorp.de/ 1453 http://home.schmorp.de/

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines