GitHub-Mirror/Star64_linux
2
0
Fork 0
mirror of https://github.com/Fishwaldo/Star64_linux.git synced 2025-03-28 10:04:14 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

sched: Fix wake_affine() vs RT tasks

Browse source 
Mike reports that since e9e9250b (sched: Scale down cpu_power due to RT
tasks), wake_affine() goes funny on RT tasks due to them still having a
!0 weight and wake_affine() still subtracts that from the rq weight.

Since nobody should be using se->weight for RT tasks, set the value to
zero. Also, since we now use ->cpu_power to normalize rq weights to
account for RT cpu usage, add that factor into the imbalance computation.

Reported-by: Mike Galbraith <efault@gmx.de>
Tested-by: Mike Galbraith <efault@gmx.de>
Signed-off-by: Peter Zijlstra <a.p.zijlstra@chello.nl>
LKML-Reference: <1275316109.27810.22969.camel@twins>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
This commit is contained in:
Peter Zijlstra 2010-05-31 12:37:30 +02:00 • committed by Ingo Molnar
parent 54e88fad22
commit e51fd5e22e
2 changed files with 22 additions and 24 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
kernel/sched.c
View file

@ -544,6 +544,8 @@ struct rq {
struct root_domain *rd; struct root_domain *rd;
struct sched_domain *sd; struct sched_domain *sd;
unsigned long cpu_power;
unsigned char idle_at_tick; unsigned char idle_at_tick;
/* For active balancing */ /* For active balancing */
int post_schedule; int post_schedule;
@ -1499,24 +1501,9 @@ static unsigned long target_load(int cpu, int type)
return max(rq->cpu_load[type-1], total); return max(rq->cpu_load[type-1], total);
} }
static struct sched_group *group_of(int cpu)
{
struct sched_domain *sd = rcu_dereference_sched(cpu_rq(cpu)->sd);
if (!sd)
return NULL;
return sd->groups;
}
static unsigned long power_of(int cpu) static unsigned long power_of(int cpu)
{ {
struct sched_group *group = group_of(cpu); return cpu_rq(cpu)->cpu_power;
if (!group)
return SCHED_LOAD_SCALE;
return group->cpu_power;
} }
static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd); static int task_hot(struct task_struct *p, u64 now, struct sched_domain *sd);
@ -1854,8 +1841,8 @@ static void dec_nr_running(struct rq *rq)
static void set_load_weight(struct task_struct *p) static void set_load_weight(struct task_struct *p)
{ {
if (task_has_rt_policy(p)) { if (task_has_rt_policy(p)) {
p->se.load.weight = prio_to_weight[0] * 2; p->se.load.weight = 0;
p->se.load.inv_weight = prio_to_wmult[0] >> 1; p->se.load.inv_weight = WMULT_CONST;
return; return;
} }
@ -7605,6 +7592,7 @@ void __init sched_init(void)
#ifdef CONFIG_SMP #ifdef CONFIG_SMP
rq->sd = NULL; rq->sd = NULL;
rq->rd = NULL; rq->rd = NULL;
rq->cpu_power = SCHED_LOAD_SCALE;
rq->post_schedule = 0; rq->post_schedule = 0;
rq->active_balance = 0; rq->active_balance = 0;
rq->next_balance = jiffies; rq->next_balance = jiffies;

22
kernel/sched_fair.c
View file

@ -1225,7 +1225,6 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync)
unsigned long this_load, load; unsigned long this_load, load;
int idx, this_cpu, prev_cpu; int idx, this_cpu, prev_cpu;
unsigned long tl_per_task; unsigned long tl_per_task;
unsigned int imbalance;
struct task_group *tg; struct task_group *tg;
unsigned long weight; unsigned long weight;
int balanced; int balanced;
@ -1252,8 +1251,6 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync)
tg = task_group(p); tg = task_group(p);
weight = p->se.load.weight; weight = p->se.load.weight;
imbalance = 100 + (sd->imbalance_pct - 100) / 2;
/* /*
* In low-load situations, where prev_cpu is idle and this_cpu is idle * In low-load situations, where prev_cpu is idle and this_cpu is idle
* due to the sync cause above having dropped this_load to 0, we'll * due to the sync cause above having dropped this_load to 0, we'll
@ -1263,9 +1260,21 @@ static int wake_affine(struct sched_domain *sd, struct task_struct *p, int sync)
* Otherwise check if either cpus are near enough in load to allow this * Otherwise check if either cpus are near enough in load to allow this
* task to be woken on this_cpu. * task to be woken on this_cpu.
*/ */
balanced = !this_load || if (this_load) {
100*(this_load + effective_load(tg, this_cpu, weight, weight)) <= unsigned long this_eff_load, prev_eff_load;
imbalance*(load + effective_load(tg, prev_cpu, 0, weight));
this_eff_load = 100;
this_eff_load *= power_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 *= load + effective_load(tg, prev_cpu, 0, weight);
balanced = this_eff_load <= prev_eff_load;
} else
balanced = true;
/* /*
* If the currently running task will sleep within * If the currently running task will sleep within
@ -2298,6 +2307,7 @@ static void update_cpu_power(struct sched_domain *sd, int cpu)
if (!power) if (!power)
power = 1; power = 1;
cpu_rq(cpu)->cpu_power = power;
sdg->cpu_power = power; sdg->cpu_power = power;
} }