linux-kernel - Re: [PATCH v6 04/11] cpufreq/schedutil: use rt utilization tracking

lists.openwall.net		lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC
Open Source and information security mailing list archives

Hash Suite: Windows password security audit tool. GUI, reports in PDF.

[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]

Message-ID: <20180622113713.GJ2494@hirez.programming.kicks-ass.net>
Date:   Fri, 22 Jun 2018 13:37:13 +0200
From:   Peter Zijlstra <peterz@...radead.org>
To:     Quentin Perret <quentin.perret@....com>
Cc:     Vincent Guittot <vincent.guittot@...aro.org>, mingo@...nel.org,
        linux-kernel@...r.kernel.org, rjw@...ysocki.net,
        juri.lelli@...hat.com, dietmar.eggemann@....com,
        Morten.Rasmussen@....com, viresh.kumar@...aro.org,
        valentin.schneider@....com, patrick.bellasi@....com,
        joel@...lfernandes.org, daniel.lezcano@...aro.org,
        Ingo Molnar <mingo@...hat.com>
Subject: Re: [PATCH v6 04/11] cpufreq/schedutil: use rt utilization tracking

On Fri, Jun 22, 2018 at 08:58:53AM +0100, Quentin Perret wrote:
> Say we have 50% of the capacity stolen by RT, and a 25% CFS task
> running. If we re-scale, we'll end up with a 50% request for CFS
> (util==512 for your code above). But if we want to see a little bit
> of idle time in the system, we should really request an OPP for 75%+ of
> capacity no ? Or am I missing something ?

That is true.. So we could limit the scaling to the case where there is
no idle time, something like:

	util = sg_cpu->util_cfs;

	cap_cfs = (1024 - (sg_cpu->util_rt + ...));
	if (util == cap_cfs)
		util = sg_cpu->max;

That specifically handles the '0% idle -> 100% freq' case, but I don't
realy like edge behaviour like that. If for some reason it all doesn't
quite align you're left with bits.

And the linear scaling is the next simplest thing that avoids the hard
boundary case.

I suppose we can make it more complicated, something like:

             u           u
  f := u + (--- - u) * (---)^n
            1-r         1-r

Where: u := cfs util
       r := \Sum !cfs util
       f := frequency request

That would still satisfy all criteria I think:

  r = 0      -> f := u
  u = (1-r)  -> f := 1

and in particular:

  u << (1-r) -> f ~= u

which casuses less inflation than the linear thing where there is idle
time.

In your specific example that ends up with:

             .25           .25
  f = .25 + (--- - .25) * (---)^n = .25 + .0625 (for n=2)
             .5            .5     = .25 + .125  (for n=1)

But is that needed complexity?