sched: Move CFS tasks to CPUs with higher capacity
Sai Gurrappadi [Wed, 1 Jul 2015 01:06:40 +0000 (18:06 -0700)]
Original commit message:

"When a CPU is used to handle a lot of IRQs or some RT tasks, the remaining
capacity for CFS tasks can be significantly reduced. Once we detect such
situation by comparing cpu_capacity_orig and cpu_capacity, we trig an idle
load balance to check if it's worth moving its tasks on an idle CPU.

It's worth trying to move the task before the CPU is fully utilized to
minimize the preemption by irq or RT tasks.

Once the idle load_balance has selected the busiest CPU, it will look for an
active load balance for only two cases:

  - There is only 1 task on the busiest CPU.

  - We haven't been able to move a task of the busiest rq.

A CPU with a reduced capacity is included in the 1st case, and it's worth to
actively migrate its task if the idle CPU has got more available capacity for
CFS tasks. This test has been added in need_active_balance.

As a sidenote, this will not generate more spurious ilb because we already
trig an ilb if there is more than 1 busy cpu. If this cpu is the only one that
has a task, we will trig the ilb once for migrating the task.

The nohz_kick_needed function has been cleaned up a bit while adding the new
test.

env.src_cpu and env.src_rq must be set unconditionnally because they are used
in need_active_balance which is called even if busiest->nr_running equals 1"

Signed-off-by: Vincent Guittot <vincent.guittot@linaro.org>
Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
Cc: Morten.Rasmussen@arm.com
Cc: dietmar.eggemann@arm.com
Cc: efault@gmx.de
Cc: kamalesh@linux.vnet.ibm.com
Cc: linaro-kernel@lists.linaro.org
Cc: nicolas.pitre@linaro.org
Cc: preeti@linux.vnet.ibm.com
Cc: riel@redhat.com
Link: http://lkml.kernel.org/r/1425052454-25797-12-git-send-email-vincent.guittot@linaro.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>

Partial backport of upstream commit: 1aaf90a4b88aae26a4535ba01dacab520a310d17

Doesn't apply cleanly to k3.10 so did a manual backport.

Only intended for k3.10 kernels.

Change-Id: Idb88d844725aec934a7c0376b4fb0965c965da7c
Signed-off-by: Sai Gurrappadi <sgurrappadi@nvidia.com>
Reviewed-on: http://git-master/r/764514
(cherry picked from commit 900cc112802a46d6803e381a8dadf7c3c4bf385b)
Reviewed-on: http://git-master/r/814730
GVS: Gerrit_Virtual_Submit
Reviewed-by: Michael Hsu <mhsu@nvidia.com>
Tested-by: Michael Hsu <mhsu@nvidia.com>
Reviewed-by: Ashutosh Jha <ajha@nvidia.com>

kernel/sched/fair.c

index c7ab8ea..20b0c08 100644 (file)
@@ -5009,6 +5009,19 @@ static struct rq *find_busiest_queue(struct lb_env *env,
 /* Working cpumask for load_balance and load_balance_newidle. */
 DEFINE_PER_CPU(cpumask_var_t, load_balance_mask);
 
+/*
+ * Check whether the capacity of the rq has been noticeably reduced by side
+ * activity. The imabalance_pct is used for the threshold.
+ * Return true if the capacity is reduced.
+ */
+static inline int check_cpu_power(struct rq *rq, struct sched_domain *sd)
+{
+       struct sched_group *sdg = sd->groups;
+       unsigned long power_orig = sdg->sgp->power_orig;
+
+       return rq->cpu_power * sd->imbalance_pct < power_orig * 100;
+}
+
 static int need_active_balance(struct lb_env *env)
 {
        struct sched_domain *sd = env->sd;
@@ -5024,6 +5037,13 @@ static int need_active_balance(struct lb_env *env)
                        return 1;
        }
 
+       if ((env->idle != CPU_NOT_IDLE) &&
+           (env->src_rq->cfs.h_nr_running == 1)) {
+               if (check_cpu_power(env->src_rq, sd) &&
+                   (power_of(env->src_cpu) * sd->imbalance_pct < power_of(env->dst_cpu) * 100))
+                       return 1;
+       }
+
        return unlikely(sd->nr_balance_failed > sd->cache_nice_tries+2);
 }
 
@@ -5085,6 +5105,9 @@ redo:
 
        schedstat_add(sd, lb_imbalance[idle], env.imbalance);
 
+       env.src_cpu   = busiest->cpu;
+       env.src_rq    = busiest;
+
        ld_moved = 0;
        if (busiest->nr_running > 1) {
                /*
@@ -5094,8 +5117,6 @@ redo:
                 * correctly treated as an imbalance.
                 */
                env.flags |= LBF_ALL_PINNED;
-               env.src_cpu   = busiest->cpu;
-               env.src_rq    = busiest;
                env.loop_max  = min(sysctl_sched_nr_migrate, busiest->nr_running);
 
                update_h_load(env.src_cpu);
@@ -5652,13 +5673,14 @@ end:
  *   - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler
  *     domain span are idle.
  */
-static inline int nohz_kick_needed(struct rq *rq, int cpu)
+static inline bool nohz_kick_needed(struct rq *rq, int cpu)
 {
        unsigned long now = jiffies;
        struct sched_domain *sd;
+       bool kick = false;
 
        if (unlikely(idle_cpu(cpu)))
-               return 0;
+               return false;
 
        /*
        * We may be recently in ticked or tickless idle mode. At the first
@@ -5672,13 +5694,13 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)
         * balancing.
         */
        if (likely(!atomic_read(&nohz.nr_cpus)))
-               return 0;
+               return false;
 
        if (time_before(now, nohz.next_balance))
-               return 0;
+               return false;
 
        if (rq->nr_running >= 2)
-               goto need_kick;
+               return true;
 
        rcu_read_lock();
        for_each_domain(cpu, sd) {
@@ -5686,24 +5708,33 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)
                struct sched_group_power *sgp = sg->sgp;
                int nr_busy = atomic_read(&sgp->nr_busy_cpus);
 
-               if (sd->flags & SD_SHARE_PKG_RESOURCES && nr_busy > 1)
-                       goto need_kick_unlock;
+               if (sd->flags & SD_SHARE_PKG_RESOURCES && nr_busy > 1) {
+                       kick = true;
+                       goto unlock;
+               }
 
                if (sd->flags & SD_ASYM_PACKING && nr_busy != sg->group_weight
                    && (cpumask_first_and(nohz.idle_cpus_mask,
-                                         sched_domain_span(sd)) < cpu))
-                       goto need_kick_unlock;
+                                         sched_domain_span(sd)) < cpu)) {
+                       kick = true;
+                       goto unlock;
+               }
 
                if (!(sd->flags & (SD_SHARE_PKG_RESOURCES | SD_ASYM_PACKING)))
                        break;
        }
-       rcu_read_unlock();
-       return 0;
 
-need_kick_unlock:
+       sd = rcu_dereference(rq->sd);
+       if (sd) {
+               if ((rq->cfs.h_nr_running >= 1) && check_cpu_power(rq, sd)) {
+                       kick = true;
+                       goto unlock;
+               }
+       }
+
+unlock:
        rcu_read_unlock();
-need_kick:
-       return 1;
+       return kick;
 }
 #else
 static void nohz_idle_balance(int this_cpu, enum cpu_idle_type idle) { }