xfs: use a cursor for bulk AIL insertion

Delayed logging can insert tens of thousands of log items into the
AIL at the same LSN. When the committing of log commit records
occur, we can get insertions occurring at an LSN that is not at the
end of the AIL. If there are thousands of items in the AIL on the
tail LSN, each insertion has to walk the AIL to find the correct
place to insert the new item into the AIL. This can consume large
amounts of CPU time and block other operations from occurring while
the traversals are in progress.

To avoid this repeated walk, use a AIL cursor to record
where we should be inserting the new items into the AIL without
having to repeat the walk. The cursor infrastructure already
provides this functionality for push walks, so is a simple extension
of existing code. While this will not avoid the initial walk, it
will avoid repeating it tens of thousands of times during a single
checkpoint commit.

This version includes logic improvements from Christoph Hellwig.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Alex Elder <aelder@sgi.com>

1 files changed, 23 insertions, 4 deletions

diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index c83f63b33aae..efc147f0e9b6 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -1426,6 +1426,7 @@ xfs_trans_committed(
 static inline void
 xfs_log_item_batch_insert(
         struct xfs_ail          *ailp,
+        struct xfs_ail_cursor   *cur,
         struct xfs_log_item     **log_items,
         int                     nr_items,
         xfs_lsn_t               commit_lsn)
@@ -1434,7 +1435,7 @@ xfs_log_item_batch_insert(
 
         spin_lock(&ailp->xa_lock);
         /* xfs_trans_ail_update_bulk drops ailp->xa_lock */
-        xfs_trans_ail_update_bulk(ailp, log_items, nr_items, commit_lsn);
+        xfs_trans_ail_update_bulk(ailp, cur, log_items, nr_items, commit_lsn);
 
         for (i = 0; i < nr_items; i++)
                 IOP_UNPIN(log_items[i], 0);
@@ -1452,6 +1453,13 @@ xfs_log_item_batch_insert(
  * as an iclog write error even though we haven't started any IO yet. Hence in
  * this case all we need to do is IOP_COMMITTED processing, followed by an
  * IOP_UNPIN(aborted) call.
+ *
+ * The AIL cursor is used to optimise the insert process. If commit_lsn is not
+ * at the end of the AIL, the insert cursor avoids the need to walk
+ * the AIL to find the insertion point on every xfs_log_item_batch_insert()
+ * call. This saves a lot of needless list walking and is a net win, even
+ * though it slightly increases that amount of AIL lock traffic to set it up
+ * and tear it down.
  */
 void
 xfs_trans_committed_bulk(
@@ -1463,8 +1471,13 @@ xfs_trans_committed_bulk(
 #define LOG_ITEM_BATCH_SIZE     32
         struct xfs_log_item     *log_items[LOG_ITEM_BATCH_SIZE];
         struct xfs_log_vec      *lv;
+        struct xfs_ail_cursor   cur;
         int                     i = 0;
 
+        spin_lock(&ailp->xa_lock);
+        xfs_trans_ail_cursor_last(ailp, &cur, commit_lsn);
+        spin_unlock(&ailp->xa_lock);
+
         /* unpin all the log items */
         for (lv = log_vector; lv; lv = lv->lv_next ) {
                 struct xfs_log_item     *lip = lv->lv_item;
@@ -1493,7 +1506,9 @@ xfs_trans_committed_bulk(
                         /*
                          * Not a bulk update option due to unusual item_lsn.
                          * Push into AIL immediately, rechecking the lsn once
-                         * we have the ail lock. Then unpin the item.
+                         * we have the ail lock. Then unpin the item. This does
+                         * not affect the AIL cursor the bulk insert path is
+                         * using.
                          */
                         spin_lock(&ailp->xa_lock);
                         if (XFS_LSN_CMP(item_lsn, lip->li_lsn) > 0)
@@ -1507,7 +1522,7 @@ xfs_trans_committed_bulk(
                 /* Item is a candidate for bulk AIL insert.  */
                 log_items[i++] = lv->lv_item;
                 if (i >= LOG_ITEM_BATCH_SIZE) {
-                        xfs_log_item_batch_insert(ailp, log_items,
+                        xfs_log_item_batch_insert(ailp, &cur, log_items,
                                         LOG_ITEM_BATCH_SIZE, commit_lsn);
                         i = 0;
                 }
@@ -1515,7 +1530,11 @@ xfs_trans_committed_bulk(
 
         /* make sure we insert the remainder! */
         if (i)
-                xfs_log_item_batch_insert(ailp, log_items, i, commit_lsn);
+                xfs_log_item_batch_insert(ailp, &cur, log_items, i, commit_lsn);
+
+        spin_lock(&ailp->xa_lock);
+        xfs_trans_ail_cursor_done(ailp, &cur);
+        spin_unlock(&ailp->xa_lock);
 }
 
 /*