Re: [PATCH v7 06/12] sched/core: Push current task from non preferred CPU
From: Shrikanth Hegde
Date: Mon Jul 13 2026 - 08:36:32 EST
On 7/11/26 4:32 AM, Yury Norov wrote:
On Fri, Jul 10, 2026 at 03:26:42AM +0530, Shrikanth Hegde wrote:
Actively push out task running on a non-preferred CPU. Since the task is
running on the CPU, need to stop the cpu and push the task out.
However, if the task is pinned only to non-preferred CPUs, it will continue
running there. This will help in maintaining the userspace affinities
unlike CPU hotplug or isolated cpusets.
Though code is similar to __balance_push_cpu_stop and quite close to
push_cpu_stop, it is being kept separate as it provides a cleaner
implementation with CONFIG_PREFERRED_CPU.
Add push_task_work_done flag to protect work buffer.
Works only with FAIR class.
For now, only current running task is pushed out. This keeps the code
simpler. In future optimization maybe done to move all the queued
task on the rq.
Signed-off-by: Shrikanth Hegde <sshegde@xxxxxxxxxxxxx>
---
v6->v7:
- Moved is_migration_disabled
- removed fair class check
kernel/sched/core.c | 78 ++++++++++++++++++++++++++++++++++++++++++++
kernel/sched/sched.h | 8 +++++
2 files changed, 86 insertions(+)
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 9e8eec4451b6..74c93a88bf84 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -5774,6 +5774,9 @@ void sched_tick(void)
unsigned long hw_pressure;
u64 resched_latency;
+ if (!cpu_preferred(cpu))
+ sched_push_current_non_preferred_cpu(rq);
+
if (housekeeping_cpu(cpu, HK_TYPE_KERNEL_NOISE))
arch_scale_freq_tick();
@@ -11292,3 +11295,78 @@ void sched_change_end(struct sched_change_ctx *ctx)
p->sched_class->prio_changed(rq, p, ctx->prio);
}
}
+
+#ifdef CONFIG_PREFERRED_CPU
+static DEFINE_PER_CPU(struct cpu_stop_work, npc_push_task_work);
+
+static int sched_non_preferred_cpu_push_stop(void *arg)
+{
+ struct task_struct *p = arg;
+ struct rq *rq = this_rq();
+ struct rq_flags rf;
+ int cpu;
+
+ /* sanity checks and clear */
+ if (cpu_preferred(rq->cpu) || is_migration_disabled(p)) {
+ scoped_guard(rq_lock, rq)
+ rq->push_task_work_done = false;
+ put_task_struct(p);
+ return 0;
+ }
+
+ raw_spin_lock_irq(&p->pi_lock);
+
+ /* This could take rq lock. So call it before rq lock is taken */
+ cpu = select_fallback_rq(rq->cpu, p);
+ rq_lock(rq, &rf);
+ rq->push_task_work_done = false;
+ update_rq_clock(rq);
+
+ context_unsafe_alias(rq);
+
+ if (task_rq(p) == rq && task_on_rq_queued(p))
+ rq = __migrate_task(rq, &rf, p, cpu);
+
+ rq_unlock(rq, &rf);
+ raw_spin_unlock_irq(&p->pi_lock);
+ put_task_struct(p);
+
+ return 0;
+}
+
+/*
+ * Push the current task running on non-preferred CPU(npc).
+ * Using this non preferred CPU will lead to more vCPU preemptions
+ * in the host. So it is better not to use this CPU.
+ *
+ * Since task is running, call a stopper to push the task out. This is
+ * similar to how task moves during hotplug. In select_fallback_rq a
+ * preferred CPU will be chosen and henceforth task shouldn't come back to
+ * this CPU again.
+ *
+ * Works for FAIR class only
+ *
+ * If task is affined only non-preferred CPUs, it can't be moved out
+ */
+void sched_push_current_non_preferred_cpu(struct rq *rq)
+{
+ struct task_struct *push_task = rq->curr;
+
+ /* Don't push the task if task's affinity doesn't allow */
+ if (!task_can_sched_on_preferred(rq->cpu, push_task))
+ return;
Shouldn't you protect it with the rq lock against races with affinity or
policy changes? The task_can_sched_on_preferred() checks p->sched_class
and p->cpus_ptr.
Likely yes. I did below. It has survived light testing so far.
i.e.
- Moved checks under rq lock held.
- There was a tiny window where task could have migrated.
Moved it down further just before migrating.
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 6ed61182b19f..eda080ab3427 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -11311,7 +11311,7 @@ static int sched_non_preferred_cpu_push_stop(void *arg)
int cpu;
/* sanity checks and clear */
- if (cpu_preferred(rq->cpu) || is_migration_disabled(p)) {
+ if (cpu_preferred(rq->cpu)) {
scoped_guard(rq_lock, rq)
rq->push_task_work_done = false;
put_task_struct(p);
@@ -11328,7 +11328,8 @@ static int sched_non_preferred_cpu_push_stop(void *arg)
context_unsafe_alias(rq);
- if (task_rq(p) == rq && task_on_rq_queued(p)) {
+ if (task_rq(p) == rq && task_on_rq_queued(p)
+ && !is_migration_disabled(p)) {
struct rq *dest_rq;
dest_rq = __migrate_task(rq, &rf, p, cpu);
@@ -11362,19 +11363,20 @@ void sched_push_current_non_preferred_cpu(struct rq *rq)
{
struct task_struct *push_task = rq->curr;
- /* Don't push the task if task's affinity doesn't allow */
- if (!task_can_sched_on_preferred(rq->cpu, push_task))
- return;
+ scoped_guard(rq_lock, rq) {
+ /* Don't push the task if task's affinity doesn't allow */
+ if (!task_can_sched_on_preferred(rq->cpu, push_task))
+ return;
- /* There is already a stopper thread. Don't race with it. */
- if (rq->push_task_work_done)
- return;
+ /* There is already a stopper thread. Don't race with it. */
+ if (rq->push_task_work_done)
+ return;
- /* sched_tick runs with interrupts disabled. */
- get_task_struct(push_task);
+ /* sched_tick runs with interrupts disabled. */
+ get_task_struct(push_task);
- scoped_guard(rq_lock, rq)
rq->push_task_work_done = true;
+ }
stop_one_cpu_nowait(rq->cpu, sched_non_preferred_cpu_push_stop,
push_task, this_cpu_ptr(&npc_push_task_work));
+
+ /* There is already a stopper thread. Don't race with it. */
+ if (rq->push_task_work_done)
+ return;
+
+ /* sched_tick runs with interrupts disabled. */
+ get_task_struct(push_task);
+
+ scoped_guard(rq_lock, rq)
+ rq->push_task_work_done = true;
+
+ stop_one_cpu_nowait(rq->cpu, sched_non_preferred_cpu_push_stop,
+ push_task, this_cpu_ptr(&npc_push_task_work));
+}
+#endif
diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
index 6de6366f2faa..80c02e2c09eb 100644
--- a/kernel/sched/sched.h
+++ b/kernel/sched/sched.h
@@ -1277,6 +1277,8 @@ struct rq {
struct list_head cfs_tasks;
+ bool push_task_work_done;
+
struct sched_avg avg_rt;
struct sched_avg avg_dl;
#ifdef CONFIG_HAVE_SCHED_AVG_IRQ
@@ -4242,4 +4244,10 @@ static inline bool task_can_sched_on_preferred(int cpu, struct task_struct *p)
return cpumask_intersects(p->cpus_ptr, cpu_preferred_mask);
}
+#ifdef CONFIG_PREFERRED_CPU
+void sched_push_current_non_preferred_cpu(struct rq *rq);
+#else /* !CONFIG_PREFERRED_CPU */
+static inline void sched_push_current_non_preferred_cpu(struct rq *rq) { }
+#endif
+
#endif /* _KERNEL_SCHED_SCHED_H */
--
2.47.3