[PATCH v3 1/2] sched/uclamp: Add a new sysctl to control RT default boost value

From: Qais Yousef
Date: Tue Apr 28 2020 - 12:42:03 EST

Next message: Peter Vasil: "[PATCH v2] pwm: sun4i: direct clock output support for Allwinner A64"
Previous message: Jessica Yu: "Re: [PATCH v3 09/10] module: Remove module_disable_ro()"
Next in thread: Qais Yousef: "[PATCH v3 2/2] Documentation/sysctl: Document uclamp sysctl knobs"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]

RT tasks by default run at the highest capacity/performance level. When
uclamp is selected this default behavior is retained by enforcing the
requested uclamp.min (p->uclamp_req[UCLAMP_MIN]) of the RT tasks to be
uclamp_none(UCLAMP_MAX), which is SCHED_CAPACITY_SCALE; the maximum
value.

This is also referred to as 'the default boost value of RT tasks'.

See commit 1a00d999971c ("sched/uclamp: Set default clamps for RT tasks").

On battery powered devices, it is desired to control this default
(currently hardcoded) behavior at runtime to reduce energy consumed by
RT tasks.

For example, a mobile device manufacturer where big.LITTLE architecture
is dominant, the performance of the little cores varies across SoCs, and
on high end ones the big cores could be too power hungry.

Given the diversity of SoCs, the new knob allows manufactures to tune
the best performance/power for RT tasks for the particular hardware they
run on.

They could opt to further tune the value when the user selects
a different power saving mode or when the device is actively charging.

The runtime aspect of it further helps in creating a single kernel image
that can be run on multiple devices that require different tuning.

Keep in mind that a lot of RT tasks in the system are created by the
kernel. On Android for instance I can see over 50 RT tasks, only
a handful of which created by the Android framework.

To control the default behavior globally by system admins and device
integrators, introduce the new sysctl_sched_uclamp_util_min_rt_default
to change the default boost value of the RT tasks.

I anticipate this to be mostly in the form of modifying the init script
of a particular device.

Whenever the new default changes, it'd be applied lazily on the next
opportunity the scheduler needs to calculate the effective uclamp.min
value for the task, assuming that it still uses the system default value
and not a user applied one.

Tested on Juno-r2 in combination with the RT capacity awareness [1].
By default an RT task will go to the highest capacity CPU and run at the
maximum frequency, which is particularly energy inefficient on high end
mobile devices because the biggest core[s] are 'huge' and power hungry.

With this patch the RT task can be controlled to run anywhere by
default, and doesn't cause the frequency to be maximum all the time.
Yet any task that really needs to be boosted can easily escape this
default behavior by modifying its requested uclamp.min value
(p->uclamp_req[UCLAMP_MIN]) via sched_setattr() syscall.

[1] 804d402fb6f6: ("sched/rt: Make RT capacity-aware")

Signed-off-by: Qais Yousef <qais.yousef@xxxxxxx>
CC: Jonathan Corbet <corbet@xxxxxxx>
CC: Juri Lelli <juri.lelli@xxxxxxxxxx>
CC: Vincent Guittot <vincent.guittot@xxxxxxxxxx>
CC: Dietmar Eggemann <dietmar.eggemann@xxxxxxx>
CC: Steven Rostedt <rostedt@xxxxxxxxxxx>
CC: Ben Segall <bsegall@xxxxxxxxxx>
CC: Mel Gorman <mgorman@xxxxxxx>
CC: Luis Chamberlain <mcgrof@xxxxxxxxxx>
CC: Kees Cook <keescook@xxxxxxxxxxxx>
CC: Iurii Zaikin <yzaikin@xxxxxxxxxx>
CC: Quentin Perret <qperret@xxxxxxxxxx>
CC: Valentin Schneider <valentin.schneider@xxxxxxx>
CC: Patrick Bellasi <patrick.bellasi@xxxxxxxxxx>
CC: Pavan Kondeti <pkondeti@xxxxxxxxxxxxxx>
CC: linux-doc@xxxxxxxxxxxxxxx
CC: linux-kernel@xxxxxxxxxxxxxxx
CC: linux-fsdevel@xxxxxxxxxxxxxxx
---

Changes in v3:

* Do the sync in uclamp_eff_get() (Patrck & Dietmar)
* Rename to sysctl_sched_uclamp_util_min_rt_default (Patrick, Steve,
Dietmar)
* Ensure the sync is applied only to RT tasks (Patrick)

v2 can be found here (apologies forgot to mark it as v2 in the subject)

https://lore.kernel.org/lkml/20200403123020.13897-1-qais.yousef@xxxxxxx/

include/linux/sched/sysctl.h | 1 +
kernel/sched/core.c | 63 +++++++++++++++++++++++++++++++++---
kernel/sysctl.c | 7 ++++
3 files changed, 66 insertions(+), 5 deletions(-)

diff --git a/include/linux/sched/sysctl.h b/include/linux/sched/sysctl.h
index d4f6215ee03f..e62cef019094 100644
--- a/include/linux/sched/sysctl.h
+++ b/include/linux/sched/sysctl.h
@@ -59,6 +59,7 @@ extern int sysctl_sched_rt_runtime;
#ifdef CONFIG_UCLAMP_TASK
extern unsigned int sysctl_sched_uclamp_util_min;
extern unsigned int sysctl_sched_uclamp_util_max;
+extern unsigned int sysctl_sched_uclamp_util_min_rt_default;
#endif

#ifdef CONFIG_CFS_BANDWIDTH
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 9a2fbf98fd6f..17325b4aa451 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -790,6 +790,26 @@ unsigned int sysctl_sched_uclamp_util_min = SCHED_CAPACITY_SCALE;
/* Max allowed maximum utilization */
unsigned int sysctl_sched_uclamp_util_max = SCHED_CAPACITY_SCALE;

+/*
+ * By default RT tasks run at the maximum performance point/capacity of the
+ * system. Uclamp enforces this by always setting UCLAMP_MIN of RT tasks to
+ * SCHED_CAPACITY_SCALE.
+ *
+ * This knob allows admins to change the default behavior when uclamp is being
+ * used. In battery powered devices, particularly, running at the maximum
+ * capacity and frequency will increase energy consumption and shorten the
+ * battery life.
+ *
+ * This knob only affects RT tasks that their uclamp_se->user_defined == false.
+ *
+ * This knob will not override the system default sched_util_clamp_min defined
+ * above.
+ *
+ * Any modification is applied lazily on the next attempt to calculate the
+ * effective value of the task.
+ */
+unsigned int sysctl_sched_uclamp_util_min_rt_default = SCHED_CAPACITY_SCALE;
+
/* All clamps are required to be less or equal than these values */
static struct uclamp_se uclamp_default[UCLAMP_CNT];

@@ -872,6 +892,14 @@ unsigned int uclamp_rq_max_value(struct rq *rq, enum uclamp_id clamp_id,
return uclamp_idle_value(rq, clamp_id, clamp_value);
}

+static void uclamp_sync_util_min_rt_default(struct task_struct *p)
+{
+ struct uclamp_se *uc_se = &p->uclamp_req[UCLAMP_MIN];
+
+ if (unlikely(rt_task(p)) && !uc_se->user_defined)
+ uclamp_se_set(uc_se, sysctl_sched_uclamp_util_min_rt_default, false);
+}
+
static inline struct uclamp_se
uclamp_tg_restrict(struct task_struct *p, enum uclamp_id clamp_id)
{
@@ -907,8 +935,15 @@ uclamp_tg_restrict(struct task_struct *p, enum uclamp_id clamp_id)
static inline struct uclamp_se
uclamp_eff_get(struct task_struct *p, enum uclamp_id clamp_id)
{
- struct uclamp_se uc_req = uclamp_tg_restrict(p, clamp_id);
- struct uclamp_se uc_max = uclamp_default[clamp_id];
+ struct uclamp_se uc_req, uc_max;
+
+ /*
+ * Sync up any change to sysctl_sched_uclamp_util_min_rt_default value.
+ */
+ uclamp_sync_util_min_rt_default(p);
+
+ uc_req = uclamp_tg_restrict(p, clamp_id);
+ uc_max = uclamp_default[clamp_id];

/* System default restrictions always apply */
if (unlikely(uc_req.value > uc_max.value))
@@ -1114,12 +1149,13 @@ int sysctl_sched_uclamp_handler(struct ctl_table *table, int write,
loff_t *ppos)
{
bool update_root_tg = false;
- int old_min, old_max;
+ int old_min, old_max, old_min_rt;
int result;

mutex_lock(&uclamp_mutex);
old_min = sysctl_sched_uclamp_util_min;
old_max = sysctl_sched_uclamp_util_max;
+ old_min_rt = sysctl_sched_uclamp_util_min_rt_default;

result = proc_dointvec(table, write, buffer, lenp, ppos);
if (result)
@@ -1133,6 +1169,18 @@ int sysctl_sched_uclamp_handler(struct ctl_table *table, int write,
goto undo;
}

+ /*
+ * The new value will be applied to RT tasks the next time the
+ * scheduler needs to calculate the effective uclamp.min for that task,
+ * assuming the task is using the system default and not a user
+ * specified value. In the latter we shall leave the value as the user
+ * requested.
+ */
+ if (sysctl_sched_uclamp_util_min_rt_default > SCHED_CAPACITY_SCALE) {
+ result = -EINVAL;
+ goto undo;
+ }
+
if (old_min != sysctl_sched_uclamp_util_min) {
uclamp_se_set(&uclamp_default[UCLAMP_MIN],
sysctl_sched_uclamp_util_min, false);
@@ -1158,6 +1206,7 @@ int sysctl_sched_uclamp_handler(struct ctl_table *table, int write,
undo:
sysctl_sched_uclamp_util_min = old_min;
sysctl_sched_uclamp_util_max = old_max;
+ sysctl_sched_uclamp_util_min_rt_default = old_min_rt;
done:
mutex_unlock(&uclamp_mutex);

@@ -1200,9 +1249,13 @@ static void __setscheduler_uclamp(struct task_struct *p,
if (uc_se->user_defined)
continue;

- /* By default, RT tasks always get 100% boost */
+ /*
+ * By default, RT tasks always get 100% boost, which the admins
+ * are allowed to change via
+ * sysctl_sched_uclamp_util_min_rt_default knob.
+ */
if (unlikely(rt_task(p) && clamp_id == UCLAMP_MIN))
- clamp_value = uclamp_none(UCLAMP_MAX);
+ clamp_value = sysctl_sched_uclamp_util_min_rt_default;

uclamp_se_set(uc_se, clamp_value, false);
}
diff --git a/kernel/sysctl.c b/kernel/sysctl.c
index 8a176d8727a3..64117363c502 100644
--- a/kernel/sysctl.c
+++ b/kernel/sysctl.c
@@ -453,6 +453,13 @@ static struct ctl_table kern_table[] = {
.mode = 0644,
.proc_handler = sysctl_sched_uclamp_handler,
},
+ {
+ .procname = "sched_util_clamp_min_rt_default",
+ .data = &sysctl_sched_uclamp_util_min_rt_default,
+ .maxlen = sizeof(unsigned int),
+ .mode = 0644,
+ .proc_handler = sysctl_sched_uclamp_handler,
+ },
#endif
#ifdef CONFIG_SCHED_AUTOGROUP
{
--
2.17.1

Next message: Peter Vasil: "[PATCH v2] pwm: sun4i: direct clock output support for Allwinner A64"
Previous message: Jessica Yu: "Re: [PATCH v3 09/10] module: Remove module_disable_ro()"
Next in thread: Qais Yousef: "[PATCH v3 2/2] Documentation/sysctl: Document uclamp sysctl knobs"
Messages sorted by: [ date ] [ thread ] [ subject ] [ author ]