Re: [PATCH sched_ext] sched/ext: Keep tick enabled for finite-slice tasks

Hi Zhimin,

On Thu, Jul 16, 2026 at 10:37:46AM +0800, Zhimin Feng wrote:
> SCX tasks with finite slices need the scheduler tick to make forward
> progress on slice expiration. However, set_next_task_scx() used to refresh
> the nohz dependency through sched_update_tick_dependency(), which evaluates
> sched_can_stop_tick() using rq->curr.
> 
> When switching from idle, RT, CFS, or another previous task to a
> finite-slice SCX task on a nohz_full CPU, rq->curr may still point at
> the previous task while set_next_task_scx() is running. If that previous
> task allows the tick to stop, the scheduler dependency can remain
> cleared even though the next SCX task has p->scx.slice != SCX_SLICE_INF.
> 
> CFS does not hit the same gap for bandwidth-constrained tasks because its
> pick path has a next-task based check: sched_fair_update_stop_tick()
> explicitly sets TICK_DEP_BIT_SCHED when the selected CFS task needs
> bandwidth accounting on a nohz_full CPU.
> 
> Add a helper to set the scheduler tick dependency directly and use it from
> set_next_task_scx() whenever the next SCX task has a finite slice.
> This avoids basing the finite-slice decision on the old rq->curr while
> preserving the existing tickless behavior for SCX_SLICE_INF tasks.
> 
> Signed-off-by: Zhimin Feng <[email protected]>
> Co-developed-by: Chengming Zhou <[email protected]>
> Signed-off-by: Chengming Zhou <[email protected]>

This should already be fixed upstream by commit 4ec10f38ff901 ("sched_ext:
Enable tick for finite slices on nohz_full"):

See also:
https://lore.kernel.org/all/[email protected]/

Thanks,
-Andrea

> ---
>  kernel/sched/ext/ext.c | 21 ++++++++++++++++++---
>  kernel/sched/sched.h   | 11 +++++++++++
>  2 files changed, 29 insertions(+), 3 deletions(-)
> 
> diff --git a/kernel/sched/ext/ext.c b/kernel/sched/ext/ext.c
> index 691d53fe0f64..6c0c805d489a 100644
> --- a/kernel/sched/ext/ext.c
> +++ b/kernel/sched/ext/ext.c
> @@ -2950,6 +2950,8 @@ static int balance_one(struct rq *rq, struct task_struct *prev)
>  static void set_next_task_scx(struct rq *rq, struct task_struct *p, bool first)
>  {
>  	struct scx_sched *sch = scx_task_sched(p);
> +	bool can_stop_tick;
> +	bool tick_state_changed;
>  
>  	if (p->scx.flags & SCX_TASK_QUEUED) {
>  		/*
> @@ -2972,15 +2974,28 @@ static void set_next_task_scx(struct rq *rq, struct task_struct *p, bool first)
>  	 * @p is getting newly scheduled or got kicked after someone updated its
>  	 * slice. Refresh whether tick can be stopped. See scx_can_stop_tick().
>  	 */
> -	if ((p->scx.slice == SCX_SLICE_INF) !=
> -	    (bool)(rq->scx.flags & SCX_RQ_CAN_STOP_TICK)) {
> -		if (p->scx.slice == SCX_SLICE_INF)
> +	can_stop_tick = p->scx.slice == SCX_SLICE_INF;
> +	tick_state_changed = can_stop_tick !=
> +		(bool)(rq->scx.flags & SCX_RQ_CAN_STOP_TICK);
> +	if (tick_state_changed) {
> +		if (can_stop_tick)
>  			rq->scx.flags |= SCX_RQ_CAN_STOP_TICK;
>  		else
>  			rq->scx.flags &= ~SCX_RQ_CAN_STOP_TICK;
> +	}
>  
> +	/*
> +	 * If @p has a finite slice, it needs the scheduler tick to make
> +	 * forward progress on slice expiration. Don't rely on
> +	 * sched_update_tick_dependency() here because rq->curr may still be
> +	 * the previous task while set_next_task_scx() is running.
> +	 */
> +	if (!can_stop_tick)
> +		sched_set_tick_dependency(rq);
> +	else if (tick_state_changed)
>  		sched_update_tick_dependency(rq);
>  
> +	if (tick_state_changed) {
>  		/*
>  		 * For now, let's refresh the load_avgs just when transitioning
>  		 * in and out of nohz. In the future, we might want to add a
> diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
> index 56acf502ba26..d692d92fc095 100644
> --- a/kernel/sched/sched.h
> +++ b/kernel/sched/sched.h
> @@ -2998,9 +2998,20 @@ static inline void sched_update_tick_dependency(struct rq *rq)
>  	else
>  		tick_nohz_dep_set_cpu(cpu, TICK_DEP_BIT_SCHED);
>  }
> +
> +static inline void sched_set_tick_dependency(struct rq *rq)
> +{
> +	int cpu = cpu_of(rq);
> +
> +	if (!tick_nohz_full_cpu(cpu))
> +		return;
> +
> +	tick_nohz_dep_set_cpu(cpu, TICK_DEP_BIT_SCHED);
> +}
>  #else /* !CONFIG_NO_HZ_FULL: */
>  static inline int sched_tick_offload_init(void) { return 0; }
>  static inline void sched_update_tick_dependency(struct rq *rq) { }
> +static inline void sched_set_tick_dependency(struct rq *rq) { }
>  #endif /* !CONFIG_NO_HZ_FULL */
>  
>  static inline void add_nr_running(struct rq *rq, unsigned count)
> -- 
> 2.39.5