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.32 by root, Wed Aug 17 05:26:20 2005 UTC vs.
Revision 1.34 by root, Thu Aug 18 16:32:10 2005 UTC

… …
63use base 'Exporter'; 63use base 'Exporter';
64 64
65use Fcntl (); 65use Fcntl ();
66 66
67BEGIN { 67BEGIN {
68 $VERSION = 1.3; 68 $VERSION = 1.5;
69
70 69
71 @EXPORT = qw(aio_read aio_write aio_open aio_close aio_stat aio_lstat aio_unlink 70 @EXPORT = qw(aio_read aio_write aio_open aio_close aio_stat aio_lstat aio_unlink
72 aio_rmdir aio_symlink aio_fsync aio_fdatasync aio_readahead); 71 aio_rmdir aio_symlink aio_fsync aio_fdatasync aio_readahead);
73 @EXPORT_OK = qw(poll_fileno poll_cb min_parallel max_parallel max_outstanding nreqs); 72 @EXPORT_OK = qw(poll_fileno poll_cb min_parallel max_parallel max_outstanding nreqs);
74 73
… …
288 IO::AIO::poll_wait, IO::AIO::poll_cb 287 IO::AIO::poll_wait, IO::AIO::poll_cb
289 if IO::AIO::nreqs; 288 if IO::AIO::nreqs;
290 289
291=item IO::AIO::min_parallel $nthreads 290=item IO::AIO::min_parallel $nthreads
292 291
293Set the minimum number of AIO threads to C<$nthreads>. The default is 292Set the minimum number of AIO threads to C<$nthreads>. The current default
294C<1>, which means a single asynchronous operation can be done at one time 293is C<4>, which means four asynchronous operations can be done at one time
295(the number of outstanding operations, however, is unlimited). 294(the number of outstanding operations, however, is unlimited).
295
296IO::AIO starts threads only on demand, when an AIO request is queued and
297no free thread exists.
296 298
297It is recommended to keep the number of threads low, as some Linux 299It is recommended to keep the number of threads low, as some Linux
298kernel versions will scale negatively with the number of threads (higher 300kernel versions will scale negatively with the number of threads (higher
299parallelity => MUCH higher latency). With current Linux 2.6 versions, 4-32 301parallelity => MUCH higher latency). With current Linux 2.6 versions, 4-32
300threads should be fine. 302threads should be fine.
301 303
302Under normal circumstances you don't need to call this function, as this 304Under most circumstances you don't need to call this function, as the
303module automatically starts some threads (the exact number might change, 305module selects a default that is suitable for low to moderate load.
304and is currently 4).
305 306
306=item IO::AIO::max_parallel $nthreads 307=item IO::AIO::max_parallel $nthreads
307 308
308Sets the maximum number of AIO threads to C<$nthreads>. If more than 309Sets the maximum number of AIO threads to C<$nthreads>. If more than the
309the specified number of threads are currently running, kill them. This 310specified number of threads are currently running, this function kills
310function blocks until the limit is reached. 311them. This function blocks until the limit is reached.
312
313While C<$nthreads> are zero, aio requests get queued but not executed
314until the number of threads has been increased again.
311 315
312This module automatically runs C<max_parallel 0> at program end, to ensure 316This module automatically runs C<max_parallel 0> at program end, to ensure
313that all threads are killed and that there are no outstanding requests. 317that all threads are killed and that there are no outstanding requests.
314 318
315Under normal circumstances you don't need to call this function. 319Under normal circumstances you don't need to call this function.
… …
319Sets the maximum number of outstanding requests to C<$nreqs>. If you 323Sets the maximum number of outstanding requests to C<$nreqs>. If you
320try to queue up more than this number of requests, the caller will block until 324try to queue up more than this number of requests, the caller will block until
321some requests have been handled. 325some requests have been handled.
322 326
323The default is very large, so normally there is no practical limit. If you 327The default is very large, so normally there is no practical limit. If you
324queue up many requests in a loop it it often improves speed if you set 328queue up many requests in a loop it often improves speed if you set
325this to a relatively low number, such as C<100>. 329this to a relatively low number, such as C<100>.
326 330
327Under normal circumstances you don't need to call this function. 331Under normal circumstances you don't need to call this function.
328 332
329=back 333=back
… …
354 358
3551; 3591;
356 360
357=head2 FORK BEHAVIOUR 361=head2 FORK BEHAVIOUR
358 362
359Before the fork IO::AIO enters a quiescent state where no requests can be 363Before the fork, IO::AIO enters a quiescent state where no requests
360added in other threads and no results will be processed. After the fork 364can be added in other threads and no results will be processed. After
361the parent simply leaves the quiescent state and continues request/result 365the fork the parent simply leaves the quiescent state and continues
362processing, while the child clears the request/result queue and starts the 366request/result processing, while the child clears the request/result
363same number of threads as were in use by the parent. 367queue (so the requests started before the fork will only be handled in
368the parent). Threats will be started on demand until the limit ste in the
369parent process has been reached again.
364 370
365=head1 SEE ALSO 371=head1 SEE ALSO
366 372
367L<Coro>, L<Linux::AIO>. 373L<Coro>, L<Linux::AIO>.
368 374

Diff Legend

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