fuse: improve aio directIO write performance for size extending writes

While sending the blocking directIO in fuse, the write request is broken
into sub-requests, each of default size 128k and all the requests are sent
in non-blocking background mode if async_dio mode is supported by libfuse.
The process which issue the write wait for the completion of all the
sub-requests. Sending multiple requests parallely gives a chance to perform
parallel writes in the user space fuse implementation if it is
multi-threaded and hence improves the performance.

When there is a size extending aio dio write, we switch to blocking mode so
that we can properly update the size of the file after completion of the
writes. However, in this situation all the sub-requests are sent in
serialized manner where the next request is sent only after receiving the
reply of the current request. Hence the multi-threaded user space
implementation is not utilized properly.

This patch changes the size extending aio dio behavior to exactly follow
blocking dio. For multi threaded fuse implementation having 10 threads and
using buffer size of 64MB to perform async directIO, we are getting double
the speed.

Signed-off-by: Ashish Sangwan <ashishsangwan2@gmail.com>
Signed-off-by: Miklos Szeredi <mszeredi@redhat.com>

diff --git a/fs/fuse/file.c b/fs/fuse/file.c
index 9154f8679024f25b33a7dac1607877da2ce3fab9..7270e89880b59ec6edec70cafa0c7c052b99fb44 100644 (file)
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -562,7 +562,6 @@ static ssize_t fuse_get_res_by_io(struct fuse_io_priv *io)
  */
 static void fuse_aio_complete(struct fuse_io_priv *io, int err, ssize_t pos)
 {
-       bool is_sync = is_sync_kiocb(io->iocb);
        int left;
 
        spin_lock(&io->lock);
@@ -572,11 +571,11 @@ static void fuse_aio_complete(struct fuse_io_priv *io, int err, ssize_t pos)
                io->bytes = pos;
 
        left = --io->reqs;
-       if (!left && is_sync)
+       if (!left && io->blocking)
                complete(io->done);
        spin_unlock(&io->lock);
 
-       if (!left && !is_sync) {
+       if (!left && !io->blocking) {
                ssize_t res = fuse_get_res_by_io(io);
 
                if (res >= 0) {
@@ -2850,7 +2849,6 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
        size_t count = iov_iter_count(iter);
        loff_t offset = iocb->ki_pos;
        struct fuse_io_priv *io;
-       bool is_sync = is_sync_kiocb(iocb);
 
        pos = offset;
        inode = file->f_mapping->host;
@@ -2885,17 +2883,16 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
         */
        io->async = async_dio;
        io->iocb = iocb;
+       io->blocking = is_sync_kiocb(iocb);
 
        /*
-        * We cannot asynchronously extend the size of a file. We have no method
-        * to wait on real async I/O requests, so we must submit this request
-        * synchronously.
+        * We cannot asynchronously extend the size of a file.
+        * In such case the aio will behave exactly like sync io.
         */
-       if (!is_sync && (offset + count > i_size) &&
-           iov_iter_rw(iter) == WRITE)
-               io->async = false;
+       if ((offset + count > i_size) && iov_iter_rw(iter) == WRITE)
+               io->blocking = true;
 
-       if (io->async && is_sync) {
+       if (io->async && io->blocking) {
                /*
                 * Additional reference to keep io around after
                 * calling fuse_aio_complete()
@@ -2915,7 +2912,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
                fuse_aio_complete(io, ret < 0 ? ret : 0, -1);
 
                /* we have a non-extending, async request, so return */
-               if (!is_sync)
+               if (!io->blocking)
                        return -EIOCBQUEUED;
 
                wait_for_completion(&wait);

diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index 929c383432b034f3f695e0cc83e55e9b48c35898..5db5d24f91a5929dd7c291c833b7049778336da3 100644 (file)
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -259,6 +259,7 @@ struct fuse_io_priv {
        struct kiocb *iocb;
        struct file *file;
        struct completion *done;
+       bool blocking;
 };
 
 #define FUSE_IO_PRIV_SYNC(f) \