[patch]block: avoid building too big plug list

[patch]block: avoid building too big plug list

[Shaohua Li]

When I test fio script with big I/O depth, I found the total throughput drops
compared to some relative small I/O depth. The reason is the thread accumulates
big requests in its plug list and causes some delays (surely this depends
on CPU speed).
I thought we'd better have a threshold for requests. When a threshold reaches,
this means there is no request merge and queue lock contention isn't severe
when pushing per-task requests to queue, so the main advantages of blk plug
don't exist. We can force a plug list flush in this case.
With this, my test throughput actually increases and almost equals to small
I/O depth. Another side effect is irq off time decreases in blk_flush_plug_list()
for big I/O depth.
The BLK_MAX_REQUEST_COUNT is choosen arbitarily, but 16 is efficiently to
reduce lock contention to me. But I'm open here, 32 is ok in my test too.

Signed-off-by: Shaohua Li <shaohua.li@intel.com>
---
 block/blk-core.c       |    5 +++++
 include/linux/blkdev.h |    3 +++
 2 files changed, 8 insertions(+)

Index: linux/block/blk-core.c
===================================================================
--- linux.orig/block/blk-core.c	2011-07-07 09:07:11.000000000 +0800
+++ linux/block/blk-core.c	2011-07-08 09:49:41.000000000 +0800
@@ -1302,7 +1302,10 @@ get_rq:
 				plug->should_sort = 1;
 		}
 		list_add_tail(&req->queuelist, &plug->list);
+		plug->count++;
 		drive_stat_acct(req, 1);
+		if (plug->count >= BLK_MAX_REQUEST_COUNT)
+			blk_flush_plug_list(plug, false);
 	} else {
 		spin_lock_irq(q->queue_lock);
 		add_acct_request(q, req, where);
@@ -2626,6 +2629,7 @@ void blk_start_plug(struct blk_plug *plu
 	INIT_LIST_HEAD(&plug->list);
 	INIT_LIST_HEAD(&plug->cb_list);
 	plug->should_sort = 0;
+	plug->count = 0;
 
 	/*
 	 * If this is a nested plug, don't actually assign it. It will be
@@ -2709,6 +2713,7 @@ void blk_flush_plug_list(struct blk_plug
 		return;
 
 	list_splice_init(&plug->list, &list);
+	plug->count = 0;
 
 	if (plug->should_sort) {
 		list_sort(NULL, &list, plug_rq_cmp);
Index: linux/include/linux/blkdev.h
===================================================================
--- linux.orig/include/linux/blkdev.h	2011-07-07 09:07:11.000000000 +0800
+++ linux/include/linux/blkdev.h	2011-07-08 09:49:24.000000000 +0800
@@ -862,7 +862,10 @@ struct blk_plug {
 	struct list_head list;
 	struct list_head cb_list;
 	unsigned int should_sort;
+	unsigned int count;
 };
+#define BLK_MAX_REQUEST_COUNT 16
+
 struct blk_plug_cb {
 	struct list_head list;
 	void (*callback)(struct blk_plug_cb *);

Re: [patch]block: avoid building too big plug list

[Jens Axboe]

On 2011-07-08 03:59, Shaohua Li wrote:
> When I test fio script with big I/O depth, I found the total throughput drops
> compared to some relative small I/O depth. The reason is the thread accumulates
> big requests in its plug list and causes some delays (surely this depends
> on CPU speed).
> I thought we'd better have a threshold for requests. When a threshold reaches,
> this means there is no request merge and queue lock contention isn't severe
> when pushing per-task requests to queue, so the main advantages of blk plug
> don't exist. We can force a plug list flush in this case.
> With this, my test throughput actually increases and almost equals to small
> I/O depth. Another side effect is irq off time decreases in blk_flush_plug_list()
> for big I/O depth.
> The BLK_MAX_REQUEST_COUNT is choosen arbitarily, but 16 is efficiently to
> reduce lock contention to me. But I'm open here, 32 is ok in my test too.

Thanks, I have wondered whether that would potentially cause an issue.
So this patch is quite fine with me, generally a good idea to cap it.
I'll queue it up with 16 for the max depth, that's still quite a decent
proportion of local to queued requests.

Thanks!

-- 
Jens Axboe