sched: Let 'struct sched_group_power' care about CPU capacity

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.

Since struct sched_group_power is really about compute capacity of sched
groups, let's rename it to struct sched_group_capacity. Similarly sgp
becomes sgc. Related variables and functions dealing with groups are also
adjusted accordingly.

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: Linus Torvalds <torvalds@linux-foundation.org>
Cc: linux-kernel@vger.kernel.org
Link: http://lkml.kernel.org/n/tip-5yeix833vvgf2uyj5o36hpu9@git.kernel.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>

4 files changed, 115 insertions, 115 deletions

diff --git a/include/linux/sched.h b/include/linux/sched.h
index 6790c3b42072..a96f03598c61 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1013,7 +1013,7 @@ typedef const int (*sched_domain_flags_f)(void);
 struct sd_data {
         struct sched_domain **__percpu sd;
         struct sched_group **__percpu sg;
-        struct sched_group_power **__percpu sgp;
+        struct sched_group_capacity **__percpu sgc;
 };
 
 struct sched_domain_topology_level {
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index afcc84234a3e..2e1fb0902200 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -5221,14 +5221,13 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level,
                 }
 
                 /*
-                 * Even though we initialize ->power to something semi-sane,
-                 * we leave power_orig unset. This allows us to detect if
+                 * Even though we initialize ->capacity to something semi-sane,
+                 * we leave capacity_orig unset. This allows us to detect if
                  * domain iteration is still funny without causing /0 traps.
                  */
-                if (!group->sgp->power_orig) {
+                if (!group->sgc->capacity_orig) {
                         printk(KERN_CONT "\n");
-                        printk(KERN_ERR "ERROR: domain->cpu_power not "
-                                        "set\n");
+                        printk(KERN_ERR "ERROR: domain->cpu_capacity not set\n");
                         break;
                 }
 
@@ -5250,9 +5249,9 @@ 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->sgp->power != SCHED_POWER_SCALE) {
-                        printk(KERN_CONT " (cpu_power = %d)",
-                                group->sgp->power);
+                if (group->sgc->capacity != SCHED_POWER_SCALE) {
+                        printk(KERN_CONT " (cpu_capacity = %d)",
+                                group->sgc->capacity);
                 }
 
                 group = group->next;
@@ -5466,7 +5465,7 @@ static struct root_domain *alloc_rootdomain(void)
         return rd;
 }
 
-static void free_sched_groups(struct sched_group *sg, int free_sgp)
+static void free_sched_groups(struct sched_group *sg, int free_sgc)
 {
         struct sched_group *tmp, *first;
 
@@ -5477,8 +5476,8 @@ static void free_sched_groups(struct sched_group *sg, int free_sgp)
         do {
                 tmp = sg->next;
 
-                if (free_sgp && atomic_dec_and_test(&sg->sgp->ref))
-                        kfree(sg->sgp);
+                if (free_sgc && atomic_dec_and_test(&sg->sgc->ref))
+                        kfree(sg->sgc);
 
                 kfree(sg);
                 sg = tmp;
@@ -5496,7 +5495,7 @@ static void free_sched_domain(struct rcu_head *rcu)
         if (sd->flags & SD_OVERLAP) {
                 free_sched_groups(sd->groups, 1);
         } else if (atomic_dec_and_test(&sd->groups->ref)) {
-                kfree(sd->groups->sgp);
+                kfree(sd->groups->sgc);
                 kfree(sd->groups);
         }
         kfree(sd);
@@ -5707,17 +5706,17 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu)
 
                 cpumask_or(covered, covered, sg_span);
 
-                sg->sgp = *per_cpu_ptr(sdd->sgp, i);
-                if (atomic_inc_return(&sg->sgp->ref) == 1)
+                sg->sgc = *per_cpu_ptr(sdd->sgc, i);
+                if (atomic_inc_return(&sg->sgc->ref) == 1)
                         build_group_mask(sd, sg);
 
                 /*
-                 * Initialize sgp->power such that even if we mess up the
+                 * Initialize sgc->capacity such that even if we mess up the
                  * domains and no possible iteration will get us here, we won't
                  * die on a /0 trap.
                  */
-                sg->sgp->power = SCHED_POWER_SCALE * cpumask_weight(sg_span);
-                sg->sgp->power_orig = sg->sgp->power;
+                sg->sgc->capacity = SCHED_POWER_SCALE * cpumask_weight(sg_span);
+                sg->sgc->capacity_orig = sg->sgc->capacity;
 
                 /*
                  * Make sure the first group of this domain contains the
@@ -5755,8 +5754,8 @@ static int get_group(int cpu, struct sd_data *sdd, struct sched_group **sg)
 
         if (sg) {
                 *sg = *per_cpu_ptr(sdd->sg, cpu);
-                (*sg)->sgp = *per_cpu_ptr(sdd->sgp, cpu);
-                atomic_set(&(*sg)->sgp->ref, 1); /* for claim_allocations */
+                (*sg)->sgc = *per_cpu_ptr(sdd->sgc, cpu);
+                atomic_set(&(*sg)->sgc->ref, 1); /* for claim_allocations */
         }
 
         return cpu;
@@ -5819,16 +5818,16 @@ build_sched_groups(struct sched_domain *sd, int cpu)
 }
 
 /*
- * Initialize sched groups cpu_power.
+ * Initialize sched groups cpu_capacity.
  *
- * cpu_power indicates the capacity of sched group, which is used while
+ * cpu_capacity indicates the capacity of sched group, which is used while
  * distributing the load between different sched groups in a sched domain.
- * Typically cpu_power for all the groups in a sched domain will be same unless
- * there are asymmetries in the topology. If there are asymmetries, group
- * having more cpu_power will pickup more load compared to the group having
- * less cpu_power.
+ * Typically cpu_capacity for all the groups in a sched domain will be same
+ * unless there are asymmetries in the topology. If there are asymmetries,
+ * group having more cpu_capacity will pickup more load compared to the
+ * group having less cpu_capacity.
  */
-static void init_sched_groups_power(int cpu, struct sched_domain *sd)
+static void init_sched_groups_capacity(int cpu, struct sched_domain *sd)
 {
         struct sched_group *sg = sd->groups;
 
@@ -5842,8 +5841,8 @@ static void init_sched_groups_power(int cpu, struct sched_domain *sd)
         if (cpu != group_balance_cpu(sg))
                 return;
 
-        update_group_power(sd, cpu);
-        atomic_set(&sg->sgp->nr_busy_cpus, sg->group_weight);
+        update_group_capacity(sd, cpu);
+        atomic_set(&sg->sgc->nr_busy_cpus, sg->group_weight);
 }
 
 /*
@@ -5934,8 +5933,8 @@ static void claim_allocations(int cpu, struct sched_domain *sd)
         if (atomic_read(&(*per_cpu_ptr(sdd->sg, cpu))->ref))
                 *per_cpu_ptr(sdd->sg, cpu) = NULL;
 
-        if (atomic_read(&(*per_cpu_ptr(sdd->sgp, cpu))->ref))
-                *per_cpu_ptr(sdd->sgp, cpu) = NULL;
+        if (atomic_read(&(*per_cpu_ptr(sdd->sgc, cpu))->ref))
+                *per_cpu_ptr(sdd->sgc, cpu) = NULL;
 }
 
 #ifdef CONFIG_NUMA
@@ -6337,14 +6336,14 @@ static int __sdt_alloc(const struct cpumask *cpu_map)
                 if (!sdd->sg)