1 files changed, 37 insertions, 28 deletions

diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index f0d2f8a352bf..51003e1c794d 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -9603,24 +9603,6 @@ static void nohz_balancer_kick(struct rq *rq)
         }
 
         rcu_read_lock();
-        sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
-        if (sds) {
-                /*
-                 * If there is an imbalance between LLC domains (IOW we could
-                 * increase the overall cache use), we need some less-loaded LLC
-                 * domain to pull some load. Likewise, we may need to spread
-                 * load within the current LLC domain (e.g. packed SMT cores but
-                 * other CPUs are idle). We can't really know from here how busy
-                 * the others are - so just get a nohz balance going if it looks
-                 * like this LLC domain has tasks we could move.
-                 */
-                nr_busy = atomic_read(&sds->nr_busy_cpus);
-                if (nr_busy > 1) {
-                        flags = NOHZ_KICK_MASK;
-                        goto unlock;
-                }
-
-        }
 
         sd = rcu_dereference(rq->sd);
         if (sd) {
@@ -9635,6 +9617,21 @@ static void nohz_balancer_kick(struct rq *rq)
                 }
         }
 
+        sd = rcu_dereference(per_cpu(sd_asym_packing, cpu));
+        if (sd) {
+                /*
+                 * When ASYM_PACKING; see if there's a more preferred CPU
+                 * currently idle; in which case, kick the ILB to move tasks
+                 * around.
+                 */
+                for_each_cpu_and(i, sched_domain_span(sd), nohz.idle_cpus_mask) {
+                        if (sched_asym_prefer(i, cpu)) {
+                                flags = NOHZ_KICK_MASK;
+                                goto unlock;
+                        }
+                }
+        }
+
         sd = rcu_dereference(per_cpu(sd_asym_cpucapacity, cpu));
         if (sd) {
                 /*
@@ -9645,20 +9642,32 @@ static void nohz_balancer_kick(struct rq *rq)
                         flags = NOHZ_KICK_MASK;
                         goto unlock;
                 }
+
+                /*
+                 * For asymmetric systems, we do not want to nicely balance
+                 * cache use, instead we want to embrace asymmetry and only
+                 * ensure tasks have enough CPU capacity.
+                 *
+                 * Skip the LLC logic because it's not relevant in that case.
+                 */
+                goto unlock;
         }
 
-        sd = rcu_dereference(per_cpu(sd_asym_packing, cpu));
-        if (sd) {
+        sds = rcu_dereference(per_cpu(sd_llc_shared, cpu));
+        if (sds) {
                 /*
-                 * When ASYM_PACKING; see if there's a more preferred CPU
-                 * currently idle; in which case, kick the ILB to move tasks
-                 * around.
+                 * If there is an imbalance between LLC domains (IOW we could
+                 * increase the overall cache use), we need some less-loaded LLC
+                 * domain to pull some load. Likewise, we may need to spread
+                 * load within the current LLC domain (e.g. packed SMT cores but
+                 * other CPUs are idle). We can't really know from here how busy
+                 * the others are - so just get a nohz balance going if it looks
+                 * like this LLC domain has tasks we could move.
                  */
-                for_each_cpu_and(i, sched_domain_span(sd), nohz.idle_cpus_mask) {
-                        if (sched_asym_prefer(i, cpu)) {
-                                flags = NOHZ_KICK_MASK;
-                                goto unlock;
-                        }
+                nr_busy = atomic_read(&sds->nr_busy_cpus);
+                if (nr_busy > 1) {
+                        flags = NOHZ_KICK_MASK;
+                        goto unlock;
                 }
         }
 unlock: