cfq-iosched: Always provide group isolation.

CFQ sysfs tunable

=================

/sys/block/<disk>/queue/iosched/group_isolation

-----------------------------------------------

If group_isolation=1, it provides stronger isolation between groups at the

expense of throughput. By default group_isolation is 0. In general that

means that if group_isolation=0, expect fairness for sequential workload

only. Set group_isolation=1 to see fairness for random IO workload also.

Generally CFQ will put random seeky workload in sync-noidle category. CFQ

will disable idling on these queues and it does a collective idling on group

of such queues. Generally these are slow moving queues and if there is a

sync-noidle service tree in each group, that group gets exclusive access to

disk for certain period. That means it will bring the throughput down if

group does not have enough IO to drive deeper queue depths and utilize disk

capacity to the fullest in the slice allocated to it. But the flip side is

that even a random reader should get better latencies and overall throughput

if there are lots of sequential readers/sync-idle workload running in the

system.

If group_isolation=0, then CFQ automatically moves all the random seeky queues

in the root group. That means there will be no service differentiation for

that kind of workload. This leads to better throughput as we do collective

idling on root sync-noidle tree.

By default one should run with group_isolation=0. If that is not sufficient

and one wants stronger isolation between groups, then set group_isolation=1

but this will come at cost of reduced throughput.

/sys/block/<disk>/queue/iosched/slice_idle

------------------------------------------

On a faster hardware CFQ can be slow, especially with sequential workload.

	struct cfq_rb_root *service_tree;

	struct cfq_queue *new_cfqq;

	struct cfq_group *cfqg;

	struct cfq_group *orig_cfqg;

	/* Number of sectors dispatched from queue in single dispatch round */

	unsigned long nr_sectors;

};

	unsigned int cfq_slice_idle;

	unsigned int cfq_group_idle;

	unsigned int cfq_latency;

	unsigned int cfq_group_isolation;

	unsigned int cic_index;

	struct list_head cic_list;

	int new_cfqq = 1;

	int group_changed = 0;

#ifdef CONFIG_CFQ_GROUP_IOSCHED

	if (!cfqd->cfq_group_isolation

	    && cfqq_type(cfqq) == SYNC_NOIDLE_WORKLOAD

	    && cfqq->cfqg && cfqq->cfqg != &cfqd->root_group) {

		/* Move this cfq to root group */

		cfq_log_cfqq(cfqd, cfqq, "moving to root group");

		if (!RB_EMPTY_NODE(&cfqq->rb_node))

			cfq_group_service_tree_del(cfqd, cfqq->cfqg);

		cfqq->orig_cfqg = cfqq->cfqg;

		cfqq->cfqg = &cfqd->root_group;

		cfqd->root_group.ref++;

		group_changed = 1;

	} else if (!cfqd->cfq_group_isolation

		   && cfqq_type(cfqq) == SYNC_WORKLOAD && cfqq->orig_cfqg) {

		/* cfqq is sequential now needs to go to its original group */

		BUG_ON(cfqq->cfqg != &cfqd->root_group);

		if (!RB_EMPTY_NODE(&cfqq->rb_node))

			cfq_group_service_tree_del(cfqd, cfqq->cfqg);

		cfq_put_cfqg(cfqq->cfqg);

		cfqq->cfqg = cfqq->orig_cfqg;

		cfqq->orig_cfqg = NULL;

		group_changed = 1;

		cfq_log_cfqq(cfqd, cfqq, "moved to origin group");

	}

#endif

	service_tree = service_tree_for(cfqq->cfqg, cfqq_prio(cfqq),

						cfqq_type(cfqq));

	if (cfq_class_idle(cfqq)) {

static void cfq_put_queue(struct cfq_queue *cfqq)

{

	struct cfq_data *cfqd = cfqq->cfqd;

	struct cfq_group *cfqg, *orig_cfqg;

	struct cfq_group *cfqg;

	BUG_ON(cfqq->ref <= 0);

	BUG_ON(rb_first(&cfqq->sort_list));

	BUG_ON(cfqq->allocated[READ] + cfqq->allocated[WRITE]);

	cfqg = cfqq->cfqg;

	orig_cfqg = cfqq->orig_cfqg;

	if (unlikely(cfqd->active_queue == cfqq)) {

		__cfq_slice_expired(cfqd, cfqq, 0);

	BUG_ON(cfq_cfqq_on_rr(cfqq));

	kmem_cache_free(cfq_pool, cfqq);

	cfq_put_cfqg(cfqg);

	if (orig_cfqg)

		cfq_put_cfqg(orig_cfqg);

}

/*

	cfqd->cfq_slice_idle = cfq_slice_idle;

	cfqd->cfq_group_idle = cfq_group_idle;

	cfqd->cfq_latency = 1;

	cfqd->cfq_group_isolation = 0;

	cfqd->hw_tag = -1;

	/*

	 * we optimistically start assuming sync ops weren't delayed in last

SHOW_FUNCTION(cfq_slice_async_show, cfqd->cfq_slice[0], 1);

SHOW_FUNCTION(cfq_slice_async_rq_show, cfqd->cfq_slice_async_rq, 0);

SHOW_FUNCTION(cfq_low_latency_show, cfqd->cfq_latency, 0);

SHOW_FUNCTION(cfq_group_isolation_show, cfqd->cfq_group_isolation, 0);

#undef SHOW_FUNCTION

#define STORE_FUNCTION(__FUNC, __PTR, MIN, MAX, __CONV)			\

STORE_FUNCTION(cfq_slice_async_rq_store, &cfqd->cfq_slice_async_rq, 1,

		UINT_MAX, 0);

STORE_FUNCTION(cfq_low_latency_store, &cfqd->cfq_latency, 0, 1, 0);

STORE_FUNCTION(cfq_group_isolation_store, &cfqd->cfq_group_isolation, 0, 1, 0);

#undef STORE_FUNCTION

#define CFQ_ATTR(name) \

	CFQ_ATTR(slice_idle),

	CFQ_ATTR(group_idle),

	CFQ_ATTR(low_latency),

	CFQ_ATTR(group_isolation),

	__ATTR_NULL

};