sched: select_task_rq_fair() cleanup/changes
PATCH 2/2 sched: More generic WAKE_AFFINE vs select_idle_sibling()
In reply to Peter ZijlstraInstead of only considering SD_WAKE_AFFINE | SD_PREFER_SIBLING domains also allow all SD_PREFER_SIBLING domains below a SD_WAKE_AFFINE domain to change the affinity target.
LKML-Reference: <new-submission>
--- kernel/sched_fair.c | 33 ++++++++++++++++----------------- 1 file changed, 16 insertions(+), 17 deletions(-)
kernel/sched_fair.c +16 -17
@@ -1359,20 +1359,16 @@ select_idle_sibling(struct task_struct ** test in select_task_rq_fair) and the prev_cpu is idle then that's * always a better target than the current cpu. */ -if (target == cpu) { -if (!cpu_rq (prev_cpu)->cfs.nr_running) - target = prev_cpu; - } +if (target == cpu && !cpu_rq (prev_cpu)->cfs.nr_running) +return prev_cpu;/* * Otherwise, iterate the domain and find an elegible idle cpu. */ -if (target ==-1 || target == cpu) { -for_each_cpu_and (i,sched_domain_span (sd), &p->cpus_allowed) { -if (!cpu_rq (i)->cfs.nr_running) { - target = i; -break ; - } +for_each_cpu_and (i,sched_domain_span (sd), &p->cpus_allowed) { +if (!cpu_rq (i)->cfs.nr_running) { + target = i; +break ; } }
@@ -1433,7 +1429,12 @@ static int select_task_rq_fair(struct ta want_sd =0 ; } -if (want_affine && (tmp->flags &SD_WAKE_AFFINE )) { +/* +* While iterating the domains looking for a spanning +* WAKE_AFFINE domain, adjust the affine target to any idle cpu +* in cache sharing domains along the way. +*/ +if (want_affine) {int target =-1 ;/*
@@ -1446,17 +1447,15 @@ static int select_task_rq_fair(struct ta/* * If there's an idle sibling in this domain, make that * the wake_affine target instead of the current cpu. -* -* XXX: should we possibly do this outside of -* WAKE_AFFINE, in case the shared cache domain is -* smaller than the WAKE_AFFINE domain? */ if (tmp->flags &SD_PREFER_SIBLING ) target =select_idle_sibling (p, tmp, target);if (target >=0 ) { - affine_sd = tmp; - want_affine =0 ; +if (tmp->flags &SD_WAKE_AFFINE ) { + affine_sd = tmp; + want_affine =0 ; + } cpu = target; } }
PATCH 1/2 sched: cleanup select_task_rq_fair()
In reply to Peter ZijlstraClean up the new affine to idle sibling bits while trying to grok them. Should not have any function differences.
LKML-Reference: <new-submission>
--- kernel/sched_fair.c | 73 ++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 51 insertions(+), 22 deletions(-)
kernel/sched_fair.c +51 -22
@@ -1345,6 +1345,41 @@ find_idlest_cpu(struct sched_group *grou }/* +* Try and locate an idle CPU in the sched_domain. +*/ +static int +select_idle_sibling (struct task_struct *p,struct sched_domain *sd,int target) +{ +int cpu =smp_processor_id (); +int prev_cpu =task_cpu (p); +int i; + +/* +* If this domain spans both cpu and prev_cpu (see the SD_WAKE_AFFINE +* test in select_task_rq_fair) and the prev_cpu is idle then that's +* always a better target than the current cpu. +*/ +if (target == cpu) { +if (!cpu_rq (prev_cpu)->cfs.nr_running) + target = prev_cpu; + } + +/* +* Otherwise, iterate the domain and find an elegible idle cpu. +*/ +if (target ==-1 || target == cpu) { +for_each_cpu_and (i,sched_domain_span (sd), &p->cpus_allowed) { +if (!cpu_rq (i)->cfs.nr_running) { + target = i; +break ; + } + } + } + +return target; +} + +/* * sched_balance_self: balance the current task (running on cpu) in domains * that have the 'flag' flag set. In practice, this is SD_BALANCE_FORK and * SD_BALANCE_EXEC.
@@ -1399,36 +1434,30 @@ static int select_task_rq_fair(struct ta }if (want_affine && (tmp->flags &SD_WAKE_AFFINE )) { -int candidate =-1 , i; +int target =-1 ; +/* +* If both cpu and prev_cpu are part of this domain, +* cpu is a valid SD_WAKE_AFFINE target. +*/ if (cpumask_test_cpu (prev_cpu,sched_domain_span (tmp))) - candidate = cpu; + target = cpu;/* -* Check for an idle shared cache. +* If there's an idle sibling in this domain, make that +* the wake_affine target instead of the current cpu. +* +* XXX: should we possibly do this outside of +* WAKE_AFFINE, in case the shared cache domain is +* smaller than the WAKE_AFFINE domain? */ -if (tmp->flags &SD_PREFER_SIBLING ) { -if (candidate == cpu) { -if (!cpu_rq (prev_cpu)->cfs.nr_running) - candidate = prev_cpu; - } - -if (candidate ==-1 || candidate == cpu) { -for_each_cpu (i,sched_domain_span (tmp)) { -if (!cpumask_test_cpu (i, &p->cpus_allowed)) -continue ; -if (!cpu_rq (i)->cfs.nr_running) { - candidate = i; -break ; - } - } - } - } +if (tmp->flags &SD_PREFER_SIBLING ) + target =select_idle_sibling (p, tmp, target); -if (candidate >=0 ) { +if (target >=0 ) { affine_sd = tmp; want_affine =0 ; - cpu = candidate; + cpu = target; } }
cover sched: select_task_rq_fair() cleanup/changes
Some bits I came up with while trying to grok the recent changes in the mentioned function.
Please have a careful look.
[tip:sched/core] sched: Cleanup select_task_rq_fair()
In reply to Peter ZijlstraCommit-ID: a50bde5130f65733142b32975616427d0ea50856 Gitweb: http://git.kernel.org/tip/a50bde5130f65733142b32975616427d0ea50856 Author: Peter Zijlstra <[email protected]> AuthorDate: Thu, 12 Nov 2009 15:55:28 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Fri, 13 Nov 2009 10:09:58 +0100
sched: Cleanup select_task_rq_fair()
Clean up the new affine to idle sibling bits while trying to grok them. Should not have any function differences.
LKML-Reference: <[email protected]>
--- kernel/sched_fair.c | 73 +++++++++++++++++++++++++++++++++++--------------- 1 files changed, 51 insertions(+), 22 deletions(-)
kernel/sched_fair.c +51 -22
@@ -1319,6 +1319,41 @@ find_idlest_cpu(struct sched_group *group, struct task_struct *p, int this_cpu) }/* +* Try and locate an idle CPU in the sched_domain. +*/ +static int +select_idle_sibling (struct task_struct *p,struct sched_domain *sd,int target) +{ +int cpu =smp_processor_id (); +int prev_cpu =task_cpu (p); +int i; + +/* +* If this domain spans both cpu and prev_cpu (see the SD_WAKE_AFFINE +* test in select_task_rq_fair) and the prev_cpu is idle then that's +* always a better target than the current cpu. +*/ +if (target == cpu) { +if (!cpu_rq (prev_cpu)->cfs.nr_running) + target = prev_cpu; + } + +/* +* Otherwise, iterate the domain and find an elegible idle cpu. +*/ +if (target ==-1 || target == cpu) { +for_each_cpu_and (i,sched_domain_span (sd), &p->cpus_allowed) { +if (!cpu_rq (i)->cfs.nr_running) { + target = i; +break ; + } + } + } + +return target; +} + +/* * sched_balance_self: balance the current task (running on cpu) in domains * that have the 'flag' flag set. In practice, this is SD_BALANCE_FORK and * SD_BALANCE_EXEC.
@@ -1373,36 +1408,30 @@ static int select_task_rq_fair(struct task_struct *p, int sd_flag, int wake_flag }if (want_affine && (tmp->flags &SD_WAKE_AFFINE )) { -int candidate =-1 , i; +int target =-1 ; +/* +* If both cpu and prev_cpu are part of this domain, +* cpu is a valid SD_WAKE_AFFINE target. +*/ if (cpumask_test_cpu (prev_cpu,sched_domain_span (tmp))) - candidate = cpu; + target = cpu;/* -* Check for an idle shared cache. +* If there's an idle sibling in this domain, make that +* the wake_affine target instead of the current cpu. +* +* XXX: should we possibly do this outside of +* WAKE_AFFINE, in case the shared cache domain is +* smaller than the WAKE_AFFINE domain? */ -if (tmp->flags &SD_PREFER_SIBLING ) { -if (candidate == cpu) { -if (!cpu_rq (prev_cpu)->cfs.nr_running) - candidate = prev_cpu; - } - -if (candidate ==-1 || candidate == cpu) { -for_each_cpu (i,sched_domain_span (tmp)) { -if (!cpumask_test_cpu (i, &p->cpus_allowed)) -continue ; -if (!cpu_rq (i)->cfs.nr_running) { - candidate = i; -break ; - } - } - } - } +if (tmp->flags &SD_PREFER_SIBLING ) + target =select_idle_sibling (p, tmp, target); -if (candidate >=0 ) { +if (target >=0 ) { affine_sd = tmp; want_affine =0 ; - cpu = candidate; + cpu = target; } }
[tip:sched/core] sched: More generic WAKE_AFFINE vs select_idle_sibling()
In reply to Peter ZijlstraCommit-ID: fe3bcfe1f6c1fc4ea7706ac2d05e579fd9092682 Gitweb: http://git.kernel.org/tip/fe3bcfe1f6c1fc4ea7706ac2d05e579fd9092682 Author: Peter Zijlstra <[email protected]> AuthorDate: Thu, 12 Nov 2009 15:55:29 +0100 Committer: Ingo Molnar <[email protected]> CommitDate: Fri, 13 Nov 2009 10:09:59 +0100
sched: More generic WAKE_AFFINE vs select_idle_sibling()
Instead of only considering SD_WAKE_AFFINE | SD_PREFER_SIBLING domains also allow all SD_PREFER_SIBLING domains below a SD_WAKE_AFFINE domain to change the affinity target.
LKML-Reference: <[email protected]>
--- kernel/sched_fair.c | 33 ++++++++++++++++----------------- 1 files changed, 16 insertions(+), 17 deletions(-)
kernel/sched_fair.c +16 -17
@@ -1333,20 +1333,16 @@ select_idle_sibling(struct task_struct *p, struct sched_domain *sd, int target)* test in select_task_rq_fair) and the prev_cpu is idle then that's * always a better target than the current cpu. */ -if (target == cpu) { -if (!cpu_rq (prev_cpu)->cfs.nr_running) - target = prev_cpu; - } +if (target == cpu && !cpu_rq (prev_cpu)->cfs.nr_running) +return prev_cpu;/* * Otherwise, iterate the domain and find an elegible idle cpu. */ -if (target ==-1 || target == cpu) { -for_each_cpu_and (i,sched_domain_span (sd), &p->cpus_allowed) { -if (!cpu_rq (i)->cfs.nr_running) { - target = i; -break ; - } +for_each_cpu_and (i,sched_domain_span (sd), &p->cpus_allowed) { +if (!cpu_rq (i)->cfs.nr_running) { + target = i; +break ; } }
@@ -1407,7 +1403,12 @@ static int select_task_rq_fair(struct task_struct *p, int sd_flag, int wake_flag want_sd =0 ; } -if (want_affine && (tmp->flags &SD_WAKE_AFFINE )) { +/* +* While iterating the domains looking for a spanning +* WAKE_AFFINE domain, adjust the affine target to any idle cpu +* in cache sharing domains along the way. +*/ +if (want_affine) {int target =-1 ;/*
@@ -1420,17 +1421,15 @@ static int select_task_rq_fair(struct task_struct *p, int sd_flag, int wake_flag/* * If there's an idle sibling in this domain, make that * the wake_affine target instead of the current cpu. -* -* XXX: should we possibly do this outside of -* WAKE_AFFINE, in case the shared cache domain is -* smaller than the WAKE_AFFINE domain? */ if (tmp->flags &SD_PREFER_SIBLING ) target =select_idle_sibling (p, tmp, target);if (target >=0 ) { - affine_sd = tmp; - want_affine =0 ; +if (tmp->flags &SD_WAKE_AFFINE ) { + affine_sd = tmp; + want_affine =0 ; + } cpu = target; } }