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.31 by root, Wed Aug 17 05:06:59 2005 UTC vs.
Revision 1.36 by root, Tue Aug 23 00:03:14 2005 UTC

… …
63use base 'Exporter'; 63use base 'Exporter';
64 64
65use Fcntl (); 65use Fcntl ();
66 66
67BEGIN { 67BEGIN {
68 $VERSION = 1.2; 68 $VERSION = 1.6;
69 69
70 @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
71 aio_rmdir aio_symlink aio_fsync aio_fdatasync aio_readahead); 71 aio_rmdir aio_symlink aio_fsync aio_fdatasync aio_readahead);
72 @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);
73 73
… …
162 aio_read $fh, 7, 15, $buffer, 0, sub { 162 aio_read $fh, 7, 15, $buffer, 0, sub {
163 $_[0] > 0 or die "read error: $!"; 163 $_[0] > 0 or die "read error: $!";
164 print "read $_[0] bytes: <$buffer>\n"; 164 print "read $_[0] bytes: <$buffer>\n";
165 }; 165 };
166 166
167=item aio_sendfile $out_fh, $in_fh, $in_offset, $length, $callback
168
169Tries to copy C<$length> bytes from C<$in_fh> to C<$out_fh>. It starts
170reading at byte offset C<$in_offset>, and starts writing at the current
171file offset of C<$out_fh>. Because of that, it is not safe to issue more
172than one C<aio_sendfile> per C<$out_fh>, as they will interfere with each
173other.
174
175This call tries to make use of a native C<sendfile> syscall to provide
176zero-copy operation. For this to work, C<$out_fh> should refer to a
177socket, and C<$in_fh> should refer to mmap'able file.
178
179If the native sendfile call fails or is not implemented, it will be
180emulated, so you can call C<aio_sendfile> on any type of filehandle
181regardless of the limitations of the operating system.
182
183Please note, however, that C<aio_sendfile> can read more bytes from
184C<$in_fh> than are written, and there is no way to find out how many
185bytes have been read from C<aio_sendfile> alone, as C<aio_sendfile> only
186provides the number of bytes written to C<$out_fh>. Only if the result
187value equals C<$length> one can assume that C<$length> bytes have been
188read.
189
167=item aio_readahead $fh,$offset,$length, $callback 190=item aio_readahead $fh,$offset,$length, $callback
168 191
169C<aio_readahead> populates the page cache with data from a file so that 192C<aio_readahead> populates the page cache with data from a file so that
170subsequent reads from that file will not block on disk I/O. The C<$offset> 193subsequent reads from that file will not block on disk I/O. The C<$offset>
171argument specifies the starting point from which data is to be read and 194argument specifies the starting point from which data is to be read and
… …
287 IO::AIO::poll_wait, IO::AIO::poll_cb 310 IO::AIO::poll_wait, IO::AIO::poll_cb
288 if IO::AIO::nreqs; 311 if IO::AIO::nreqs;
289 312
290=item IO::AIO::min_parallel $nthreads 313=item IO::AIO::min_parallel $nthreads
291 314
292Set the minimum number of AIO threads to C<$nthreads>. The default is 315Set the minimum number of AIO threads to C<$nthreads>. The current default
293C<1>, which means a single asynchronous operation can be done at one time 316is C<4>, which means four asynchronous operations can be done at one time
294(the number of outstanding operations, however, is unlimited). 317(the number of outstanding operations, however, is unlimited).
318
319IO::AIO starts threads only on demand, when an AIO request is queued and
320no free thread exists.
295 321
296It is recommended to keep the number of threads low, as some Linux 322It is recommended to keep the number of threads low, as some Linux
297kernel versions will scale negatively with the number of threads (higher 323kernel versions will scale negatively with the number of threads (higher
298parallelity => MUCH higher latency). With current Linux 2.6 versions, 4-32 324parallelity => MUCH higher latency). With current Linux 2.6 versions, 4-32
299threads should be fine. 325threads should be fine.
300 326
301Under normal circumstances you don't need to call this function, as this 327Under most circumstances you don't need to call this function, as the
302module automatically starts some threads (the exact number might change, 328module selects a default that is suitable for low to moderate load.
303and is currently 4).
304 329
305=item IO::AIO::max_parallel $nthreads 330=item IO::AIO::max_parallel $nthreads
306 331
307Sets the maximum number of AIO threads to C<$nthreads>. If more than 332Sets the maximum number of AIO threads to C<$nthreads>. If more than the
308the specified number of threads are currently running, kill them. This 333specified number of threads are currently running, this function kills
309function blocks until the limit is reached. 334them. This function blocks until the limit is reached.
335
336While C<$nthreads> are zero, aio requests get queued but not executed
337until the number of threads has been increased again.
310 338
311This module automatically runs C<max_parallel 0> at program end, to ensure 339This module automatically runs C<max_parallel 0> at program end, to ensure
312that all threads are killed and that there are no outstanding requests. 340that all threads are killed and that there are no outstanding requests.
313 341
314Under normal circumstances you don't need to call this function. 342Under normal circumstances you don't need to call this function.
… …
318Sets the maximum number of outstanding requests to C<$nreqs>. If you 346Sets the maximum number of outstanding requests to C<$nreqs>. If you
319try to queue up more than this number of requests, the caller will block until 347try to queue up more than this number of requests, the caller will block until
320some requests have been handled. 348some requests have been handled.
321 349
322The default is very large, so normally there is no practical limit. If you 350The default is very large, so normally there is no practical limit. If you
323queue up many requests in a loop it it often improves speed if you set 351queue up many requests in a loop it often improves speed if you set
324this to a relatively low number, such as C<100>. 352this to a relatively low number, such as C<100>.
325 353
326Under normal circumstances you don't need to call this function. 354Under normal circumstances you don't need to call this function.
327 355
328=back 356=back
… …
353 381
3541; 3821;
355 383
356=head2 FORK BEHAVIOUR 384=head2 FORK BEHAVIOUR
357 385
358Before the fork IO::AIO enters a quiescent state where no requests can be 386Before the fork, IO::AIO enters a quiescent state where no requests
359added in other threads and no results will be processed. After the fork 387can be added in other threads and no results will be processed. After
360the parent simply leaves the quiescent state and continues request/result 388the fork the parent simply leaves the quiescent state and continues
361processing, while the child clears the request/result queue and starts the 389request/result processing, while the child clears the request/result
362same number of threads as were in use by the parent. 390queue (so the requests started before the fork will only be handled in
391the parent). Threats will be started on demand until the limit ste in the
392parent process has been reached again.
363 393
364=head1 SEE ALSO 394=head1 SEE ALSO
365 395
366L<Coro>, L<Linux::AIO>. 396L<Coro>, L<Linux::AIO>.
367 397

Diff Legend

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