On 28/04/20 06:02, Scott Wood wrote:
> From: Rik van Riel <riel@xxxxxxxxxx>
>
> Bugzilla: 1331562
>
> The CFS load balancer can take a little while, to the point of
> it having a special LBF_NEED_BREAK flag, when the task moving
> code takes a breather.
>
> However, at that point it will jump right back in to load balancing,
> without checking whether the CPU has gained any runnable real time
> (or deadline) tasks.
>
> Only idle_balance used to check for runnable real time tasks on a
> CPU. This patch moves that check into a separate inline function,
> and calls that function in load_balance, at approximately the same
> granularity that LBF_NEED_BREAK happens.
>
> Besides breaking out of load_balance, this patch also clears
> continue_balancing, in order for rebalance_domains to break out
> of its loop when a realtime task becomes runnable.
>
> Signed-off-by: Rik van Riel <riel@xxxxxxxxxx>
> Reported-by: Clark Williams <williams@xxxxxxxxxx>
> Signed-off-by: Clark Williams <williams@xxxxxxxxxx>
> ---
> kernel/sched/fair.c | 19 +++++++++++++++++--
> kernel/sched/sched.h | 6 ++++++
> 2 files changed, 23 insertions(+), 2 deletions(-)
>
> diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
> index dfde7f0ce3db..e7437e4e40b4 100644
> --- a/kernel/sched/fair.c
> +++ b/kernel/sched/fair.c
> @@ -9394,6 +9400,10 @@ static int should_we_balance(struct lb_env *env)
> struct sched_group *sg = env->sd->groups;
> int cpu, balance_cpu = -1;
>
> + /* Run the realtime task now; load balance later. */
> + if (rq_has_runnable_rt_task(env->dst_rq))
> + return 0;
> +
I have a feeling this isn't very nice to CFS tasks, since we would now
"waste" load-balance attempts if they happen to coincide with an RT task
being runnable.
On your 72 CPUs machine, the system-wide balance happens (at best) every
72ms if you have idle time, every ~2300ms otherwise (every balance
CPU gets to try to balance however, so it's not as horrible as I'm making
it sound). This is totally worst-case scenario territory, and you'd hope
newidle_balance() could help here and there (as it isn't gated by any
balance interval).
Still, even for a single rq, postponing a system-wide balance for a
full balance interval (i.e. ~2 secs worst case here) just because we had a
single RT task running when we tried to balance seems a bit much.
It may be possible to hack something to detect those cases and reset the
interval to "now" when e.g. dequeuing the last RT task (& after having
previously aborted a load-balance due to RT/DL/foobar).
> /*
> * Ensure the balancing environment is consistent; can happen
> * when the softirq triggers 'during' hotplug.
> diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
> index 3d97c51544d7..a2a01dfd2bea 100644
> --- a/kernel/sched/sched.h
> +++ b/kernel/sched/sched.h
> @@ -1878,6 +1878,12 @@ static inline struct cpuidle_state *idle_get_state(struct rq *rq)
>
> return rq->idle_state;
> }
> +
> +/* Is there a task of a high priority class? */
> +static inline bool rq_has_runnable_rt_task(struct rq *rq)
> +{
> + return unlikely(rq->nr_running != rq->cfs.h_nr_running);
Seeing as that can be RT, DL or stopper, that name is somewhat misleading.
> +}
> #else
> static inline void idle_set_state(struct rq *rq,
> struct cpuidle_state *idle_state)
