Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ae4df9d6 authored by Peter Zijlstra's avatar Peter Zijlstra Committed by Ingo Molnar
Browse files

sched/topology: Rename sched_group_cpus() 



There's a discrepancy in naming between the sched_domain and
sched_group cpumask accessor. Since we're doing changes, fix it.

  $ git grep sched_group_cpus | wc -l
  28
  $ git grep sched_domain_span | wc -l
  38

Suggests changing sched_group_cpus() into sched_group_span():

  for i  in `git grep -l sched_group_cpus`
  do
    sed -ie 's/sched_group_cpus/sched_group_span/g' $i
  done

Signed-off-by: default avatarPeter Zijlstra (Intel) <peterz@infradead.org>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Mike Galbraith <efault@gmx.de>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: linux-kernel@vger.kernel.org
Signed-off-by: default avatarIngo Molnar <mingo@kernel.org>
parent e5c14b1f

kernel/sched/fair.c

+10 −10
Original line number Diff line number Diff line
@@ -5484,12 +5484,12 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p, 
		int i;



		/* Skip over this group if it has no CPUs allowed */

		if (!cpumask_intersects(sched_group_cpus(group),

		if (!cpumask_intersects(sched_group_span(group),

					&p->cpus_allowed))

			continue;



		local_group = cpumask_test_cpu(this_cpu,

					       sched_group_cpus(group));

					       sched_group_span(group));



		/*

		 * Tally up the load of all CPUs in the group and find
@@ -5499,7 +5499,7 @@ find_idlest_group(struct sched_domain *sd, struct task_struct *p, 
		runnable_load = 0;

		max_spare_cap = 0;



		for_each_cpu(i, sched_group_cpus(group)) {

		for_each_cpu(i, sched_group_span(group)) {

			/* Bias balancing toward cpus of our domain */

			if (local_group)

				load = source_load(i, load_idx);
@@ -5602,10 +5602,10 @@ find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu) 


	/* Check if we have any choice: */

	if (group->group_weight == 1)

		return cpumask_first(sched_group_cpus(group));

		return cpumask_first(sched_group_span(group));



	/* Traverse only the allowed CPUs */

	for_each_cpu_and(i, sched_group_cpus(group), &p->cpus_allowed) {

	for_each_cpu_and(i, sched_group_span(group), &p->cpus_allowed) {

		if (idle_cpu(i)) {

			struct rq *rq = cpu_rq(i);

			struct cpuidle_state *idle = idle_get_state(rq);
@@ -7192,7 +7192,7 @@ void update_group_capacity(struct sched_domain *sd, int cpu) 
		 * span the current group.

		 */



		for_each_cpu(cpu, sched_group_cpus(sdg)) {

		for_each_cpu(cpu, sched_group_span(sdg)) {

			struct sched_group_capacity *sgc;

			struct rq *rq = cpu_rq(cpu);
@@ -7371,7 +7371,7 @@ static inline void update_sg_lb_stats(struct lb_env *env, 


	memset(sgs, 0, sizeof(*sgs));



	for_each_cpu_and(i, sched_group_cpus(group), env->cpus) {

	for_each_cpu_and(i, sched_group_span(group), env->cpus) {

		struct rq *rq = cpu_rq(i);



		/* Bias balancing toward cpus of our domain */
@@ -7535,7 +7535,7 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd 
		struct sg_lb_stats *sgs = &tmp_sgs;

		int local_group;



		local_group = cpumask_test_cpu(env->dst_cpu, sched_group_cpus(sg));

		local_group = cpumask_test_cpu(env->dst_cpu, sched_group_span(sg));

		if (local_group) {

			sds->local = sg;

			sgs = local;
@@ -7890,7 +7890,7 @@ static struct rq *find_busiest_queue(struct lb_env *env, 
	unsigned long busiest_load = 0, busiest_capacity = 1;

	int i;



	for_each_cpu_and(i, sched_group_cpus(group), env->cpus) {

	for_each_cpu_and(i, sched_group_span(group), env->cpus) {

		unsigned long capacity, wl;

		enum fbq_type rt;
@@ -8043,7 +8043,7 @@ static int load_balance(int this_cpu, struct rq *this_rq, 
		.sd		= sd,

		.dst_cpu	= this_cpu,

		.dst_rq		= this_rq,

		.dst_grpmask    = sched_group_cpus(sd->groups),

		.dst_grpmask    = sched_group_span(sd->groups),

		.idle		= idle,

		.loop_break	= sched_nr_migrate_break,

		.cpus		= cpus,

kernel/sched/sched.h

+2 −2
Original line number Diff line number Diff line
@@ -1048,7 +1048,7 @@ struct sched_group { 
	unsigned long cpumask[0];

};



static inline struct cpumask *sched_group_cpus(struct sched_group *sg)

static inline struct cpumask *sched_group_span(struct sched_group *sg)

{

	return to_cpumask(sg->cpumask);

}
@@ -1067,7 +1067,7 @@ static inline struct cpumask *group_balance_mask(struct sched_group *sg) 
 */

static inline unsigned int group_first_cpu(struct sched_group *group)

{

	return cpumask_first(sched_group_cpus(group));

	return cpumask_first(sched_group_span(group));

}



extern int group_balance_cpu(struct sched_group *sg);

kernel/sched/topology.c

+19 −19
Original line number Diff line number Diff line
@@ -53,7 +53,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, 
		printk(KERN_ERR "ERROR: domain->span does not contain "

				"CPU%d\n", cpu);

	}

	if (!cpumask_test_cpu(cpu, sched_group_cpus(group))) {

	if (!cpumask_test_cpu(cpu, sched_group_span(group))) {

		printk(KERN_ERR "ERROR: domain->groups does not contain"

				" CPU%d\n", cpu);

	}
@@ -66,27 +66,27 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, 
			break;

		}



		if (!cpumask_weight(sched_group_cpus(group))) {

		if (!cpumask_weight(sched_group_span(group))) {

			printk(KERN_CONT "\n");

			printk(KERN_ERR "ERROR: empty group\n");

			break;

		}



		if (!(sd->flags & SD_OVERLAP) &&

		    cpumask_intersects(groupmask, sched_group_cpus(group))) {

		    cpumask_intersects(groupmask, sched_group_span(group))) {

			printk(KERN_CONT "\n");

			printk(KERN_ERR "ERROR: repeated CPUs\n");

			break;

		}



		cpumask_or(groupmask, groupmask, sched_group_cpus(group));

		cpumask_or(groupmask, groupmask, sched_group_span(group));



		printk(KERN_CONT " %d:{ span=%*pbl",

				group->sgc->id,

				cpumask_pr_args(sched_group_cpus(group)));

				cpumask_pr_args(sched_group_span(group)));



		if ((sd->flags & SD_OVERLAP) &&

		    !cpumask_equal(group_balance_mask(group), sched_group_cpus(group))) {

		    !cpumask_equal(group_balance_mask(group), sched_group_span(group))) {

			printk(KERN_CONT " mask=%*pbl",

				cpumask_pr_args(group_balance_mask(group)));

		}
@@ -96,7 +96,7 @@ static int sched_domain_debug_one(struct sched_domain *sd, int cpu, int level, 


		if (group == sd->groups && sd->child &&

		    !cpumask_equal(sched_domain_span(sd->child),

				   sched_group_cpus(group))) {

				   sched_group_span(group))) {

			printk(KERN_ERR "ERROR: domain->groups does not match domain->child\n");

		}
@@ -618,7 +618,7 @@ int group_balance_cpu(struct sched_group *sg) 
static void

build_balance_mask(struct sched_domain *sd, struct sched_group *sg, struct cpumask *mask)

{

	const struct cpumask *sg_span = sched_group_cpus(sg);

	const struct cpumask *sg_span = sched_group_span(sg);

	struct sd_data *sdd = sd->private;

	struct sched_domain *sibling;

	int i;
@@ -664,7 +664,7 @@ build_group_from_child_sched_domain(struct sched_domain *sd, int cpu) 
	if (!sg)

		return NULL;



	sg_span = sched_group_cpus(sg);

	sg_span = sched_group_span(sg);

	if (sd->child)

		cpumask_copy(sg_span, sched_domain_span(sd->child));

	else
@@ -682,7 +682,7 @@ static void init_overlap_sched_group(struct sched_domain *sd, 
	int cpu;



	build_balance_mask(sd, sg, mask);

	cpu = cpumask_first_and(sched_group_cpus(sg), mask);

	cpu = cpumask_first_and(sched_group_span(sg), mask);



	sg->sgc = *per_cpu_ptr(sdd->sgc, cpu);

	if (atomic_inc_return(&sg->sgc->ref) == 1)
@@ -695,7 +695,7 @@ static void init_overlap_sched_group(struct sched_domain *sd, 
	 * domains and no possible iteration will get us here, we won't

	 * die on a /0 trap.

	 */

	sg_span = sched_group_cpus(sg);

	sg_span = sched_group_span(sg);

	sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sg_span);

	sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;

}
@@ -737,7 +737,7 @@ build_overlap_sched_groups(struct sched_domain *sd, int cpu) 
		if (!sg)

			goto fail;



		sg_span = sched_group_cpus(sg);

		sg_span = sched_group_span(sg);

		cpumask_or(covered, covered, sg_span);



		init_overlap_sched_group(sd, sg);
@@ -848,14 +848,14 @@ static struct sched_group *get_group(int cpu, struct sd_data *sdd) 
	atomic_inc(&sg->sgc->ref);



	if (child) {

		cpumask_copy(sched_group_cpus(sg), sched_domain_span(child));

		cpumask_copy(group_balance_mask(sg), sched_group_cpus(sg));

		cpumask_copy(sched_group_span(sg), sched_domain_span(child));

		cpumask_copy(group_balance_mask(sg), sched_group_span(sg));

	} else {

		cpumask_set_cpu(cpu, sched_group_cpus(sg));

		cpumask_set_cpu(cpu, sched_group_span(sg));

		cpumask_set_cpu(cpu, group_balance_mask(sg));

	}



	sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sched_group_cpus(sg));

	sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sched_group_span(sg));

	sg->sgc->min_capacity = SCHED_CAPACITY_SCALE;



	return sg;
@@ -890,7 +890,7 @@ build_sched_groups(struct sched_domain *sd, int cpu) 


		sg = get_group(i, sdd);



		cpumask_or(covered, covered, sched_group_cpus(sg));

		cpumask_or(covered, covered, sched_group_span(sg));



		if (!first)

			first = sg;
@@ -923,12 +923,12 @@ static void init_sched_groups_capacity(int cpu, struct sched_domain *sd) 
	do {

		int cpu, max_cpu = -1;



		sg->group_weight = cpumask_weight(sched_group_cpus(sg));

		sg->group_weight = cpumask_weight(sched_group_span(sg));



		if (!(sd->flags & SD_ASYM_PACKING))

			goto next;



		for_each_cpu(cpu, sched_group_cpus(sg)) {

		for_each_cpu(cpu, sched_group_span(sg)) {

			if (max_cpu < 0)

				max_cpu = cpu;

			else if (sched_asym_prefer(cpu, max_cpu))