sched/cpufreq: Clarify sugov_get_util() (45f5519e) · Commits · e / devices / android_kernel_fairphone_FP4

kernel/sched/cpufreq_schedutil.c

+54 −21

Original line number	Original line	Diff line number	Diff line
	@@ -177,6 +177,26 @@ static unsigned int get_next_freq(struct sugov_policy *sg_policy,
	return cpufreq_driver_resolve_freq(policy, freq);		return cpufreq_driver_resolve_freq(policy, freq);
	}		}

			/*
			* This function computes an effective utilization for the given CPU, to be
			* used for frequency selection given the linear relation: f = u * f_max.
			*
			* The scheduler tracks the following metrics:
			*
			* cpu_util_{cfs,rt,dl,irq}()
			* cpu_bw_dl()
			*
			* Where the cfs,rt and dl util numbers are tracked with the same metric and
			* synchronized windows and are thus directly comparable.
			*
			* The cfs,rt,dl utilization are the running times measured with rq->clock_task
			* which excludes things like IRQ and steal-time. These latter are then accrued
			* in the irq utilization.
			*
			* The DL bandwidth number otoh is not a measured metric but a value computed
			* based on the task model parameters and gives the minimal utilization
			* required to meet deadlines.
			*/
	static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)		static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
	{		{
	struct rq *rq = cpu_rq(sg_cpu->cpu);		struct rq *rq = cpu_rq(sg_cpu->cpu);
	@@ -188,47 +208,60 @@ static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
	if (rt_rq_is_runnable(&rq->rt))		if (rt_rq_is_runnable(&rq->rt))
	return max;		return max;

			/*
			* Early check to see if IRQ/steal time saturates the CPU, can be
			* because of inaccuracies in how we track these -- see
			* update_irq_load_avg().
			*/
	irq = cpu_util_irq(rq);		irq = cpu_util_irq(rq);

	if (unlikely(irq >= max))		if (unlikely(irq >= max))
	return max;		return max;

	/* Sum rq utilization */		/*
			* Because the time spend on RT/DL tasks is visible as 'lost' time to
			* CFS tasks and we use the same metric to track the effective
			* utilization (PELT windows are synchronized) we can directly add them
			* to obtain the CPU's actual utilization.
			*/
	util = cpu_util_cfs(rq);		util = cpu_util_cfs(rq);
	util += cpu_util_rt(rq);		util += cpu_util_rt(rq);

	/*		/*
	* Interrupt time is not seen by RQS utilization so we can compare		* We do not make cpu_util_dl() a permanent part of this sum because we
	* them with the CPU capacity		* want to use cpu_bw_dl() later on, but we need to check if the
			* CFS+RT+DL sum is saturated (ie. no idle time) such that we select
			* f_max when there is no idle time.
			*
			* NOTE: numerical errors or stop class might cause us to not quite hit
			* saturation when we should -- something for later.
	*/		*/
	if ((util + cpu_util_dl(rq)) >= max)		if ((util + cpu_util_dl(rq)) >= max)
	return max;		return max;

	/*		/*
	* As there is still idle time on the CPU, we need to compute the		* There is still idle time; further improve the number by using the
	* utilization level of the CPU.		* irq metric. Because IRQ/steal time is hidden from the task clock we
			* need to scale the task numbers:
	*		*
			* 1 - irq
			* U' = irq + ------- * U
			* max
			*/
			util *= (max - irq);
			util /= max;
			util += irq;

			/*
	* Bandwidth required by DEADLINE must always be granted while, for		* Bandwidth required by DEADLINE must always be granted while, for
	* FAIR and RT, we use blocked utilization of IDLE CPUs as a mechanism		* FAIR and RT, we use blocked utilization of IDLE CPUs as a mechanism
	* to gracefully reduce the frequency when no tasks show up for longer		* to gracefully reduce the frequency when no tasks show up for longer
	* periods of time.		* periods of time.
	*		*
	* Ideally we would like to set util_dl as min/guaranteed freq and		* Ideally we would like to set bw_dl as min/guaranteed freq and util +
	* util_cfs + util_dl as requested freq. However, cpufreq is not yet		* bw_dl as requested freq. However, cpufreq is not yet ready for such
	* ready for such an interface. So, we only do the latter for now.		* an interface. So, we only do the latter for now.
	*/		*/
			return min(max, util + sg_cpu->bw_dl);
	/* Weight RQS utilization to normal context window */
	util *= (max - irq);
	util /= max;

	/* Add interrupt utilization */
	util += irq;

	/* Add DL bandwidth requirement */
	util += sg_cpu->bw_dl;

	return min(max, util);
	}		}

	/**		/**