[lkml]   [2018]   [Aug]   [6]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
Messages in this thread
Patch in this message
Subject[PATCH v3 06/14] sched/cpufreq: uclamp: add utilization clamping for RT tasks
Currently schedutil enforces a maximum frequency when RT tasks are
RUNNABLE. Such a mandatory policy can be made more tunable from
userspace thus allowing for example to define a max frequency which is
still reasonable for the execution of a specific RT workload. This
will contribute to make the RT class more friendly for power/energy
sensitive use-cases.

This patch extends the usage of util_{min,max} to the RT scheduling
class. Whenever a task in this class is RUNNABLE, the util required is
defined by the constraints of the CPU control group the task belongs to.

Since utilization clamping applies now to both CFS and RT task, there
can be two alternative approaches:
A) clamp the combined utilization
B) combine the clamped utilizations
which have pros and cons.
Approach A) is more power efficient, since it generally selects lower
frequencies when we have both RT and CFS utilization. However, this
could affect performance of the lower priority CFS class, since the
minimum utilization clamp could be completely eclipsed by the RT
Approach B) is more fair to the lower priority CFS class since it always
adds the required minimum utilization to that class too. For that reason
it could be less power efficient and, since we do not distinguish clamp
values based on the scheduling class, it could also end up boosting CFS
tasks more then required (e.g. when the current min utilization of a CPU
is required by an RT task). That's why this approach is masked behind a
sched feature.

The IO wait boost value is thus subject to clamping for RT tasks too.
This is to ensure that RT tasks as well as CFS ones are always subject
to the set of current utilization clamping constraints.
It's worth to notice that, by default, clamp values are
min_util, max_util = (0, SCHED_CAPACITY_SCALE)
and thus, RT tasks always run at the maximum OPP if not otherwise
constrained by userspace.

Signed-off-by: Patrick Bellasi <>
Cc: Ingo Molnar <>
Cc: Peter Zijlstra <>
Cc: Rafael J. Wysocki <>
Cc: Viresh Kumar <>
Cc: Suren Baghdasaryan <>
Cc: Todd Kjos <>
Cc: Joel Fernandes <>
Cc: Juri Lelli <>
Cc: Dietmar Eggemann <>
Cc: Morten Rasmussen <>

Changes in v3:
- rebased on tip/sched/core

Changes in v2:
- rebased on v4.18-rc4
kernel/sched/cpufreq_schedutil.c | 33 +++++++++++++++++++++-----------
kernel/sched/features.h | 5 +++++
2 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
index a7affc729c25..bb25ef66c2d3 100644
--- a/kernel/sched/cpufreq_schedutil.c
+++ b/kernel/sched/cpufreq_schedutil.c
@@ -200,6 +200,7 @@ static unsigned int get_next_freq(struct sugov_policy *sg_policy,
static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
struct rq *rq = cpu_rq(sg_cpu->cpu);
+ unsigned long util_cfs, util_rt;
unsigned long util, irq, max;

sg_cpu->max = max = arch_scale_cpu_capacity(NULL, sg_cpu->cpu);
@@ -223,13 +224,25 @@ static unsigned long sugov_get_util(struct sugov_cpu *sg_cpu)
* utilization (PELT windows are synchronized) we can directly add them
* to obtain the CPU's actual utilization.
- * CFS utilization can be boosted or capped, depending on utilization
- * clamp constraints configured for currently RUNNABLE tasks.
+ * CFS and RT utilizations can be boosted or capped, depending on
+ * utilization constraints enforce by currently RUNNABLE tasks.
+ * They are individually clamped to ensure fairness across classes,
+ * meaning that CFS always gets (if possible) the (minimum) required
+ * bandwidth on top of that required by higher priority classes.
- util = cpu_util_cfs(rq);
- if (util)
- util = uclamp_util(cpu_of(rq), util);
- util += cpu_util_rt(rq);
+ util_cfs = cpu_util_cfs(rq);
+ util_rt = cpu_util_rt(rq);
+ if (sched_feat(UCLAMP_SCHED_CLASS)) {
+ util = 0;
+ if (util_cfs)
+ util += uclamp_util(cpu_of(rq), util_cfs);
+ if (util_rt)
+ util += uclamp_util(cpu_of(rq), util_rt);
+ } else {
+ util = cpu_util_cfs(rq);
+ util += cpu_util_rt(rq);
+ util = uclamp_util(cpu_of(rq), util);
+ }

* We do not make cpu_util_dl() a permanent part of this sum because we
@@ -333,13 +346,11 @@ static void sugov_iowait_boost(struct sugov_cpu *sg_cpu, u64 time,
* Since DL tasks have a much more advanced bandwidth control, it's
* safe to assume that IO boost does not apply to those tasks.
- * Instead, since RT tasks are currently not utiliation clamped,
- * we don't want to apply clamping on IO boost while there is
- * blocked RT utilization.
+ * Instead, for CFS and RT tasks we clamp the IO boost max value
+ * considering the current constraints for the CPU.
max_boost = sg_cpu->iowait_boost_max;
- if (!cpu_util_rt(cpu_rq(sg_cpu->cpu)))
- max_boost = uclamp_util(sg_cpu->cpu, max_boost);
+ max_boost = uclamp_util(sg_cpu->cpu, max_boost);

/* Double the boost at each request */
if (sg_cpu->iowait_boost) {
diff --git a/kernel/sched/features.h b/kernel/sched/features.h
index 85ae8488039c..a3ca449e36c1 100644
--- a/kernel/sched/features.h
+++ b/kernel/sched/features.h
@@ -90,3 +90,8 @@ SCHED_FEAT(WA_BIAS, true)
* UtilEstimation. Use estimated CPU utilization.
+ * Per class CPU's utilization clamping.
+ */
 \ /
  Last update: 2018-08-06 18:43    [W:0.470 / U:0.268 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site