Re: [PATCH 5/6] sched: remove remaining power to the CPU

[Preeti Murthy]

Hi Nicolas,
You might want to change the subject.

s/sched: remove remaining power to the CPU/
sched: remove remaining usage of cpu *power* .

The subject has to explicitly specify in some way
that it is a change made to the terminology.

Regards
Preeti U Murthy



On Thu, May 15, 2014 at 2:27 AM, Nicolas Pitre <nicolas.pitre@xxxxxxxxxx> wrote:
> It is better not to think about compute capacity as being equivalent to
> "CPU power".  The upcoming "power aware" scheduler may create confusion
> with the notion of energy consumption if "power" is used too liberally.
>
> This is the remaining "power" -> "capacity" rename.  Those symbols
> visible to the rest of the kernel are not included yet.
>
> Signed-off-by: Nicolas Pitre <nico@xxxxxxxxxx>
> ---
>  kernel/sched/core.c  |   6 +--
>  kernel/sched/fair.c  | 102 +++++++++++++++++++++++++--------------------------
>  kernel/sched/sched.h |   2 +-
>  3 files changed, 55 insertions(+), 55 deletions(-)
>
> diff --git a/kernel/sched/core.c b/kernel/sched/core.c
> index d8ba3ab1c0..00d04e9e7b 100644
> --- a/kernel/sched/core.c
> +++ b/kernel/sched/core.c
> @@ -5764,7 +5764,7 @@ static int get_group(int cpu, struct sd_data *sdd, struct sched_group **sg)
>  /*
>   * build_sched_groups will build a circular linked list of the groups
>   * covered by the given span, and will set each group's ->cpumask correctly,
> - * and ->cpu_power to 0.
> + * and ->cpu_capacity to 0.
>   *
>   * Assumes the sched_domain tree is fully constructed
>   */
> @@ -6473,7 +6473,7 @@ static int build_sched_domains(const struct cpumask *cpu_map,
>                 }
>         }
>
> -       /* Calculate CPU power for physical packages and nodes */
> +       /* Calculate CPU capacity for physical packages and nodes */
>         for (i = nr_cpumask_bits-1; i >= 0; i--) {
>                 if (!cpumask_test_cpu(i, cpu_map))
>                         continue;
> @@ -6923,7 +6923,7 @@ void __init sched_init(void)
>  #ifdef CONFIG_SMP
>                 rq->sd = NULL;
>                 rq->rd = NULL;
> -               rq->cpu_power = SCHED_POWER_SCALE;
> +               rq->cpu_capacity = SCHED_POWER_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 6bc1e54d30..06619b52dd 100644
> --- a/kernel/sched/fair.c
> +++ b/kernel/sched/fair.c
> @@ -1017,7 +1017,7 @@ bool should_numa_migrate_memory(struct task_struct *p, struct page * page,
>  static unsigned long weighted_cpuload(const int cpu);
>  static unsigned long source_load(int cpu, int type);
>  static unsigned long target_load(int cpu, int type);
> -static unsigned long power_of(int cpu);
> +static unsigned long capacity_of(int cpu);
>  static long effective_load(struct task_group *tg, int cpu, long wl, long wg);
>
>  /* Cached statistics for all CPUs within a node */
> @@ -1046,7 +1046,7 @@ static void update_numa_stats(struct numa_stats *ns, int nid)
>
>                 ns->nr_running += rq->nr_running;
>                 ns->load += weighted_cpuload(cpu);
> -               ns->compute_capacity += power_of(cpu);
> +               ns->compute_capacity += capacity_of(cpu);
>
>                 cpus++;
>         }
> @@ -1185,7 +1185,7 @@ balance:
>         dst_load = env->dst_stats.load;
>         src_load = env->src_stats.load;
>
> -       /* XXX missing power terms */
> +       /* XXX missing capacity terms */
>         load = task_h_load(env->p);
>         dst_load += load;
>         src_load -= load;
> @@ -4015,9 +4015,9 @@ static unsigned long target_load(int cpu, int type)
>         return max(rq->cpu_load[type-1], total);
>  }
>
> -static unsigned long power_of(int cpu)
> +static unsigned long capacity_of(int cpu)
>  {
> -       return cpu_rq(cpu)->cpu_power;
> +       return cpu_rq(cpu)->cpu_capacity;
>  }
>
>  static unsigned long cpu_avg_load_per_task(int cpu)
> @@ -4260,12 +4260,12 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync)
>                 s64 this_eff_load, prev_eff_load;
>
>                 this_eff_load = 100;
> -               this_eff_load *= power_of(prev_cpu);
> +               this_eff_load *= capacity_of(prev_cpu);
>                 this_eff_load *= this_load +
>                         effective_load(tg, this_cpu, weight, weight);
>
>                 prev_eff_load = 100 + (sd->imbalance_pct - 100) / 2;
> -               prev_eff_load *= power_of(this_cpu);
> +               prev_eff_load *= capacity_of(this_cpu);
>                 prev_eff_load *= load + effective_load(tg, prev_cpu, 0, weight);
>
>                 balanced = this_eff_load <= prev_eff_load;
> @@ -4919,14 +4919,14 @@ static bool yield_to_task_fair(struct rq *rq, struct task_struct *p, bool preemp
>   *
>   *   W'_i,n = (2^n - 1) / 2^n * W_i,n + 1 / 2^n * W_i,0               (3)
>   *
> - * P_i is the cpu power (or compute capacity) of cpu i, typically it is the
> + * C_i is the compute capacity of cpu i, typically it is the
>   * fraction of 'recent' time available for SCHED_OTHER task execution. But it
>   * can also include other factors [XXX].
>   *
>   * To achieve this balance we define a measure of imbalance which follows
>   * directly from (1):
>   *
> - *   imb_i,j = max{ avg(W/P), W_i/P_i } - min{ avg(W/P), W_j/P_j }    (4)
> + *   imb_i,j = max{ avg(W/C), W_i/C_i } - min{ avg(W/C), W_j/C_j }    (4)
>   *
>   * We them move tasks around to minimize the imbalance. In the continuous
>   * function space it is obvious this converges, in the discrete case we get
> @@ -5560,17 +5560,17 @@ static inline int get_sd_load_idx(struct sched_domain *sd,
>         return load_idx;
>  }
>
> -static unsigned long default_scale_freq_power(struct sched_domain *sd, int cpu)
> +static unsigned long default_scale_capacity(struct sched_domain *sd, int cpu)
>  {
>         return SCHED_POWER_SCALE;
>  }
>
>  unsigned long __weak arch_scale_freq_power(struct sched_domain *sd, int cpu)
>  {
> -       return default_scale_freq_power(sd, cpu);
> +       return default_scale_capacity(sd, cpu);
>  }
>
> -static unsigned long default_scale_smt_power(struct sched_domain *sd, int cpu)
> +static unsigned long default_scale_smt_capacity(struct sched_domain *sd, int cpu)
>  {
>         unsigned long weight = sd->span_weight;
>         unsigned long smt_gain = sd->smt_gain;
> @@ -5582,10 +5582,10 @@ static unsigned long default_scale_smt_power(struct sched_domain *sd, int cpu)
>
>  unsigned long __weak arch_scale_smt_power(struct sched_domain *sd, int cpu)
>  {
> -       return default_scale_smt_power(sd, cpu);
> +       return default_scale_smt_capacity(sd, cpu);
>  }
>
> -static unsigned long scale_rt_power(int cpu)
> +static unsigned long scale_rt_capacity(int cpu)
>  {
>         struct rq *rq = cpu_rq(cpu);
>         u64 total, available, age_stamp, avg;
> @@ -5605,7 +5605,7 @@ static unsigned long scale_rt_power(int cpu)
>         total = sched_avg_period() + delta;
>
>         if (unlikely(total < avg)) {
> -               /* Ensures that power won't end up being negative */
> +               /* Ensures that capacity won't end up being negative */
>                 available = 0;
>         } else {
>                 available = total - avg;
> @@ -5619,38 +5619,38 @@ static unsigned long scale_rt_power(int cpu)
>         return div_u64(available, total);
>  }
>
> -static void update_cpu_power(struct sched_domain *sd, int cpu)
> +static void update_cpu_capacity(struct sched_domain *sd, int cpu)
>  {
>         unsigned long weight = sd->span_weight;
> -       unsigned long power = SCHED_POWER_SCALE;
> +       unsigned long capacity = SCHED_POWER_SCALE;
>         struct sched_group *sdg = sd->groups;
>
>         if ((sd->flags & SD_SHARE_CPUPOWER) && weight > 1) {
>                 if (sched_feat(ARCH_POWER))
> -                       power *= arch_scale_smt_power(sd, cpu);
> +                       capacity *= arch_scale_smt_power(sd, cpu);
>                 else
> -                       power *= default_scale_smt_power(sd, cpu);
> +                       capacity *= default_scale_smt_capacity(sd, cpu);
>
> -               power >>= SCHED_POWER_SHIFT;
> +               capacity >>= SCHED_POWER_SHIFT;
>         }
>
> -       sdg->sgc->capacity_orig = power;
> +       sdg->sgc->capacity_orig = capacity;
>
>         if (sched_feat(ARCH_POWER))
> -               power *= arch_scale_freq_power(sd, cpu);
> +               capacity *= arch_scale_freq_power(sd, cpu);
>         else
> -               power *= default_scale_freq_power(sd, cpu);
> +               capacity *= default_scale_capacity(sd, cpu);
>
> -       power >>= SCHED_POWER_SHIFT;
> +       capacity >>= SCHED_POWER_SHIFT;
>
> -       power *= scale_rt_power(cpu);
> -       power >>= SCHED_POWER_SHIFT;
> +       capacity *= scale_rt_capacity(cpu);
> +       capacity >>= SCHED_POWER_SHIFT;
>
> -       if (!power)
> -               power = 1;
> +       if (!capacity)
> +               capacity = 1;
>
> -       cpu_rq(cpu)->cpu_power = power;
> -       sdg->sgc->capacity = power;
> +       cpu_rq(cpu)->cpu_capacity = capacity;
> +       sdg->sgc->capacity = capacity;
>  }
>
>  void update_group_capacity(struct sched_domain *sd, int cpu)
> @@ -5665,7 +5665,7 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
>         sdg->sgc->next_update = jiffies + interval;
>
>         if (!child) {
> -               update_cpu_power(sd, cpu);
> +               update_cpu_capacity(sd, cpu);
>                 return;
>         }
>
> @@ -5686,8 +5686,8 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
>                          * gets here before we've attached the domains to the
>                          * runqueues.
>                          *
> -                        * Use power_of(), which is set irrespective of domains
> -                        * in update_cpu_power().
> +                        * Use capacity_of(), which is set irrespective of domains
> +                        * in update_cpu_capacity().
>                          *
>                          * This avoids capacity/capacity_orig from being 0 and
>                          * causing divide-by-zero issues on boot.
> @@ -5695,8 +5695,8 @@ void update_group_capacity(struct sched_domain *sd, int cpu)
>                          * Runtime updates will correct capacity_orig.
>                          */
>                         if (unlikely(!rq->sd)) {
> -                               capacity_orig += power_of(cpu);
> -                               capacity += power_of(cpu);
> +                               capacity_orig += capacity_of(cpu);
> +                               capacity += capacity_of(cpu);
>                                 continue;
>                         }
>
> @@ -5784,7 +5784,7 @@ static inline int sg_imbalanced(struct sched_group *group)
>  /*
>   * Compute the group capacity factor.
>   *
> - * Avoid the issue where N*frac(smt_power) >= 1 creates 'phantom' cores by
> + * Avoid the issue where N*frac(smt_capacity) >= 1 creates 'phantom' cores by
>   * first dividing out the smt factor and computing the actual number of cores
>   * and limit unit capacity with that.
>   */
> @@ -6082,7 +6082,7 @@ void fix_small_imbalance(struct lb_env *env, struct sd_lb_stats *sds)
>
>         /*
>          * OK, we don't have enough imbalance to justify moving tasks,
> -        * however we may be able to increase total CPU power used by
> +        * however we may be able to increase total CPU capacity used by
>          * moving them.
>          */
>
> @@ -6143,7 +6143,7 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
>         /*
>          * In the presence of smp nice balancing, certain scenarios can have
>          * max load less than avg load(as we skip the groups at or below
> -        * its cpu_power, while calculating max_load..)
> +        * its cpu_capacity, while calculating max_load..)
>          */
>         if (busiest->avg_load <= sds->avg_load ||
>             local->avg_load >= sds->avg_load) {
> @@ -6298,11 +6298,11 @@ static struct rq *find_busiest_queue(struct lb_env *env,
>                                      struct sched_group *group)
>  {
>         struct rq *busiest = NULL, *rq;
> -       unsigned long busiest_load = 0, busiest_power = 1;
> +       unsigned long busiest_load = 0, busiest_capacity = 1;
>         int i;
>
>         for_each_cpu_and(i, sched_group_cpus(group), env->cpus) {
> -               unsigned long power, capa_factor, wl;
> +               unsigned long capacity, capa_factor, wl;
>                 enum fbq_type rt;
>
>                 rq = cpu_rq(i);
> @@ -6330,8 +6330,8 @@ static struct rq *find_busiest_queue(struct lb_env *env,
>                 if (rt > env->fbq_type)
>                         continue;
>
> -               power = power_of(i);
> -               capa_factor = DIV_ROUND_CLOSEST(power, SCHED_POWER_SCALE);
> +               capacity = capacity_of(i);
> +               capa_factor = DIV_ROUND_CLOSEST(capacity, SCHED_POWER_SCALE);
>                 if (!capa_factor)
>                         capa_factor = fix_small_capacity(env->sd, group);
>
> @@ -6339,25 +6339,25 @@ static struct rq *find_busiest_queue(struct lb_env *env,
>
>                 /*
>                  * When comparing with imbalance, use weighted_cpuload()
> -                * which is not scaled with the cpu power.
> +                * which is not scaled with the cpu capacity.
>                  */
>                 if (capa_factor && rq->nr_running == 1 && wl > env->imbalance)
>                         continue;
>
>                 /*
>                  * For the load comparisons with the other cpu's, consider
> -                * the weighted_cpuload() scaled with the cpu power, so that
> -                * the load can be moved away from the cpu that is potentially
> -                * running at a lower capacity.
> +                * the weighted_cpuload() scaled with the cpu capacity, so
> +                * that the load can be moved away from the cpu that is
> +                * potentially running at a lower capacity.
>                  *
> -                * Thus we're looking for max(wl_i / power_i), crosswise
> +                * Thus we're looking for max(wl_i / capacity_i), crosswise
>                  * multiplication to rid ourselves of the division works out
> -                * to: wl_i * power_j > wl_j * power_i;  where j is our
> -                * previous maximum.
> +                * to: wl_i * capacity_j > wl_j * capacity_i;  where j is
> +                * our previous maximum.
>                  */
> -               if (wl * busiest_power > busiest_load * power) {
> +               if (wl * busiest_capacity > busiest_load * capacity) {
>                         busiest_load = wl;
> -                       busiest_power = power;
> +                       busiest_capacity = capacity;
>                         busiest = rq;
>                 }
>         }
> diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
> index b384ccd07b..fe89387931 100644
> --- a/kernel/sched/sched.h
> +++ b/kernel/sched/sched.h
> @@ -567,7 +567,7 @@ struct rq {
>         struct root_domain *rd;
>         struct sched_domain *sd;
>
> -       unsigned long cpu_power;
> +       unsigned long cpu_capacity;
>
>         unsigned char idle_balance;
>         /* For active balancing */
> --
> 1.8.4.108.g55ea5f6
>
> --
> To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
> the body of a message to majordomo@xxxxxxxxxxxxxxx
> More majordomo info at  http://vger.kernel.org/majordomo-info.html
> Please read the FAQ at  http://www.tux.org/lkml/
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/