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
utilization.
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 <patrick.bellasi@arm.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Rafael J. Wysocki <rafael.j.wysocki@intel.com>
Cc: Viresh Kumar <viresh.kumar@linaro.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Todd Kjos <tkjos@google.com>
Cc: Joel Fernandes <joelaf@google.com>
Cc: Juri Lelli <juri.lelli@redhat.com>
Cc: Dietmar Eggemann <dietmar.eggemann@arm.com>
Cc: Morten Rasmussen <morten.rasmussen@arm.com>
Cc: linux-kernel@vger.kernel.org
Cc: linux-pm@vger.kernel.org
---
Changes in v3:
 - rebased on tip/sched/core

Changes in v2:
 - rebased on v4.18-rc4

diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
index c5bc6c2387a01c23619f7b99af41172b0d6b9c06..2715492b8ac1e6c3da15d051700fa7429d31ae27 100644 (file)
--- a/kernel/sched/cpufreq_schedutil.c
+++ b/kernel/sched/cpufreq_schedutil.c
@@ -203,6 +203,7 @@ unsigned long schedutil_freq_util(int cpu, unsigned long util_cfs,
 {
        struct rq *rq = cpu_rq(cpu);
        unsigned long util, irq, max;
+       unsigned long util_rt;
 
        max = arch_scale_cpu_capacity(NULL, cpu);
 
@@ -224,15 +225,26 @@ unsigned long schedutil_freq_util(int cpu, unsigned long util_cfs,
         * utilization (PELT windows are synchronized) we can directly add them
         * to obtain the CPU's actual utilization.
         */
-
+       util_rt  = cpu_util_rt(rq);
        if (type == frequency_util) {
 
                /*
-                * 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  = util_cfs ? uclamp_util(cpu, util_cfs) : 0;
-               util += cpu_util_rt(rq);
+               if (sched_feat(UCLAMP_SCHED_CLASS)) {
+                       util = 0;
+                       if (util_cfs)
+                               util += uclamp_util(cpu, util_cfs);
+                       if (util_rt)
+                               util += uclamp_util(cpu, util_rt);
+               } else {
+                       util = util_cfs + util_rt;
+                       util = uclamp_util(cpu, util);
+               }
 
                /*
                 * For frequency selection we do not make cpu_util_dl() a
@@ -250,7 +262,7 @@ unsigned long schedutil_freq_util(int cpu, unsigned long util_cfs,
                        return max;
        } else {
 
-               util = util_cfs + cpu_util_rt(rq);
+               util = util_cfs + util_rt;
 
                /*
                 * OTOH, for energy computation we need the estimated
@@ -368,13 +380,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 85ae8488039c088c00bf12f182e4027c061ab2f0..a3ca449e36c14226bf1e64dfe0a1cd1b115c36b9 100644 (file)
--- a/kernel/sched/features.h
+++ b/kernel/sched/features.h
@@ -90,3 +90,8 @@ SCHED_FEAT(WA_BIAS, true)
  * UtilEstimation. Use estimated CPU utilization.
  */
 SCHED_FEAT(UTIL_EST, true)
+
+/*
+ * Per class CPU's utilization clamping.
+ */
+SCHED_FEAT(UCLAMP_SCHED_CLASS, false)