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
@@ -9377,10 +9377,16 @@ voluntary_active_balance(struct lb_env *env)
return 0;
}
-static int need_active_balance(struct lb_env *env)
+static int need_active_balance(struct lb_env *env, int *continue_balancing)
{
struct sched_domain *sd = env->sd;
+ /* Run the realtime task now; load balance later. */
+ if (rq_has_runnable_rt_task(env->dst_rq)) {
+ *continue_balancing = 0;
+ return 0;
+ }
+
if (voluntary_active_balance(env))
return 1;
@@ -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;
+
/*
* Ensure the balancing environment is consistent; can happen
* when the softirq triggers 'during' hotplug.
@@ -9521,6 +9531,11 @@ static int load_balance(int this_cpu, struct rq *this_rq,
local_irq_restore(rf.flags);
+ if (rq_has_runnable_rt_task(this_rq)) {
+ *continue_balancing = 0;
+ goto out;
+ }
+
if (env.flags & LBF_NEED_BREAK) {
env.flags &= ~LBF_NEED_BREAK;
goto more_balance;
@@ -9604,7 +9619,7 @@ static int load_balance(int this_cpu, struct rq *this_rq,
if (idle != CPU_NEWLY_IDLE)
sd->nr_balance_failed++;
- if (need_active_balance(&env)) {
+ if (need_active_balance(&env, continue_balancing)) {
unsigned long flags;
raw_spin_lock_irqsave(&busiest->lock, flags);
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);
+}
#else
static inline void idle_set_state(struct rq *rq,
struct cpuidle_state *idle_state)
--
2.18.2
