[lkml]   [2006]   [Dec]   [28]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
    SubjectRe: [RFC] Heads up on a series of AIO patchsets
    [ I'm only subscribed to linux-fsdevel@ from above Cc list, please keep this
    list in Cc: for AIO related stuff. ]

    On Wed, Dec 27, 2006 at 04:25:30PM +0000, Christoph Hellwig ( wrote:
    > (1) note that there is another problem with the current kevent interface,
    > and that is that it duplicates the event infrastructure for it's
    > underlying subsystems instead of reusing existing code (e.g.
    > inotify, epoll, dio-aio). If we want kevent to be _the_ unified
    > event system for Linux we need people to help out with straightening
    > out these even provides as Evgeny seems to be unwilling/unable to
    > do the work himself and the duplication is simply not acceptable.

    I would rewrite inotify/epoll to use kevent, but I would strongly prefer
    that it would be done by peopl who created original interfaces - it is
    politic decision, not techinical - I do not want to be blamed on each
    corner that I killed other people work :)

    FS and network AIO kevent based stuff was dropped from kevent tree in
    favour of upcoming project (description below).

    According do AIO - my personal opinion is that AIO should be designed
    asynchronously in all aspects. Here is brief note on how I plan to
    iplement it (I plan to start in about a week after New Year vacations).


    All existing AIO - both mainline and kevent based lack major feature -
    they are not fully asyncronous, i.e. they require synchronous set of
    steps, some of which can be asynchronous. For example aio_sendfile() [1]
    requires open of the file descriptor and only then aio_sendfile() call.
    The same applies to mainline AIO and read/write calls.

    My idea is to create real asyncronous IO - i.e. some entity which will
    describe set of tasks which should be performed asynchronously (from
    user point of view, although read and write obviously must be done after
    open and before close), for example syscall which gets as parameter
    destination socket and local filename (with optional offset and length
    fields), which will asynchronously from user point of view open a file
    and transfer requested part to the destination socket and then return
    opened file descriptor (or it can be closed if requested). Similar
    mechanism can be done for read/write calls.

    This approach as long as asynchronous IO at all requires access to user
    memory from kernels thread or even interrupt handler (that is where
    kevent based AIO completes its requests) - it can be done in the way
    similar to how existing kevent ring buffer implementation and also can
    use dedicated kernel thread or workqueue to copy data into process

    It is very interesting task and should greatly speed up workloads of
    busy web/ftp and other servers, which can work with a huge number of
    files and huge number of clients.
    I've put it into TODO list.

    Someone, please stop the time for several days, so I could create some
    really good things for the universe.

    1. Network AIO

    Evgeniy Polyakov
    To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
    the body of a message to
    More majordomo info at
    Please read the FAQ at

     \ /
      Last update: 2006-12-28 12:45    [W:0.022 / U:57.292 seconds]
    ©2003-2017 Jasper Spaans. hosted at Digital OceanAdvertise on this site