redonkable
/
alistair23-linux
1
0
Fork 0
Code Releases Activity

[PATCH] kernel/sched.c: whitespace cleanups 

[akpm@osdl.org: additional cleanups]
Signed-off-by: Miguel Ojeda Sandonis <maxextreme@gmail.com>
Acked-by: Ingo Molnar <mingo@elte.hu>
Cc: Nick Piggin <nickpiggin@yahoo.com.au>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
hifive-unleashed-5.1
Miguel Ojeda Sandonis 2006-12-10 02:20:38 -08:00 committed by Linus Torvalds
parent 62ab616d54
commit 33859f7f97
1 changed files with 55 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
kernel/sched.c
View File

@ -466,7 +466,8 @@ static int show_schedstat(struct seq_file *seq, void *v)
seq_printf(seq, "domain%d %s", dcnt++, mask_str); seq_printf(seq, "domain%d %s", dcnt++, mask_str);
for (itype = SCHED_IDLE; itype < MAX_IDLE_TYPES; for (itype = SCHED_IDLE; itype < MAX_IDLE_TYPES;
itype++) { itype++) {
seq_printf(seq, " %lu %lu %lu %lu %lu %lu %lu %lu", seq_printf(seq, " %lu %lu %lu %lu %lu %lu %lu "
"%lu",
sd->lb_cnt[itype], sd->lb_cnt[itype],
sd->lb_balanced[itype], sd->lb_balanced[itype],
sd->lb_failed[itype], sd->lb_failed[itype],
@ -476,11 +477,13 @@ static int show_schedstat(struct seq_file *seq, void *v)
sd->lb_nobusyq[itype], sd->lb_nobusyq[itype],
sd->lb_nobusyg[itype]); sd->lb_nobusyg[itype]);
} }
seq_printf(seq, " %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu %lu\n", seq_printf(seq, " %lu %lu %lu %lu %lu %lu %lu %lu %lu"
" %lu %lu %lu\n",
sd->alb_cnt, sd->alb_failed, sd->alb_pushed, sd->alb_cnt, sd->alb_failed, sd->alb_pushed,
sd->sbe_cnt, sd->sbe_balanced, sd->sbe_pushed, sd->sbe_cnt, sd->sbe_balanced, sd->sbe_pushed,
sd->sbf_cnt, sd->sbf_balanced, sd->sbf_pushed, sd->sbf_cnt, sd->sbf_balanced, sd->sbf_pushed,
sd->ttwu_wake_remote, sd->ttwu_move_affine, sd->ttwu_move_balance); sd->ttwu_wake_remote, sd->ttwu_move_affine,
sd->ttwu_move_balance);
} }
preempt_enable(); preempt_enable();
#endif #endif
@ -1454,7 +1457,9 @@ static int try_to_wake_up(struct task_struct *p, unsigned int state, int sync)
if (this_sd->flags & SD_WAKE_AFFINE) { if (this_sd->flags & SD_WAKE_AFFINE) {
unsigned long tl = this_load; unsigned long tl = this_load;
unsigned long tl_per_task = cpu_avg_load_per_task(this_cpu); unsigned long tl_per_task;
tl_per_task = cpu_avg_load_per_task(this_cpu);
/* /*
* If sync wakeup then subtract the (maximum possible) * If sync wakeup then subtract the (maximum possible)
@ -2487,18 +2492,21 @@ small_imbalance:
pwr_now /= SCHED_LOAD_SCALE; pwr_now /= SCHED_LOAD_SCALE;
/* Amount of load we'd subtract */ /* Amount of load we'd subtract */
tmp = busiest_load_per_task*SCHED_LOAD_SCALE/busiest->cpu_power; tmp = busiest_load_per_task * SCHED_LOAD_SCALE /
busiest->cpu_power;
if (max_load > tmp) if (max_load > tmp)
pwr_move += busiest->cpu_power * pwr_move += busiest->cpu_power *
min(busiest_load_per_task, max_load - tmp); min(busiest_load_per_task, max_load - tmp);
/* Amount of load we'd add */ /* Amount of load we'd add */
if (max_load*busiest->cpu_power < if (max_load * busiest->cpu_power <
busiest_load_per_task*SCHED_LOAD_SCALE) busiest_load_per_task * SCHED_LOAD_SCALE)
tmp = max_load*busiest->cpu_power/this->cpu_power; tmp = max_load * busiest->cpu_power / this->cpu_power;
else else
tmp = busiest_load_per_task*SCHED_LOAD_SCALE/this->cpu_power; tmp = busiest_load_per_task * SCHED_LOAD_SCALE /
pwr_move += this->cpu_power*min(this_load_per_task, this_load + tmp); this->cpu_power;
pwr_move += this->cpu_power *
min(this_load_per_task, this_load + tmp);
pwr_move /= SCHED_LOAD_SCALE; pwr_move /= SCHED_LOAD_SCALE;
/* Move if we gain throughput */ /* Move if we gain throughput */
@ -3366,7 +3374,8 @@ void fastcall add_preempt_count(int val)
/* /*
* Spinlock count overflowing soon? * Spinlock count overflowing soon?
*/ */
DEBUG_LOCKS_WARN_ON((preempt_count() & PREEMPT_MASK) >= PREEMPT_MASK-10); DEBUG_LOCKS_WARN_ON((preempt_count() & PREEMPT_MASK) >=
PREEMPT_MASK - 10);
} }
EXPORT_SYMBOL(add_preempt_count); EXPORT_SYMBOL(add_preempt_count);
@ -5439,16 +5448,19 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
if (!(sd->flags & SD_LOAD_BALANCE)) { if (!(sd->flags & SD_LOAD_BALANCE)) {
printk("does not load-balance\n"); printk("does not load-balance\n");
if (sd->parent) if (sd->parent)
printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain has parent"); printk(KERN_ERR "ERROR: !SD_LOAD_BALANCE domain"
" has parent");
break; break;
} }
printk("span %s\n", str); printk("span %s\n", str);
if (!cpu_isset(cpu, sd->span)) if (!cpu_isset(cpu, sd->span))
printk(KERN_ERR "ERROR: domain->span does not contain CPU%d\n", cpu); printk(KERN_ERR "ERROR: domain->span does not contain "
"CPU%d\n", cpu);
if (!cpu_isset(cpu, group->cpumask)) if (!cpu_isset(cpu, group->cpumask))
printk(KERN_ERR "ERROR: domain->groups does not contain CPU%d\n", cpu); printk(KERN_ERR "ERROR: domain->groups does not contain"
" CPU%d\n", cpu);
printk(KERN_DEBUG); printk(KERN_DEBUG);
for (i = 0; i < level + 2; i++) for (i = 0; i < level + 2; i++)
@ -5463,7 +5475,8 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
if (!group->cpu_power) { if (!group->cpu_power) {
printk("\n"); printk("\n");
printk(KERN_ERR "ERROR: domain->cpu_power not set\n"); printk(KERN_ERR "ERROR: domain->cpu_power not "
"set\n");
} }
if (!cpus_weight(group->cpumask)) { if (!cpus_weight(group->cpumask)) {
@ -5486,15 +5499,17 @@ static void sched_domain_debug(struct sched_domain *sd, int cpu)
printk("\n"); printk("\n");
if (!cpus_equal(sd->span, groupmask)) if (!cpus_equal(sd->span, groupmask))
printk(KERN_ERR "ERROR: groups don't span domain->span\n"); printk(KERN_ERR "ERROR: groups don't span "
"domain->span\n");
level++; level++;
sd = sd->parent; sd = sd->parent;
if (!sd)
continue;
if (sd) { if (!cpus_subset(groupmask, sd->span))
if (!cpus_subset(groupmask, sd->span)) printk(KERN_ERR "ERROR: parent span is not a superset "
printk(KERN_ERR "ERROR: parent span is not a superset of domain->span\n"); "of domain->span\n");
}
} while (sd); } while (sd);
} }
@ -5812,8 +5827,9 @@ __setup("max_cache_size=", setup_max_cache_size);
*/ */
static void touch_cache(void *__cache, unsigned long __size) static void touch_cache(void *__cache, unsigned long __size)
{ {
unsigned long size = __size/sizeof(long), chunk1 = size/3, unsigned long size = __size / sizeof(long);
chunk2 = 2*size/3; unsigned long chunk1 = size / 3;
unsigned long chunk2 = 2 * size / 3;
unsigned long *cache = __cache; unsigned long *cache = __cache;
int i; int i;
@ -5922,11 +5938,11 @@ measure_cost(int cpu1, int cpu2, void *cache, unsigned int size)
*/ */
measure_one(cache, size, cpu1, cpu2); measure_one(cache, size, cpu1, cpu2);
for (i = 0; i < ITERATIONS; i++) for (i = 0; i < ITERATIONS; i++)
cost1 += measure_one(cache, size - i*1024, cpu1, cpu2); cost1 += measure_one(cache, size - i * 1024, cpu1, cpu2);
measure_one(cache, size, cpu2, cpu1); measure_one(cache, size, cpu2, cpu1);
for (i = 0; i < ITERATIONS; i++) for (i = 0; i < ITERATIONS; i++)
cost1 += measure_one(cache, size - i*1024, cpu2, cpu1); cost1 += measure_one(cache, size - i * 1024, cpu2, cpu1);
/* /*
* (We measure the non-migrating [cached] cost on both * (We measure the non-migrating [cached] cost on both
@ -5936,17 +5952,17 @@ measure_cost(int cpu1, int cpu2, void *cache, unsigned int size)
measure_one(cache, size, cpu1, cpu1); measure_one(cache, size, cpu1, cpu1);
for (i = 0; i < ITERATIONS; i++) for (i = 0; i < ITERATIONS; i++)
cost2 += measure_one(cache, size - i*1024, cpu1, cpu1); cost2 += measure_one(cache, size - i * 1024, cpu1, cpu1);
measure_one(cache, size, cpu2, cpu2); measure_one(cache, size, cpu2, cpu2);
for (i = 0; i < ITERATIONS; i++) for (i = 0; i < ITERATIONS; i++)
cost2 += measure_one(cache, size - i*1024, cpu2, cpu2); cost2 += measure_one(cache, size - i * 1024, cpu2, cpu2);
/* /*
* Get the per-iteration migration cost: * Get the per-iteration migration cost:
*/ */
do_div(cost1, 2*ITERATIONS); do_div(cost1, 2 * ITERATIONS);
do_div(cost2, 2*ITERATIONS); do_div(cost2, 2 * ITERATIONS);
return cost1 - cost2; return cost1 - cost2;
} }
@ -5984,7 +6000,7 @@ static unsigned long long measure_migration_cost(int cpu1, int cpu2)
*/ */
cache = vmalloc(max_size); cache = vmalloc(max_size);
if (!cache) { if (!cache) {
printk("could not vmalloc %d bytes for cache!\n", 2*max_size); printk("could not vmalloc %d bytes for cache!\n", 2 * max_size);
return 1000000; /* return 1 msec on very small boxen */ return 1000000; /* return 1 msec on very small boxen */
} }
@ -6009,7 +6025,8 @@ static unsigned long long measure_migration_cost(int cpu1, int cpu2)
avg_fluct = (avg_fluct + fluct)/2; avg_fluct = (avg_fluct + fluct)/2;
if (migration_debug) if (migration_debug)
printk("-> [%d][%d][%7d] %3ld.%ld [%3ld.%ld] (%ld): (%8Ld %8Ld)\n", printk("-> [%d][%d][%7d] %3ld.%ld [%3ld.%ld] (%ld): "
"(%8Ld %8Ld)\n",
cpu1, cpu2, size, cpu1, cpu2, size,
(long)cost / 1000000, (long)cost / 1000000,
((long)cost / 100000) % 10, ((long)cost / 100000) % 10,
@ -6104,20 +6121,18 @@ static void calibrate_migration_costs(const cpumask_t *cpu_map)
-1 -1
#endif #endif
); );
if (system_state == SYSTEM_BOOTING) { if (system_state == SYSTEM_BOOTING && num_online_cpus() > 1) {
if (num_online_cpus() > 1) { printk("migration_cost=");
printk("migration_cost="); for (distance = 0; distance <= max_distance; distance++) {
for (distance = 0; distance <= max_distance; distance++) { if (distance)
if (distance) printk(",");
printk(","); printk("%ld", (long)migration_cost[distance] / 1000);
printk("%ld", (long)migration_cost[distance] / 1000);
}
printk("\n");
} }
printk("\n");
} }
j1 = jiffies; j1 = jiffies;
if (migration_debug) if (migration_debug)
printk("migration: %ld seconds\n", (j1-j0)/HZ); printk("migration: %ld seconds\n", (j1-j0) / HZ);
/* /*
* Move back to the original CPU. NUMA-Q gets confused * Move back to the original CPU. NUMA-Q gets confused