[ViewVC] Diff of: cvs/IO-AIO/README

Comparing IO-AIO/README (file contents):
Revision 1.36 by root, Sun Jun 7 18:31:18 2009 UTC vs.
Revision 1.42 by root, Thu Jan 7 20:25:57 2010 UTC

      # AnyEvent integration (EV, Event, Glib, Tk, POE, urxvt, pureperl...)
      use AnyEvent::AIO;
      # EV integration
-     my $w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
+     my $aio_w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
      # Event integration
      Event->io (fd => IO::AIO::poll_fileno,
                 poll => 'r',
                 cb => \&IO::AIO::poll_cb);
      Danga::Socket->AddOtherFds (IO::AIO::poll_fileno =>
                                  \&IO::AIO::poll_cb);
 DESCRIPTION
     This module implements asynchronous I/O using whatever means your
-    operating system supports.
+    operating system supports. It is implemented as an interface to "libeio"
+    (<http://software.schmorp.de/pkg/libeio.html>).
     Asynchronous means that operations that can normally block your program
     (e.g. reading from disk) will be done asynchronously: the operation will
     still block, but you can do something else in the meantime. This is
     extremely useful for programs that need to stay interactive even when
     operations concurrently.
     While most of this works on all types of file descriptors (for example
     sockets), using these functions on file descriptors that support
     nonblocking operation (again, sockets, pipes etc.) is very inefficient.
-    Use an event loop for that (such as the Event module): IO::AIO will
+    Use an event loop for that (such as the EV module): IO::AIO will
     naturally fit into such an event loop itself.
     In this version, a number of threads are started that execute your
     requests and signal their completion. You don't need thread support in
     perl, and the threads created by this module will not be visible to
     it is currently not reentrant in any way, so use appropriate locking
     yourself, always call "poll_cb" from within the same thread, or never
     call "poll_cb" (or other "aio_" functions) recursively.
   EXAMPLE
-    This is a simple example that uses the Event module and loads
+    This is a simple example that uses the EV module and loads /etc/passwd
-    /etc/passwd asynchronously:
+    asynchronously:
        use Fcntl;
-       use Event;
+       use EV;
        use IO::AIO;
-       # register the IO::AIO callback with Event
+       # register the IO::AIO callback with EV
-       Event->io (fd => IO::AIO::poll_fileno,
+       my $aio_w = EV::io IO::AIO::poll_fileno, EV::READ, \&IO::AIO::poll_cb;
-                  poll => 'r',
-                  cb => \&IO::AIO::poll_cb);
        # queue the request to open /etc/passwd
        aio_open "/etc/passwd", O_RDONLY, 0, sub {
           my $fh = shift
              or die "error while opening: $!";
              # file contents now in $contents
              print $contents;
              # exit event loop and program
-             Event::unloop;
+             EV::unloop;
           };
        };
        # possibly queue up other requests, or open GUI windows,
        # check for sockets etc. etc.
        # process events as long as there are some:
-       Event::loop;
+       EV::loop;
 REQUEST ANATOMY AND LIFETIME
     Every "aio_*" function creates a request. which is a C data structure
     not directly visible to Perl.
         This call tries to make use of a native "sendfile" syscall to
         provide zero-copy operation. For this to work, $out_fh should refer
         to a socket, and $in_fh should refer to mmap'able file.
-        If the native sendfile call fails or is not implemented, it will be
+        If a native sendfile cannot be found or it fails with "ENOSYS",
+        "ENOTSUP", "EOPNOTSUPP", "EAFNOSUPPORT", "EPROTOTYPE" or "ENOTSOCK",
-        emulated, so you can call "aio_sendfile" on any type of filehandle
+        it will be emulated, so you can call "aio_sendfile" on any type of
-        regardless of the limitations of the operating system.
+        filehandle regardless of the limitations of the operating system.
         Please note, however, that "aio_sendfile" can read more bytes from
         $in_fh than are written, and there is no way to find out how many
         bytes have been read from "aio_sendfile" alone, as "aio_sendfile"
         only provides the number of bytes written to $out_fh. Only if the
            aio_stat "/etc/passwd", sub {
               $_[0] and die "stat failed: $!";
               print "size is ", -s _, "\n";
            };
+    aio_statvfs $fh_or_path, $callback->($statvfs)
+        Works like the POSIX "statvfs" or "fstatvfs" syscalls, depending on
+        whether a file handle or path was passed.
+        On success, the callback is passed a hash reference with the
+        following members: "bsize", "frsize", "blocks", "bfree", "bavail",
+        "files", "ffree", "favail", "fsid", "flag" and "namemax". On
+        failure, "undef" is passed.
+        The following POSIX IO::AIO::ST_* constants are defined: "ST_RDONLY"
+        and "ST_NOSUID".
+        The following non-POSIX IO::AIO::ST_* flag masks are defined to
+        their correct value when available, or to 0 on systems that do not
+        support them: "ST_NODEV", "ST_NOEXEC", "ST_SYNCHRONOUS",
+        "ST_MANDLOCK", "ST_WRITE", "ST_APPEND", "ST_IMMUTABLE",
+        "ST_NOATIME", "ST_NODIRATIME" and "ST_RELATIME".
+        Example: stat "/wd" and dump out the data if successful.
+           aio_statvfs "/wd", sub {
+              my $f = $_[0]
+                 or die "statvfs: $!";
+              use Data::Dumper;
+              say Dumper $f;
+           };
+           # result:
+           {
+              bsize   => 1024,
+              bfree   => 4333064312,
+              blocks  => 10253828096,
+              files   => 2050765568,
+              flag    => 4096,
+              favail  => 2042092649,
+              bavail  => 4333064312,
+              ffree   => 2042092649,
+              namemax => 255,
+              frsize  => 1024,
+              fsid    => 1810
+           }
     aio_utime $fh_or_path, $atime, $mtime, $callback->($status)
         Works like perl's "utime" function (including the special case of
         $atime and $mtime being undef). Fractional times are supported if
         the underlying syscalls support them.
             you need to know, you have to run stat yourself. Also, for speed
             reasons, the $type scalars are read-only: you can not modify
             them.
             $inode is the inode number (which might not be exact on systems
-            with 64 bit inode numbers and 32 bit perls). On systems that do
+            with 64 bit inode numbers and 32 bit perls). This field has
-            not deliver the inode information, this will always be zero.
+            unspecified content on systems that do not deliver the inode
+            information.
         IO::AIO::READDIR_DIRS_FIRST
             When this flag is set, then the names will be returned in an
             order where likely directories come first. This is useful when
             you need to quickly find directories, or you want to find all
         into memory. Status is the same as with aio_read.
     aio_copy $srcpath, $dstpath, $callback->($status)
         Try to copy the *file* (directories not supported as either source
         or destination) from $srcpath to $dstpath and call the callback with
-        the 0 (error) or -1 ok.
+        a status of 0 (ok) or -1 (error, see $!).
         This is a composite request that creates the destination file with
         mode 0200 and copies the contents of the source file into it using
         "aio_sendfile", followed by restoring atime, mtime, access mode and
         uid/gid, in that order.
         uid/gid, where errors are being ignored.
     aio_move $srcpath, $dstpath, $callback->($status)
         Try to move the *file* (directories not supported as either source
         or destination) from $srcpath to $dstpath and call the callback with
-        the 0 (error) or -1 ok.
+        a status of 0 (ok) or -1 (error, see $!).
         This is a composite request that tries to rename(2) the file first;
         if rename fails with "EXDEV", it copies the file with "aio_copy"
         and, if that is successful, unlinks the $srcpath.
         operations (E.g. rename). This might not work on all operating
         systems or have any specific effect, but usually it makes sure that
         directory changes get written to disc. It works for anything that
         can be opened for read-only, not just directories.
+        Future versions of this function might fall back to other methods
+        when "fsync" on the directory fails (such as calling "sync").
         Passes 0 when everything went ok, and -1 on error.
+    aio_msync $scalar, $offset = 0, $length = undef, flags = 0,
+    $callback->($status)
+        This is a rather advanced IO::AIO call, which only works on
+        mmap(2)ed scalars (see the Sys::Mmap or Mmap modules for details on
+        this, note that the scalar must only be modified in-place while an
+        aio operation is pending on it).
+        It calls the "msync" function of your OS, if available, with the
+        memory area starting at $offset in the string and ending $length
+        bytes later. If $length is negative, counts from the end, and if
+        $length is "undef", then it goes till the end of the string. The
+        flags can be a combination of "IO::AIO::MS_ASYNC",
+        "IO::AIO::MS_INVALIDATE" and "IO::AIO::MS_SYNC".
+    aio_mtouch $scalar, $offset = 0, $length = undef, flags = 0,
+    $callback->($status)
+        This is a rather advanced IO::AIO call, which works best on
+        mmap(2)ed scalars.
+        It touches (reads or writes) all memory pages in the specified range
+        inside the scalar. All caveats and parameters are the same as for
+        "aio_msync", above, except for flags, which must be either 0 (which
+        reads all pages and ensures they are instantiated) or
+        "IO::AIO::MT_MODIFY", which modifies the memory page s(by reading
+        and writing an octet from it, which dirties the page).
     aio_group $callback->(...)
         This is a very special aio request: Instead of doing something, it
         is a container for other aio requests, which is useful if you want
         to bundle many requests into a single, composite, request with a
     cancel $req
         Cancels the request, if possible. Has the effect of skipping
         execution when entering the execute state and skipping calling the
         callback when entering the the result state, but will leave the
-        request otherwise untouched. That means that requests that currently
+        request otherwise untouched (with the exception of readdir). That
-        execute will not be stopped and resources held by the request will
+        means that requests that currently execute will not be stopped and
-        not be freed prematurely.
+        resources held by the request will not be freed prematurely.
     cb $req $callback->(...)
         Replace (or simply set) the callback registered to the request.
   IO::AIO::GRP CLASS
     $grp->cancel_subs
         Cancel all subrequests and clears any feeder, but not the group
         request itself. Useful when you queued a lot of events but got a
         result early.
+        The group request will finish normally (you cannot add requests to
+        the group).
     $grp->result (...)
         Set the result value(s) that will be passed to the group callback
         when all subrequests have finished and set the groups errno to the
         current value of errno (just like calling "errno" without an error
   SUPPORT FUNCTIONS
    EVENT PROCESSING AND EVENT LOOP INTEGRATION
     $fileno = IO::AIO::poll_fileno
         Return the *request result pipe file descriptor*. This filehandle
         must be polled for reading by some mechanism outside this module
-        (e.g. Event or select, see below or the SYNOPSIS). If the pipe
+        (e.g. EV, Glib, select and so on, see below or the SYNOPSIS). If the
-        becomes readable you have to call "poll_cb" to check the results.
+        pipe becomes readable you have to call "poll_cb" to check the
+        results.
         See "poll_cb" for an example.
     IO::AIO::poll_cb
         Process some outstanding events on the result pipe. You have to call
         If not all requests were processed for whatever reason, the
         filehandle will still be ready when "poll_cb" returns, so normally
         you don't have to do anything special to have it called later.
         Example: Install an Event watcher that automatically calls
-        IO::AIO::poll_cb with high priority:
+        IO::AIO::poll_cb with high priority (more examples can be found in
+        the SYNOPSIS section, at the top of this document):
            Event->io (fd => IO::AIO::poll_fileno,
                       poll => 'r', async => 1,
                       cb => \&IO::AIO::poll_cb);
     IO::AIO::npending
         Returns the number of requests currently in the pending state
         (executed, but not yet processed by poll_cb).
+   MISCELLANEOUS FUNCTIONS
+    IO::AIO implements some functions that might be useful, but are not
+    asynchronous.
+    IO::AIO::sendfile $ofh, $ifh, $offset, $count
+        Calls the "eio_sendfile_sync" function, which is like
+        "aio_sendfile", but is blocking (this makes most sense if you know
+        the input data is likely cached already and the output filehandle is
+        set to non-blocking operations).
+        Returns the number of bytes copied, or -1 on error.
+    IO::AIO::fadvise $fh, $offset, $len, $advice
+        Simply calls the "posix_fadvise" function (see it's manpage for
+        details). The following advice constants are avaiable:
+        "IO::AIO::FADV_NORMAL", "IO::AIO::FADV_SEQUENTIAL",
+        "IO::AIO::FADV_RANDOM", "IO::AIO::FADV_NOREUSE",
+        "IO::AIO::FADV_WILLNEED", "IO::AIO::FADV_DONTNEED".
+        On systems that do not implement "posix_fadvise", this function
+        returns ENOSYS, otherwise the return value of "posix_fadvise".
   FORK BEHAVIOUR
     This module should do "the right thing" when the process using it forks:
     Before the fork, IO::AIO enters a quiescent state where no requests can
     be added in other threads and no results will be processed. After the

Diff Legend

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

Comparing IO-AIO/README (file contents): Revision 1.36 by root, Sun Jun 7 18:31:18 2009 UTC vs. Revision 1.42 by root, Thu Jan 7 20:25:57 2010 UTC

Diff Legend

Comparing IO-AIO/README (file contents):
Revision 1.36 by root, Sun Jun 7 18:31:18 2009 UTC vs.
Revision 1.42 by root, Thu Jan 7 20:25:57 2010 UTC