lkml.org 
[lkml]   [2011]   [May]   [1]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    From
    Subject[PATCH v1 13/19] sched: update f_b_g() to use u64 for weights
    Date
    This patch updates f_b_g() and helper functions to use u64 to handle the
    increased sched load resolution.

    Signed-off-by: Nikhil Rao <ncrao@google.com>
    ---
    kernel/sched_fair.c | 51 +++++++++++++++++++++++++++------------------------
    1 files changed, 27 insertions(+), 24 deletions(-)

    diff --git a/kernel/sched_fair.c b/kernel/sched_fair.c
    index 152b472..3e01c8d 100644
    --- a/kernel/sched_fair.c
    +++ b/kernel/sched_fair.c
    @@ -2946,12 +2946,13 @@ static int check_asym_packing(struct sched_domain *sd,
    static inline void fix_small_imbalance(struct sd_lb_stats *sds,
    int this_cpu, unsigned long *imbalance)
    {
    - unsigned long tmp, pwr_now = 0, pwr_move = 0;
    + u64 tmp, pwr_now = 0, pwr_move = 0;
    unsigned int imbn = 2;
    unsigned long scaled_busy_load_per_task;

    if (sds->this_nr_running) {
    - sds->this_load_per_task /= sds->this_nr_running;
    + sds->this_load_per_task = div_u64(sds->this_load_per_task,
    + sds->this_nr_running);
    if (sds->busiest_load_per_task >
    sds->this_load_per_task)
    imbn = 1;
    @@ -2959,9 +2960,9 @@ static inline void fix_small_imbalance(struct sd_lb_stats *sds,
    sds->this_load_per_task =
    cpu_avg_load_per_task(this_cpu);

    - scaled_busy_load_per_task = sds->busiest_load_per_task
    - * SCHED_POWER_SCALE;
    - scaled_busy_load_per_task /= sds->busiest->cpu_power;
    + scaled_busy_load_per_task =
    + div_u64(sds->busiest_load_per_task * SCHED_POWER_SCALE,
    + sds->busiest->cpu_power);

    if (sds->max_load - sds->this_load + scaled_busy_load_per_task >=
    (scaled_busy_load_per_task * imbn)) {
    @@ -2979,11 +2980,11 @@ static inline void fix_small_imbalance(struct sd_lb_stats *sds,
    min(sds->busiest_load_per_task, sds->max_load);
    pwr_now += sds->this->cpu_power *
    min(sds->this_load_per_task, sds->this_load);
    - pwr_now /= SCHED_POWER_SCALE;
    + pwr_now = div_u64(pwr_now, SCHED_POWER_SCALE);

    /* Amount of load we'd subtract */
    - tmp = (sds->busiest_load_per_task * SCHED_POWER_SCALE) /
    - sds->busiest->cpu_power;
    + tmp = div_u64(sds->busiest_load_per_task * SCHED_POWER_SCALE,
    + sds->busiest->cpu_power);
    if (sds->max_load > tmp)
    pwr_move += sds->busiest->cpu_power *
    min(sds->busiest_load_per_task, sds->max_load - tmp);
    @@ -2991,14 +2992,15 @@ static inline void fix_small_imbalance(struct sd_lb_stats *sds,
    /* Amount of load we'd add */
    if (sds->max_load * sds->busiest->cpu_power <
    sds->busiest_load_per_task * SCHED_POWER_SCALE)
    - tmp = (sds->max_load * sds->busiest->cpu_power) /
    - sds->this->cpu_power;
    + tmp = div_u64(sds->max_load * sds->busiest->cpu_power,
    + sds->this->cpu_power);
    else
    - tmp = (sds->busiest_load_per_task * SCHED_POWER_SCALE) /
    - sds->this->cpu_power;
    + tmp = div_u64(sds->busiest_load_per_task * SCHED_POWER_SCALE,
    + sds->this->cpu_power);
    +
    pwr_move += sds->this->cpu_power *
    min(sds->this_load_per_task, sds->this_load + tmp);
    - pwr_move /= SCHED_POWER_SCALE;
    + pwr_move = div_u64(pwr_move, SCHED_POWER_SCALE);

    /* Move if we gain throughput */
    if (pwr_move > pwr_now)
    @@ -3015,9 +3017,10 @@ static inline void fix_small_imbalance(struct sd_lb_stats *sds,
    static inline void calculate_imbalance(struct sd_lb_stats *sds, int this_cpu,
    unsigned long *imbalance)
    {
    - unsigned long max_pull, load_above_capacity = ~0UL;
    + u64 max_pull, load_above_capacity = ~0ULL;

    - sds->busiest_load_per_task /= sds->busiest_nr_running;
    + sds->busiest_load_per_task = div_u64(sds->busiest_load_per_task,
    + sds->busiest_nr_running);
    if (sds->group_imb) {
    sds->busiest_load_per_task =
    min(sds->busiest_load_per_task, sds->avg_load);
    @@ -3034,15 +3037,15 @@ static inline void calculate_imbalance(struct sd_lb_stats *sds, int this_cpu,
    }

    if (!sds->group_imb) {
    + unsigned long imb_capacity = (sds->busiest_nr_running -
    + sds->busiest_group_capacity);
    /*
    * Don't want to pull so many tasks that a group would go idle.
    */
    - load_above_capacity = (sds->busiest_nr_running -
    - sds->busiest_group_capacity);
    -
    - load_above_capacity *= (SCHED_LOAD_SCALE * SCHED_POWER_SCALE);
    -
    - load_above_capacity /= sds->busiest->cpu_power;
    + load_above_capacity = NICE_0_LOAD * imb_capacity;
    + load_above_capacity =
    + div_u64(load_above_capacity * SCHED_POWER_SCALE,
    + sds->busiest->cpu_power);
    }

    /*
    @@ -3059,8 +3062,8 @@ static inline void calculate_imbalance(struct sd_lb_stats *sds, int this_cpu,

    /* How much load to actually move to equalise the imbalance */
    *imbalance = min(max_pull * sds->busiest->cpu_power,
    - (sds->avg_load - sds->this_load) * sds->this->cpu_power)
    - / SCHED_POWER_SCALE;
    + (sds->avg_load - sds->this_load)*sds->this->cpu_power);
    + *imbalance = div_u64(*imbalance, SCHED_POWER_SCALE);

    /*
    * if *imbalance is less than the average load per runnable task
    @@ -3129,7 +3132,7 @@ find_busiest_group(struct sched_domain *sd, int this_cpu,
    if (!sds.busiest || sds.busiest_nr_running == 0)
    goto out_balanced;

    - sds.avg_load = (SCHED_POWER_SCALE * sds.total_load) / sds.total_pwr;
    + sds.avg_load = div_u64(sds.total_load*SCHED_POWER_SCALE, sds.total_pwr);

    /*
    * If the busiest group is imbalanced the below checks don't
    --
    1.7.3.1


    \
     
     \ /
      Last update: 2011-05-02 03:23    [W:0.035 / U:120.900 seconds]
    ©2003-2016 Jasper Spaans. hosted at Digital OceanAdvertise on this site