* [PATCH v2 0/2] Add support for AArch64 AMUv1-based arch_freq_get_on_cpu @ 2023-11-27 16:08 ` Beata Michalska 0 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2023-11-27 16:08 UTC (permalink / raw) To: linux-kernel, linux-arm-kernel, linux-pm, sumitg Cc: sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra 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/20230606155754.245998-1-beata.michalska@arm.com/ 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 ^ permalink raw reply [flat|nested] 30+ messages in thread
* [PATCH v2 0/2] Add support for AArch64 AMUv1-based arch_freq_get_on_cpu @ 2023-11-27 16:08 ` Beata Michalska 0 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2023-11-27 16:08 UTC (permalink / raw) To: linux-kernel, linux-arm-kernel, linux-pm, sumitg Cc: sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra 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/20230606155754.245998-1-beata.michalska@arm.com/ 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 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu 2023-11-27 16:08 ` Beata Michalska @ 2023-11-27 16:08 ` Beata Michalska -1 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2023-11-27 16:08 UTC (permalink / raw) To: linux-kernel, linux-arm-kernel, linux-pm, sumitg Cc: sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra, Sudeep Holla 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 <ionela.voinescu@arm.com> Signed-off-by: Beata Michalska <beata.michalska@arm.com> Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> --- 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 ^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu @ 2023-11-27 16:08 ` Beata Michalska 0 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2023-11-27 16:08 UTC (permalink / raw) To: linux-kernel, linux-arm-kernel, linux-pm, sumitg Cc: sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra, Sudeep Holla 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 <ionela.voinescu@arm.com> Signed-off-by: Beata Michalska <beata.michalska@arm.com> Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> --- 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 linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 30+ messages in thread
* Re: [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu 2023-11-27 16:08 ` Beata Michalska @ 2023-11-28 15:13 ` Ionela Voinescu -1 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-11-28 15:13 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sudeep Holla 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 <ionela.voinescu@arm.com> > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> > --- > > 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/20231109101438.1139696-8-vincent.guittot@linaro.org/ > + 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 > ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu @ 2023-11-28 15:13 ` Ionela Voinescu 0 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-11-28 15:13 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sudeep Holla 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 <ionela.voinescu@arm.com> > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> > --- > > 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/20231109101438.1139696-8-vincent.guittot@linaro.org/ > + 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 > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu 2023-11-28 15:13 ` Ionela Voinescu @ 2024-02-02 9:20 ` Beata Michalska -1 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2024-02-02 9:20 UTC (permalink / raw) To: Ionela Voinescu Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sudeep Holla 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 <ionela.voinescu@arm.com> > > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > > Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> > > --- > > > > 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/20231109101438.1139696-8-vincent.guittot@linaro.org/ > > > + 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 > > ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu @ 2024-02-02 9:20 ` Beata Michalska 0 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2024-02-02 9:20 UTC (permalink / raw) To: Ionela Voinescu Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sudeep Holla 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 <ionela.voinescu@arm.com> > > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > > Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> > > --- > > > > 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/20231109101438.1139696-8-vincent.guittot@linaro.org/ > > > + 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 > > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu 2023-11-27 16:08 ` Beata Michalska @ 2024-02-22 19:55 ` Vanshidhar Konda -1 siblings, 0 replies; 30+ messages in thread From: Vanshidhar Konda @ 2024-02-22 19:55 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra, Sudeep Holla, lihuisong 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/20231212072617.14756-1-lihuisong@huawei.com/ 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 <ionela.voinescu@arm.com> >Signed-off-by: Beata Michalska <beata.michalska@arm.com> >Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> >--- > >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 >linux-arm-kernel@lists.infradead.org >http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu @ 2024-02-22 19:55 ` Vanshidhar Konda 0 siblings, 0 replies; 30+ messages in thread From: Vanshidhar Konda @ 2024-02-22 19:55 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra, Sudeep Holla, lihuisong 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/20231212072617.14756-1-lihuisong@huawei.com/ 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 <ionela.voinescu@arm.com> >Signed-off-by: Beata Michalska <beata.michalska@arm.com> >Reviewed-by: Sudeep Holla <sudeep.holla@arm.com> >--- > >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 >linux-arm-kernel@lists.infradead.org >http://lists.infradead.org/mailman/listinfo/linux-arm-kernel _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-11-27 16:08 ` Beata Michalska @ 2023-11-27 16:08 ` Beata Michalska -1 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2023-11-27 16:08 UTC (permalink / raw) To: linux-kernel, linux-arm-kernel, linux-pm, sumitg Cc: sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra From: Sumit Gupta <sumitg@nvidia.com> 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 <sumitg@nvidia.com> [BM: Subject & commit msg] Signed-off-by: Beata Michalska <beata.michalska@arm.com> --- 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 ^ permalink raw reply related [flat|nested] 30+ messages in thread
* [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-11-27 16:08 ` Beata Michalska 0 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2023-11-27 16:08 UTC (permalink / raw) To: linux-kernel, linux-arm-kernel, linux-pm, sumitg Cc: sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra From: Sumit Gupta <sumitg@nvidia.com> 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 <sumitg@nvidia.com> [BM: Subject & commit msg] Signed-off-by: Beata Michalska <beata.michalska@arm.com> --- 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 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply related [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-11-27 16:08 ` Beata Michalska @ 2023-11-28 14:01 ` Ionela Voinescu -1 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-11-28 14:01 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra Hi Beata, Sumit, On Monday 27 Nov 2023 at 16:08:38 (+0000), Beata Michalska wrote: > From: Sumit Gupta <sumitg@nvidia.com> > > 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 <sumitg@nvidia.com> > [BM: Subject & commit msg] > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > --- > 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ Thank you, Ionela. > if (!new_freq) > return 0; > > -- > 2.25.1 > ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-11-28 14:01 ` Ionela Voinescu 0 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-11-28 14:01 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra Hi Beata, Sumit, On Monday 27 Nov 2023 at 16:08:38 (+0000), Beata Michalska wrote: > From: Sumit Gupta <sumitg@nvidia.com> > > 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 <sumitg@nvidia.com> > [BM: Subject & commit msg] > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > --- > 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ Thank you, Ionela. > if (!new_freq) > return 0; > > -- > 2.25.1 > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-11-28 14:01 ` Ionela Voinescu @ 2023-12-01 13:02 ` Sumit Gupta -1 siblings, 0 replies; 30+ messages in thread From: Sumit Gupta @ 2023-12-01 13:02 UTC (permalink / raw) To: Ionela Voinescu, Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sumit Gupta 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > 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/20230418113459.12860-7-sumitg@nvidia.com/ Best regards, Sumit Gupta >> if (!new_freq) >> return 0; >> >> -- >> 2.25.1 >> ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-12-01 13:02 ` Sumit Gupta 0 siblings, 0 replies; 30+ messages in thread From: Sumit Gupta @ 2023-12-01 13:02 UTC (permalink / raw) To: Ionela Voinescu, Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sumit Gupta 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > 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/20230418113459.12860-7-sumitg@nvidia.com/ Best regards, Sumit Gupta >> if (!new_freq) >> return 0; >> >> -- >> 2.25.1 >> _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-12-01 13:02 ` Sumit Gupta @ 2023-12-05 11:05 ` Ionela Voinescu -1 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-12-05 11:05 UTC (permalink / raw) To: Sumit Gupta Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > > > 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/20230418113459.12860-7-sumitg@nvidia.com/ 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 > > > ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-12-05 11:05 ` Ionela Voinescu 0 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-12-05 11:05 UTC (permalink / raw) To: Sumit Gupta Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > > > 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/20230418113459.12860-7-sumitg@nvidia.com/ 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 > > > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-12-05 11:05 ` Ionela Voinescu @ 2023-12-06 13:28 ` Sumit Gupta -1 siblings, 0 replies; 30+ messages in thread From: Sumit Gupta @ 2023-12-06 13:28 UTC (permalink / raw) To: Ionela Voinescu Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sumit Gupta 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ >>> >>> 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/20230418113459.12860-7-sumitg@nvidia.com/ > > 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 ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-12-06 13:28 ` Sumit Gupta 0 siblings, 0 replies; 30+ messages in thread From: Sumit Gupta @ 2023-12-06 13:28 UTC (permalink / raw) To: Ionela Voinescu Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, Sumit Gupta 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ >>> >>> 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/20230418113459.12860-7-sumitg@nvidia.com/ > > 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 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-12-06 13:28 ` Sumit Gupta @ 2023-12-07 9:22 ` Ionela Voinescu -1 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-12-07 9:22 UTC (permalink / raw) To: Sumit Gupta Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > > > > > > > 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/20230418113459.12860-7-sumitg@nvidia.com/ > > > > 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 ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-12-07 9:22 ` Ionela Voinescu 0 siblings, 0 replies; 30+ messages in thread From: Ionela Voinescu @ 2023-12-07 9:22 UTC (permalink / raw) To: Sumit Gupta Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > > > > > > > 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/20230418113459.12860-7-sumitg@nvidia.com/ > > > > 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 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-12-07 9:22 ` Ionela Voinescu @ 2023-12-08 15:34 ` Sumit Gupta -1 siblings, 0 replies; 30+ messages in thread From: Sumit Gupta @ 2023-12-08 15:34 UTC (permalink / raw) To: Ionela Voinescu Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ >>>>> >>>>> 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/20230418113459.12860-7-sumitg@nvidia.com/ >>> >>> 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 ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-12-08 15:34 ` Sumit Gupta 0 siblings, 0 replies; 30+ messages in thread From: Sumit Gupta @ 2023-12-08 15:34 UTC (permalink / raw) To: Ionela Voinescu Cc: Beata Michalska, linux-kernel, linux-arm-kernel, linux-pm, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra, 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ >>>>> >>>>> 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/20230418113459.12860-7-sumitg@nvidia.com/ >>> >>> 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 _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-11-28 14:01 ` Ionela Voinescu @ 2024-02-02 9:14 ` Beata Michalska -1 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2024-02-02 9:14 UTC (permalink / raw) To: Ionela Voinescu Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra 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 <sumitg@nvidia.com> > > > > 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 <sumitg@nvidia.com> > > [BM: Subject & commit msg] > > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > > --- > > 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > Thank you, > Ionela. > > > if (!new_freq) > > return 0; > > > > -- > > 2.25.1 > > ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2024-02-02 9:14 ` Beata Michalska 0 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2024-02-02 9:14 UTC (permalink / raw) To: Ionela Voinescu Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, yang, linux-tegra 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 <sumitg@nvidia.com> > > > > 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 <sumitg@nvidia.com> > > [BM: Subject & commit msg] > > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > > --- > > 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/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ > > Thank you, > Ionela. > > > if (!new_freq) > > return 0; > > > > -- > > 2.25.1 > > _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-11-27 16:08 ` Beata Michalska @ 2023-12-06 20:41 ` Rafael J. Wysocki -1 siblings, 0 replies; 30+ messages in thread From: Rafael J. Wysocki @ 2023-12-06 20:41 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra On Mon, Nov 27, 2023 at 5:09 PM Beata Michalska <beata.michalska@arm.com> wrote: > > From: Sumit Gupta <sumitg@nvidia.com> > > 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 <sumitg@nvidia.com> > [BM: Subject & commit msg] > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > --- > 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; > > -- ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2023-12-06 20:41 ` Rafael J. Wysocki 0 siblings, 0 replies; 30+ messages in thread From: Rafael J. Wysocki @ 2023-12-06 20:41 UTC (permalink / raw) To: Beata Michalska Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, rafael, ionela.voinescu, yang, linux-tegra On Mon, Nov 27, 2023 at 5:09 PM Beata Michalska <beata.michalska@arm.com> wrote: > > From: Sumit Gupta <sumitg@nvidia.com> > > 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 <sumitg@nvidia.com> > [BM: Subject & commit msg] > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > --- > 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; > > -- _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq 2023-12-06 20:41 ` Rafael J. Wysocki @ 2024-02-02 9:05 ` Beata Michalska -1 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2024-02-02 9:05 UTC (permalink / raw) To: Rafael J. Wysocki Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, ionela.voinescu, yang, linux-tegra 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 <beata.michalska@arm.com> wrote: > > > > From: Sumit Gupta <sumitg@nvidia.com> > > > > 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 <sumitg@nvidia.com> > > [BM: Subject & commit msg] > > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > > --- > > 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%2FfFfQh+Rhy@arm.com/ [2] https://lore.kernel.org/lkml/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ --- BR Beata > > > if (!new_freq) > > return 0; > > > > -- _______________________________________________ linux-arm-kernel mailing list linux-arm-kernel@lists.infradead.org http://lists.infradead.org/mailman/listinfo/linux-arm-kernel ^ permalink raw reply [flat|nested] 30+ messages in thread
* Re: [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq @ 2024-02-02 9:05 ` Beata Michalska 0 siblings, 0 replies; 30+ messages in thread From: Beata Michalska @ 2024-02-02 9:05 UTC (permalink / raw) To: Rafael J. Wysocki Cc: linux-kernel, linux-arm-kernel, linux-pm, sumitg, sudeep.holla, will, catalin.marinas, viresh.kumar, ionela.voinescu, yang, linux-tegra 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 <beata.michalska@arm.com> wrote: > > > > From: Sumit Gupta <sumitg@nvidia.com> > > > > 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 <sumitg@nvidia.com> > > [BM: Subject & commit msg] > > Signed-off-by: Beata Michalska <beata.michalska@arm.com> > > --- > > 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%2FfFfQh+Rhy@arm.com/ [2] https://lore.kernel.org/lkml/6a5710f6-bfbb-5dfd-11cd-0cd02220cee7@nvidia.com/ --- BR Beata > > > if (!new_freq) > > return 0; > > > > -- ^ permalink raw reply [flat|nested] 30+ messages in thread
end of thread, other threads:[~2024-02-22 19:56 UTC | newest] Thread overview: 30+ messages (download: mbox.gz / follow: Atom feed) -- links below jump to the message on this page -- 2023-11-27 16:08 [PATCH v2 0/2] Add support for AArch64 AMUv1-based arch_freq_get_on_cpu Beata Michalska 2023-11-27 16:08 ` Beata Michalska 2023-11-27 16:08 ` [PATCH v2 1/2] arm64: Provide an AMU-based version of arch_freq_get_on_cpu Beata Michalska 2023-11-27 16:08 ` Beata Michalska 2023-11-28 15:13 ` Ionela Voinescu 2023-11-28 15:13 ` Ionela Voinescu 2024-02-02 9:20 ` Beata Michalska 2024-02-02 9:20 ` Beata Michalska 2024-02-22 19:55 ` Vanshidhar Konda 2024-02-22 19:55 ` Vanshidhar Konda 2023-11-27 16:08 ` [PATCH v2 2/2] cpufreq: Wire-up arch-flavored freq info into cpufreq_verify_current_freq Beata Michalska 2023-11-27 16:08 ` Beata Michalska 2023-11-28 14:01 ` Ionela Voinescu 2023-11-28 14:01 ` Ionela Voinescu 2023-12-01 13:02 ` Sumit Gupta 2023-12-01 13:02 ` Sumit Gupta 2023-12-05 11:05 ` Ionela Voinescu 2023-12-05 11:05 ` Ionela Voinescu 2023-12-06 13:28 ` Sumit Gupta 2023-12-06 13:28 ` Sumit Gupta 2023-12-07 9:22 ` Ionela Voinescu 2023-12-07 9:22 ` Ionela Voinescu 2023-12-08 15:34 ` Sumit Gupta 2023-12-08 15:34 ` Sumit Gupta 2024-02-02 9:14 ` Beata Michalska 2024-02-02 9:14 ` Beata Michalska 2023-12-06 20:41 ` Rafael J. Wysocki 2023-12-06 20:41 ` Rafael J. Wysocki 2024-02-02 9:05 ` Beata Michalska 2024-02-02 9:05 ` Beata Michalska
This is an external index of several public inboxes, see mirroring instructions on how to clone and mirror all data and code used by this external index.