blk-mq: support batching dispatch in case of io

More and more drivers want to get batching requests queued from
block layer, such as mmc, and tcp based storage drivers. Also
current in-tree users have virtio-scsi, virtio-blk and nvme.

For none, we already support batching dispatch.

But for io scheduler, every time we just take one request from scheduler
and pass the single request to blk_mq_dispatch_rq_list(). This way makes
batching dispatch not possible when io scheduler is applied. One reason
is that we don't want to hurt sequential IO performance, becasue IO
merge chance is reduced if more requests are dequeued from scheduler
queue.

Try to support batching dispatch for io scheduler by starting with the
following simple approach:

1) still make sure we can get budget before dequeueing request

2) use hctx->dispatch_busy to evaluate if queue is busy, if it is busy
we fackback to non-batching dispatch, otherwise dequeue as many as
possible requests from scheduler, and pass them to blk_mq_dispatch_rq_list().

Wrt. 2), we use similar policy for none, and turns out that SCSI SSD
performance got improved much.

In future, maybe we can develop more intelligent algorithem for batching
dispatch.

Baolin has tested this patch and found that MMC performance is improved[3].

[1] https://lore.kernel.org/linux-block/20200512075501.GF1531898@T590/#r
[2] https://lore.kernel.org/linux-block/fe6bd8b9-6ed9-b225-f80c-314746133722@grimberg.me/
[3] https://lore.kernel.org/linux-block/CADBw62o9eTQDJ9RvNgEqSpXmg6Xcq=2TxH0Hfxhp29uF2W=TXA@mail.gmail.com/

Signed-off-by: Ming Lei <ming.lei@redhat.com>
Tested-by: Baolin Wang <baolin.wang7@gmail.com>
Reviewed-by: Christoph Hellwig <hch@lst.de>
Cc: Sagi Grimberg <sagi@grimberg.me>
Cc: Baolin Wang <baolin.wang7@gmail.com>
Cc: Christoph Hellwig <hch@infradead.org>
Signed-off-by: Jens Axboe <axboe@kernel.dk>

diff --git a/block/blk-mq-sched.c b/block/blk-mq-sched.c
index 4c72073830f3cbfabbd24e2382cb02a943ef88c1..1c52e56a19b1a4a81e0520dbf360e923e63d6e6f 100644 (file)
--- a/block/blk-mq-sched.c
+++ b/block/blk-mq-sched.c
@@ -7,6 +7,7 @@
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/blk-mq.h>
+#include <linux/list_sort.h>
 
 #include <trace/events/block.h>
 
@@ -80,6 +81,37 @@ void blk_mq_sched_restart(struct blk_mq_hw_ctx *hctx)
        blk_mq_run_hw_queue(hctx, true);
 }
 
+static int sched_rq_cmp(void *priv, struct list_head *a, struct list_head *b)
+{
+       struct request *rqa = container_of(a, struct request, queuelist);
+       struct request *rqb = container_of(b, struct request, queuelist);
+
+       return rqa->mq_hctx > rqb->mq_hctx;
+}
+
+static bool blk_mq_dispatch_hctx_list(struct list_head *rq_list)
+{
+       struct blk_mq_hw_ctx *hctx =
+               list_first_entry(rq_list, struct request, queuelist)->mq_hctx;
+       struct request *rq;
+       LIST_HEAD(hctx_list);
+       unsigned int count = 0;
+       bool ret;
+
+       list_for_each_entry(rq, rq_list, queuelist) {
+               if (rq->mq_hctx != hctx) {
+                       list_cut_before(&hctx_list, rq_list, &rq->queuelist);
+                       goto dispatch;
+               }
+               count++;
+       }
+       list_splice_tail_init(rq_list, &hctx_list);
+
+dispatch:
+       ret = blk_mq_dispatch_rq_list(hctx, &hctx_list, count);
+       return ret;
+}
+
 #define BLK_MQ_BUDGET_DELAY    3               /* ms units */
 
 /*
@@ -90,20 +122,29 @@ void blk_mq_sched_restart(struct blk_mq_hw_ctx *hctx)
  * Returns -EAGAIN if hctx->dispatch was found non-empty and run_work has to
  * be run again.  This is necessary to avoid starving flushes.
  */
-static int blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx)
+static int __blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx)
 {
        struct request_queue *q = hctx->queue;
        struct elevator_queue *e = q->elevator;
+       bool multi_hctxs = false, run_queue = false;
+       bool dispatched = false, busy = false;
+       unsigned int max_dispatch;
        LIST_HEAD(rq_list);
-       int ret = 0;
-       struct request *rq;
+       int count = 0;
+
+       if (hctx->dispatch_busy)
+               max_dispatch = 1;
+       else
+               max_dispatch = hctx->queue->nr_requests;
 
        do {
+               struct request *rq;
+
                if (e->type->ops.has_work && !e->type->ops.has_work(hctx))
                        break;
 
                if (!list_empty_careful(&hctx->dispatch)) {
-                       ret = -EAGAIN;
+                       busy = true;
                        break;
                }
 
@@ -120,7 +161,7 @@ static int blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx)
                         * no guarantee anyone will kick the queue.  Kick it
                         * ourselves.
                         */
-                       blk_mq_delay_run_hw_queues(q, BLK_MQ_BUDGET_DELAY);
+                       run_queue = true;
                        break;
                }
 
@@ -129,8 +170,42 @@ static int blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx)
                 * if this rq won't be queued to driver via .queue_rq()
                 * in blk_mq_dispatch_rq_list().
                 */
-               list_add(&rq->queuelist, &rq_list);
-       } while (blk_mq_dispatch_rq_list(rq->mq_hctx, &rq_list, 1));
+               list_add_tail(&rq->queuelist, &rq_list);
+               if (rq->mq_hctx != hctx)
+                       multi_hctxs = true;
+       } while (++count < max_dispatch);
+
+       if (!count) {
+               if (run_queue)
+                       blk_mq_delay_run_hw_queues(q, BLK_MQ_BUDGET_DELAY);
+       } else if (multi_hctxs) {
+               /*
+                * Requests from different hctx may be dequeued from some
+                * schedulers, such as bfq and deadline.
+                *
+                * Sort the requests in the list according to their hctx,
+                * dispatch batching requests from same hctx at a time.
+                */
+               list_sort(NULL, &rq_list, sched_rq_cmp);
+               do {
+                       dispatched |= blk_mq_dispatch_hctx_list(&rq_list);
+               } while (!list_empty(&rq_list));
+       } else {
+               dispatched = blk_mq_dispatch_rq_list(hctx, &rq_list, count);
+       }
+
+       if (busy)
+               return -EAGAIN;
+       return !!dispatched;
+}
+
+static int blk_mq_do_dispatch_sched(struct blk_mq_hw_ctx *hctx)
+{
+       int ret;
+
+       do {
+               ret = __blk_mq_do_dispatch_sched(hctx);
+       } while (ret == 1);
 
        return ret;
 }

diff --git a/block/blk-mq.c b/block/blk-mq.c
index 1b701e1666818139fe25880e4c6cfd12dd0ace58..a8fac4ff6fef3fd922b01929253be38fe4edf1a7 100644 (file)
--- a/block/blk-mq.c
+++ b/block/blk-mq.c
@@ -1319,8 +1319,6 @@ bool blk_mq_dispatch_rq_list(struct blk_mq_hw_ctx *hctx, struct list_head *list,
        if (list_empty(list))
                return false;
 
-       WARN_ON(!list_is_singular(list) && nr_budgets);
-
        /*
         * Now process all the entries, sending them to the driver.
         */