linux-kernel - Re: [RFC V2 PATCH 1/5] cfq-iosched: adapt slice to number of processes doing I/O

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-Id: <200910211516.n9LFG27p031289@segfault.boston.devel.redhat.com>
Date:	Wed, 21 Oct 2009 11:16:02 -0400
From:	Jeff Moyer <jmoyer@...hat.com>
To:	Corrado Zoccolo <czoccolo@...il.com>
Cc:	"Linux-Kernel" <linux-kernel@...r.kernel.org>,
	Jens Axboe <jens.axboe@...cle.com>
Subject: Re: [RFC V2 PATCH 1/5] cfq-iosched: adapt slice to number of processes doing I/O

Hi, Corrado!

Corrado Zoccolo <czoccolo@...il.com> writes:

> When the number of processes performing I/O concurrently increases,
> a fixed time slice per process will cause large latencies.
>
> This patch, if low_latency mode is enabled,  will scale the time slice
> assigned to each process according to a 300ms target latency.
>
> In order to keep fairness among processes:
> * The number of active processes is computed using a special form of
> running average, that quickly follows sudden increases (to keep latency low),
> and decrease slowly (to have fairness in spite of rapid decreases of this
> value).
>
> To safeguard sequential bandwidth, we impose a minimum time slice
> (computed using 2*cfq_slice_idle as base, adjusted according to priority
> and async-ness).

I like the idea as well, but I have a question and some nits to pick.

>  static inline void
>  cfq_set_prio_slice(struct cfq_data *cfqd, struct cfq_queue *cfqq)
>  {
> -	cfqq->slice_end = cfq_prio_to_slice(cfqd, cfqq) + jiffies;
> +	unsigned slice = cfq_prio_to_slice(cfqd, cfqq);
> +	if (cfqd->cfq_latency) {
> +		unsigned iq = cfq_get_avg_queues(cfqd, cfq_class_rt(cfqq));
> +		unsigned process_thr = cfq_target_latency / cfqd->cfq_slice[1];
> +		if (iq > process_thr) {
> +			unsigned low_slice = 2 * slice * cfqd->cfq_slice_idle
> +				/ cfqd->cfq_slice[1];
> +			slice = max(slice * cfq_target_latency /
> +				(cfqd->cfq_slice[1] * iq),

Couldn't you have just divided the slice by iq?  And why iq?  Why not
nr_qs or avg_qlen or something?  It's a minor nit; I can live with it.

> +				min(slice, low_slice));
> +		}
> +	}
> +	cfqq->slice_end = jiffies + slice;
>  	cfq_log_cfqq(cfqd, cfqq, "set_slice=%lu", cfqq->slice_end - jiffies);

Wow.  That function is *dense*.  I tried to write it in a more
readable fashion, but please chime in if I misinterpreted anything.

static inline void
cfq_set_prio_slice(struct cfq_data *cfqd, struct cfq_queue *cfqq)
{
        unsigned slice = cfq_prio_to_slice(cfqd, cfqq);

	if (cfqd->cfq_latency) {
		unsigned iq = cfq_get_avg_queues(cfqd, cfq_class_rt(cfqq));
		unsigned slice_sync = cfqd->cfq_slice[1];
		unsigned process_thr = cfq_target_latency / slice_sync;

		if (iq > process_thr) {
			/*
			 * Minimum slice is computed using 2*slice_idle as
			 * a base, and then scaling it by priority and
			 * async-ness.
			 */
			unsigned total_sync = slice_sync * iq;
			unsigned slice_fraction = cfq_target_latency / total_sync;
			unsigned min_slice = (2 * cfqd->cfq_slice_idle) *
				(slice / slice_sync);
			min_slice = min(slice, min_slice);
			slice *= slice_fraction;
			slice = max(slice, min_slice);
		}
	}
	cfqq->slice_end = jiffies + slice;
	cfq_log_cfqq(cfqd, cfqq, "set_slice=%lu", cfqq->slice_end - jiffies);
}


Cheers,
Jeff
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/