[ViewVC] Diff of: cvs/IO-AIO/AIO.pm

Comparing IO-AIO/AIO.pm (file contents):
Revision 1.75 by root, Tue Oct 24 20:10:26 2006 UTC vs.
Revision 1.79 by root, Thu Oct 26 14:35:34 2006 UTC

                      aio_lstat aio_unlink aio_rmdir aio_readdir aio_scandir aio_symlink
                      aio_fsync aio_fdatasync aio_readahead aio_rename aio_link aio_move
                      aio_group aio_nop);
    our @EXPORT = (@AIO_REQ, qw(aioreq_pri aioreq_nice));
    our @EXPORT_OK = qw(poll_fileno poll_cb poll_wait flush
-                       min_parallel max_parallel max_outstanding nreqs);
+                       min_parallel max_parallel nreqs);
    @IO::AIO::GRP::ISA = 'IO::AIO::REQ';
    require XSLoader;
    XSLoader::load ("IO::AIO", $VERSION);
 with the filenames.
 =item aio_scandir $path, $maxreq, $callback->($dirs, $nondirs)
 Scans a directory (similar to C<aio_readdir>) but additionally tries to
-separate the entries of directory C<$path> into two sets of names, ones
+efficiently separate the entries of directory C<$path> into two sets of
-you can recurse into (directories or links to them), and ones you cannot
+names, directories you can recurse into (directories), and ones you cannot
-recurse into (everything else).
+recurse into (everything else, including symlinks to directories).
 C<aio_scandir> is a composite request that creates of many sub requests_
 C<$maxreq> specifies the maximum number of outstanding aio requests that
 this function generates. If it is C<< <= 0 >>, then a suitable default
 will be chosen (currently 6).
 =item * They can also can also be added to other IO::AIO::GRP objects.
 =item * You must not add requests to a group from within the group callback (or
 any later time).
-=item * This does not harmonise well with C<max_outstanding>, so best do
-not combine C<aio_group> with it. Groups and feeders are recommended for
-this kind of concurrency-limiting.
 =back
 Their lifetime, simplified, looks like this: when they are empty, they
 will finish very quickly. If they contain only requests that are in the
 C<done> state, they will also finish. Otherwise they will continue to
 Process all outstanding events on the result pipe. You have to call this
 regularly. Returns the number of events processed. Returns immediately
 when no events are outstanding.
+If not all requests were processed for whatever reason, the filehandle
+will still be ready when C<poll_cb> returns.
 Example: Install an Event watcher that automatically calls
 IO::AIO::poll_cb with high priority:
    Event->io (fd => IO::AIO::poll_fileno,
               poll => 'r', async => 1,
               cb => \&IO::AIO::poll_cb);
+=item IO::AIO::poll_some $max_requests
+Similar to C<poll_cb>, but only processes up to C<$max_requests> requests
+at a time.
+Useful if you want to ensure some level of interactiveness when perl is
+not fast enough to process all requests in time.
+Example: Install an Event watcher that automatically calls
+IO::AIO::poll_some with low priority, to ensure that other parts of the
+program get the CPU sometimes even under high AIO load.
+   Event->io (fd => IO::AIO::poll_fileno,
+              poll => 'r', nice => 1,
+              cb => sub { IO::AIO::poll_some 256 });
 =item IO::AIO::poll_wait
 Wait till the result filehandle becomes ready for reading (simply does a
 C<select> on the filehandle. This is useful if you want to synchronously wait
 This module automatically runs C<max_parallel 0> at program end, to ensure
 that all threads are killed and that there are no outstanding requests.
 Under normal circumstances you don't need to call this function.
-=item $oldnreqs = IO::AIO::max_outstanding $nreqs
+=item $oldmaxreqs = IO::AIO::max_outstanding $maxreqs
-[DEPRECATED]
+This is a very bad function to use in interactive programs because it
+blocks, and a bad way to reduce concurrency because it is inexact: Better
+use an C<aio_group> together with a feed callback.
 Sets the maximum number of outstanding requests to C<$nreqs>. If you
-try to queue up more than this number of requests, the caller will block until
+to queue up more than this number of requests, the next call to the
-some requests have been handled.
+C<poll_cb> (and C<poll_some> and other functions calling C<poll_cb>)
+function will block until the limit is no longer exceeded.
-The default is very large, so normally there is no practical limit. If you
+The default value is very large, so there is no practical limit on the
-queue up many requests in a loop it often improves speed if you set
+number of outstanding requests.
-this to a relatively low number, such as C<100>.
-This function does not work well together with C<aio_group>'s, and their
+You can still queue as many requests as you want. Therefore,
-feeder interface is better suited to limiting concurrency, so do not use
+C<max_oustsanding> is mainly useful in simple scripts (with low values) or
-this function.
+as a stop gap to shield against fatal memory overflow (with large values).
-Under normal circumstances you don't need to call this function.
 =back
 =cut

Diff Legend

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

Comparing IO-AIO/AIO.pm (file contents): Revision 1.75 by root, Tue Oct 24 20:10:26 2006 UTC vs. Revision 1.79 by root, Thu Oct 26 14:35:34 2006 UTC

Diff Legend

Comparing IO-AIO/AIO.pm (file contents):
Revision 1.75 by root, Tue Oct 24 20:10:26 2006 UTC vs.
Revision 1.79 by root, Thu Oct 26 14:35:34 2006 UTC