sched: add heuristic logic to pick idle peers
PATCH 1/1 sched: add heuristic logic to pick idle peers
nr_busy_cpus in sched_group_power structure cannot present the purpose for judging below statement:
"this cpu's scheduler group has multiple busy cpu's exceeding
the group's power."
But only could tell how many cpus is doing their jobs for currently.
However, the original purpose to add this logic still looks good. So we move this kind of logic to find_new_ilb, so that we could pick out peer from our sharing resource domain whenever possible.
--- kernel/sched/fair.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-)
kernel/sched/fair.c +22 -6
@@ -5368,10 +5368,31 @@ static struct {unsigned long next_balance;/* in jiffy units */ } nohz____cacheline_aligned ; +/* +* Add the heuristic logic to try waking up idle cpu from +* those peers who share resources with us, so that the +* cost would be brought to minimum. +*/ static inline int find_new_ilb (int call_cpu) { -int ilb =cpumask_first (nohz.idle_cpus_mask); +int ilb = nr_cpu_ids; +struct sched_domain *sd; + +rcu_read_lock (); +for_each_domain (call_cpu, sd) { +/* We loop till sched_domain no longer share resource */ +if (!(sd->flags &SD_SHARE_PKG_RESOURCES )) { + ilb =cpumask_first (nohz.idle_cpus_mask); +break ; + } +/* else, we would try to pick the idle cpu from peers first */ + ilb =cpumask_first_and (nohz.idle_cpus_mask, +sched_domain_span (sd)); +if (ilb < nr_cpu_ids) +break ; + } +rcu_read_unlock ();if (ilb < nr_cpu_ids &&idle_cpu (ilb))return ilb;
@@ -5620,8 +5641,6 @@ end:* Current heuristic for kicking the idle load balancer in the presence * of an idle cpu is the system. * - This rq has more than one task. -* - At any scheduler domain level, this cpu's scheduler group has multiple -* busy cpu's exceeding the group's power. * - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler * domain span are idle. */
@@ -5659,9 +5678,6 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)struct sched_group_power *sgp = sg->sgp;int nr_busy =atomic_read (&sgp->nr_busy_cpus); -if (sd->flags &SD_SHARE_PKG_RESOURCES && nr_busy >1 ) - goto need_kick_unlock; -if (sd->flags &SD_ASYM_PACKING && nr_busy != sg->group_weight && (cpumask_first_and (nohz.idle_cpus_mask,sched_domain_span (sd)) < cpu))
Signature · 1 line
1.7.10.4
Hi, Lei
Quoted 6 lines · Lei Wen
nr_busy_cpusinsched_group_powerstructure cannot present the purpose for judging below statement:
"this cpu's scheduler group has multiple busy cpu's exceeding
the group's power."But only could tell how many cpus is doing their jobs for currently.
AFAIK, this nr_busy_cpus presents how many cpus in local group are not idle, the logical here in nohz_kick_needed() is:
if domain cpus share resources and at least 2 cpus in local group are not idle, prefer to do balance.
And the idea behind is, we catch the timing when there are idle-cpu and busy-group and task-moving may cost low.
Your change will remove this timing for balance, I think you may need some test to prove that this patch will make things better.
Regards,
Michael Wang
Quoted 67 lines
However, the original purpose to add this logic still looks good. So we move this kind of logic to
find_new_ilb, so that we could pick out peer from our sharing resource domain whenever possible.Signed-off-by Lei Wen <[email protected]>--- kernel/sched/fair.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-)kernel/sched/fair.c +22
-6@@ -5368,10 +5368,31 @@ static struct {unsigned long next_balance;/* in jiffy units */ } nohz____cacheline_aligned ; +/* +* Add the heuristic logic to try waking up idle cpu from +* those peers who share resources with us, so that the +* cost would be brought to minimum. +*/ static inline int find_new_ilb (int call_cpu) { -int ilb =cpumask_first (nohz.idle_cpus_mask); +int ilb = nr_cpu_ids; +struct sched_domain *sd; + +rcu_read_lock (); +for_each_domain (call_cpu, sd) { +/* We loop till sched_domain no longer share resource */ +if (!(sd->flags &SD_SHARE_PKG_RESOURCES )) { + ilb =cpumask_first (nohz.idle_cpus_mask); +break ; + } +/* else, we would try to pick the idle cpu from peers first */ + ilb =cpumask_first_and (nohz.idle_cpus_mask, +sched_domain_span (sd)); +if (ilb < nr_cpu_ids) +break ; + } +rcu_read_unlock ();if (ilb < nr_cpu_ids &&idle_cpu (ilb))return ilb;@@ -5620,8 +5641,6 @@ end:* Current heuristic for kicking the idle load balancer in the presence * of an idle cpu is the system. * - This rq has more than one task. -* - At any scheduler domain level, this cpu's scheduler group has multiple -* busy cpu's exceeding the group's power. * - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler * domain span are idle. */ @@ -5659,9 +5678,6 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)struct sched_group_power *sgp = sg->sgp;int nr_busy =atomic_read (&sgp->nr_busy_cpus); -if (sd->flags &SD_SHARE_PKG_RESOURCES && nr_busy >1 ) - goto need_kick_unlock; -if (sd->flags &SD_ASYM_PACKING && nr_busy != sg->group_weight && (cpumask_first_and (nohz.idle_cpus_mask,sched_domain_span (sd)) < cpu))
Hi Michael,
Quoted 8 lines · Michael Wang
Hi, Lei
Quoted 5 lines · Lei Wen
nr_busy_cpusinsched_group_powerstructure cannot present the purpose for judging below statement:
"this cpu's scheduler group has multiple busy cpu's exceeding
the group's power."
Quoted 8 lines
Quoted 1 line
But only could tell how many cpus is doing their jobs for currently.
AFAIK, this
nr_busy_cpuspresents how many cpus in local group are not idle, the logical here innohz_kick_needed()is:if domain cpus share resources and at least 2 cpus in local group are not idle, prefer to do balance.
Seems reasonable for me. But this comment is conflicted with current documented one. Do we need to modify the comment anyway, as previous says nr_busy>1 is "scheduler group has multiple busy cpu;s exceeding the group's power"?
Quoted 2 lines
And the idea behind is, we catch the timing when there are idle-cpu and busy-group and task-moving may cost low.
Since there is only one task over runqueue now, then why we could need the load balance any way?...
Quoted 3 lines
Your change will remove this timing for balance, I think you may need some test to prove that this patch will make things better.
I see. Yes, test data is always good. :)
Do you have any suggestion like using what kind of test program to collect this data?
Thanks,
Lei
Quoted 77 lines
Regards,
Michael WangQuoted 58 lines
However, the original purpose to add this logic still looks good. So we move this kind of logic to
find_new_ilb, so that we could pick out peer from our sharing resource domain whenever possible.Signed-off-by Lei Wen <[email protected]>--- kernel/sched/fair.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-)kernel/sched/fair.c +22
-3@@ -5368,10 +5368,31 @@ static struct {unsigned long next_balance;/* in jiffy units */ } nohz____cacheline_aligned ; +/* +* Add the heuristic logic to try waking up idle cpu from +* those peers who share resources with us, so that the +* cost would be brought to minimum. +*/ static inline int find_new_ilb (int call_cpu) { -int ilb =cpumask_first (nohz.idle_cpus_mask); +int ilb = nr_cpu_ids; +struct sched_domain *sd; + +rcu_read_lock (); +for_each_domain (call_cpu, sd) { +/* We loop till sched_domain no longer share resource */ +if (!(sd->flags &SD_SHARE_PKG_RESOURCES )) { + ilb =cpumask_first (nohz.idle_cpus_mask); +break ; + } +/* else, we would try to pick the idle cpu from peers first */ + ilb =cpumask_first_and (nohz.idle_cpus_mask, +sched_domain_span (sd)); +if (ilb < nr_cpu_ids) +break ; + } +rcu_read_unlock ();if (ilb < nr_cpu_ids &&idle_cpu (ilb))return ilb;@@ -5620,8 +5641,6 @@ end:* Current heuristic for kicking the idle load balancer in the presence * of an idle cpu is the system. * - This rq has more than one task. -* - At any scheduler domain level, this cpu's scheduler group has multiple -* busy cpu's exceeding the group's power. * - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler * domain span are idle. */ kernel/sched/fair.c static inline int nohz_kick_needed(struct rq *rq, int cpu) · line 5683
Quoted 9 lines
kernel/sched/fair.c +0
-3@@ -5659,9 +5678,6 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)struct sched_group_power *sgp = sg->sgp;int nr_busy =atomic_read (&sgp->nr_busy_cpus); -if (sd->flags &SD_SHARE_PKG_RESOURCES && nr_busy >1 ) - goto need_kick_unlock; -if (sd->flags &SD_ASYM_PACKING && nr_busy != sg->group_weight && (cpumask_first_and (nohz.idle_cpus_mask,sched_domain_span (sd)) < cpu))--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Quoted 17 lines · Lei Wen
Hi Michael,
Quoted 13 lines · Michael Wang
Hi, Lei
Quoted 6 lines · Lei Wen
nr_busy_cpusinsched_group_powerstructure cannot present the purpose for judging below statement:
"this cpu's scheduler group has multiple busy cpu's exceeding
the group's power."But only could tell how many cpus is doing their jobs for currently.
AFAIK, this
nr_busy_cpuspresents how many cpus in local group are not idle, the logical here innohz_kick_needed()is:
Quoted 7 lines
Quoted 3 lines
if domain cpus share resources and at least 2 cpus in local group are not idle, prefer to do balance.
Seems reasonable for me. But this comment is conflicted with current documented one. Do we need to modify the comment anyway, as previous says nr_busy>1 is "scheduler group has multiple busy cpu;s exceeding the group's power"?
I agree it doesn't make sense (to me), the logical here only make sure there are at least 2 non-idle cpus in local group, we may need some more powerful folks to confirm that point.
Quoted 6 lines
Quoted 3 lines
And the idea behind is, we catch the timing when there are idle-cpu and busy-group and task-moving may cost low.
Since there is only one task over runqueue now, then why we could need the load balance any way?...
IMHO, this is just shot in the darkness... like 'I think in such cases the chances of requiring a balance will be high', but the problem is, the logical is already in mainline for some reasons, if we want to say that is wrong, then we need to collect enough proof...
Quoted 8 lines
Quoted 4 lines
Your change will remove this timing for balance, I think you may need some test to prove that this patch will make things better.
I see. Yes, test data is always good. :)
Do you have any suggestion like using what kind of test program to collect this data?
Any workload which require a good balance to check whether the patch cause damage, any workload which is latency-sensitive to check whether the patch bring benefit, what about kernbench with enough threads firstly?
Actually all the popular benchmark worth a try, until some improvement was found, if after all the test, still no benefit located, then the idea may have to be dropped...
Regards,
Michael Wang
Quoted 82 lines
Thanks,
LeiQuoted 77 lines
Regards,
Michael WangQuoted 58 lines
However, the original purpose to add this logic still looks good. So we move this kind of logic to
find_new_ilb, so that we could pick out peer from our sharing resource domain whenever possible.Signed-off-by Lei Wen <[email protected]>--- kernel/sched/fair.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-)kernel/sched/fair.c +22
-3@@ -5368,10 +5368,31 @@ static struct {unsigned long next_balance;/* in jiffy units */ } nohz____cacheline_aligned ; +/* +* Add the heuristic logic to try waking up idle cpu from +* those peers who share resources with us, so that the +* cost would be brought to minimum. +*/ static inline int find_new_ilb (int call_cpu) { -int ilb =cpumask_first (nohz.idle_cpus_mask); +int ilb = nr_cpu_ids; +struct sched_domain *sd; + +rcu_read_lock (); +for_each_domain (call_cpu, sd) { +/* We loop till sched_domain no longer share resource */ +if (!(sd->flags &SD_SHARE_PKG_RESOURCES )) { + ilb =cpumask_first (nohz.idle_cpus_mask); +break ; + } +/* else, we would try to pick the idle cpu from peers first */ + ilb =cpumask_first_and (nohz.idle_cpus_mask, +sched_domain_span (sd)); +if (ilb < nr_cpu_ids) +break ; + } +rcu_read_unlock ();if (ilb < nr_cpu_ids &&idle_cpu (ilb))return ilb;@@ -5620,8 +5641,6 @@ end:* Current heuristic for kicking the idle load balancer in the presence * of an idle cpu is the system. * - This rq has more than one task. -* - At any scheduler domain level, this cpu's scheduler group has multiple -* busy cpu's exceeding the group's power. * - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler * domain span are idle. */ kernel/sched/fair.c static inline int nohz_kick_needed(struct rq *rq, int cpu) · line 5683
Quoted 9 lines
kernel/sched/fair.c +0
-3@@ -5659,9 +5678,6 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)struct sched_group_power *sgp = sg->sgp;int nr_busy =atomic_read (&sgp->nr_busy_cpus); -if (sd->flags &SD_SHARE_PKG_RESOURCES && nr_busy >1 ) - goto need_kick_unlock; -if (sd->flags &SD_ASYM_PACKING && nr_busy != sg->group_weight && (cpumask_first_and (nohz.idle_cpus_mask,sched_domain_span (sd)) < cpu))--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Hi Michael,
Quoted 34 lines · Michael Wang
Quoted 17 lines · Lei Wen
Hi Michael,
Quoted 13 lines · Michael Wang
Hi, Lei
Quoted 6 lines · Lei Wen
nr_busy_cpusinsched_group_powerstructure cannot present the purpose for judging below statement:
"this cpu's scheduler group has multiple busy cpu's exceeding
the group's power."But only could tell how many cpus is doing their jobs for currently.
AFAIK, this
nr_busy_cpuspresents how many cpus in local group are not idle, the logical here innohz_kick_needed()is:Quoted 7 lines
Quoted 3 lines
if domain cpus share resources and at least 2 cpus in local group are not idle, prefer to do balance.
Seems reasonable for me. But this comment is conflicted with current documented one. Do we need to modify the comment anyway, as previous says nr_busy>1 is "scheduler group has multiple busy cpu;s exceeding the group's power"?
I agree it doesn't make sense (to me), the logical here only make sure there are at least 2 non-idle cpus in local group, we may need some more powerful folks to confirm that point.
Quoted 4 lines
Quoted 3 lines
And the idea behind is, we catch the timing when there are idle-cpu and busy-group and task-moving may cost low.
Quoted 7 lines
Quoted 2 lines
Since there is only one task over runqueue now, then why we could need the load balance any way?...
IMHO, this is just shot in the darkness... like 'I think in such cases the chances of requiring a balance will be high', but the problem is, the logical is already in mainline for some reasons, if we want to say that is wrong, then we need to collect enough proof...
I see...
Quoted 10 lines
Quoted 9 lines
Quoted 5 lines
Your change will remove this timing for balance, I think you may need some test to prove that this patch will make things better.
I see. Yes, test data is always good. :)
Do you have any suggestion like using what kind of test program to collect this data?
Quoted 7 lines
Any workload which require a good balance to check whether the patch cause damage, any workload which is latency-sensitive to check whether the patch bring benefit, what about kernbench with enough threads firstly?
Actually all the popular benchmark worth a try, until some improvement was found, if after all the test, still no benefit located, then the idea may have to be dropped...
Thanks for suggestion, I would do some test locally first and try to get such proof. :)
Thanks,
Lei
Quoted 87 lines
Regards,
Michael WangQuoted 82 lines
Thanks,
LeiQuoted 77 lines
Regards,
Michael WangQuoted 58 lines
However, the original purpose to add this logic still looks good. So we move this kind of logic to
find_new_ilb, so that we could pick out peer from our sharing resource domain whenever possible.Signed-off-by Lei Wen <[email protected]>--- kernel/sched/fair.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-)kernel/sched/fair.c +22
-3@@ -5368,10 +5368,31 @@ static struct {unsigned long next_balance;/* in jiffy units */ } nohz____cacheline_aligned ; +/* +* Add the heuristic logic to try waking up idle cpu from +* those peers who share resources with us, so that the +* cost would be brought to minimum. +*/ static inline int find_new_ilb (int call_cpu) { -int ilb =cpumask_first (nohz.idle_cpus_mask); +int ilb = nr_cpu_ids; +struct sched_domain *sd; + +rcu_read_lock (); +for_each_domain (call_cpu, sd) { +/* We loop till sched_domain no longer share resource */ +if (!(sd->flags &SD_SHARE_PKG_RESOURCES )) { + ilb =cpumask_first (nohz.idle_cpus_mask); +break ; + } +/* else, we would try to pick the idle cpu from peers first */ + ilb =cpumask_first_and (nohz.idle_cpus_mask, +sched_domain_span (sd)); +if (ilb < nr_cpu_ids) +break ; + } +rcu_read_unlock ();if (ilb < nr_cpu_ids &&idle_cpu (ilb))return ilb;@@ -5620,8 +5641,6 @@ end:* Current heuristic for kicking the idle load balancer in the presence * of an idle cpu is the system. * - This rq has more than one task. -* - At any scheduler domain level, this cpu's scheduler group has multiple -* busy cpu's exceeding the group's power. * - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler * domain span are idle. */ kernel/sched/fair.c static inline int nohz_kick_needed(struct rq *rq, int cpu) · line 5683
Quoted 9 lines
kernel/sched/fair.c +0
-3@@ -5659,9 +5678,6 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)struct sched_group_power *sgp = sg->sgp;int nr_busy =atomic_read (&sgp->nr_busy_cpus); -if (sd->flags &SD_SHARE_PKG_RESOURCES && nr_busy >1 ) - goto need_kick_unlock; -if (sd->flags &SD_ASYM_PACKING && nr_busy != sg->group_weight && (cpumask_first_and (nohz.idle_cpus_mask,sched_domain_span (sd)) < cpu))--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/
Hi Michael,
Quoted 51 lines · Michael Wang
Quoted 17 lines · Lei Wen
Hi Michael,
Quoted 13 lines · Michael Wang
Hi, Lei
Quoted 6 lines · Lei Wen
nr_busy_cpusinsched_group_powerstructure cannot present the purpose for judging below statement:
"this cpu's scheduler group has multiple busy cpu's exceeding
the group's power."But only could tell how many cpus is doing their jobs for currently.
AFAIK, this
nr_busy_cpuspresents how many cpus in local group are not idle, the logical here innohz_kick_needed()is:Quoted 7 lines
Quoted 3 lines
if domain cpus share resources and at least 2 cpus in local group are not idle, prefer to do balance.
Seems reasonable for me. But this comment is conflicted with current documented one. Do we need to modify the comment anyway, as previous says nr_busy>1 is "scheduler group has multiple busy cpu;s exceeding the group's power"?
I agree it doesn't make sense (to me), the logical here only make sure there are at least 2 non-idle cpus in local group, we may need some more powerful folks to confirm that point.
Quoted 6 lines
Quoted 3 lines
And the idea behind is, we catch the timing when there are idle-cpu and busy-group and task-moving may cost low.
Since there is only one task over runqueue now, then why we could need the load balance any way?...
IMHO, this is just shot in the darkness... like 'I think in such cases the chances of requiring a balance will be high', but the problem is, the logical is already in mainline for some reasons, if we want to say that is wrong, then we need to collect enough proof...
Quoted 8 lines
Quoted 4 lines
Your change will remove this timing for balance, I think you may need some test to prove that this patch will make things better.
I see. Yes, test data is always good. :)
Do you have any suggestion like using what kind of test program to collect this data?
Quoted 7 lines
Any workload which require a good balance to check whether the patch cause damage, any workload which is latency-sensitive to check whether the patch bring benefit, what about kernbench with enough threads firstly?
Actually all the popular benchmark worth a try, until some improvement was found, if after all the test, still no benefit located, then the idea may have to be dropped...
I try several benchmark, like cyclictest, sysbench... But seems the score it report shows get benefit little.
However, since this change is applying towards idle path, the benchmark maybe wrong direction to illustrate its correctness.
Suppose we are having two cpu socket/cluster, and two cpus in each socket/cluster.
And socket 0's two cpus are idle, socket 1's one cpu has two pined task, another is also idle.
In such case, scheduler would keep wake the cpu0 in socket 0, and let it do the nohz balance.
But for two tasks in socket1/cpu0 is pined, so it cannot be moved. So result is socket 0 would be waken up at least every scheduler tick.
If in such scenario, scheduler choose socket1/cpu1 with the patch applied, the whole system's power
could be reduced, since waking up cpu0 over socket0 would increase addition socket/cluster power.
Could it be one proof to support this patch?
Thanks,
Lei
Quoted 87 lines
Regards,
Michael WangQuoted 82 lines
Thanks,
LeiQuoted 77 lines
Regards,
Michael WangQuoted 58 lines
However, the original purpose to add this logic still looks good. So we move this kind of logic to
find_new_ilb, so that we could pick out peer from our sharing resource domain whenever possible.Signed-off-by Lei Wen <[email protected]>--- kernel/sched/fair.c | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-)kernel/sched/fair.c +22
-3@@ -5368,10 +5368,31 @@ static struct {unsigned long next_balance;/* in jiffy units */ } nohz____cacheline_aligned ; +/* +* Add the heuristic logic to try waking up idle cpu from +* those peers who share resources with us, so that the +* cost would be brought to minimum. +*/ static inline int find_new_ilb (int call_cpu) { -int ilb =cpumask_first (nohz.idle_cpus_mask); +int ilb = nr_cpu_ids; +struct sched_domain *sd; + +rcu_read_lock (); +for_each_domain (call_cpu, sd) { +/* We loop till sched_domain no longer share resource */ +if (!(sd->flags &SD_SHARE_PKG_RESOURCES )) { + ilb =cpumask_first (nohz.idle_cpus_mask); +break ; + } +/* else, we would try to pick the idle cpu from peers first */ + ilb =cpumask_first_and (nohz.idle_cpus_mask, +sched_domain_span (sd)); +if (ilb < nr_cpu_ids) +break ; + } +rcu_read_unlock ();if (ilb < nr_cpu_ids &&idle_cpu (ilb))return ilb;@@ -5620,8 +5641,6 @@ end:* Current heuristic for kicking the idle load balancer in the presence * of an idle cpu is the system. * - This rq has more than one task. -* - At any scheduler domain level, this cpu's scheduler group has multiple -* busy cpu's exceeding the group's power. * - For SD_ASYM_PACKING, if the lower numbered cpu's in the scheduler * domain span are idle. */ kernel/sched/fair.c static inline int nohz_kick_needed(struct rq *rq, int cpu) · line 5683
Quoted 9 lines
kernel/sched/fair.c +0
-3@@ -5659,9 +5678,6 @@ static inline int nohz_kick_needed(struct rq *rq, int cpu)struct sched_group_power *sgp = sg->sgp;int nr_busy =atomic_read (&sgp->nr_busy_cpus); -if (sd->flags &SD_SHARE_PKG_RESOURCES && nr_busy >1 ) - goto need_kick_unlock; -if (sd->flags &SD_ASYM_PACKING && nr_busy != sg->group_weight && (cpumask_first_and (nohz.idle_cpus_mask,sched_domain_span (sd)) < cpu))--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/