Re: [PATCH] sched/cache: honor migrate_llc_task semantics in active load balance

[Tim Chen <tim.c.chen@linux.intel.com>]

On Thu, 2026-08-06 at 23:35 +0800, Chen, Yu C wrote:
> Hi Lu Wang, Tim,
> 
> On 8/1/2026 8:22 PM, Lu Wang wrote:
> > A passive load-balance pass marks group_llc_balance as migrate_llc_task
> > and queues active balance when it cannot move a task. The CPU stopper
> > callback constructs a fresh lb_env, so preserve the migration type on
> > the runqueue across the asynchronous boundary.
> > 
> > For CAS-directed active balance, reject a candidate whose preferred LLC
> > does not match the destination LLC. This keeps the fallback from moving
> > a task away from its preferred LLC.
> > 
> 
> It looks like this proposal provides fine-grain control on per-task base
> migration strategy is promising.
> 
> > +static inline bool
> > +migrate_llc_task_wrong_dst(struct task_struct *p, struct lb_env *env)
> > +{
> > +	return sched_cache_enabled() &&
> > +	       env->migration_type == migrate_llc_task &&
> > +	       READ_ONCE(p->preferred_llc) != llc_id(env->dst_cpu);
> > +}
> > +
> 
> [ ... ]
> 
> > @@ -13654,6 +13672,7 @@ static int active_load_balance_cpu_stop(void *data)
> >   			.src_rq		= busiest_rq,
> >   			.idle		= CPU_IDLE,
> >   			.flags		= LBF_ACTIVE_LB,
> > +			.migration_type	= (enum migration_type)busiest_rq->active_balance_type,
> 
> If we overwrite migration_type for ALB (default is 0, i.e. migrate_load),
> then in can_migrate_task() a delayed task might not be migrated in ALB:
> 
> if ((p->se.sched_delayed) && (env->migration_type != migrate_load))

This is a good catch.

It may be easier to create a migrate_llc_task_alb type and pass that
in migration type.  Then modify the above as 

if ((p->se.sched_delayed) && env->migration_type != migrate_load 
		          && env->migration_type != migrate_llc_task_alb)
	return 0

That avoids creating two cpu stop functions.

Tim

> 	return 0;
> So an enhanced approach I'm thinking of is to pass
> migrate_llc_task information via env->flags:
> >   		};
> >   
> >   		schedstat_inc(sd->alb_count);
> > diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
> > index 56acf502b..82084d405 100644
> > --- a/kernel/sched/sched.h
> > +++ b/kernel/sched/sched.h
> > @@ -1266,6 +1266,7 @@ struct rq {
> >   	/* For active balancing */
> >   	int			active_balance;
> >   	int			push_cpu;
> > +	int			active_balance_type; /* enum migration_type */
> 
> We can set env->flags by invoking different callbacks of 
> stop_one_cpu_nowait(),
> thus avoiding the need to introduce active_balance_type into rq - which 
> could
> cause false sharing if cache-line alignment is broken.
> 
> something like:
> 
> #define LBF_ACTIVE_LB_LLC      0x40
> 
> -static int active_load_balance_cpu_stop(void *data)
> +static int __active_load_balance_cpu_stop(void *data, unsigned int 
> lb_flags)
> -static int active_load_balance_cpu_stop(void *data)
> +static int __active_load_balance_cpu_stop(void *data, unsigned int 
> lb_flags)
>   {
>          struct rq *busiest_rq = data;
>          int busiest_cpu = cpu_of(busiest_rq);
> @@ -13659,7 +13687,7 @@ static int active_load_balance_cpu_stop(void *data)
>                          .src_cpu        = busiest_rq->cpu,
>                          .src_rq         = busiest_rq,
>                          .idle           = CPU_IDLE,
> -                       .flags          = LBF_ACTIVE_LB,
> +                       .flags          = LBF_ACTIVE_LB | lb_flags,
>                  };
> 
> and in migrate_llc_task_wrong_dst(), we check env->flags & LBF_ACTIVE_LB_LLC
> instead.
> 
> static int active_load_balance_cpu_stop(void *data)
> {
>          return __active_load_balance_cpu_stop(data, 0);
> }
> 
> static int active_load_balance_llc_cpu_stop(void *data)
> {
>          return __active_load_balance_cpu_stop(data, LBF_ACTIVE_LB_LLC); 
> <-- new flag
> }
> 
> static inline cpu_stop_fn_t alb_stop_fn(struct lb_env *env)
> {
>          if (env->migration_type == migrate_llc_task)
>                  return active_load_balance_llc_cpu_stop;
> 
>          return active_load_balance_cpu_stop;
> }
> 
> if (active_balance) {
> 	stop_one_cpu_nowait(cpu_of(busiest),
> 		alb_stop_fn(&env), busiest,
> 		&busiest->active_balance_work);
> }
> 
> 
> thanks,
> Chenyu
> 
> >   	struct cpu_stop_work	active_balance_work;
> >   
> >   	/* CPU of this runqueue: */