lkml.org 
[lkml]   [2015]   [Sep]   [13]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
    Patch in this message
    /
    Date
    From
    Subject[tip:sched/core] sched/fair: Get rid of scaling utilization by capacity_orig
    Commit-ID:  231678b768da07d19ab5683a39eeb0c250631d02
    Gitweb: http://git.kernel.org/tip/231678b768da07d19ab5683a39eeb0c250631d02
    Author: Dietmar Eggemann <dietmar.eggemann@arm.com>
    AuthorDate: Fri, 14 Aug 2015 17:23:13 +0100
    Committer: Ingo Molnar <mingo@kernel.org>
    CommitDate: Sun, 13 Sep 2015 09:52:57 +0200

    sched/fair: Get rid of scaling utilization by capacity_orig

    Utilization is currently scaled by capacity_orig, but since we now have
    frequency and cpu invariant cfs_rq.avg.util_avg, frequency and cpu scaling
    now happens as part of the utilization tracking itself.
    So cfs_rq.avg.util_avg should no longer be scaled in cpu_util().

    Signed-off-by: Dietmar Eggemann <dietmar.eggemann@arm.com>
    Signed-off-by: Morten Rasmussen <morten.rasmussen@arm.com>
    Signed-off-by: Peter Zijlstra (Intel) <peterz@infradead.org>
    Cc: Juri Lelli <Juri.Lelli@arm.com>
    Cc: Linus Torvalds <torvalds@linux-foundation.org>
    Cc: Mike Galbraith <efault@gmx.de>
    Cc: Peter Zijlstra <peterz@infradead.org>
    Cc: Steve Muckle <steve.muckle@linaro.org>
    Cc: Thomas Gleixner <tglx@linutronix.de>
    Cc: daniel.lezcano@linaro.org <daniel.lezcano@linaro.org>
    Cc: mturquette@baylibre.com <mturquette@baylibre.com>
    Cc: pang.xunlei@zte.com.cn <pang.xunlei@zte.com.cn>
    Cc: rjw@rjwysocki.net <rjw@rjwysocki.net>
    Cc: sgurrappadi@nvidia.com <sgurrappadi@nvidia.com>
    Cc: vincent.guittot@linaro.org <vincent.guittot@linaro.org>
    Cc: yuyang.du@intel.com <yuyang.du@intel.com>
    Link: http://lkml.kernel.org/r/55EDAF43.30500@arm.com
    Signed-off-by: Ingo Molnar <mingo@kernel.org>
    ---
    kernel/sched/fair.c | 38 ++++++++++++++++++++++----------------
    1 file changed, 22 insertions(+), 16 deletions(-)

    diff --git a/kernel/sched/fair.c b/kernel/sched/fair.c
    index 1b56d63..047fd1c 100644
    --- a/kernel/sched/fair.c
    +++ b/kernel/sched/fair.c
    @@ -4862,33 +4862,39 @@ next:
    done:
    return target;
    }
    +
    /*
    * cpu_util returns the amount of capacity of a CPU that is used by CFS
    * tasks. The unit of the return value must be the one of capacity so we can
    * compare the utilization with the capacity of the CPU that is available for
    * CFS task (ie cpu_capacity).
    - * cfs.avg.util_avg is the sum of running time of runnable tasks on a
    - * CPU. It represents the amount of utilization of a CPU in the range
    - * [0..SCHED_LOAD_SCALE]. The utilization of a CPU can't be higher than the
    - * full capacity of the CPU because it's about the running time on this CPU.
    - * Nevertheless, cfs.avg.util_avg can be higher than SCHED_LOAD_SCALE
    - * because of unfortunate rounding in util_avg or just
    - * after migrating tasks until the average stabilizes with the new running
    - * time. So we need to check that the utilization stays into the range
    - * [0..cpu_capacity_orig] and cap if necessary.
    - * Without capping the utilization, a group could be seen as overloaded (CPU0
    - * utilization at 121% + CPU1 utilization at 80%) whereas CPU1 has 20% of
    - * available capacity.
    + *
    + * cfs_rq.avg.util_avg is the sum of running time of runnable tasks plus the
    + * recent utilization of currently non-runnable tasks on a CPU. It represents
    + * the amount of utilization of a CPU in the range [0..capacity_orig] where
    + * capacity_orig is the cpu_capacity available at the highest frequency
    + * (arch_scale_freq_capacity()).
    + * The utilization of a CPU converges towards a sum equal to or less than the
    + * current capacity (capacity_curr <= capacity_orig) of the CPU because it is
    + * the running time on this CPU scaled by capacity_curr.
    + *
    + * Nevertheless, cfs_rq.avg.util_avg can be higher than capacity_curr or even
    + * higher than capacity_orig because of unfortunate rounding in
    + * cfs.avg.util_avg or just after migrating tasks and new task wakeups until
    + * the average stabilizes with the new running time. We need to check that the
    + * utilization stays within the range of [0..capacity_orig] and cap it if
    + * necessary. Without utilization capping, a group could be seen as overloaded
    + * (CPU0 utilization at 121% + CPU1 utilization at 80%) whereas CPU1 has 20% of
    + * available capacity. We allow utilization to overshoot capacity_curr (but not
    + * capacity_orig) as it useful for predicting the capacity required after task
    + * migrations (scheduler-driven DVFS).
    */
    static int cpu_util(int cpu)
    {
    unsigned long util = cpu_rq(cpu)->cfs.avg.util_avg;
    unsigned long capacity = capacity_orig_of(cpu);

    - if (util >= SCHED_LOAD_SCALE)
    - return capacity;
    -
    - return (util * capacity) >> SCHED_LOAD_SHIFT;
    + return (util >= capacity) ? capacity : util;
    }

    /*

    \
     
     \ /
      Last update: 2015-09-13 13:21    [W:4.139 / U:0.028 seconds]
    ©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site