Introducing AArch64 specific version of arch_freq_get_on_cpu, cashing on
existing implementation for FIE and AMUv1 support.
Additionally wiring it up with cpufreq_verify_current_freq to hopefully
eliminate issues when cpufreq_driver->get() returns frequency that is not
entirely aligned.
The changes have been rather lightly (due to some limitations) tested on
an FVP model.
v2:
- Splitting the patches
- Adding comment for full dyntick mode
- Plugging arch_freq_get_on_cpu into cpufreq_verify_current_freq instead
of in show_cpuinfo_cur_freq to allow the framework to stay more in sync
with potential freq changes
[1]
https://lore.kernel.org/lkml/[email protected]/
Beata Michalska (1):
arm64: Provide an AMU-based version of arch_freq_get_on_cpu
Sumit Gupta (1):
cpufreq: Wire-up arch-flavored freq info into
cpufreq_verify_current_freq
arch/arm64/kernel/topology.c | 39 ++++++++++++++++++++++++++++++++++++
drivers/cpufreq/cpufreq.c | 3 ++-
2 files changed, 41 insertions(+), 1 deletion(-)
--
2.25.1
From: Sumit Gupta <[email protected]>
When available, use arch_freq_get_on_cpu to obtain current frequency
(usually an average reported over given period of time)
to better align the cpufreq's view on the current state of affairs.
This also automatically pulls in the update for cpuinfo_cur_freq sysfs
attribute, aligning it with the scaling_cur_freq one, and thus providing
consistent view on relevant platforms.
Signed-off-by: Sumit Gupta <[email protected]>
[BM: Subject & commit msg]
Signed-off-by: Beata Michalska <[email protected]>
---
drivers/cpufreq/cpufreq.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 8c4f9c2f9c44..109559438f45 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
{
unsigned int new_freq;
- new_freq = cpufreq_driver->get(policy->cpu);
+ new_freq = arch_freq_get_on_cpu(policy->cpu);
+ new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
if (!new_freq)
return 0;
--
2.25.1
With the Frequency Invariance Engine (FIE) being already wired up with
sched tick and making use of relevant (core counter and constant
counter) AMU counters, getting the current frequency for a given CPU
on supported platforms, can be achieved by utilizing the frequency scale
factor which reflects an average CPU frequency for the last tick period
length.
Suggested-by: Ionela Voinescu <[email protected]>
Signed-off-by: Beata Michalska <[email protected]>
Reviewed-by: Sudeep Holla <[email protected]>
---
Notes:
Due to [1], if merged, there might be a need to modify the patch to
accommodate changes [1] introduces:
freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT
to
freq = per_cpu(capacity_freq_ref, cpu); >> SCHED_CAPACITY_SHIFT
[1]
https://lore.kernel.org/linux-arm-kernel/20231121154349.GA1938@willie-the-truck/T/#mcb018d076dbce6f60ed2779634a9b6ffe622641e
arch/arm64/kernel/topology.c | 39 ++++++++++++++++++++++++++++++++++++
1 file changed, 39 insertions(+)
diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
index 615c1a20129f..ae2445f6e7da 100644
--- a/arch/arm64/kernel/topology.c
+++ b/arch/arm64/kernel/topology.c
@@ -17,6 +17,7 @@
#include <linux/cpufreq.h>
#include <linux/init.h>
#include <linux/percpu.h>
+#include <linux/sched/isolation.h>
#include <asm/cpu.h>
#include <asm/cputype.h>
@@ -186,6 +187,44 @@ static void amu_scale_freq_tick(void)
this_cpu_write(arch_freq_scale, (unsigned long)scale);
}
+unsigned int arch_freq_get_on_cpu(int cpu)
+{
+ unsigned int freq;
+ u64 scale;
+
+ if (!cpumask_test_cpu(cpu, amu_fie_cpus))
+ return 0;
+
+ /*
+ * For those CPUs that are in full dynticks mode, try an alternative
+ * source for the counters (and thus freq scale),
+ * if available for given policy
+ */
+ if (!housekeeping_cpu(cpu, HK_TYPE_TICK)) {
+ struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
+ int ref_cpu = nr_cpu_ids;
+
+ if (cpumask_intersects(housekeeping_cpumask(HK_TYPE_TICK),
+ policy->cpus))
+ ref_cpu = cpumask_nth_and(cpu, policy->cpus,
+ housekeeping_cpumask(HK_TYPE_TICK));
+ cpufreq_cpu_put(policy);
+ if (ref_cpu >= nr_cpu_ids)
+ return 0;
+ cpu = ref_cpu;
+ }
+
+ /*
+ * Reversed computation to the one used to determine
+ * the arch_freq_scale value
+ * (see amu_scale_freq_tick for details)
+ */
+ scale = per_cpu(arch_freq_scale, cpu);
+ freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT;
+ freq *= scale;
+ return freq;
+}
+
static struct scale_freq_data amu_sfd = {
.source = SCALE_FREQ_SOURCE_ARCH,
.set_freq_scale = amu_scale_freq_tick,
--
2.25.1
Hi Beata, Sumit,
On Monday 27 Nov 2023 at 16:08:38 (+0000), Beata Michalska wrote:
> From: Sumit Gupta <[email protected]>
>
> When available, use arch_freq_get_on_cpu to obtain current frequency
> (usually an average reported over given period of time)
> to better align the cpufreq's view on the current state of affairs.
> This also automatically pulls in the update for cpuinfo_cur_freq sysfs
> attribute, aligning it with the scaling_cur_freq one, and thus providing
> consistent view on relevant platforms.
>
> Signed-off-by: Sumit Gupta <[email protected]>
> [BM: Subject & commit msg]
> Signed-off-by: Beata Michalska <[email protected]>
> ---
> drivers/cpufreq/cpufreq.c | 3 ++-
> 1 file changed, 2 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
> index 8c4f9c2f9c44..109559438f45 100644
> --- a/drivers/cpufreq/cpufreq.c
> +++ b/drivers/cpufreq/cpufreq.c
> @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
> {
> unsigned int new_freq;
>
> - new_freq = cpufreq_driver->get(policy->cpu);
> + new_freq = arch_freq_get_on_cpu(policy->cpu);
> + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
Given that arch_freq_get_on_cpu() is an average frequency, it does not
seem right to me to trigger the sync & update process of
cpufreq_verify_current_freq() based on it.
cpufreq_verify_current_freq() will at least modify the internal state of
the policy and send PRE and POST notifications, if not do a full frequency
update, based on this average frequency, which is likely different from
the current frequency, even beyond the 1MHz threshold.
While I believe it's okay to return this average frequency in
cpuinfo_cur_freq, I don't think it should be used as an indication of
an accurate current frequency, which is what
cpufreq_verify_current_freq() expects.
Sumit, can you give more details on the issue at [1] and why this change
fixes it?
[1] https://lore.kernel.org/lkml/[email protected]/
Thank you,
Ionela.
> if (!new_freq)
> return 0;
>
> --
> 2.25.1
>
Hi Beata,
On Monday 27 Nov 2023 at 16:08:37 (+0000), Beata Michalska wrote:
> With the Frequency Invariance Engine (FIE) being already wired up with
> sched tick and making use of relevant (core counter and constant
> counter) AMU counters, getting the current frequency for a given CPU
> on supported platforms, can be achieved by utilizing the frequency scale
> factor which reflects an average CPU frequency for the last tick period
> length.
>
> Suggested-by: Ionela Voinescu <[email protected]>
> Signed-off-by: Beata Michalska <[email protected]>
> Reviewed-by: Sudeep Holla <[email protected]>
> ---
>
> Notes:
> Due to [1], if merged, there might be a need to modify the patch to
> accommodate changes [1] introduces:
>
> freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT
> to
> freq = per_cpu(capacity_freq_ref, cpu); >> SCHED_CAPACITY_SHIFT
> [1]
> https://lore.kernel.org/linux-arm-kernel/20231121154349.GA1938@willie-the-truck/T/#mcb018d076dbce6f60ed2779634a9b6ffe622641e
>
> arch/arm64/kernel/topology.c | 39 ++++++++++++++++++++++++++++++++++++
> 1 file changed, 39 insertions(+)
>
> diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
> index 615c1a20129f..ae2445f6e7da 100644
> --- a/arch/arm64/kernel/topology.c
> +++ b/arch/arm64/kernel/topology.c
> @@ -17,6 +17,7 @@
> #include <linux/cpufreq.h>
> #include <linux/init.h>
> #include <linux/percpu.h>
> +#include <linux/sched/isolation.h>
>
> #include <asm/cpu.h>
> #include <asm/cputype.h>
> @@ -186,6 +187,44 @@ static void amu_scale_freq_tick(void)
> this_cpu_write(arch_freq_scale, (unsigned long)scale);
> }
>
> +unsigned int arch_freq_get_on_cpu(int cpu)
> +{
> + unsigned int freq;
> + u64 scale;
> +
> + if (!cpumask_test_cpu(cpu, amu_fie_cpus))
> + return 0;
> +
> + /*
> + * For those CPUs that are in full dynticks mode, try an alternative
> + * source for the counters (and thus freq scale),
> + * if available for given policy
> + */
> + if (!housekeeping_cpu(cpu, HK_TYPE_TICK)) {
> + struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
> + int ref_cpu = nr_cpu_ids;
> +
> + if (cpumask_intersects(housekeeping_cpumask(HK_TYPE_TICK),
> + policy->cpus))
> + ref_cpu = cpumask_nth_and(cpu, policy->cpus,
> + housekeeping_cpumask(HK_TYPE_TICK));
> + cpufreq_cpu_put(policy);
> + if (ref_cpu >= nr_cpu_ids)
> + return 0;
> + cpu = ref_cpu;
> + }
> +
> + /*
> + * Reversed computation to the one used to determine
> + * the arch_freq_scale value
> + * (see amu_scale_freq_tick for details)
> + */
> + scale = per_cpu(arch_freq_scale, cpu);
Any reason for not using arch_scale_freq_capacity() here?
To me it seems a bit nicer to use the "official" function to return the
frequency scale factor.
> + freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT;
Given Vincent's patch at [1] I think here might be best to call
arch_scale_freq_ref() instead. That's because the frequency scale factor
will use that frequency as the maximum frequency in its calculations and
we'd not want to use a different one here.
The annoyance is coping with capacity_freq_ref not having been set
yet, and that would be easy if capacity_freq_ref was initialized to 0.
Luckily with Vincent's changes it can now be 0. I'll comments on his
patches and ask him to make this change.
So I think you can safely use arch_scale_freq_ref() here. If
arch_scale_freq_ref() returns 0, arch_freq_get_on_cpu() will just return
0 as well.
[1] https://lore.kernel.org/lkml/[email protected]/
> + freq *= scale;
In some scenarios the frequencies visible to cpufreq might not look like
actual frequencies, but some scaled abstract performance values. One
example is cppc_cpufreq when one does not provide the optional frequency
information in the CPC objects but just the performance information.
Therefore the maximum frequency seen here can be quite a small value, so
it might be best to do the multiplication first and the shift after that.
Thanks,
Ionela.
> + return freq;
> +}
> +
> static struct scale_freq_data amu_sfd = {
> .source = SCALE_FREQ_SOURCE_ARCH,
> .set_freq_scale = amu_scale_freq_tick,
> --
> 2.25.1
>
Hi Ionela,
>> --- a/drivers/cpufreq/cpufreq.c
>> +++ b/drivers/cpufreq/cpufreq.c
>> @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
>> {
>> unsigned int new_freq;
>>
>> - new_freq = cpufreq_driver->get(policy->cpu);
>> + new_freq = arch_freq_get_on_cpu(policy->cpu);
>> + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
>
> Given that arch_freq_get_on_cpu() is an average frequency, it does not
> seem right to me to trigger the sync & update process of
> cpufreq_verify_current_freq() based on it.
>
> cpufreq_verify_current_freq() will at least modify the internal state of
> the policy and send PRE and POST notifications, if not do a full frequency
> update, based on this average frequency, which is likely different from
> the current frequency, even beyond the 1MHz threshold.
>
> While I believe it's okay to return this average frequency in
> cpuinfo_cur_freq, I don't think it should be used as an indication of
> an accurate current frequency, which is what
> cpufreq_verify_current_freq() expects.
>
> Sumit, can you give more details on the issue at [1] and why this change
> fixes it?
>
> [1] https://lore.kernel.org/lkml/[email protected]/
>
> Thank you,
> Ionela.
>
cpufreq_verify_current_freq() also updates 'policy->cur' in POST
notification if the frequency from hardware has more delta (out of sync).
As the value from 'cpufreq_driver->get()' is not reliable due to [1],
calling the 'get' hook can update the 'policy->cur' with a wrong value
when governor starts in cpufreq_start_governor().
And if the frequency is never changed after the governor starts during
boot e.g. when performance governor is set as default, then
'scaling_cur_freq' always returns wrong value.
Instead, the arch_freq_get_on_cpu() API updates 'policy->cur' with a
more stable freq value.
[1] https://lore.kernel.org/lkml/[email protected]/
Best regards,
Sumit Gupta
>> if (!new_freq)
>> return 0;
>>
>> --
>> 2.25.1
>>
Hi Sumit,
On Friday 01 Dec 2023 at 18:32:10 (+0530), Sumit Gupta wrote:
> Hi Ionela,
>
> > > --- a/drivers/cpufreq/cpufreq.c
> > > +++ b/drivers/cpufreq/cpufreq.c
> > > @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
> > > {
> > > unsigned int new_freq;
> > >
> > > - new_freq = cpufreq_driver->get(policy->cpu);
> > > + new_freq = arch_freq_get_on_cpu(policy->cpu);
> > > + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
> >
> > Given that arch_freq_get_on_cpu() is an average frequency, it does not
> > seem right to me to trigger the sync & update process of
> > cpufreq_verify_current_freq() based on it.
> >
> > cpufreq_verify_current_freq() will at least modify the internal state of
> > the policy and send PRE and POST notifications, if not do a full frequency
> > update, based on this average frequency, which is likely different from
> > the current frequency, even beyond the 1MHz threshold.
> >
> > While I believe it's okay to return this average frequency in
> > cpuinfo_cur_freq, I don't think it should be used as an indication of
> > an accurate current frequency, which is what
> > cpufreq_verify_current_freq() expects.
> >
> > Sumit, can you give more details on the issue at [1] and why this change
> > fixes it?
> >
> > [1] https://lore.kernel.org/lkml/[email protected]/
> >
> > Thank you,
> > Ionela.
> >
> cpufreq_verify_current_freq() also updates 'policy->cur' in POST
> notification if the frequency from hardware has more delta (out of sync).
>
> As the value from 'cpufreq_driver->get()' is not reliable due to [1],
> calling the 'get' hook can update the 'policy->cur' with a wrong value when
> governor starts in cpufreq_start_governor().
> And if the frequency is never changed after the governor starts during
> boot e.g. when performance governor is set as default, then
> 'scaling_cur_freq' always returns wrong value.
>
> Instead, the arch_freq_get_on_cpu() API updates 'policy->cur' with a more
> stable freq value.
>
> [1] https://lore.kernel.org/lkml/[email protected]/
Got it, many thanks!
As the code is right now in v2, arch_freq_get_on_cpu() is called on
show_scaling_cur_freq(), so the problem you describe would not show up.
policy->cur would still be incorrect, but 'scaling_cur_freq' would
return the value from arch_freq_get_on_cpu().
Would it be enough if arch_freq_get_on_cpu() gets also called from
show_cpuinfo_cur_freq() instead of cpufreq_verify_current_freq()?
Thanks,
Ionela.
>
> Best regards,
> Sumit Gupta
>
> > > if (!new_freq)
> > > return 0;
> > >
> > > --
> > > 2.25.1
> > >
On 05/12/23 16:35, Ionela Voinescu wrote:
> External email: Use caution opening links or attachments
>
>
> Hi Sumit,
>
> On Friday 01 Dec 2023 at 18:32:10 (+0530), Sumit Gupta wrote:
>> Hi Ionela,
>>
>>>> --- a/drivers/cpufreq/cpufreq.c
>>>> +++ b/drivers/cpufreq/cpufreq.c
>>>> @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
>>>> {
>>>> unsigned int new_freq;
>>>>
>>>> - new_freq = cpufreq_driver->get(policy->cpu);
>>>> + new_freq = arch_freq_get_on_cpu(policy->cpu);
>>>> + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
>>>
>>> Given that arch_freq_get_on_cpu() is an average frequency, it does not
>>> seem right to me to trigger the sync & update process of
>>> cpufreq_verify_current_freq() based on it.
>>>
>>> cpufreq_verify_current_freq() will at least modify the internal state of
>>> the policy and send PRE and POST notifications, if not do a full frequency
>>> update, based on this average frequency, which is likely different from
>>> the current frequency, even beyond the 1MHz threshold.
>>>
>>> While I believe it's okay to return this average frequency in
>>> cpuinfo_cur_freq, I don't think it should be used as an indication of
>>> an accurate current frequency, which is what
>>> cpufreq_verify_current_freq() expects.
>>>
>>> Sumit, can you give more details on the issue at [1] and why this change
>>> fixes it?
>>>
>>> [1] https://lore.kernel.org/lkml/[email protected]/
>>>
>>> Thank you,
>>> Ionela.
>>>
>> cpufreq_verify_current_freq() also updates 'policy->cur' in POST
>> notification if the frequency from hardware has more delta (out of sync).
>>
>> As the value from 'cpufreq_driver->get()' is not reliable due to [1],
>> calling the 'get' hook can update the 'policy->cur' with a wrong value when
>> governor starts in cpufreq_start_governor().
>> And if the frequency is never changed after the governor starts during
>> boot e.g. when performance governor is set as default, then
>> 'scaling_cur_freq' always returns wrong value.
>>
>> Instead, the arch_freq_get_on_cpu() API updates 'policy->cur' with a more
>> stable freq value.
>>
>> [1] https://lore.kernel.org/lkml/[email protected]/
>
> Got it, many thanks!
>
> As the code is right now in v2, arch_freq_get_on_cpu() is called on
> show_scaling_cur_freq(), so the problem you describe would not show up.
> policy->cur would still be incorrect, but 'scaling_cur_freq' would
> return the value from arch_freq_get_on_cpu().
>
> Would it be enough if arch_freq_get_on_cpu() gets also called from
> show_cpuinfo_cur_freq() instead of cpufreq_verify_current_freq()?
>
> Thanks,
> Ionela.
>
Yes.
I am not sure if making both the nodes 'scaling_cur_freq' and
'cpuinfo_cur_freq' same is fine?
Best Regards,
Sumit Gupta
On Mon, Nov 27, 2023 at 5:09 PM Beata Michalska <[email protected]> wrote:
>
> From: Sumit Gupta <[email protected]>
>
> When available, use arch_freq_get_on_cpu to obtain current frequency
> (usually an average reported over given period of time)
> to better align the cpufreq's view on the current state of affairs.
And why is this a good idea?
Any problem statement?
> This also automatically pulls in the update for cpuinfo_cur_freq sysfs
> attribute, aligning it with the scaling_cur_freq one, and thus providing
> consistent view on relevant platforms.
I have no idea what the above is supposed to mean, sorry.
> Signed-off-by: Sumit Gupta <[email protected]>
> [BM: Subject & commit msg]
> Signed-off-by: Beata Michalska <[email protected]>
> ---
> drivers/cpufreq/cpufreq.c | 3 ++-
> 1 file changed, 2 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
> index 8c4f9c2f9c44..109559438f45 100644
> --- a/drivers/cpufreq/cpufreq.c
> +++ b/drivers/cpufreq/cpufreq.c
> @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
> {
> unsigned int new_freq;
>
> - new_freq = cpufreq_driver->get(policy->cpu);
> + new_freq = arch_freq_get_on_cpu(policy->cpu);
> + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
Please don't use ?: in general and it is not even useful here AFAICS.
What would be wrong with
new_freq = arch_freq_get_on_cpu(policy->cpu);
if (!new_freq)
new_freq = cpufreq_driver->get(policy->cpu);
?
> if (!new_freq)
> return 0;
>
> --
On Wednesday 06 Dec 2023 at 18:58:17 (+0530), Sumit Gupta wrote:
>
>
> On 05/12/23 16:35, Ionela Voinescu wrote:
> > External email: Use caution opening links or attachments
> >
> >
> > Hi Sumit,
> >
> > On Friday 01 Dec 2023 at 18:32:10 (+0530), Sumit Gupta wrote:
> > > Hi Ionela,
> > >
> > > > > --- a/drivers/cpufreq/cpufreq.c
> > > > > +++ b/drivers/cpufreq/cpufreq.c
> > > > > @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
> > > > > {
> > > > > unsigned int new_freq;
> > > > >
> > > > > - new_freq = cpufreq_driver->get(policy->cpu);
> > > > > + new_freq = arch_freq_get_on_cpu(policy->cpu);
> > > > > + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
> > > >
> > > > Given that arch_freq_get_on_cpu() is an average frequency, it does not
> > > > seem right to me to trigger the sync & update process of
> > > > cpufreq_verify_current_freq() based on it.
> > > >
> > > > cpufreq_verify_current_freq() will at least modify the internal state of
> > > > the policy and send PRE and POST notifications, if not do a full frequency
> > > > update, based on this average frequency, which is likely different from
> > > > the current frequency, even beyond the 1MHz threshold.
> > > >
> > > > While I believe it's okay to return this average frequency in
> > > > cpuinfo_cur_freq, I don't think it should be used as an indication of
> > > > an accurate current frequency, which is what
> > > > cpufreq_verify_current_freq() expects.
> > > >
> > > > Sumit, can you give more details on the issue at [1] and why this change
> > > > fixes it?
> > > >
> > > > [1] https://lore.kernel.org/lkml/[email protected]/
> > > >
> > > > Thank you,
> > > > Ionela.
> > > >
> > > cpufreq_verify_current_freq() also updates 'policy->cur' in POST
> > > notification if the frequency from hardware has more delta (out of sync).
> > >
> > > As the value from 'cpufreq_driver->get()' is not reliable due to [1],
> > > calling the 'get' hook can update the 'policy->cur' with a wrong value when
> > > governor starts in cpufreq_start_governor().
> > > And if the frequency is never changed after the governor starts during
> > > boot e.g. when performance governor is set as default, then
> > > 'scaling_cur_freq' always returns wrong value.
> > >
> > > Instead, the arch_freq_get_on_cpu() API updates 'policy->cur' with a more
> > > stable freq value.
> > >
> > > [1] https://lore.kernel.org/lkml/[email protected]/
> >
> > Got it, many thanks!
> >
> > As the code is right now in v2, arch_freq_get_on_cpu() is called on
> > show_scaling_cur_freq(), so the problem you describe would not show up.
> > policy->cur would still be incorrect, but 'scaling_cur_freq' would
> > return the value from arch_freq_get_on_cpu().
> >
> > Would it be enough if arch_freq_get_on_cpu() gets also called from
> > show_cpuinfo_cur_freq() instead of cpufreq_verify_current_freq()?
> >
> > Thanks,
> > Ionela.
> >
>
> Yes.
> I am not sure if making both the nodes 'scaling_cur_freq' and
> 'cpuinfo_cur_freq' same is fine?
That would happen anyway if arch_freq_get_on_cpu() is called from
cpufreq_verify_current_freq().
In principle, according to [1], it would be correct to use it for
'cpuinfo_cur_freq' and not 'scaling_cur_freq'. But the call from
show_scaling_cur_freq() is already there before these patches,
introduced a long time ago for x86.
The topic was discussed at [2] and the agreement so far was that it
would be best to keep the behaviour the same for both x86 and arm.
I don't like going against the user-guide, but these patches don't
actually go against the user-guide. The old call to
arch_freq_get_on_cpu() from show_scaling_cur_freq() goes against it.
But I agree that's something necessary to keep, as legacy for x86.
Additionally, you also mentioned that you'd prefer to have a more
accurate frequency returned for 'scaling_cur_freq'.
[1] https://www.kernel.org/doc/Documentation/cpu-freq/user-guide.txt
[2] https://lore.kernel.org/lkml/20230609043922.eyyqutbwlofqaddz@vireshk-i7/
Thanks,
Ionela.
>
> Best Regards,
> Sumit Gupta
>>>>>> --- a/drivers/cpufreq/cpufreq.c
>>>>>> +++ b/drivers/cpufreq/cpufreq.c
>>>>>> @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
>>>>>> {
>>>>>> unsigned int new_freq;
>>>>>>
>>>>>> - new_freq = cpufreq_driver->get(policy->cpu);
>>>>>> + new_freq = arch_freq_get_on_cpu(policy->cpu);
>>>>>> + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
>>>>>
>>>>> Given that arch_freq_get_on_cpu() is an average frequency, it does not
>>>>> seem right to me to trigger the sync & update process of
>>>>> cpufreq_verify_current_freq() based on it.
>>>>>
>>>>> cpufreq_verify_current_freq() will at least modify the internal state of
>>>>> the policy and send PRE and POST notifications, if not do a full frequency
>>>>> update, based on this average frequency, which is likely different from
>>>>> the current frequency, even beyond the 1MHz threshold.
>>>>>
>>>>> While I believe it's okay to return this average frequency in
>>>>> cpuinfo_cur_freq, I don't think it should be used as an indication of
>>>>> an accurate current frequency, which is what
>>>>> cpufreq_verify_current_freq() expects.
>>>>>
>>>>> Sumit, can you give more details on the issue at [1] and why this change
>>>>> fixes it?
>>>>>
>>>>> [1] https://lore.kernel.org/lkml/[email protected]/
>>>>>
>>>>> Thank you,
>>>>> Ionela.
>>>>>
>>>> cpufreq_verify_current_freq() also updates 'policy->cur' in POST
>>>> notification if the frequency from hardware has more delta (out of sync).
>>>>
>>>> As the value from 'cpufreq_driver->get()' is not reliable due to [1],
>>>> calling the 'get' hook can update the 'policy->cur' with a wrong value when
>>>> governor starts in cpufreq_start_governor().
>>>> And if the frequency is never changed after the governor starts during
>>>> boot e.g. when performance governor is set as default, then
>>>> 'scaling_cur_freq' always returns wrong value.
>>>>
>>>> Instead, the arch_freq_get_on_cpu() API updates 'policy->cur' with a more
>>>> stable freq value.
>>>>
>>>> [1] https://lore.kernel.org/lkml/[email protected]/
>>>
>>> Got it, many thanks!
>>>
>>> As the code is right now in v2, arch_freq_get_on_cpu() is called on
>>> show_scaling_cur_freq(), so the problem you describe would not show up.
>>> policy->cur would still be incorrect, but 'scaling_cur_freq' would
>>> return the value from arch_freq_get_on_cpu().
>>>
>>> Would it be enough if arch_freq_get_on_cpu() gets also called from
>>> show_cpuinfo_cur_freq() instead of cpufreq_verify_current_freq()?
>>>
>>> Thanks,
>>> Ionela.
>>>
>>
>> Yes.
>> I am not sure if making both the nodes 'scaling_cur_freq' and
>> 'cpuinfo_cur_freq' same is fine?
>
> That would happen anyway if arch_freq_get_on_cpu() is called from
> cpufreq_verify_current_freq().
>
Yes, that will happen in both the cases.
> In principle, according to [1], it would be correct to use it for
> 'cpuinfo_cur_freq' and not 'scaling_cur_freq'. But the call from
> show_scaling_cur_freq() is already there before these patches,
> introduced a long time ago for x86.
>
> The topic was discussed at [2] and the agreement so far was that it
> would be best to keep the behaviour the same for both x86 and arm.
>
Looking at the previous discussion in [2], seems to be fine.
Best Regards,
Sumit Gupta
> I don't like going against the user-guide, but these patches don't
> actually go against the user-guide. The old call to
> arch_freq_get_on_cpu() from show_scaling_cur_freq() goes against it.
> But I agree that's something necessary to keep, as legacy for x86.
> Additionally, you also mentioned that you'd prefer to have a more
> accurate frequency returned for 'scaling_cur_freq'.
>
> [1] https://www.kernel.org/doc/Documentation/cpu-freq/user-guide.txt
> [2] https://lore.kernel.org/lkml/20230609043922.eyyqutbwlofqaddz@vireshk-i7/
>
> Thanks,
> Ionela.
>
>>
>> Best Regards,
>> Sumit Gupta
Apologies for extremely late reply, juggling too many things at time ....
On Wed, Dec 06, 2023 at 09:41:05PM +0100, Rafael J. Wysocki wrote:
> On Mon, Nov 27, 2023 at 5:09 PM Beata Michalska <[email protected]> wrote:
> >
> > From: Sumit Gupta <[email protected]>
> >
> > When available, use arch_freq_get_on_cpu to obtain current frequency
> > (usually an average reported over given period of time)
> > to better align the cpufreq's view on the current state of affairs.
>
> And why is this a good idea?
Apart from being problematic with an issue pointed at [1] (which will result
in dropping the change in cpufreq) this was to keep the cpufreq core aware of
potential frequency changes and take appropriate action (informing the governor)
case it got out of sync.
>
> Any problem statement?
The problem has been raised here [2]
>
> > This also automatically pulls in the update for cpuinfo_cur_freq sysfs
> > attribute, aligning it with the scaling_cur_freq one, and thus providing
> > consistent view on relevant platforms.
>
> I have no idea what the above is supposed to mean, sorry.
Bad wording I guess. With this change both 'cpuinfo_cur_freq' and
'scaling_cur_freq' will use the arch_freq_get_on_cpu if available, and will use
the same source of information (one depending on a platform).
>
> > Signed-off-by: Sumit Gupta <[email protected]>
> > [BM: Subject & commit msg]
> > Signed-off-by: Beata Michalska <[email protected]>
> > ---
> > drivers/cpufreq/cpufreq.c | 3 ++-
> > 1 file changed, 2 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
> > index 8c4f9c2f9c44..109559438f45 100644
> > --- a/drivers/cpufreq/cpufreq.c
> > +++ b/drivers/cpufreq/cpufreq.c
> > @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
> > {
> > unsigned int new_freq;
> >
> > - new_freq = cpufreq_driver->get(policy->cpu);
> > + new_freq = arch_freq_get_on_cpu(policy->cpu);
> > + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
>
> Please don't use ?: in general and it is not even useful here AFAICS.
>
> What would be wrong with
>
> new_freq = arch_freq_get_on_cpu(policy->cpu);
> if (!new_freq)
> new_freq = cpufreq_driver->get(policy->cpu);
>
> ?
Nothing wrong with that.
---
[1] https://lore.kernel.org/all/ZWXy0h%[email protected]/
[2] https://lore.kernel.org/lkml/[email protected]/
---
BR
Beata
>
> > if (!new_freq)
> > return 0;
> >
> > --
Hi Ionela,
So sorry for relpying so late, lost if from my rader for a while ...
On Tue, Nov 28, 2023 at 02:01:54PM +0000, Ionela Voinescu wrote:
> Hi Beata, Sumit,
>
> On Monday 27 Nov 2023 at 16:08:38 (+0000), Beata Michalska wrote:
> > From: Sumit Gupta <[email protected]>
> >
> > When available, use arch_freq_get_on_cpu to obtain current frequency
> > (usually an average reported over given period of time)
> > to better align the cpufreq's view on the current state of affairs.
> > This also automatically pulls in the update for cpuinfo_cur_freq sysfs
> > attribute, aligning it with the scaling_cur_freq one, and thus providing
> > consistent view on relevant platforms.
> >
> > Signed-off-by: Sumit Gupta <[email protected]>
> > [BM: Subject & commit msg]
> > Signed-off-by: Beata Michalska <[email protected]>
> > ---
> > drivers/cpufreq/cpufreq.c | 3 ++-
> > 1 file changed, 2 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
> > index 8c4f9c2f9c44..109559438f45 100644
> > --- a/drivers/cpufreq/cpufreq.c
> > +++ b/drivers/cpufreq/cpufreq.c
> > @@ -1756,7 +1756,8 @@ static unsigned int cpufreq_verify_current_freq(struct cpufreq_policy *policy, b
> > {
> > unsigned int new_freq;
> >
> > - new_freq = cpufreq_driver->get(policy->cpu);
> > + new_freq = arch_freq_get_on_cpu(policy->cpu);
> > + new_freq = new_freq ?: cpufreq_driver->get(policy->cpu);
>
> Given that arch_freq_get_on_cpu() is an average frequency, it does not
> seem right to me to trigger the sync & update process of
> cpufreq_verify_current_freq() based on it.
>
> cpufreq_verify_current_freq() will at least modify the internal state of
> the policy and send PRE and POST notifications, if not do a full frequency
> update, based on this average frequency, which is likely different from
> the current frequency, even beyond the 1MHz threshold.
>
Noted, will drop this change.
---
BR
Beata
> While I believe it's okay to return this average frequency in
> cpuinfo_cur_freq, I don't think it should be used as an indication of
> an accurate current frequency, which is what
> cpufreq_verify_current_freq() expects.
>
> Sumit, can you give more details on the issue at [1] and why this change
> fixes it?
>
> [1] https://lore.kernel.org/lkml/[email protected]/
>
> Thank you,
> Ionela.
>
> > if (!new_freq)
> > return 0;
> >
> > --
> > 2.25.1
> >
On Tue, Nov 28, 2023 at 03:13:51PM +0000, Ionela Voinescu wrote:
> Hi Beata,
>
> On Monday 27 Nov 2023 at 16:08:37 (+0000), Beata Michalska wrote:
> > With the Frequency Invariance Engine (FIE) being already wired up with
> > sched tick and making use of relevant (core counter and constant
> > counter) AMU counters, getting the current frequency for a given CPU
> > on supported platforms, can be achieved by utilizing the frequency scale
> > factor which reflects an average CPU frequency for the last tick period
> > length.
> >
> > Suggested-by: Ionela Voinescu <[email protected]>
> > Signed-off-by: Beata Michalska <[email protected]>
> > Reviewed-by: Sudeep Holla <[email protected]>
> > ---
> >
> > Notes:
> > Due to [1], if merged, there might be a need to modify the patch to
> > accommodate changes [1] introduces:
> >
> > freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT
> > to
> > freq = per_cpu(capacity_freq_ref, cpu); >> SCHED_CAPACITY_SHIFT
> > [1]
> > https://lore.kernel.org/linux-arm-kernel/20231121154349.GA1938@willie-the-truck/T/#mcb018d076dbce6f60ed2779634a9b6ffe622641e
> >
> > arch/arm64/kernel/topology.c | 39 ++++++++++++++++++++++++++++++++++++
> > 1 file changed, 39 insertions(+)
> >
> > diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
> > index 615c1a20129f..ae2445f6e7da 100644
> > --- a/arch/arm64/kernel/topology.c
> > +++ b/arch/arm64/kernel/topology.c
> > @@ -17,6 +17,7 @@
> > #include <linux/cpufreq.h>
> > #include <linux/init.h>
> > #include <linux/percpu.h>
> > +#include <linux/sched/isolation.h>
> >
> > #include <asm/cpu.h>
> > #include <asm/cputype.h>
> > @@ -186,6 +187,44 @@ static void amu_scale_freq_tick(void)
> > this_cpu_write(arch_freq_scale, (unsigned long)scale);
> > }
> >
> > +unsigned int arch_freq_get_on_cpu(int cpu)
> > +{
> > + unsigned int freq;
> > + u64 scale;
> > +
> > + if (!cpumask_test_cpu(cpu, amu_fie_cpus))
> > + return 0;
> > +
> > + /*
> > + * For those CPUs that are in full dynticks mode, try an alternative
> > + * source for the counters (and thus freq scale),
> > + * if available for given policy
> > + */
> > + if (!housekeeping_cpu(cpu, HK_TYPE_TICK)) {
> > + struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
> > + int ref_cpu = nr_cpu_ids;
> > +
> > + if (cpumask_intersects(housekeeping_cpumask(HK_TYPE_TICK),
> > + policy->cpus))
> > + ref_cpu = cpumask_nth_and(cpu, policy->cpus,
> > + housekeeping_cpumask(HK_TYPE_TICK));
> > + cpufreq_cpu_put(policy);
> > + if (ref_cpu >= nr_cpu_ids)
> > + return 0;
> > + cpu = ref_cpu;
> > + }
> > +
> > + /*
> > + * Reversed computation to the one used to determine
> > + * the arch_freq_scale value
> > + * (see amu_scale_freq_tick for details)
> > + */
> > + scale = per_cpu(arch_freq_scale, cpu);
>
> Any reason for not using arch_scale_freq_capacity() here?
>
> To me it seems a bit nicer to use the "official" function to return the
> frequency scale factor.
>
Noted.
> > + freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT;
>
> Given Vincent's patch at [1] I think here might be best to call
> arch_scale_freq_ref() instead. That's because the frequency scale factor
> will use that frequency as the maximum frequency in its calculations and
> we'd not want to use a different one here.
>
OK.
> The annoyance is coping with capacity_freq_ref not having been set
> yet, and that would be easy if capacity_freq_ref was initialized to 0.
> Luckily with Vincent's changes it can now be 0. I'll comments on his
> patches and ask him to make this change.
>
> So I think you can safely use arch_scale_freq_ref() here. If
> arch_scale_freq_ref() returns 0, arch_freq_get_on_cpu() will just return
> 0 as well.
>
Will do.
> [1] https://lore.kernel.org/lkml/[email protected]/
>
> > + freq *= scale;
>
> In some scenarios the frequencies visible to cpufreq might not look like
> actual frequencies, but some scaled abstract performance values. One
> example is cppc_cpufreq when one does not provide the optional frequency
> information in the CPC objects but just the performance information.
>
> Therefore the maximum frequency seen here can be quite a small value, so
> it might be best to do the multiplication first and the shift after that.
>
Right, that was in v1! Must have mixed up things ending with stale data.
Will address that in the next version - if one is out.
---
BR
Beata
> Thanks,
> Ionela.
>
> > + return freq;
> > +}
> > +
> > static struct scale_freq_data amu_sfd = {
> > .source = SCALE_FREQ_SOURCE_ARCH,
> > .set_freq_scale = amu_scale_freq_tick,
> > --
> > 2.25.1
> >
Hello Beata,
I tested this patch based on the discussion in [1] on an AmpereOne
system when the system was mostly idle. The results below are when only
I applied the first patch in this series to the kernel. I noticed that
the frequency reported through scaling_cur_freq vs cpuinfo_cur_freq is
quite different for some cores. When the cores are loaded using
stress-ng, the scaling_cur_freq and cpuinfo_cur_freq values are quite
similar.
Applying the second patch in this series causes the difference between
scaling_cur_freq and cpuinfo_cur_freq to disappear, but calculating the
core frequency based on the feedback_ctrs shows that the value is
incorrect for both.
The kernel I compiled for testing is based on the Fedora 39 config file.
These configs seem relevant to the discussion:
CONFIG_NO_HZ_COMMON=y
# CONFIG_HZ_PERIODIC is not set
# CONFIG_NO_HZ_IDLE is not set
CONFIG_NO_HZ_FULL=y
CONFIG_CONTEXT_TRACKING_USER=y
# CONFIG_CONTEXT_TRACKING_USER_FORCE is not set
CONFIG_NO_HZ=y
[1]: https://lore.kernel.org/linux-arm-kernel/[email protected]/
Results:
cpu_num scaling_cur_freq cpuinfo_cur_freq
[11]: 1874560 1000000
[12]: 2056158 1385000
[13]: 1974146 1000000
[21]: 1587518 1000000
[23]: 1593376 1000000
..
.. skipping similar results for ~50 other cores for brevity
..
nohz_full=113-118
[113]: 1874560 1000000
[114]: 1968288 1000000
[115]: 1962430 1000000
[116]: 1871631 1000000
[117]: 1877489 1000000
[118]: 1877489 1000000
isolcpus=119-127
[119]: 2999296 1000000
[120]: 2999296 1000000
[121]: 2999296 1000000
[125]: 2999296 1000000
[126]: 2999296 1000000
[127]: 2999296 1000000
Thanks,
Vanshi
On Mon, Nov 27, 2023 at 04:08:37PM +0000, Beata Michalska wrote:
>With the Frequency Invariance Engine (FIE) being already wired up with
>sched tick and making use of relevant (core counter and constant
>counter) AMU counters, getting the current frequency for a given CPU
>on supported platforms, can be achieved by utilizing the frequency scale
>factor which reflects an average CPU frequency for the last tick period
>length.
>
>Suggested-by: Ionela Voinescu <[email protected]>
>Signed-off-by: Beata Michalska <[email protected]>
>Reviewed-by: Sudeep Holla <[email protected]>
>---
>
>Notes:
> Due to [1], if merged, there might be a need to modify the patch to
> accommodate changes [1] introduces:
>
> freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT
> to
> freq = per_cpu(capacity_freq_ref, cpu); >> SCHED_CAPACITY_SHIFT
> [1]
> https://lore.kernel.org/linux-arm-kernel/20231121154349.GA1938@willie-the-truck/T/#mcb018d076dbce6f60ed2779634a9b6ffe622641e
>
> arch/arm64/kernel/topology.c | 39 ++++++++++++++++++++++++++++++++++++
> 1 file changed, 39 insertions(+)
>
>diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
>index 615c1a20129f..ae2445f6e7da 100644
>--- a/arch/arm64/kernel/topology.c
>+++ b/arch/arm64/kernel/topology.c
>@@ -17,6 +17,7 @@
> #include <linux/cpufreq.h>
> #include <linux/init.h>
> #include <linux/percpu.h>
>+#include <linux/sched/isolation.h>
>
> #include <asm/cpu.h>
> #include <asm/cputype.h>
>@@ -186,6 +187,44 @@ static void amu_scale_freq_tick(void)
> this_cpu_write(arch_freq_scale, (unsigned long)scale);
> }
>
>+unsigned int arch_freq_get_on_cpu(int cpu)
>+{
>+ unsigned int freq;
>+ u64 scale;
>+
>+ if (!cpumask_test_cpu(cpu, amu_fie_cpus))
>+ return 0;
>+
>+ /*
>+ * For those CPUs that are in full dynticks mode, try an alternative
>+ * source for the counters (and thus freq scale),
>+ * if available for given policy
>+ */
>+ if (!housekeeping_cpu(cpu, HK_TYPE_TICK)) {
>+ struct cpufreq_policy *policy = cpufreq_cpu_get(cpu);
>+ int ref_cpu = nr_cpu_ids;
>+
>+ if (cpumask_intersects(housekeeping_cpumask(HK_TYPE_TICK),
>+ policy->cpus))
>+ ref_cpu = cpumask_nth_and(cpu, policy->cpus,
>+ housekeeping_cpumask(HK_TYPE_TICK));
>+ cpufreq_cpu_put(policy);
>+ if (ref_cpu >= nr_cpu_ids)
>+ return 0;
>+ cpu = ref_cpu;
>+ }
>+
>+ /*
>+ * Reversed computation to the one used to determine
>+ * the arch_freq_scale value
>+ * (see amu_scale_freq_tick for details)
>+ */
>+ scale = per_cpu(arch_freq_scale, cpu);
>+ freq = cpufreq_get_hw_max_freq(cpu) >> SCHED_CAPACITY_SHIFT;
>+ freq *= scale;
>+ return freq;
>+}
>+
> static struct scale_freq_data amu_sfd = {
> .source = SCALE_FREQ_SOURCE_ARCH,
> .set_freq_scale = amu_scale_freq_tick,
>--
>2.25.1
>
>
>_______________________________________________
>linux-arm-kernel mailing list
>[email protected]
>http://lists.infradead.org/mailman/listinfo/linux-arm-kernel