lkml.org 
[lkml]   [2014]   [Nov]   [19]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
From
Date
SubjectRe: [PATCH v9 08/10] sched: replace capacity_factor by usage
On 19 November 2014 16:15, pang.xunlei <pang.xunlei@linaro.org> wrote:
> On 4 November 2014 00:54, Vincent Guittot <vincent.guittot@linaro.org> wrote:

[snip]

>> +static inline bool
>> +group_has_capacity(struct lb_env *env, struct sg_lb_stats *sgs)
>> {
>> - unsigned int capacity_factor, smt, cpus;
>> - unsigned int capacity, capacity_orig;
>> + if ((sgs->group_capacity * 100) >
>> + (sgs->group_usage * env->sd->imbalance_pct))
> Hi Vincent,
>
> In case of when some CPU(s) is used to handle heavy IRQs or RT tasks,
> get_cpu_usage() will get low usage(capacity), and cpu_capacity gets
> low as well, so do those of the whole group correspondingly.
> So in this case, is there any guarantee that this math will return false?

As an example, we will return false whatever the non-zero value of
group_capacity if there is no CFS tasks in the group

Regards,
Vincent

>
> Thanks,
> Xunlei
>> + return true;
>>
>> - capacity = group->sgc->capacity;
>> - capacity_orig = group->sgc->capacity_orig;
>> - cpus = group->group_weight;
>> + if (sgs->sum_nr_running < sgs->group_weight)
>> + return true;
>> +
>> + return false;
>> +}
>>
>> - /* smt := ceil(cpus / capacity), assumes: 1 < smt_capacity < 2 */
>> - smt = DIV_ROUND_UP(SCHED_CAPACITY_SCALE * cpus, capacity_orig);
>> - capacity_factor = cpus / smt; /* cores */
>> +/*
>> + * group_is_overloaded returns true if the group has more tasks than it can
>> + * handle. We consider that a group is overloaded if the number of tasks is
>> + * greater than the number of CPUs and the tasks already use all available
>> + * capacity for CFS tasks. For the latter, we use a threshold to stabilize
>> + * the state, to take into account the variance of tasks' load and to return
>> + * true if available capacity is no more meaningful for load balancer
>> + */
>> +static inline bool
>> +group_is_overloaded(struct lb_env *env, struct sg_lb_stats *sgs)
>> +{
>> + if (sgs->sum_nr_running <= sgs->group_weight)
>> + return false;
>>
>> - capacity_factor = min_t(unsigned,
>> - capacity_factor, DIV_ROUND_CLOSEST(capacity, SCHED_CAPACITY_SCALE));
>> - if (!capacity_factor)
>> - capacity_factor = fix_small_capacity(env->sd, group);
>> + if ((sgs->group_capacity * 100) <
>> + (sgs->group_usage * env->sd->imbalance_pct))
>> + return true;
>>
>> - return capacity_factor;
>> + return false;
>> }
>>
>> -static enum group_type
>> -group_classify(struct sched_group *group, struct sg_lb_stats *sgs)
>> +static enum group_type group_classify(struct lb_env *env,
>> + struct sched_group *group,
>> + struct sg_lb_stats *sgs)
>> {
>> - if (sgs->sum_nr_running > sgs->group_capacity_factor)
>> + if (sgs->group_no_capacity)
>> return group_overloaded;
>>
>> if (sg_imbalanced(group))
>> @@ -6087,11 +6083,9 @@ static inline void update_sg_lb_stats(struct lb_env *env,
>> sgs->load_per_task = sgs->sum_weighted_load / sgs->sum_nr_running;
>>
>> sgs->group_weight = group->group_weight;
>> - sgs->group_capacity_factor = sg_capacity_factor(env, group);
>> - sgs->group_type = group_classify(group, sgs);
>>
>> - if (sgs->group_capacity_factor > sgs->sum_nr_running)
>> - sgs->group_has_free_capacity = 1;
>> + sgs->group_no_capacity = group_is_overloaded(env, sgs);
>> + sgs->group_type = group_classify(env, group, sgs);
>> }
>>
>> /**
>> @@ -6213,17 +6207,20 @@ static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sd
>>
>> /*
>> * In case the child domain prefers tasks go to siblings
>> - * first, lower the sg capacity factor to one so that we'll try
>> + * first, lower the sg capacity so that we'll try
>> * and move all the excess tasks away. We lower the capacity
>> * of a group only if the local group has the capacity to fit
>> - * these excess tasks, i.e. nr_running < group_capacity_factor. The
>> - * extra check prevents the case where you always pull from the
>> - * heaviest group when it is already under-utilized (possible
>> - * with a large weight task outweighs the tasks on the system).
>> + * these excess tasks. The extra check prevents the case where
>> + * you always pull from the heaviest group when it is already
>> + * under-utilized (possible with a large weight task outweighs
>> + * the tasks on the system).
>> */
>> if (prefer_sibling && sds->local &&
>> - sds->local_stat.group_has_free_capacity)
>> - sgs->group_capacity_factor = min(sgs->group_capacity_factor, 1U);
>> + group_has_capacity(env, &sds->local_stat) &&
>> + (sgs->sum_nr_running > 1)) {
>> + sgs->group_no_capacity = 1;
>> + sgs->group_type = group_overloaded;
>> + }
>>
>> if (update_sd_pick_busiest(env, sds, sg, sgs)) {
>> sds->busiest = sg;
>> @@ -6402,11 +6399,12 @@ static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *s
>> */
>> if (busiest->group_type == group_overloaded &&
>> local->group_type == group_overloaded) {
>> - load_above_capacity =
>> - (busiest->sum_nr_running - busiest->group_capacity_factor);
>> -
>> - load_above_capacity *= (SCHED_LOAD_SCALE * SCHED_CAPACITY_SCALE);
>> - load_above_capacity /= busiest->group_capacity;
>> + load_above_capacity = busiest->sum_nr_running *
>> + SCHED_LOAD_SCALE;
>> + if (load_above_capacity > busiest->group_capacity)
>> + load_above_capacity -= busiest->group_capacity;
>> + else
>> + load_above_capacity = ~0UL;
>> }
>>
>> /*
>> @@ -6469,6 +6467,7 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
>> local = &sds.local_stat;
>> busiest = &sds.busiest_stat;
>>
>> + /* ASYM feature bypasses nice load balance check */
>> if ((env->idle == CPU_IDLE || env->idle == CPU_NEWLY_IDLE) &&
>> check_asym_packing(env, &sds))
>> return sds.busiest;
>> @@ -6489,8 +6488,8 @@ static struct sched_group *find_busiest_group(struct lb_env *env)
>> goto force_balance;
>>
>> /* SD_BALANCE_NEWIDLE trumps SMP nice when underutilized */
>> - if (env->idle == CPU_NEWLY_IDLE && local->group_has_free_capacity &&
>> - !busiest->group_has_free_capacity)
>> + if (env->idle == CPU_NEWLY_IDLE && group_has_capacity(env, local) &&
>> + busiest->group_no_capacity)
>> goto force_balance;
>>
>> /*
>> @@ -6549,7 +6548,7 @@ static struct rq *find_busiest_queue(struct lb_env *env,
>> int i;
>>
>> for_each_cpu_and(i, sched_group_cpus(group), env->cpus) {
>> - unsigned long capacity, capacity_factor, wl;
>> + unsigned long capacity, wl;
>> enum fbq_type rt;
>>
>> rq = cpu_rq(i);
>> @@ -6578,9 +6577,6 @@ static struct rq *find_busiest_queue(struct lb_env *env,
>> continue;
>>
>> capacity = capacity_of(i);
>> - capacity_factor = DIV_ROUND_CLOSEST(capacity, SCHED_CAPACITY_SCALE);
>> - if (!capacity_factor)
>> - capacity_factor = fix_small_capacity(env->sd, group);
>>
>> wl = weighted_cpuload(i);
>>
>> @@ -6588,7 +6584,9 @@ static struct rq *find_busiest_queue(struct lb_env *env,
>> * When comparing with imbalance, use weighted_cpuload()
>> * which is not scaled with the cpu capacity.
>> */
>> - if (capacity_factor && rq->nr_running == 1 && wl > env->imbalance)
>> +
>> + if (rq->nr_running == 1 && wl > env->imbalance &&
>> + !check_cpu_capacity(rq, env->sd))
>> continue;
>>
>> /*
>> diff --git a/kernel/sched/sched.h b/kernel/sched/sched.h
>> index aaaa3e4..8fd30c1 100644
>> --- a/kernel/sched/sched.h
>> +++ b/kernel/sched/sched.h
>> @@ -759,7 +759,7 @@ struct sched_group_capacity {
>> * CPU capacity of this group, SCHED_LOAD_SCALE being max capacity
>> * for a single CPU.
>> */
>> - unsigned int capacity, capacity_orig;
>> + unsigned int capacity;
>> unsigned long next_update;
>> int imbalance; /* XXX unrelated to capacity but shared group state */
>> /*
>> --
>> 1.9.1
>>
>>
>> _______________________________________________
>> linaro-kernel mailing list
>> linaro-kernel@lists.linaro.org
>> http://lists.linaro.org/mailman/listinfo/linaro-kernel


\
 
 \ /
  Last update: 2014-11-19 19:01    [W:0.073 / U:21.816 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site