sched: Final power vs. capacity cleanups

It is better not to think about compute capacity as being equivalent
to "CPU power".  The upcoming "power aware" scheduler work may create
confusion with the notion of energy consumption if "power" is used too
liberally.

This contains the architecture visible changes.  Incidentally, only ARM
takes advantage of the available pow^H^H^Hcapacity scaling hooks and
therefore those changes outside kernel/sched/ are confined to one ARM
specific file.  The default arch_scale_smt_power() hook is not overridden
by anyone.

Replacements are as follows:

	arch_scale_freq_power  --> arch_scale_freq_capacity
	arch_scale_smt_power   --> arch_scale_smt_capacity
	SCHED_POWER_SCALE      --> SCHED_CAPACITY_SCALE
	SCHED_POWER_SHIFT      --> SCHED_CAPACITY_SHIFT

The local usage of "power" in arch/arm/kernel/topology.c is also changed
to "capacity" as appropriate.

Signed-off-by: Nicolas Pitre <nico@linaro.org>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Daniel Lezcano <daniel.lezcano@linaro.org>
Cc: Morten Rasmussen <morten.rasmussen@arm.com>
Cc: "Rafael J. Wysocki" <rjw@rjwysocki.net>
Cc: linaro-kernel@lists.linaro.org
Cc: Arnd Bergmann <arnd@arndb.de>
Cc: Dietmar Eggemann <dietmar.eggemann@arm.com>
Cc: Grant Likely <grant.likely@linaro.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mark Brown <broonie@linaro.org>
Cc: Rob Herring <robh+dt@kernel.org>
Cc: Russell King <linux@arm.linux.org.uk>
Cc: Sudeep KarkadaNagesha <sudeep.karkadanagesha@arm.com>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: devicetree@vger.kernel.org
Cc: linux-arm-kernel@lists.infradead.org
Cc: linux-kernel@vger.kernel.org
Link: http://lkml.kernel.org/n/tip-48zba9qbznvglwelgq2cfygh@git.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>

2 files changed, 33 insertions, 32 deletions

diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 07bc78a50329..7ba4f5413a10 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -5249,7 +5249,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                 cpulist_scnprintf(str, sizeof(str), sched_group_cpus(group));
 
                 printk(KERN_CONT " %s", str);
-                if (group->sgc->capacity != SCHED_POWER_SCALE) {
+                if (group->sgc->capacity != SCHED_CAPACITY_SCALE) {
                         printk(KERN_CONT " (cpu_capacity = %d)",
                                 group->sgc->capacity);
                 }
@@ -5715,7 +5715,7 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
                  * domains and no possible iteration will get us here, we won't
                  * die on a /0 trap.
                  */
-                sg->sgc->capacity = SCHED_POWER_SCALE * cpumask_weight(sg_span);
+                sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sg_span);
                 sg->sgc->capacity_orig = sg->sgc->capacity;
 
                 /*
@@ -6921,7 +6921,7 @@ void __init sched_init(void)
 #ifdef CONFIG_SMP
                 rq->sd = NULL;
                 rq->rd = NULL;
-                rq->cpu_capacity = SCHED_POWER_SCALE;
+                rq->cpu_capacity = SCHED_CAPACITY_SCALE;
                 rq->post_schedule = 0;
                 rq->active_balance = 0;
                 rq->next_balance = jiffies;
diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
index 58684f684fa8..dc7d6527a282 100644
--- a/kernel/sched/fair.c
+++ b/kernel/sched/fair.c
@@ -1062,9 +1062,9 @@ static void update_numa_stats(struct numa_stats *ns, int nid)
         if (!cpus)
                 return;
 
-        ns->load = (ns->load * SCHED_POWER_SCALE) / ns->compute_capacity;
+        ns->load = (ns->load * SCHED_CAPACITY_SCALE) / ns->compute_capacity;
         ns->task_capacity =
-                DIV_ROUND_CLOSEST(ns->compute_capacity, SCHED_POWER_SCALE);
+                DIV_ROUND_CLOSEST(ns->compute_capacity, SCHED_CAPACITY_SCALE);
         ns->has_free_capacity = (ns->nr_running < ns->task_capacity);
 }
 
@@ -4370,7 +4370,7 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p,
                 }
 
                 /* Adjust by relative CPU capacity of the group */
-                avg_load = (avg_load * SCHED_POWER_SCALE) / group->sgc->capacity;
+                avg_load = (avg_load * SCHED_CAPACITY_SCALE) / group->sgc->capacity;
 
                 if (local_group) {
                         this_load = avg_load;
@@ -5609,10 +5609,10 @@ static inline int get_sd_load_idx(struct sched_domain *sd,
 
 static unsigned long default_scale_capacity(struct sched_domain *sd, int cpu)
 {
-        return SCHED_POWER_SCALE;
+        return SCHED_CAPACITY_SCALE;
 }
 
-unsigned long __weak arch_scale_freq_power(struct sched_domain *sd, int cpu)
+unsigned long __weak arch_scale_freq_capacity(struct sched_domain *sd, int cpu)
 {
         return default_scale_capacity(sd, cpu);
 }
@@ -5627,7 +5627,7 @@ static unsigned long default_scale_smt_capacity(struct sched_domain *sd, int cpu
         return smt_gain;
 }
 
-unsigned long __weak arch_scale_smt_power(struct sched_domain *sd, int cpu)
+unsigned long __weak arch_scale_smt_capacity(struct sched_domain *sd, int cpu)
 {
         return default_scale_smt_capacity(sd, cpu);
 }
@@ -5658,10 +5658,10 @@ static unsigned long scale_rt_capacity(int cpu)
                 available = total - avg;
         }
 
-        if (unlikely((s64)total < SCHED_POWER_SCALE))
-                total = SCHED_POWER_SCALE;
+        if (unlikely((s64)total < SCHED_CAPACITY_SCALE))
+                total = SCHED_CAPACITY_SCALE;
 
-        total >>= SCHED_POWER_SHIFT;
+        total >>= SCHED_CAPACITY_SHIFT;
 
         return div_u64(available, total);
 }
@@ -5669,29 +5669,29 @@ static unsigned long scale_rt_capacity(int cpu)
 static void update_cpu_capacity(struct sched_domain *sd, int cpu)
 {
         unsigned long weight = sd->span_weight;
-        unsigned long capacity = SCHED_POWER_SCALE;
+        unsigned long capacity = SCHED_CAPACITY_SCALE;
         struct sched_group *sdg = sd->groups;
 
         if ((sd->flags & SD_SHARE_CPUPOWER) && weight > 1) {
                 if (sched_feat(ARCH_POWER))
-                        capacity *= arch_scale_smt_power(sd, cpu);
+                        capacity *= arch_scale_smt_capacity(sd, cpu);
                 else
                         capacity *= default_scale_smt_capacity(sd, cpu);
 
-                capacity >>= SCHED_POWER_SHIFT;
+                capacity >>= SCHED_CAPACITY_SHIFT;
         }
 
         sdg->sgc->capacity_orig = capacity;
 
         if (sched_feat(ARCH_POWER))
-                capacity *= arch_scale_freq_power(sd, cpu);
+                capacity *= arch_scale_freq_capacity(sd, cpu);
         else
                 capacity *= default_scale_capacity(sd, cpu);
 
-        capacity >>= SCHED_POWER_SHIFT;
+        capacity >>= SCHED_CAPACITY_SHIFT;
 
         capacity *= scale_rt_capacity(cpu);
-        capacity >>= SCHED_POWER_SHIFT;
+        capacity >>= SCHED_CAPACITY_SHIFT;
 
         if (!capacity)
                 capacity = 1;
@@ -5780,7 +5780,7 @@ static inline int
 fix_small_capacity(struct sched_domain *sd, struct sched_group *group)
 {
         /*
-         * Only siblings can have significantly less than SCHED_POWER_SCALE
+         * Only siblings can have significantly less than SCHED_CAPACITY_SCALE
          */
         if (!(sd->flags & SD_SHARE_CPUPOWER))
                 return 0;
@@ -5845,11 +5845,11 @@ static inline int sg_capacity_factor(struct lb_env *env, struct sched_group *gro
         cpus = group->group_weight;
 
         /* smt := ceil(cpus / capacity), assumes: 1 < smt_capacity < 2 */
-        smt = DIV_ROUND_UP(SCHED_POWER_SCALE * cpus, capacity_orig);
+        smt = DIV_ROUND_UP(SCHED_CAPACITY_SCALE * cpus, capacity_orig);
         capacity_factor = cpus / smt; /* cores */
 
         capacity_factor = min_t(unsigned,
-                capacity_factor, DIV_ROUND_CLOSEST(capacity, SCHED_POWER_SCALE));
+                capacity_factor, DIV_ROUND_CLOSEST(capacity, SCHED_CAPACITY_SCALE));
         if (!capacity_factor)
                 capacity_factor = fix_small_capacity(env->sd, group);
 
@@ -5895,7 +5895,7 @@ static inline void update_sg_lb_stats(struct lb_env *env,
 
         /* Adjust by relative CPU capacity of the group */
         sgs->group_capacity = group->sgc->capacity;
-        sgs->avg_load = (sgs->group_load*SCHED_POWER_SCALE) / sgs->group_capacity;
+        sgs->avg_load = (sgs->group_load*SCHED_CAPACITY_SCALE) / sgs->group_capacity;
 
         if (sgs->sum_nr_running)
                 sgs->load_per_task = sgs->sum_weighted_load / sgs->sum_nr_running;
@@ -6089,7 +6089,7 @@ static int check_asym_packing(struct lb_env *env, struct sd_lb_stats *sds)
 
         env->imbalance = DIV_ROUND_CLOSEST(
                 sds->busiest_stat.avg_load * sds->busiest_stat.group_capacity,
-                SCHED_POWER_SCALE);
+                SCHED_CAPACITY_SCALE);
 
         return 1;
 }
@@ -6118,7 +6118,7 @@ void fix_small_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
                 imbn = 1;
 
         scaled_busy_load_per_task =
-                (busiest->load_per_task * SCHED_POWER_SCALE) /
+                (busiest->load_per_task * SCHED_CAPACITY_SCALE) /
                 busiest->group_capacity;
 
         if (busiest->avg_load + scaled_busy_load_per_task >=
@@ -6137,7 +6137,7 @@ void fix_small_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
                         min(busiest->load_per_task, busiest->avg_load);
         capa_now += local->group_capacity *
                         min(local->load_per_task, local->avg_load);
-        capa_now /= SCHED_POWER_SCALE;
+        capa_now /= SCHED_CAPACITY_SCALE;
 
         /* Amount of load we'd subtract */
         if (busiest->avg_load > scaled_busy_load_per_task) {
@@ -6148,16 +6148,16 @@ void fix_small_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
 
         /* Amount of load we'd add */
         if (busiest->avg_load * busiest->group_capacity <
-            busiest->load_per_task * SCHED_POWER_SCALE) {
+            busiest->load_per_task * SCHED_CAPACITY_SCALE) {
                 tmp = (busiest->avg_load * busiest->group_capacity) /
                       local->group_capacity;
         } else {
-                tmp = (busiest->load_per_task * SCHED_POWER_SCALE) /
+                tmp = (busiest->load_per_task * SCHED_CAPACITY_SCALE) /
                       local->group_capacity;
         }
         capa_move += local->group_capacity *
                     min(local->load_per_task, local->avg_load + tmp);
-        capa_move /= SCHED_POWER_SCALE;
+        capa_move /= SCHED_CAPACITY_SCALE;
 
         /* Move if we gain throughput */
         if (capa_move > capa_now)
@@ -6207,7 +6207,7 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
                 load_above_capacity =
                         (busiest->sum_nr_running - busiest->group_capacity_factor);
 
-                load_above_capacity *= (SCHED_LOAD_SCALE * SCHED_POWER_SCALE);
+                load_above_capacity *= (SCHED_LOAD_SCALE * SCHED_CAPACITY_SCALE);
                 load_above_capacity /= busiest->group_capacity;
         }
 
@@ -6225,7 +6225,7 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
         env->imbalance = min(
                 max_pull * busiest->group_capacity,
                 (sds->avg_load - local->avg_load) * local->group_capacity
-        ) / SCHED_POWER_SCALE;
+        ) / SCHED_CAPACITY_SCALE;
 
         /*
          * if *imbalance is less than the average load per runnable task
@@ -6279,7 +6279,8 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
         if (!sds.busiest || busiest->sum_nr_running == 0)
                 goto out_balanced;
 
-        sds.avg_load = (SCHED_POWER_SCALE * sds.total_load) / sds.total_capacity;
+        sds.avg_load = (SCHED_CAPACITY_SCALE * sds.total_load)
+                                                / sds.total_capacity;
 
         /*
          * If the busiest group is imbalanced the below checks don't
@@ -6378,7 +6379,7 @@ static struct rq *find_busiest_queue(struct lb_env *env,
                         continue;
 
                 capacity = capacity_of(i);
-                capacity_factor = DIV_ROUND_CLOSEST(capacity, SCHED_POWER_SCALE);
+                capacity_factor = DIV_ROUND_CLOSEST(capacity, SCHED_CAPACITY_SCALE);
                 if (!capacity_factor)
                         capacity_factor = fix_small_capacity(env->sd, group);