LU-13799 osc: Simplify clipping for transient pages

The combination of page clip and page flag setting for
transient pages takes up several % of the time when
submitting them for async DIO.

But neither is required - Transient pages do not change
after creation except in limited cases, and in any case,
they are only accessible from the submitting thread -
there is no possibility of parallel access.

So we can set the page flags, etc, at init time.

This patch improves i/o time in ms/GiB by:
Write: 17 ms/GiB
Read: 22 ms/GiB

Totals:
Write: 204 ms/GiB
Read: 198 ms/GiB

mpirun -np 1  $IOR -w -r -t 64M -b 64G -o ./iorfile --posix.odirect

With previous patches in series:
write     4647 MiB/s
read      4888 MiB/s

Plus this patch:
write     5030 MiB/s
read      5174 MiB/s

Signed-off-by: Patrick Farrell <farr0186@gmail.com>
Change-Id: I974ebb0f55734a8628f1f7e1c01092eb2ce5f83b
Reviewed-on: https://review.whamcloud.com/39440
Reviewed-by: Wang Shilong <wshilong@whamcloud.com>
Tested-by: jenkins <devops@whamcloud.com>
Reviewed-by: Andreas Dilger <adilger@whamcloud.com>
Tested-by: Maloo <maloo@whamcloud.com>
Reviewed-by: Oleg Drokin <green@whamcloud.com>

diff --git a/lustre/include/lustre_osc.h b/lustre/include/lustre_osc.h
index 793c493..464956a 100644 (file)
--- a/lustre/include/lustre_osc.h
+++ b/lustre/include/lustre_osc.h
@@ -580,7 +580,7 @@ long osc_lru_shrink(const struct lu_env *env, struct client_obd *cli,
 int osc_set_async_flags(struct osc_object *obj, struct osc_page *opg,
                        u32 async_flags);
 int osc_prep_async_page(struct osc_object *osc, struct osc_page *ops,
-                       struct page *page, loff_t offset);
+                       struct cl_page *page, loff_t offset);
 int osc_queue_async_io(const struct lu_env *env, struct cl_io *io,
                       struct osc_page *ops, cl_commit_cbt cb);
 int osc_page_cache_add(const struct lu_env *env, struct osc_page *opg,

diff --git a/lustre/llite/rw26.c b/lustre/llite/rw26.c
index 76c87ae..36d9c56 100644 (file)
--- a/lustre/llite/rw26.c
+++ b/lustre/llite/rw26.c
@@ -372,7 +372,8 @@ ll_direct_rw_pages(const struct lu_env *env, struct cl_io *io, size_t size,
                 * Set page clip to tell transfer formation engine
                 * that page has to be sent even if it is beyond KMS.
                 */
-               cl_page_clip(env, page, 0, min(size, page_size));
+               if (size < page_size)
+                       cl_page_clip(env, page, 0, size);
                ++io_pages;
 
                /* drop the reference count for cl_page_find */

diff --git a/lustre/osc/osc_cache.c b/lustre/osc/osc_cache.c
index a3953db..d193fae 100644 (file)
--- a/lustre/osc/osc_cache.c
+++ b/lustre/osc/osc_cache.c
@@ -2237,10 +2237,11 @@ int osc_io_unplug0(const struct lu_env *env, struct client_obd *cli,
 EXPORT_SYMBOL(osc_io_unplug0);
 
 int osc_prep_async_page(struct osc_object *osc, struct osc_page *ops,
-                       struct page *page, loff_t offset)
+                       struct cl_page *page, loff_t offset)
 {
        struct obd_export     *exp = osc_export(osc);
        struct osc_async_page *oap = &ops->ops_oap;
+       struct page           *vmpage = page->cp_vmpage;
        ENTRY;
 
        if (!page)
@@ -2250,16 +2251,24 @@ int osc_prep_async_page(struct osc_object *osc, struct osc_page *ops,
        oap->oap_cli = &exp->exp_obd->u.cli;
        oap->oap_obj = osc;
 
-       oap->oap_page = page;
+       oap->oap_page = vmpage;
        oap->oap_obj_off = offset;
        LASSERT(!(offset & ~PAGE_MASK));
 
+       /* Count of transient (direct i/o) pages is always stable by the time
+        * they're submitted.  Setting this here lets us avoid calling
+        * cl_page_clip later to set this.
+        */
+       if (page->cp_type == CPT_TRANSIENT)
+               oap->oap_async_flags |= ASYNC_COUNT_STABLE|ASYNC_URGENT|
+                                       ASYNC_READY;
+
        INIT_LIST_HEAD(&oap->oap_pending_item);
        INIT_LIST_HEAD(&oap->oap_rpc_item);
 
        spin_lock_init(&oap->oap_lock);
-       CDEBUG(D_INFO, "oap %p page %p obj off %llu\n",
-              oap, page, oap->oap_obj_off);
+       CDEBUG(D_INFO, "oap %p vmpage %p obj off %llu\n",
+              oap, vmpage, oap->oap_obj_off);
        RETURN(0);
 }
 EXPORT_SYMBOL(osc_prep_async_page);

diff --git a/lustre/osc/osc_io.c b/lustre/osc/osc_io.c
index 88069c2..f7f4702 100644 (file)
--- a/lustre/osc/osc_io.c
+++ b/lustre/osc/osc_io.c
@@ -191,10 +191,12 @@ int osc_io_submit(const struct lu_env *env, const struct cl_io_slice *ios,
                        continue;
                 }
 
-               spin_lock(&oap->oap_lock);
-               oap->oap_async_flags = ASYNC_URGENT|ASYNC_READY;
-               oap->oap_async_flags |= ASYNC_COUNT_STABLE;
-               spin_unlock(&oap->oap_lock);
+               if (page->cp_type != CPT_TRANSIENT) {
+                       spin_lock(&oap->oap_lock);
+                       oap->oap_async_flags = ASYNC_URGENT|ASYNC_READY;
+                       oap->oap_async_flags |= ASYNC_COUNT_STABLE;
+                       spin_unlock(&oap->oap_lock);
+               }
 
                osc_page_submit(env, opg, crt, brw_flags, submit_time);
                list_add_tail(&oap->oap_pending_item, &list);

diff --git a/lustre/osc/osc_page.c b/lustre/osc/osc_page.c
index 320c1c6..2d91dc0 100644 (file)
--- a/lustre/osc/osc_page.c
+++ b/lustre/osc/osc_page.c
@@ -215,6 +215,9 @@ static void osc_page_clip(const struct lu_env *env,
        opg->ops_from = from;
        /* argument @to is exclusive, but @ops_to is inclusive */
        opg->ops_to   = to - 1;
+       /* This isn't really necessary for transient pages, but we also don't
+        * call clip on transient pages often, so it's OK.
+        */
        spin_lock(&oap->oap_lock);
        oap->oap_async_flags |= ASYNC_COUNT_STABLE;
        spin_unlock(&oap->oap_lock);
@@ -261,8 +264,7 @@ int osc_page_init(const struct lu_env *env, struct cl_object *obj,
 
        INIT_LIST_HEAD(&opg->ops_lru);
 
-       result = osc_prep_async_page(osc, opg, cl_page->cp_vmpage,
-                                    cl_offset(obj, index));
+       result = osc_prep_async_page(osc, opg, cl_page, cl_offset(obj, index));
        if (result != 0)
                return result;