github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-09-14 16:10:02 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

sched/fair: Add cgroup_mode: up

Browse Source 
Instead of calculating the proportional fraction of the group weight for each
CPU, just give each CPU the full measure, ignoring these pesky SMP problems.

This makes the SMP cgroup fraction (F_g_n) equal to 1, and ensures a single
task in a cgroup competes on equal footing to a task in a level above.

However, as already explored, this is not a very good policy because it gets
the SMP weight distribution wrong. Included for completeness.

Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Link: https://patch.msgid.link/20260605124051.450303977%40infradead.org
This commit is contained in:
Peter Zijlstra 2026-03-12 14:59:06 +01:00
parent 4161cb2d86
commit 80ad6d3338
3 changed files with 34 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
kernel/sched/debug.c
View File

@ -634,9 +634,11 @@ static void debugfs_fair_server_init(void)
}
#ifdef CONFIG_FAIR_GROUP_SCHED
static int cgroup_mode = 0;
static int cgroup_mode = 1;
/* See __sched_cgroup_mode_update(). */
static const char *cgroup_mode_str[] = {
"up",
"smp",
};
@ -666,6 +668,7 @@ static ssize_t sched_cgroup_write(struct file *filp, const char __user *ubuf,
if (mode < 0)
return mode;
__sched_cgroup_mode_update(mode);
WRITE_ONCE(cgroup_mode, mode);
*ppos += cnt;

31
kernel/sched/fair.c
View File

@ -38,6 +38,7 @@
#include <linux/sched/isolation.h>
#include <linux/sched/nohz.h>
#include <linux/sched/prio.h>
#include <linux/static_call.h>
#include <linux/cpuidle.h>
#include <linux/interrupt.h>
@ -4800,7 +4801,7 @@ static inline int throttled_hierarchy(struct cfs_rq *cfs_rq);
*
* hence icky!
*/
static long calc_group_shares(struct cfs_rq *cfs_rq)
static long calc_smp_shares(struct cfs_rq *cfs_rq)
{
long tg_weight, tg_shares, load, shares;
struct task_group *tg = cfs_rq->tg;
@ -4834,6 +4835,32 @@ static long calc_group_shares(struct cfs_rq *cfs_rq)
return clamp_t(long, shares, MIN_SHARES, tg_shares);
}
/*
* Ignore this pesky SMP stuff, use (4).
*/
static long calc_up_shares(struct cfs_rq *cfs_rq)
{
struct task_group *tg = cfs_rq->tg;
return READ_ONCE(tg->shares);
}
DEFINE_STATIC_CALL(calc_group_shares, calc_smp_shares);
void __sched_cgroup_mode_update(int mode)
{
long (*func)(struct cfs_rq *);
switch (mode) {
case 0:
func = &calc_up_shares;
break;
case 1:
default:
func = &calc_smp_shares;
break;
}
static_call_update(calc_group_shares, func);
}
/*
* Recomputes the group entity based on the current state of its group
* runqueue.
@ -4850,7 +4877,7 @@ static void update_cfs_group(struct sched_entity *se)
if (!gcfs_rq || !gcfs_rq->load.weight)
return;
shares = calc_group_shares(gcfs_rq);
shares = static_call(calc_group_shares)(gcfs_rq);
if (unlikely(se->load.weight != shares))
reweight_entity(cfs_rq_of(se), se, shares);
}

1
kernel/sched/sched.h
View File

@ -571,6 +571,7 @@ extern void free_fair_sched_group(struct task_group *tg);
extern int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent);
extern void online_fair_sched_group(struct task_group *tg);
extern void unregister_fair_sched_group(struct task_group *tg);
extern void __sched_cgroup_mode_update(int mode);
#else /* !CONFIG_FAIR_GROUP_SCHED: */
static inline void free_fair_sched_group(struct task_group *tg) { }
static inline int alloc_fair_sched_group(struct task_group *tg, struct task_group *parent)