[v2,3/3] cpufreq: schedutil: map raw required frequency to driver frequency

On 29-05-16, 02:40, Rafael J. Wysocki wrote:
> I can't really parse the above question, so I'm not going to try to

> answer it. :-)


Sorry about that :(

IOW, I think that we should make this change into the sched-governor (I will
send a patch separately if you agree to this):

And here is my reasoning behind this.

Can you show me any case, where the above code (as present in mainline
today) leads to a freq-change? I couldn't find any.

Let me demonstrate.

Following only talks about the fast-switch path, the other path is
same as well.

Suppose this is the current range of frequencies supported by a
driver: 200, 400, 600, 800, 1000 (in MHz).

And policy->cur = next_freq = 400 MHz.

A.) Suppose that we change policy->min to 400 MHz from userspace.
    -> sugov_limits()
       This will find everything in order and simply set
       need_freq_update, without updating the frequency.

    On next util-callback, we will forcefully return true from
    sugov_should_update_freq() and reach sugov_update_commit().

    We calculate next_freq and that comes to 400 MHz again (that's the
    case we are trying to target with the above code).

    With the current code, we will forcefully end up calling
    cpufreq_driver_fast_switch().

    Because the new and current frequencies are same,
    cpufreq_driver->fast_switch() will simply return.

    NOTE: I also think that cpufreq_driver_fast_switch() should have a
    check like (policy->cur == target_freq). I will add that too, in
    case you agree.

    So, forcefully updating next_freq to UINT_MAX will end up wasting
    some cycles, but wouldn't do any useful stuff.

B.) Suppose that we change policy->min to 600 MHz from userspace.
    -> sugov_limits()
       This will find that policy->cur is less than 600 and will set
       that to 600 MHz by calling __cpufreq_driver_target(). We will
       also set need_freq_update.

       Note that next_freq and policy->cur are not in sync anymore and
       perhaps this is the most important case for the above code.

    On next util-callback, we will forcefully return true from
    sugov_should_update_freq() and reach sugov_update_commit().

    We calculate next_freq and lets say that comes to 400 MHz again
    (as that's the case we are trying to target with the above code).

    With the current code, we will forcefully end up calling
    cpufreq_driver_fast_switch().

    Because next_freq() is not part of the new range, we will clamp it
    and set it to 600 MHz eventually. Again, next and current
    frequencies are same, cpufreq_driver->fast_switch() will simply
    return.

    So, forcefully updating next_freq to UINT_MAX will end up wasting
    some cycles here as well, but would do any useful stuff.


What am I missing ?

-- 
viresh
--
To unsubscribe from this list: send the line "unsubscribe linux-pm" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

I clearly missed the !policy->fast_switch_enabled check in sugov_limit() and so
the confusion.

On 30-05-16, 16:25, Rafael J. Wysocki wrote:
> On Mon, May 30, 2016 at 12:18 PM, Viresh Kumar <viresh.kumar@linaro.org> wrote:

> > Suppose this is the current range of frequencies supported by a

> > driver: 200, 400, 600, 800, 1000 (in MHz).

> >

> > And policy->cur = next_freq = 400 MHz.

> >

> > A.) Suppose that we change policy->min to 400 MHz from userspace.

> >     -> sugov_limits()

> >        This will find everything in order and simply set

> >        need_freq_update, without updating the frequency.

> >

> >     On next util-callback, we will forcefully return true from

> >     sugov_should_update_freq() and reach sugov_update_commit().

> >

> >     We calculate next_freq and that comes to 400 MHz again (that's the

> >     case we are trying to target with the above code).

> >

> >     With the current code, we will forcefully end up calling

> >     cpufreq_driver_fast_switch().

> >

> >     Because the new and current frequencies are same,

> >     cpufreq_driver->fast_switch() will simply return.

> >

> >     NOTE: I also think that cpufreq_driver_fast_switch() should have a

> >     check like (policy->cur == target_freq). I will add that too, in

> >     case you agree.

> >

> >     So, forcefully updating next_freq to UINT_MAX will end up wasting

> >     some cycles, but wouldn't do any useful stuff.

> 

> It will, but there's no way to distinguish this case from B in the

> governor with the current min/max synchronization mechanism.  That is,

> it only knows that something has changed, but checking what exactly

> has changed would be racy.

> 

> > B.) Suppose that we change policy->min to 600 MHz from userspace.

> >     -> sugov_limits()

> >        This will find that policy->cur is less than 600 and will set

> >        that to 600 MHz by calling __cpufreq_driver_target(). We will

> >        also set need_freq_update.

> >

> >        Note that next_freq and policy->cur are not in sync anymore and

> >        perhaps this is the most important case for the above code.

> 

> It is.

> 

> Moreover, please note that __cpufreq_driver_target() is only called in

> sugov_limits() when policy->fast_switch_enabled is unset.


Yep, I missed it.

I am not sure how harmful it can be, but we are returning from sugov_limits()
without making sure that policy->cur is in valid range currently. I also know
that you left it out because of the possible races with the util handler.

But this is something that is fundamentally broken for now. The user writes
updates the policy->max/min, we return the call to the user thinks that it has
successfully written to the file and everything is aligned. But we may be
running at an frequency from invalid range. Yes, that will happen very soon, but
its broken.

-- 
viresh
--
To unsubscribe from this list: send the line "unsubscribe linux-pm" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html