This is the 1st part of consolidating how the max compute capacity is
used in the scheduler and how we calculate the frequency for a level of
utilization.
Fix some unconsistancy when computing frequency for an utilization. There
can be a mismatch between energy model and schedutil.
Next step will be to make a difference between the original
max compute capacity of a CPU and what is currently available when
there is a capping applying forever (i.e. seconds or more).
Changes since v3:
- Split patch 5 cpufreq/cppc
- Fix topology_init_cpu_capacity_cppc()
- Fix init if AMU ratio
- Added some tags
Changes since v2:
- Remove the 1st patch which has been queued in tip
- Rework how to initialize the reference frequency for cppc_cpufreq and
change topology_init_cpu_capacity_cppc() to also set capacity_ref_freq
- Add a RFC to convert AMU to use arch_scale_freq_ref and move the config
of the AMU ratio to be done when intializing cpu capacity and
capacity_ref_freq
- Added some tags
Changes since v1:
- Fix typos
- Added changes in cpufreq to use arch_scale_freq_ref() when calling
arch_set_freq_scale (patch 3).
- arch_scale_freq_ref() is always defined and returns 0 (as proposed
by Ionela) when not defined by the arch. This simplifies the code with
the addition of patch 3.
- Simplify Energy Model which always uses arch_scale_freq_ref(). The
latter returns 0 when not defined by arch instead of last item of the
perf domain. This is not a problem because the function is only defined
for compilation purpose in this case and we don't care about the
returned value. (patch 5)
- Added changes in cppc cpufreq to set capacity_ref_freq (patch 6)
- Added reviewed tag for patch 1 which got a minor change but not for
others as I did some changes which could make previous reviewed tag
no more relevant.
Vincent Guittot (7):
topology: add a new arch_scale_freq_reference
cpufreq: use the fixed and coherent frequency for scaling capacity
cpufreq/schedutil: use a fixed reference frequency
energy_model: use a fixed reference frequency
cpufreq/cppc: move and rename cppc_cpufreq_{perf_to_khz|khz_to_perf}
cpufreq/cppc: set the frequency used for computing the capacity
arm64/amu: use capacity_ref_freq to set AMU ratio
arch/arm/include/asm/topology.h | 1 +
arch/arm64/include/asm/topology.h | 1 +
arch/arm64/kernel/topology.c | 26 +++---
arch/riscv/include/asm/topology.h | 1 +
drivers/acpi/cppc_acpi.c | 93 +++++++++++++++++++++
drivers/base/arch_topology.c | 55 ++++++++----
drivers/cpufreq/cppc_cpufreq.c | 134 ++++--------------------------
drivers/cpufreq/cpufreq.c | 4 +-
include/acpi/cppc_acpi.h | 2 +
include/linux/arch_topology.h | 8 ++
include/linux/cpufreq.h | 9 ++
include/linux/energy_model.h | 14 +++-
kernel/sched/cpufreq_schedutil.c | 26 +++++-
13 files changed, 221 insertions(+), 153 deletions(-)
--
2.34.1
Create a new method to get a unique and fixed max frequency. Currently
cpuinfo.max_freq or the highest (or last) state of performance domain are
used as the max frequency when computing the frequency for a level of
utilization but:
- cpuinfo_max_freq can change at runtime. boost is one example of
such change.
- cpuinfo.max_freq and last item of the PD can be different leading to
different results between cpufreq and energy model.
We need to save the reference frequency that has been used when computing
the CPUs capacity and use this fixed and coherent value to convert between
frequency and CPU's capacity.
In fact, we already save the frequency that has been used when computing
the capacity of each CPU. We extend the precision to save khZ instead of
Mhz currently and we modify the type to be aligned with other variables
used when converting frequency to capacity and the other way.
Signed-off-by: Vincent Guittot <[email protected]>
Reviewed-by: Lukasz Luba <[email protected]>
Tested-by: Lukasz Luba <[email protected]>
---
arch/arm/include/asm/topology.h | 1 +
arch/arm64/include/asm/topology.h | 1 +
arch/riscv/include/asm/topology.h | 1 +
drivers/base/arch_topology.c | 29 ++++++++++++++---------------
include/linux/arch_topology.h | 7 +++++++
5 files changed, 24 insertions(+), 15 deletions(-)
diff --git a/arch/arm/include/asm/topology.h b/arch/arm/include/asm/topology.h
index c7d2510e5a78..853c4f81ba4a 100644
--- a/arch/arm/include/asm/topology.h
+++ b/arch/arm/include/asm/topology.h
@@ -13,6 +13,7 @@
#define arch_set_freq_scale topology_set_freq_scale
#define arch_scale_freq_capacity topology_get_freq_scale
#define arch_scale_freq_invariant topology_scale_freq_invariant
+#define arch_scale_freq_ref topology_get_freq_ref
#endif
/* Replace task scheduler's default cpu-invariant accounting */
diff --git a/arch/arm64/include/asm/topology.h b/arch/arm64/include/asm/topology.h
index 9fab663dd2de..a323b109b9c4 100644
--- a/arch/arm64/include/asm/topology.h
+++ b/arch/arm64/include/asm/topology.h
@@ -23,6 +23,7 @@ void update_freq_counters_refs(void);
#define arch_set_freq_scale topology_set_freq_scale
#define arch_scale_freq_capacity topology_get_freq_scale
#define arch_scale_freq_invariant topology_scale_freq_invariant
+#define arch_scale_freq_ref topology_get_freq_ref
#ifdef CONFIG_ACPI_CPPC_LIB
#define arch_init_invariance_cppc topology_init_cpu_capacity_cppc
diff --git a/arch/riscv/include/asm/topology.h b/arch/riscv/include/asm/topology.h
index e316ab3b77f3..61183688bdd5 100644
--- a/arch/riscv/include/asm/topology.h
+++ b/arch/riscv/include/asm/topology.h
@@ -9,6 +9,7 @@
#define arch_set_freq_scale topology_set_freq_scale
#define arch_scale_freq_capacity topology_get_freq_scale
#define arch_scale_freq_invariant topology_scale_freq_invariant
+#define arch_scale_freq_ref topology_get_freq_ref
/* Replace task scheduler's default cpu-invariant accounting */
#define arch_scale_cpu_capacity topology_get_cpu_scale
diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
index b741b5ba82bd..9a073c2d2086 100644
--- a/drivers/base/arch_topology.c
+++ b/drivers/base/arch_topology.c
@@ -19,6 +19,7 @@
#include <linux/init.h>
#include <linux/rcupdate.h>
#include <linux/sched.h>
+#include <linux/units.h>
#define CREATE_TRACE_POINTS
#include <trace/events/thermal_pressure.h>
@@ -26,7 +27,8 @@
static DEFINE_PER_CPU(struct scale_freq_data __rcu *, sft_data);
static struct cpumask scale_freq_counters_mask;
static bool scale_freq_invariant;
-static DEFINE_PER_CPU(u32, freq_factor) = 1;
+DEFINE_PER_CPU(unsigned long, capacity_ref_freq) = 1;
+EXPORT_PER_CPU_SYMBOL_GPL(capacity_ref_freq);
static bool supports_scale_freq_counters(const struct cpumask *cpus)
{
@@ -170,9 +172,9 @@ DEFINE_PER_CPU(unsigned long, thermal_pressure);
* operating on stale data when hot-plug is used for some CPUs. The
* @capped_freq reflects the currently allowed max CPUs frequency due to
* thermal capping. It might be also a boost frequency value, which is bigger
- * than the internal 'freq_factor' max frequency. In such case the pressure
- * value should simply be removed, since this is an indication that there is
- * no thermal throttling. The @capped_freq must be provided in kHz.
+ * than the internal 'capacity_ref_freq' max frequency. In such case the
+ * pressure value should simply be removed, since this is an indication that
+ * there is no thermal throttling. The @capped_freq must be provided in kHz.
*/
void topology_update_thermal_pressure(const struct cpumask *cpus,
unsigned long capped_freq)
@@ -183,10 +185,7 @@ void topology_update_thermal_pressure(const struct cpumask *cpus,
cpu = cpumask_first(cpus);
max_capacity = arch_scale_cpu_capacity(cpu);
- max_freq = per_cpu(freq_factor, cpu);
-
- /* Convert to MHz scale which is used in 'freq_factor' */
- capped_freq /= 1000;
+ max_freq = arch_scale_freq_ref(cpu);
/*
* Handle properly the boost frequencies, which should simply clean
@@ -279,13 +278,13 @@ void topology_normalize_cpu_scale(void)
capacity_scale = 1;
for_each_possible_cpu(cpu) {
- capacity = raw_capacity[cpu] * per_cpu(freq_factor, cpu);
+ capacity = raw_capacity[cpu] * per_cpu(capacity_ref_freq, cpu);
capacity_scale = max(capacity, capacity_scale);
}
pr_debug("cpu_capacity: capacity_scale=%llu\n", capacity_scale);
for_each_possible_cpu(cpu) {
- capacity = raw_capacity[cpu] * per_cpu(freq_factor, cpu);
+ capacity = raw_capacity[cpu] * per_cpu(capacity_ref_freq, cpu);
capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
capacity_scale);
topology_set_cpu_scale(cpu, capacity);
@@ -321,15 +320,15 @@ bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
cpu_node, raw_capacity[cpu]);
/*
- * Update freq_factor for calculating early boot cpu capacities.
+ * Update capacity_ref_freq for calculating early boot cpu capacities.
* For non-clk CPU DVFS mechanism, there's no way to get the
* frequency value now, assuming they are running at the same
- * frequency (by keeping the initial freq_factor value).
+ * frequency (by keeping the initial capacity_ref_freq value).
*/
cpu_clk = of_clk_get(cpu_node, 0);
if (!PTR_ERR_OR_ZERO(cpu_clk)) {
- per_cpu(freq_factor, cpu) =
- clk_get_rate(cpu_clk) / 1000;
+ per_cpu(capacity_ref_freq, cpu) =
+ clk_get_rate(cpu_clk) / HZ_PER_KHZ;
clk_put(cpu_clk);
}
} else {
@@ -411,7 +410,7 @@ init_cpu_capacity_callback(struct notifier_block *nb,
cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
for_each_cpu(cpu, policy->related_cpus)
- per_cpu(freq_factor, cpu) = policy->cpuinfo.max_freq / 1000;
+ per_cpu(capacity_ref_freq, cpu) = policy->cpuinfo.max_freq;
if (cpumask_empty(cpus_to_visit)) {
topology_normalize_cpu_scale();
diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
index a07b510e7dc5..38ca6c76af56 100644
--- a/include/linux/arch_topology.h
+++ b/include/linux/arch_topology.h
@@ -27,6 +27,13 @@ static inline unsigned long topology_get_cpu_scale(int cpu)
void topology_set_cpu_scale(unsigned int cpu, unsigned long capacity);
+DECLARE_PER_CPU(unsigned long, capacity_ref_freq);
+
+static inline unsigned long topology_get_freq_ref(int cpu)
+{
+ return per_cpu(capacity_ref_freq, cpu);
+}
+
DECLARE_PER_CPU(unsigned long, arch_freq_scale);
static inline unsigned long topology_get_freq_scale(int cpu)
--
2.34.1
cpuinfo.max_freq can change at runtime because of boost as an example. This
implies that the value could be different than the one that has been
used when computing the capacity of a CPU.
The new arch_scale_freq_ref() returns a fixed and coherent reference
frequency that can be used when computing a frequency based on utilization.
Use this arch_scale_freq_ref() when available and fallback to
policy otherwise.
Signed-off-by: Vincent Guittot <[email protected]>
Reviewed-by: Lukasz Luba <[email protected]>
Tested-by: Lukasz Luba <[email protected]>
Acked-by: Rafael J. Wysocki <[email protected]>
Reviewed-by: Dietmar Eggemann <[email protected]>
---
kernel/sched/cpufreq_schedutil.c | 26 ++++++++++++++++++++++++--
1 file changed, 24 insertions(+), 2 deletions(-)
diff --git a/kernel/sched/cpufreq_schedutil.c b/kernel/sched/cpufreq_schedutil.c
index 458d359f5991..f3a87fa16332 100644
--- a/kernel/sched/cpufreq_schedutil.c
+++ b/kernel/sched/cpufreq_schedutil.c
@@ -114,6 +114,28 @@ static void sugov_deferred_update(struct sugov_policy *sg_policy)
}
}
+/**
+ * get_capacity_ref_freq - get the reference frequency that has been used to
+ * correlate frequency and compute capacity for a given cpufreq policy. We use
+ * the CPU managing it for the arch_scale_freq_ref() call in the function.
+ * @policy: the cpufreq policy of the CPU in question.
+ *
+ * Return: the reference CPU frequency to compute a capacity.
+ */
+static __always_inline
+unsigned long get_capacity_ref_freq(struct cpufreq_policy *policy)
+{
+ unsigned int freq = arch_scale_freq_ref(policy->cpu);
+
+ if (freq)
+ return freq;
+
+ if (arch_scale_freq_invariant())
+ return policy->cpuinfo.max_freq;
+
+ return policy->cur;
+}
+
/**
* get_next_freq - Compute a new frequency for a given cpufreq policy.
* @sg_policy: schedutil policy object to compute the new frequency for.
@@ -140,10 +162,10 @@ static unsigned int get_next_freq(struct sugov_policy *sg_policy,
unsigned long util, unsigned long max)
{
struct cpufreq_policy *policy = sg_policy->policy;
- unsigned int freq = arch_scale_freq_invariant() ?
- policy->cpuinfo.max_freq : policy->cur;
+ unsigned int freq;
util = map_util_perf(util);
+ freq = get_capacity_ref_freq(policy);
freq = map_util_freq(util, freq, max);
if (freq == sg_policy->cached_raw_freq && !sg_policy->need_freq_update)
--
2.34.1
cpuinfo.max_freq can change at runtime because of boost as an example. This
implies that the value could be different from the frequency that has been
used to compute the capacity of a CPU.
The new arch_scale_freq_ref() returns a fixed and coherent frequency
that can be used to compute the capacity for a given frequency.
Signed-off-by: Vincent Guittot <[email protected]>
Acked-by: Viresh Kumar <[email protected]>
Reviewed-by: Lukasz Luba <[email protected]>
Tested-by: Lukasz Luba <[email protected]>
Acked-by: Rafael J. Wysocki <[email protected]>
---
drivers/cpufreq/cpufreq.c | 4 ++--
include/linux/cpufreq.h | 9 +++++++++
2 files changed, 11 insertions(+), 2 deletions(-)
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 60ed89000e82..8c4f9c2f9c44 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -454,7 +454,7 @@ void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
arch_set_freq_scale(policy->related_cpus,
policy->cur,
- policy->cpuinfo.max_freq);
+ arch_scale_freq_ref(policy->cpu));
spin_lock(&policy->transition_lock);
policy->transition_ongoing = false;
@@ -2174,7 +2174,7 @@ unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
policy->cur = freq;
arch_set_freq_scale(policy->related_cpus, freq,
- policy->cpuinfo.max_freq);
+ arch_scale_freq_ref(policy->cpu));
cpufreq_stats_record_transition(policy, freq);
if (trace_cpu_frequency_enabled()) {
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 71d186d6933a..bbc483b4b6e5 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -1211,6 +1211,15 @@ void arch_set_freq_scale(const struct cpumask *cpus,
{
}
#endif
+
+#ifndef arch_scale_freq_ref
+static __always_inline
+unsigned int arch_scale_freq_ref(int cpu)
+{
+ return 0;
+}
+#endif
+
/* the following are really really optional */
extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs;
--
2.34.1
We move and rename cppc_cpufreq_perf_to_khz and cppc_cpufreq_khz_to_perf
to use them outside cppc_cpufreq in topology_init_cpu_capacity_cppc().
Modify the interface to use struct cppc_perf_caps *caps instead of
struct cppc_cpudata *cpu_data as we only use the field perf_caps.
No functional change
Signed-off-by: Vincent Guittot <[email protected]>
Acked-by: Rafael J. Wysocki <[email protected]>
---
Rafael,
I have kept your Acked as the cppc_acpi.c part has moved in its own patch
and I haven't change this code. Let me know if this is a problem.
drivers/acpi/cppc_acpi.c | 93 +++++++++++++++++++++++
drivers/cpufreq/cppc_cpufreq.c | 134 +++++----------------------------
include/acpi/cppc_acpi.h | 2 +
3 files changed, 112 insertions(+), 117 deletions(-)
diff --git a/drivers/acpi/cppc_acpi.c b/drivers/acpi/cppc_acpi.c
index 7ff269a78c20..72aae5e87788 100644
--- a/drivers/acpi/cppc_acpi.c
+++ b/drivers/acpi/cppc_acpi.c
@@ -39,6 +39,8 @@
#include <linux/rwsem.h>
#include <linux/wait.h>
#include <linux/topology.h>
+#include <linux/dmi.h>
+#include <asm/unaligned.h>
#include <acpi/cppc_acpi.h>
@@ -1760,3 +1762,94 @@ unsigned int cppc_get_transition_latency(int cpu_num)
return latency_ns;
}
EXPORT_SYMBOL_GPL(cppc_get_transition_latency);
+
+/* Minimum struct length needed for the DMI processor entry we want */
+#define DMI_ENTRY_PROCESSOR_MIN_LENGTH 48
+
+/* Offset in the DMI processor structure for the max frequency */
+#define DMI_PROCESSOR_MAX_SPEED 0x14
+
+/* Callback function used to retrieve the max frequency from DMI */
+static void cppc_find_dmi_mhz(const struct dmi_header *dm, void *private)
+{
+ const u8 *dmi_data = (const u8 *)dm;
+ u16 *mhz = (u16 *)private;
+
+ if (dm->type == DMI_ENTRY_PROCESSOR &&
+ dm->length >= DMI_ENTRY_PROCESSOR_MIN_LENGTH) {
+ u16 val = (u16)get_unaligned((const u16 *)
+ (dmi_data + DMI_PROCESSOR_MAX_SPEED));
+ *mhz = val > *mhz ? val : *mhz;
+ }
+}
+
+/* Look up the max frequency in DMI */
+static u64 cppc_get_dmi_max_khz(void)
+{
+ u16 mhz = 0;
+
+ dmi_walk(cppc_find_dmi_mhz, &mhz);
+
+ /*
+ * Real stupid fallback value, just in case there is no
+ * actual value set.
+ */
+ mhz = mhz ? mhz : 1;
+
+ return (1000 * mhz);
+}
+
+/*
+ * If CPPC lowest_freq and nominal_freq registers are exposed then we can
+ * use them to convert perf to freq and vice versa. The conversion is
+ * extrapolated as an affine function passing by the 2 points:
+ * - (Low perf, Low freq)
+ * - (Nominal perf, Nominal perf)
+ */
+unsigned int cppc_perf_to_khz(struct cppc_perf_caps *caps, unsigned int perf)
+{
+ s64 retval, offset = 0;
+ static u64 max_khz;
+ u64 mul, div;
+
+ if (caps->lowest_freq && caps->nominal_freq) {
+ mul = caps->nominal_freq - caps->lowest_freq;
+ div = caps->nominal_perf - caps->lowest_perf;
+ offset = caps->nominal_freq - div64_u64(caps->nominal_perf * mul, div);
+ } else {
+ if (!max_khz)
+ max_khz = cppc_get_dmi_max_khz();
+ mul = max_khz;
+ div = caps->highest_perf;
+ }
+
+ retval = offset + div64_u64(perf * mul, div);
+ if (retval >= 0)
+ return retval;
+ return 0;
+}
+EXPORT_SYMBOL_GPL(cppc_perf_to_khz);
+
+unsigned int cppc_khz_to_perf(struct cppc_perf_caps *caps, unsigned int freq)
+{
+ s64 retval, offset = 0;
+ static u64 max_khz;
+ u64 mul, div;
+
+ if (caps->lowest_freq && caps->nominal_freq) {
+ mul = caps->nominal_perf - caps->lowest_perf;
+ div = caps->nominal_freq - caps->lowest_freq;
+ offset = caps->nominal_perf - div64_u64(caps->nominal_freq * mul, div);
+ } else {
+ if (!max_khz)
+ max_khz = cppc_get_dmi_max_khz();
+ mul = caps->highest_perf;
+ div = max_khz;
+ }
+
+ retval = offset + div64_u64(freq * mul, div);
+ if (retval >= 0)
+ return retval;
+ return 0;
+}
+EXPORT_SYMBOL_GPL(cppc_khz_to_perf);
diff --git a/drivers/cpufreq/cppc_cpufreq.c b/drivers/cpufreq/cppc_cpufreq.c
index fe08ca419b3d..14457703cf00 100644
--- a/drivers/cpufreq/cppc_cpufreq.c
+++ b/drivers/cpufreq/cppc_cpufreq.c
@@ -27,12 +27,6 @@
#include <acpi/cppc_acpi.h>
-/* Minimum struct length needed for the DMI processor entry we want */
-#define DMI_ENTRY_PROCESSOR_MIN_LENGTH 48
-
-/* Offset in the DMI processor structure for the max frequency */
-#define DMI_PROCESSOR_MAX_SPEED 0x14
-
/*
* This list contains information parsed from per CPU ACPI _CPC and _PSD
* structures: e.g. the highest and lowest supported performance, capabilities,
@@ -291,97 +285,9 @@ static inline void cppc_freq_invariance_exit(void)
}
#endif /* CONFIG_ACPI_CPPC_CPUFREQ_FIE */
-/* Callback function used to retrieve the max frequency from DMI */
-static void cppc_find_dmi_mhz(const struct dmi_header *dm, void *private)
-{
- const u8 *dmi_data = (const u8 *)dm;
- u16 *mhz = (u16 *)private;
-
- if (dm->type == DMI_ENTRY_PROCESSOR &&
- dm->length >= DMI_ENTRY_PROCESSOR_MIN_LENGTH) {
- u16 val = (u16)get_unaligned((const u16 *)
- (dmi_data + DMI_PROCESSOR_MAX_SPEED));
- *mhz = val > *mhz ? val : *mhz;
- }
-}
-
-/* Look up the max frequency in DMI */
-static u64 cppc_get_dmi_max_khz(void)
-{
- u16 mhz = 0;
-
- dmi_walk(cppc_find_dmi_mhz, &mhz);
-
- /*
- * Real stupid fallback value, just in case there is no
- * actual value set.
- */
- mhz = mhz ? mhz : 1;
-
- return (1000 * mhz);
-}
-
-/*
- * If CPPC lowest_freq and nominal_freq registers are exposed then we can
- * use them to convert perf to freq and vice versa. The conversion is
- * extrapolated as an affine function passing by the 2 points:
- * - (Low perf, Low freq)
- * - (Nominal perf, Nominal perf)
- */
-static unsigned int cppc_cpufreq_perf_to_khz(struct cppc_cpudata *cpu_data,
- unsigned int perf)
-{
- struct cppc_perf_caps *caps = &cpu_data->perf_caps;
- s64 retval, offset = 0;
- static u64 max_khz;
- u64 mul, div;
-
- if (caps->lowest_freq && caps->nominal_freq) {
- mul = caps->nominal_freq - caps->lowest_freq;
- div = caps->nominal_perf - caps->lowest_perf;
- offset = caps->nominal_freq - div64_u64(caps->nominal_perf * mul, div);
- } else {
- if (!max_khz)
- max_khz = cppc_get_dmi_max_khz();
- mul = max_khz;
- div = caps->highest_perf;
- }
-
- retval = offset + div64_u64(perf * mul, div);
- if (retval >= 0)
- return retval;
- return 0;
-}
-
-static unsigned int cppc_cpufreq_khz_to_perf(struct cppc_cpudata *cpu_data,
- unsigned int freq)
-{
- struct cppc_perf_caps *caps = &cpu_data->perf_caps;
- s64 retval, offset = 0;
- static u64 max_khz;
- u64 mul, div;
-
- if (caps->lowest_freq && caps->nominal_freq) {
- mul = caps->nominal_perf - caps->lowest_perf;
- div = caps->nominal_freq - caps->lowest_freq;
- offset = caps->nominal_perf - div64_u64(caps->nominal_freq * mul, div);
- } else {
- if (!max_khz)
- max_khz = cppc_get_dmi_max_khz();
- mul = caps->highest_perf;
- div = max_khz;
- }
-
- retval = offset + div64_u64(freq * mul, div);
- if (retval >= 0)
- return retval;
- return 0;
-}
-
static int cppc_cpufreq_set_target(struct cpufreq_policy *policy,
unsigned int target_freq,
unsigned int relation)
-
{
struct cppc_cpudata *cpu_data = policy->driver_data;
unsigned int cpu = policy->cpu;
@@ -389,7 +295,7 @@ static int cppc_cpufreq_set_target(struct cpufreq_policy *policy,
u32 desired_perf;
int ret = 0;
- desired_perf = cppc_cpufreq_khz_to_perf(cpu_data, target_freq);
+ desired_perf = cppc_khz_to_perf(&cpu_data->perf_caps, target_freq);
/* Return if it is exactly the same perf */
if (desired_perf == cpu_data->perf_ctrls.desired_perf)
return ret;
@@ -417,7 +323,7 @@ static unsigned int cppc_cpufreq_fast_switch(struct cpufreq_policy *policy,
u32 desired_perf;
int ret;
- desired_perf = cppc_cpufreq_khz_to_perf(cpu_data, target_freq);
+ desired_perf = cppc_khz_to_perf(&cpu_data->perf_caps, target_freq);
cpu_data->perf_ctrls.desired_perf = desired_perf;
ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);
@@ -530,7 +436,7 @@ static int cppc_get_cpu_power(struct device *cpu_dev,
min_step = min_cap / CPPC_EM_CAP_STEP;
max_step = max_cap / CPPC_EM_CAP_STEP;
- perf_prev = cppc_cpufreq_khz_to_perf(cpu_data, *KHz);
+ perf_prev = cppc_khz_to_perf(perf_caps, *KHz);
step = perf_prev / perf_step;
if (step > max_step)
@@ -550,8 +456,8 @@ static int cppc_get_cpu_power(struct device *cpu_dev,
perf = step * perf_step;
}
- *KHz = cppc_cpufreq_perf_to_khz(cpu_data, perf);
- perf_check = cppc_cpufreq_khz_to_perf(cpu_data, *KHz);
+ *KHz = cppc_perf_to_khz(perf_caps, perf);
+ perf_check = cppc_khz_to_perf(perf_caps, *KHz);
step_check = perf_check / perf_step;
/*
@@ -561,8 +467,8 @@ static int cppc_get_cpu_power(struct device *cpu_dev,
*/
while ((*KHz == prev_freq) || (step_check != step)) {
perf++;
- *KHz = cppc_cpufreq_perf_to_khz(cpu_data, perf);
- perf_check = cppc_cpufreq_khz_to_perf(cpu_data, *KHz);
+ *KHz = cppc_perf_to_khz(perf_caps, perf);
+ perf_check = cppc_khz_to_perf(perf_caps, *KHz);
step_check = perf_check / perf_step;
}
@@ -591,7 +497,7 @@ static int cppc_get_cpu_cost(struct device *cpu_dev, unsigned long KHz,
perf_caps = &cpu_data->perf_caps;
max_cap = arch_scale_cpu_capacity(cpu_dev->id);
- perf_prev = cppc_cpufreq_khz_to_perf(cpu_data, KHz);
+ perf_prev = cppc_khz_to_perf(perf_caps, KHz);
perf_step = CPPC_EM_CAP_STEP * perf_caps->highest_perf / max_cap;
step = perf_prev / perf_step;
@@ -724,20 +630,16 @@ static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy)
* Set min to lowest nonlinear perf to avoid any efficiency penalty (see
* Section 8.4.7.1.1.5 of ACPI 6.1 spec)
*/
- policy->min = cppc_cpufreq_perf_to_khz(cpu_data,
- caps->lowest_nonlinear_perf);
- policy->max = cppc_cpufreq_perf_to_khz(cpu_data,
- caps->nominal_perf);
+ policy->min = cppc_perf_to_khz(caps, caps->lowest_nonlinear_perf);
+ policy->max = cppc_perf_to_khz(caps, caps->nominal_perf);
/*
* Set cpuinfo.min_freq to Lowest to make the full range of performance
* available if userspace wants to use any perf between lowest & lowest
* nonlinear perf
*/
- policy->cpuinfo.min_freq = cppc_cpufreq_perf_to_khz(cpu_data,
- caps->lowest_perf);
- policy->cpuinfo.max_freq = cppc_cpufreq_perf_to_khz(cpu_data,
- caps->nominal_perf);
+ policy->cpuinfo.min_freq = cppc_perf_to_khz(caps, caps->lowest_perf);
+ policy->cpuinfo.max_freq = cppc_perf_to_khz(caps, caps->nominal_perf);
policy->transition_delay_us = cppc_cpufreq_get_transition_delay_us(cpu);
policy->shared_type = cpu_data->shared_type;
@@ -773,7 +675,7 @@ static int cppc_cpufreq_cpu_init(struct cpufreq_policy *policy)
boost_supported = true;
/* Set policy->cur to max now. The governors will adjust later. */
- policy->cur = cppc_cpufreq_perf_to_khz(cpu_data, caps->highest_perf);
+ policy->cur = cppc_perf_to_khz(caps, caps->highest_perf);
cpu_data->perf_ctrls.desired_perf = caps->highest_perf;
ret = cppc_set_perf(cpu, &cpu_data->perf_ctrls);
@@ -863,7 +765,7 @@ static unsigned int cppc_cpufreq_get_rate(unsigned int cpu)
delivered_perf = cppc_perf_from_fbctrs(cpu_data, &fb_ctrs_t0,
&fb_ctrs_t1);
- return cppc_cpufreq_perf_to_khz(cpu_data, delivered_perf);
+ return cppc_perf_to_khz(&cpu_data->perf_caps, delivered_perf);
}
static int cppc_cpufreq_set_boost(struct cpufreq_policy *policy, int state)
@@ -878,11 +780,9 @@ static int cppc_cpufreq_set_boost(struct cpufreq_policy *policy, int state)
}
if (state)
- policy->max = cppc_cpufreq_perf_to_khz(cpu_data,
- caps->highest_perf);
+ policy->max = cppc_perf_to_khz(caps, caps->highest_perf);
else
- policy->max = cppc_cpufreq_perf_to_khz(cpu_data,
- caps->nominal_perf);
+ policy->max = cppc_perf_to_khz(caps, caps->nominal_perf);
policy->cpuinfo.max_freq = policy->max;
ret = freq_qos_update_request(policy->max_freq_req, policy->max);
@@ -937,7 +837,7 @@ static unsigned int hisi_cppc_cpufreq_get_rate(unsigned int cpu)
if (ret < 0)
return -EIO;
- return cppc_cpufreq_perf_to_khz(cpu_data, desired_perf);
+ return cppc_perf_to_khz(&cpu_data->perf_caps, desired_perf);
}
static void cppc_check_hisi_workaround(void)
diff --git a/include/acpi/cppc_acpi.h b/include/acpi/cppc_acpi.h
index 6126c977ece0..3a0995f8bce8 100644
--- a/include/acpi/cppc_acpi.h
+++ b/include/acpi/cppc_acpi.h
@@ -144,6 +144,8 @@ extern int cppc_set_perf(int cpu, struct cppc_perf_ctrls *perf_ctrls);
extern int cppc_set_enable(int cpu, bool enable);
extern int cppc_get_perf_caps(int cpu, struct cppc_perf_caps *caps);
extern bool cppc_perf_ctrs_in_pcc(void);
+extern unsigned int cppc_perf_to_khz(struct cppc_perf_caps *caps, unsigned int perf);
+extern unsigned int cppc_khz_to_perf(struct cppc_perf_caps *caps, unsigned int freq);
extern bool acpi_cpc_valid(void);
extern bool cppc_allow_fast_switch(void);
extern int acpi_get_psd_map(unsigned int cpu, struct cppc_cpudata *cpu_data);
--
2.34.1
The last item of a performance domain is not always the performance point
that has been used to compute CPU's capacity. This can lead to different
target frequency compared with other part of the system like schedutil and
would result in wrong energy estimation.
A new arch_scale_freq_ref() is available to return a fixed and coherent
frequency reference that can be used when computing the CPU's frequency
for an level of utilization. Use this function to get this reference
frequency.
Energy model is never used without defining arch_scale_freq_ref() but
can be compiled. Define a default arch_scale_freq_ref() returning 0
in such case.
Signed-off-by: Vincent Guittot <[email protected]>
Reviewed-by: Lukasz Luba <[email protected]>
Tested-by: Lukasz Luba <[email protected]>
---
include/linux/energy_model.h | 14 +++++++++++---
1 file changed, 11 insertions(+), 3 deletions(-)
diff --git a/include/linux/energy_model.h b/include/linux/energy_model.h
index b9caa01dfac4..1b0c8490d4bd 100644
--- a/include/linux/energy_model.h
+++ b/include/linux/energy_model.h
@@ -204,6 +204,14 @@ struct em_perf_state *em_pd_get_efficient_state(struct em_perf_domain *pd,
return ps;
}
+#ifndef arch_scale_freq_ref
+static __always_inline
+unsigned int arch_scale_freq_ref(int cpu)
+{
+ return 0;
+}
+#endif
+
/**
* em_cpu_energy() - Estimates the energy consumed by the CPUs of a
* performance domain
@@ -224,7 +232,7 @@ static inline unsigned long em_cpu_energy(struct em_perf_domain *pd,
unsigned long max_util, unsigned long sum_util,
unsigned long allowed_cpu_cap)
{
- unsigned long freq, scale_cpu;
+ unsigned long freq, ref_freq, scale_cpu;
struct em_perf_state *ps;
int cpu;
@@ -241,11 +249,11 @@ static inline unsigned long em_cpu_energy(struct em_perf_domain *pd,
*/
cpu = cpumask_first(to_cpumask(pd->cpus));
scale_cpu = arch_scale_cpu_capacity(cpu);
- ps = &pd->table[pd->nr_perf_states - 1];
+ ref_freq = arch_scale_freq_ref(cpu);
max_util = map_util_perf(max_util);
max_util = min(max_util, allowed_cpu_cap);
- freq = map_util_freq(max_util, ps->frequency, scale_cpu);
+ freq = map_util_freq(max_util, ref_freq, scale_cpu);
/*
* Find the lowest performance state of the Energy Model above the
--
2.34.1
Use the new capacity_ref_freq to set the ratio that is used by AMU for
computing the arch_scale_freq_capacity().
This helps to keep everything aligned using the same reference for
computing CPUs capacity.
The default value of the ratio (stored in per_cpu(arch_max_freq_scale)
ensures that arch_scale_freq_capacity() returns max capacity until it is
set to its correct value with the cpu capacity and capacity_ref_freq.
Signed-off-by: Vincent Guittot <[email protected]>
---
arch/arm64/kernel/topology.c | 26 ++++++++++++++------------
drivers/base/arch_topology.c | 12 +++++++++++-
include/linux/arch_topology.h | 1 +
3 files changed, 26 insertions(+), 13 deletions(-)
diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
index 817d788cd866..626031076b75 100644
--- a/arch/arm64/kernel/topology.c
+++ b/arch/arm64/kernel/topology.c
@@ -82,7 +82,12 @@ int __init parse_acpi_topology(void)
#undef pr_fmt
#define pr_fmt(fmt) "AMU: " fmt
-static DEFINE_PER_CPU_READ_MOSTLY(unsigned long, arch_max_freq_scale);
+/*
+ * Ensure that amu_scale_freq_tick() will return SCHED_CAPACITY_SCALE until
+ * the CPU capacity and its assosciated frequency have been correctly
+ * initialized.
+ */
+static DEFINE_PER_CPU_READ_MOSTLY(unsigned long, arch_max_freq_scale) = 1UL << (2 * SCHED_CAPACITY_SHIFT);
static DEFINE_PER_CPU(u64, arch_const_cycles_prev);
static DEFINE_PER_CPU(u64, arch_core_cycles_prev);
static cpumask_var_t amu_fie_cpus;
@@ -112,14 +117,14 @@ static inline bool freq_counters_valid(int cpu)
return true;
}
-static int freq_inv_set_max_ratio(int cpu, u64 max_rate, u64 ref_rate)
+void freq_inv_set_max_ratio(int cpu, u64 max_rate)
{
- u64 ratio;
+ u64 ratio, ref_rate = arch_timer_get_rate();
if (unlikely(!max_rate || !ref_rate)) {
- pr_debug("CPU%d: invalid maximum or reference frequency.\n",
+ WARN_ONCE(1, "CPU%d: invalid maximum or reference frequency.\n",
cpu);
- return -EINVAL;
+ return;
}
/*
@@ -139,12 +144,12 @@ static int freq_inv_set_max_ratio(int cpu, u64 max_rate, u64 ref_rate)
ratio = div64_u64(ratio, max_rate);
if (!ratio) {
WARN_ONCE(1, "Reference frequency too low.\n");
- return -EINVAL;
+ return;
}
- per_cpu(arch_max_freq_scale, cpu) = (unsigned long)ratio;
+ WRITE_ONCE(per_cpu(arch_max_freq_scale, cpu), (unsigned long)ratio);
- return 0;
+ return;
}
static void amu_scale_freq_tick(void)
@@ -195,10 +200,7 @@ static void amu_fie_setup(const struct cpumask *cpus)
return;
for_each_cpu(cpu, cpus) {
- if (!freq_counters_valid(cpu) ||
- freq_inv_set_max_ratio(cpu,
- cpufreq_get_hw_max_freq(cpu) * 1000ULL,
- arch_timer_get_rate()))
+ if (!freq_counters_valid(cpu))
return;
}
diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
index d4bef370feb3..3cba7dc753b3 100644
--- a/drivers/base/arch_topology.c
+++ b/drivers/base/arch_topology.c
@@ -344,6 +344,10 @@ bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
return !ret;
}
+void __weak freq_inv_set_max_ratio(int cpu, u64 max_rate)
+{
+}
+
#ifdef CONFIG_ACPI_CPPC_LIB
#include <acpi/cppc_acpi.h>
@@ -381,6 +385,9 @@ void topology_init_cpu_capacity_cppc(void)
}
for_each_possible_cpu(cpu) {
+ freq_inv_set_max_ratio(cpu,
+ per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
+
capacity = raw_capacity[cpu];
capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
capacity_scale);
@@ -422,8 +429,11 @@ init_cpu_capacity_callback(struct notifier_block *nb,
cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
- for_each_cpu(cpu, policy->related_cpus)
+ for_each_cpu(cpu, policy->related_cpus) {
per_cpu(capacity_ref_freq, cpu) = policy->cpuinfo.max_freq;
+ freq_inv_set_max_ratio(cpu,
+ per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
+ }
if (cpumask_empty(cpus_to_visit)) {
topology_normalize_cpu_scale();
diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
index 38ca6c76af56..ffdf0b7c55fa 100644
--- a/include/linux/arch_topology.h
+++ b/include/linux/arch_topology.h
@@ -99,6 +99,7 @@ void update_siblings_masks(unsigned int cpu);
void remove_cpu_topology(unsigned int cpuid);
void reset_cpu_topology(void);
int parse_acpi_topology(void);
+void freq_inv_set_max_ratio(int cpu, u64 max_rate);
#endif
#endif /* _LINUX_ARCH_TOPOLOGY_H_ */
--
2.34.1
Save the frequency associated to the performance that has been used when
initializing the capacity of CPUs.
Also, cppc cpufreq driver can register an artificial energy model. In such
case, it needs the frequency for this compute capacity.
Signed-off-by: Vincent Guittot <[email protected]>
---
drivers/base/arch_topology.c | 15 ++++++++++++++-
1 file changed, 14 insertions(+), 1 deletion(-)
diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
index 9a073c2d2086..d4bef370feb3 100644
--- a/drivers/base/arch_topology.c
+++ b/drivers/base/arch_topology.c
@@ -349,6 +349,7 @@ bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
void topology_init_cpu_capacity_cppc(void)
{
+ u64 capacity, capacity_scale = 0;
struct cppc_perf_caps perf_caps;
int cpu;
@@ -365,6 +366,10 @@ void topology_init_cpu_capacity_cppc(void)
(perf_caps.highest_perf >= perf_caps.nominal_perf) &&
(perf_caps.highest_perf >= perf_caps.lowest_perf)) {
raw_capacity[cpu] = perf_caps.highest_perf;
+ capacity_scale = max_t(u64, capacity_scale, raw_capacity[cpu]);
+
+ per_cpu(capacity_ref_freq, cpu) = cppc_perf_to_khz(&perf_caps, raw_capacity[cpu]);
+
pr_debug("cpu_capacity: CPU%d cpu_capacity=%u (raw).\n",
cpu, raw_capacity[cpu]);
continue;
@@ -375,7 +380,15 @@ void topology_init_cpu_capacity_cppc(void)
goto exit;
}
- topology_normalize_cpu_scale();
+ for_each_possible_cpu(cpu) {
+ capacity = raw_capacity[cpu];
+ capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
+ capacity_scale);
+ topology_set_cpu_scale(cpu, capacity);
+ pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
+ cpu, topology_get_cpu_scale(cpu));
+ }
+
schedule_work(&update_topology_flags_work);
pr_debug("cpu_capacity: cpu_capacity initialization done\n");
--
2.34.1
* Vincent Guittot <[email protected]> wrote:
> --- a/include/linux/arch_topology.h
> +++ b/include/linux/arch_topology.h
> @@ -27,6 +27,13 @@ static inline unsigned long topology_get_cpu_scale(int cpu)
>
> void topology_set_cpu_scale(unsigned int cpu, unsigned long capacity);
>
> +DECLARE_PER_CPU(unsigned long, capacity_ref_freq);
> +
> +static inline unsigned long topology_get_freq_ref(int cpu)
> +{
> + return per_cpu(capacity_ref_freq, cpu);
> +}
> +
> DECLARE_PER_CPU(unsigned long, arch_freq_scale);
So mind naming it in a way that expresses that this is indeed a maximum
frequency? arch_scale_ref_freq_max or so?
Also, is there any particular concept behind naming one new symbol
'freq_ref', the other 'ref_freq'? If not then please standardize on one
variant.
Thanks,
Ingo
* Vincent Guittot <[email protected]> wrote:
> Vincent Guittot (7):
> topology: add a new arch_scale_freq_reference
> cpufreq: use the fixed and coherent frequency for scaling capacity
> cpufreq/schedutil: use a fixed reference frequency
> energy_model: use a fixed reference frequency
> cpufreq/cppc: move and rename cppc_cpufreq_{perf_to_khz|khz_to_perf}
> cpufreq/cppc: set the frequency used for computing the capacity
> arm64/amu: use capacity_ref_freq to set AMU ratio
Just a general comment wrt. titles: please capitalize the verb, as we'd do
in a proper sentence. Saves maintainers one more thing to fix when applying
patches.
Thanks,
Ingo
* Vincent Guittot <[email protected]> wrote:
> +/* Look up the max frequency in DMI */
> +static u64 cppc_get_dmi_max_khz(void)
> +{
> + u16 mhz = 0;
> +
> + dmi_walk(cppc_find_dmi_mhz, &mhz);
> +
> + /*
> + * Real stupid fallback value, just in case there is no
> + * actual value set.
> + */
> + mhz = mhz ? mhz : 1;
> +
> + return (1000 * mhz);
Nit, and I realize this is pre-existing code, but 'return' is a keyword,
not a function, so the parentheses are not needed.
Thanks,
Ingo
On Fri, 27 Oct 2023 at 11:31, Ingo Molnar <[email protected]> wrote:
>
>
> * Vincent Guittot <[email protected]> wrote:
>
> > --- a/include/linux/arch_topology.h
> > +++ b/include/linux/arch_topology.h
> > @@ -27,6 +27,13 @@ static inline unsigned long topology_get_cpu_scale(int cpu)
> >
> > void topology_set_cpu_scale(unsigned int cpu, unsigned long capacity);
> >
> > +DECLARE_PER_CPU(unsigned long, capacity_ref_freq);
> > +
> > +static inline unsigned long topology_get_freq_ref(int cpu)
> > +{
> > + return per_cpu(capacity_ref_freq, cpu);
> > +}
> > +
> > DECLARE_PER_CPU(unsigned long, arch_freq_scale);
>
> So mind naming it in a way that expresses that this is indeed a maximum
> frequency? arch_scale_ref_freq_max or so?
This does not always have to be the max frequency of the CPU but the
frequency that has been used to compute the capacity of the CPU so
it's the "reference" frequency used for computing the capacity and
that must be used to compute the capacity for a given frequency and
the other way. That 's why I have intentionally not used freq_max
Then other similar functions start with arch_scale_freq_something
>
> Also, is there any particular concept behind naming one new symbol
> 'freq_ref', the other 'ref_freq'? If not then please standardize on one
> variant.
no particular reason. ref_freq comes from "reference frequency" but
interfaces follows arch_scale_freq_something or
topology_*_freq_something
so we should keep freq_ref to keep interfaces aligned
>
> Thanks,
>
> Ingo
On Fri, Oct 27, 2023 at 10:04:00AM +0200, Vincent Guittot wrote:
> Use the new capacity_ref_freq to set the ratio that is used by AMU for
> computing the arch_scale_freq_capacity().
> This helps to keep everything aligned using the same reference for
> computing CPUs capacity.
>
> The default value of the ratio (stored in per_cpu(arch_max_freq_scale)
> ensures that arch_scale_freq_capacity() returns max capacity until it is
> set to its correct value with the cpu capacity and capacity_ref_freq.
>
> Signed-off-by: Vincent Guittot <[email protected]>
> ---
> arch/arm64/kernel/topology.c | 26 ++++++++++++++------------
> drivers/base/arch_topology.c | 12 +++++++++++-
> include/linux/arch_topology.h | 1 +
> 3 files changed, 26 insertions(+), 13 deletions(-)
>
> diff --git a/arch/arm64/kernel/topology.c b/arch/arm64/kernel/topology.c
> index 817d788cd866..626031076b75 100644
> --- a/arch/arm64/kernel/topology.c
> +++ b/arch/arm64/kernel/topology.c
> @@ -82,7 +82,12 @@ int __init parse_acpi_topology(void)
> #undef pr_fmt
> #define pr_fmt(fmt) "AMU: " fmt
>
> -static DEFINE_PER_CPU_READ_MOSTLY(unsigned long, arch_max_freq_scale);
> +/*
> + * Ensure that amu_scale_freq_tick() will return SCHED_CAPACITY_SCALE until
> + * the CPU capacity and its assosciated frequency have been correctly
> + * initialized.
> + */
> +static DEFINE_PER_CPU_READ_MOSTLY(unsigned long, arch_max_freq_scale) = 1UL << (2 * SCHED_CAPACITY_SHIFT);
> static DEFINE_PER_CPU(u64, arch_const_cycles_prev);
> static DEFINE_PER_CPU(u64, arch_core_cycles_prev);
> static cpumask_var_t amu_fie_cpus;
> @@ -112,14 +117,14 @@ static inline bool freq_counters_valid(int cpu)
> return true;
> }
>
> -static int freq_inv_set_max_ratio(int cpu, u64 max_rate, u64 ref_rate)
> +void freq_inv_set_max_ratio(int cpu, u64 max_rate)
> {
> - u64 ratio;
> + u64 ratio, ref_rate = arch_timer_get_rate();
>
> if (unlikely(!max_rate || !ref_rate)) {
> - pr_debug("CPU%d: invalid maximum or reference frequency.\n",
> + WARN_ONCE(1, "CPU%d: invalid maximum or reference frequency.\n",
> cpu);
> - return -EINVAL;
> + return;
> }
>
> /*
> @@ -139,12 +144,12 @@ static int freq_inv_set_max_ratio(int cpu, u64 max_rate, u64 ref_rate)
> ratio = div64_u64(ratio, max_rate);
> if (!ratio) {
> WARN_ONCE(1, "Reference frequency too low.\n");
> - return -EINVAL;
> + return;
> }
>
> - per_cpu(arch_max_freq_scale, cpu) = (unsigned long)ratio;
> + WRITE_ONCE(per_cpu(arch_max_freq_scale, cpu), (unsigned long)ratio);
>
> - return 0;
> + return;
> }
>
> static void amu_scale_freq_tick(void)
> @@ -195,10 +200,7 @@ static void amu_fie_setup(const struct cpumask *cpus)
> return;
>
> for_each_cpu(cpu, cpus) {
> - if (!freq_counters_valid(cpu) ||
> - freq_inv_set_max_ratio(cpu,
> - cpufreq_get_hw_max_freq(cpu) * 1000ULL,
> - arch_timer_get_rate()))
> + if (!freq_counters_valid(cpu))
> return;
> }
>
> diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
> index d4bef370feb3..3cba7dc753b3 100644
> --- a/drivers/base/arch_topology.c
> +++ b/drivers/base/arch_topology.c
> @@ -344,6 +344,10 @@ bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
> return !ret;
> }
>
> +void __weak freq_inv_set_max_ratio(int cpu, u64 max_rate)
> +{
> +}
> +
> #ifdef CONFIG_ACPI_CPPC_LIB
> #include <acpi/cppc_acpi.h>
>
> @@ -381,6 +385,9 @@ void topology_init_cpu_capacity_cppc(void)
> }
>
> for_each_possible_cpu(cpu) {
> + freq_inv_set_max_ratio(cpu,
> + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> +
The capacity_ref_freq set earlier will still lead to units mismatch,
as at the point of calling topology_init_cpu_capacity_cppc the lowest & nominal
frequencies will be provided in MHz (unless I have missed smth).
This means that use of both, the capacity_ref_freq and the arch_freq_scale
will generate unexpected results, so I guess this should get amended in the
preceding patch (?) [1]
---
BR
B.
[1] https://lore.kernel.org/linux-arm-kernel/[email protected]/T/#m42daa167097edc190b1cfc05382c385ed801d909
> capacity = raw_capacity[cpu];
> capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
> capacity_scale);
> @@ -422,8 +429,11 @@ init_cpu_capacity_callback(struct notifier_block *nb,
>
> cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
>
> - for_each_cpu(cpu, policy->related_cpus)
> + for_each_cpu(cpu, policy->related_cpus) {
> per_cpu(capacity_ref_freq, cpu) = policy->cpuinfo.max_freq;
> + freq_inv_set_max_ratio(cpu,
> + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> + }
>
> if (cpumask_empty(cpus_to_visit)) {
> topology_normalize_cpu_scale();
> diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
> index 38ca6c76af56..ffdf0b7c55fa 100644
> --- a/include/linux/arch_topology.h
> +++ b/include/linux/arch_topology.h
> @@ -99,6 +99,7 @@ void update_siblings_masks(unsigned int cpu);
> void remove_cpu_topology(unsigned int cpuid);
> void reset_cpu_topology(void);
> int parse_acpi_topology(void);
> +void freq_inv_set_max_ratio(int cpu, u64 max_rate);
> #endif
>
> #endif /* _LINUX_ARCH_TOPOLOGY_H_ */
> --
> 2.34.1
>
Hi Beata,
On Wed, 1 Nov 2023 at 00:59, Beata Michalska <[email protected]> wrote:
>
> On Fri, Oct 27, 2023 at 10:04:00AM +0200, Vincent Guittot wrote:
> > Use the new capacity_ref_freq to set the ratio that is used by AMU for
> > computing the arch_scale_freq_capacity().
> > This helps to keep everything aligned using the same reference for
> > computing CPUs capacity.
> >
[..]
> > @@ -381,6 +385,9 @@ void topology_init_cpu_capacity_cppc(void)
> > }
> >
> > for_each_possible_cpu(cpu) {
> > + freq_inv_set_max_ratio(cpu,
> > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > +
> The capacity_ref_freq set earlier will still lead to units mismatch,
> as at the point of calling topology_init_cpu_capacity_cppc the lowest & nominal
> frequencies will be provided in MHz (unless I have missed smth).
I don't get your point:
the unit of per_cpu(capacity_freq_ref, cpu) is Khz
For cppc, we have
per_cpu(capacity_freq_ref, cpu) = cppc_perf_to_khz(&perf_caps,
raw_capacity[cpu]);
freq_inv_set_max_ratio() uses
arch_timer_get_rate() which returns a freq in Hz
and
per_cpu(capacity_freq_ref, cpu) * HZ_PER_KHZ. to get a freq in Hz too.
> This means that use of both, the capacity_ref_freq and the arch_freq_scale
> will generate unexpected results, so I guess this should get amended in the
> preceding patch (?) [1]
>
> ---
> BR
> B.
>
> [1] https://lore.kernel.org/linux-arm-kernel/[email protected]/T/#m42daa167097edc190b1cfc05382c385ed801d909
>
> > capacity = raw_capacity[cpu];
> > capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
> > capacity_scale);
> > @@ -422,8 +429,11 @@ init_cpu_capacity_callback(struct notifier_block *nb,
> >
> > cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
> >
> > - for_each_cpu(cpu, policy->related_cpus)
> > + for_each_cpu(cpu, policy->related_cpus) {
> > per_cpu(capacity_ref_freq, cpu) = policy->cpuinfo.max_freq;
> > + freq_inv_set_max_ratio(cpu,
> > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > + }
> >
> > if (cpumask_empty(cpus_to_visit)) {
> > topology_normalize_cpu_scale();
> > diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
> > index 38ca6c76af56..ffdf0b7c55fa 100644
> > --- a/include/linux/arch_topology.h
> > +++ b/include/linux/arch_topology.h
> > @@ -99,6 +99,7 @@ void update_siblings_masks(unsigned int cpu);
> > void remove_cpu_topology(unsigned int cpuid);
> > void reset_cpu_topology(void);
> > int parse_acpi_topology(void);
> > +void freq_inv_set_max_ratio(int cpu, u64 max_rate);
> > #endif
> >
> > #endif /* _LINUX_ARCH_TOPOLOGY_H_ */
> > --
> > 2.34.1
> >
Hello Vincent,
On 10/27/23 10:03, Vincent Guittot wrote:
> Save the frequency associated to the performance that has been used when
> initializing the capacity of CPUs.
> Also, cppc cpufreq driver can register an artificial energy model. In such
> case, it needs the frequency for this compute capacity.
>
> Signed-off-by: Vincent Guittot <[email protected]>
> ---
> drivers/base/arch_topology.c | 15 ++++++++++++++-
> 1 file changed, 14 insertions(+), 1 deletion(-)
>
> diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
> index 9a073c2d2086..d4bef370feb3 100644
> --- a/drivers/base/arch_topology.c
> +++ b/drivers/base/arch_topology.c
> @@ -349,6 +349,7 @@ bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
>
> void topology_init_cpu_capacity_cppc(void)
> {
> + u64 capacity, capacity_scale = 0;
> struct cppc_perf_caps perf_caps;
> int cpu;
>
> @@ -365,6 +366,10 @@ void topology_init_cpu_capacity_cppc(void)
> (perf_caps.highest_perf >= perf_caps.nominal_perf) &&
> (perf_caps.highest_perf >= perf_caps.lowest_perf)) {
> raw_capacity[cpu] = perf_caps.highest_perf;
> + capacity_scale = max_t(u64, capacity_scale, raw_capacity[cpu]);
> +
> + per_cpu(capacity_ref_freq, cpu) = cppc_perf_to_khz(&perf_caps, raw_capacity[cpu]);
> +
To continue Beata's point, I think there is an issue with the following:
cppc_perf_to_khz() and cppc_khz_to_perf() were previously used with a struct containing
frequencies in KHz, cf. [1].
In the original _CPC object, frequencies are in MHz. It means that the perf_caps struct
here contains frequencies in MHz, and per_cpu(capacity_ref_freq, cpu) is in MHz aswell.
[1] https://github.com/torvalds/linux/blob/master/drivers/cpufreq/cppc_cpufreq.c#L682
> pr_debug("cpu_capacity: CPU%d cpu_capacity=%u (raw).\n",
> cpu, raw_capacity[cpu]);
> continue;
> @@ -375,7 +380,15 @@ void topology_init_cpu_capacity_cppc(void)
> goto exit;
> }
>
> - topology_normalize_cpu_scale();
> + for_each_possible_cpu(cpu) {
> + capacity = raw_capacity[cpu];
> + capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
> + capacity_scale);
> + topology_set_cpu_scale(cpu, capacity);
> + pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
> + cpu, topology_get_cpu_scale(cpu));
> + }
> +
> schedule_work(&update_topology_flags_work);
> pr_debug("cpu_capacity: cpu_capacity initialization done\n");
>
Hi Vincent,
On Wed, Nov 01, 2023 at 10:04:27AM +0100, Vincent Guittot wrote:
> Hi Beata,
>
> On Wed, 1 Nov 2023 at 00:59, Beata Michalska <[email protected]> wrote:
> >
> > On Fri, Oct 27, 2023 at 10:04:00AM +0200, Vincent Guittot wrote:
> > > Use the new capacity_ref_freq to set the ratio that is used by AMU for
> > > computing the arch_scale_freq_capacity().
> > > This helps to keep everything aligned using the same reference for
> > > computing CPUs capacity.
> > >
>
> [..]
>
> > > @@ -381,6 +385,9 @@ void topology_init_cpu_capacity_cppc(void)
> > > }
> > >
> > > for_each_possible_cpu(cpu) {
> > > + freq_inv_set_max_ratio(cpu,
> > > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > > +
> > The capacity_ref_freq set earlier will still lead to units mismatch,
> > as at the point of calling topology_init_cpu_capacity_cppc the lowest & nominal
> > frequencies will be provided in MHz (unless I have missed smth).
>
> I don't get your point:
> the unit of per_cpu(capacity_freq_ref, cpu) is Khz
>
> For cppc, we have
> per_cpu(capacity_freq_ref, cpu) = cppc_perf_to_khz(&perf_caps,
> raw_capacity[cpu]);
>
> freq_inv_set_max_ratio() uses
> arch_timer_get_rate() which returns a freq in Hz
> and
> per_cpu(capacity_freq_ref, cpu) * HZ_PER_KHZ. to get a freq in Hz too.
>
Apologies, I should have been more verbose here.
Before the change made in [1] the cppc_perf_to_khz was indeed operating on
lowest & nominal frequency values expressed in kHZ, as those were appropriately
amended:
cppc_cpufreq_cpu_init
|__> cppc_cpufreq_get_cpu_data:
|__> ...
/* Convert the lowest and nominal freq from MHz to KHz */
cpu_data->perf_caps.lowest_freq *= 1000;
cpu_data->perf_caps.nominal_freq *= 1000;
So far cppc_perf_to_khz (previously cppc_cpufreq_perf_to_khz) was being called
with the post-processed CPC data (through cppc_cpufreq_get_cpu_data) and thus
guaranteed to be operating on values in kHz.
With the new changes the cppc_perf_to_khz will operate on raw CPC data,
which are expressed in MHz.(as per acpi spec)
---
Best Regards
B.
> > This means that use of both, the capacity_ref_freq and the arch_freq_scale
> > will generate unexpected results, so I guess this should get amended in the
> > preceding patch (?) [1]
> >
> > ---
> > BR
> > B.
> >
> > [1] https://lore.kernel.org/linux-arm-kernel/[email protected]/T/#m42daa167097edc190b1cfc05382c385ed801d909
> >
> > > capacity = raw_capacity[cpu];
> > > capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
> > > capacity_scale);
> > > @@ -422,8 +429,11 @@ init_cpu_capacity_callback(struct notifier_block *nb,
> > >
> > > cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
> > >
> > > - for_each_cpu(cpu, policy->related_cpus)
> > > + for_each_cpu(cpu, policy->related_cpus) {
> > > per_cpu(capacity_ref_freq, cpu) = policy->cpuinfo.max_freq;
> > > + freq_inv_set_max_ratio(cpu,
> > > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > > + }
> > >
> > > if (cpumask_empty(cpus_to_visit)) {
> > > topology_normalize_cpu_scale();
> > > diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
> > > index 38ca6c76af56..ffdf0b7c55fa 100644
> > > --- a/include/linux/arch_topology.h
> > > +++ b/include/linux/arch_topology.h
> > > @@ -99,6 +99,7 @@ void update_siblings_masks(unsigned int cpu);
> > > void remove_cpu_topology(unsigned int cpuid);
> > > void reset_cpu_topology(void);
> > > int parse_acpi_topology(void);
> > > +void freq_inv_set_max_ratio(int cpu, u64 max_rate);
> > > #endif
> > >
> > > #endif /* _LINUX_ARCH_TOPOLOGY_H_ */
> > > --
> > > 2.34.1
> > >
On Thu, 2 Nov 2023 at 11:31, Beata Michalska <[email protected]> wrote:
>
> Hi Vincent,
>
> On Wed, Nov 01, 2023 at 10:04:27AM +0100, Vincent Guittot wrote:
> > Hi Beata,
> >
> > On Wed, 1 Nov 2023 at 00:59, Beata Michalska <[email protected]> wrote:
> > >
> > > On Fri, Oct 27, 2023 at 10:04:00AM +0200, Vincent Guittot wrote:
> > > > Use the new capacity_ref_freq to set the ratio that is used by AMU for
> > > > computing the arch_scale_freq_capacity().
> > > > This helps to keep everything aligned using the same reference for
> > > > computing CPUs capacity.
> > > >
> >
> > [..]
> >
> > > > @@ -381,6 +385,9 @@ void topology_init_cpu_capacity_cppc(void)
> > > > }
> > > >
> > > > for_each_possible_cpu(cpu) {
> > > > + freq_inv_set_max_ratio(cpu,
> > > > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > > > +
> > > The capacity_ref_freq set earlier will still lead to units mismatch,
> > > as at the point of calling topology_init_cpu_capacity_cppc the lowest & nominal
> > > frequencies will be provided in MHz (unless I have missed smth).
> >
> > I don't get your point:
> > the unit of per_cpu(capacity_freq_ref, cpu) is Khz
> >
> > For cppc, we have
> > per_cpu(capacity_freq_ref, cpu) = cppc_perf_to_khz(&perf_caps,
> > raw_capacity[cpu]);
> >
> > freq_inv_set_max_ratio() uses
> > arch_timer_get_rate() which returns a freq in Hz
> > and
> > per_cpu(capacity_freq_ref, cpu) * HZ_PER_KHZ. to get a freq in Hz too.
> >
> Apologies, I should have been more verbose here.
> Before the change made in [1] the cppc_perf_to_khz was indeed operating on
> lowest & nominal frequency values expressed in kHZ, as those were appropriately
> amended:
> cppc_cpufreq_cpu_init
> |__> cppc_cpufreq_get_cpu_data:
> |__> ...
> /* Convert the lowest and nominal freq from MHz to KHz */
> cpu_data->perf_caps.lowest_freq *= 1000;
> cpu_data->perf_caps.nominal_freq *= 1000;
>
> So far cppc_perf_to_khz (previously cppc_cpufreq_perf_to_khz) was being called
> with the post-processed CPC data (through cppc_cpufreq_get_cpu_data) and thus
> guaranteed to be operating on values in kHz.
> With the new changes the cppc_perf_to_khz will operate on raw CPC data,
> which are expressed in MHz.(as per acpi spec)
Ok, thanks for the explanation. I haven't noticed that cppc_cpufreq
was processing the raw CPC data (*1000) before using them. I'm going
to fix that.
>
> ---
> Best Regards
> B.
> > > This means that use of both, the capacity_ref_freq and the arch_freq_scale
> > > will generate unexpected results, so I guess this should get amended in the
> > > preceding patch (?) [1]
> > >
> > > ---
> > > BR
> > > B.
> > >
> > > [1] https://lore.kernel.org/linux-arm-kernel/[email protected]/T/#m42daa167097edc190b1cfc05382c385ed801d909
> > >
> > > > capacity = raw_capacity[cpu];
> > > > capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
> > > > capacity_scale);
> > > > @@ -422,8 +429,11 @@ init_cpu_capacity_callback(struct notifier_block *nb,
> > > >
> > > > cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
> > > >
> > > > - for_each_cpu(cpu, policy->related_cpus)
> > > > + for_each_cpu(cpu, policy->related_cpus) {
> > > > per_cpu(capacity_ref_freq, cpu) = policy->cpuinfo.max_freq;
> > > > + freq_inv_set_max_ratio(cpu,
> > > > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > > > + }
> > > >
> > > > if (cpumask_empty(cpus_to_visit)) {
> > > > topology_normalize_cpu_scale();
> > > > diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
> > > > index 38ca6c76af56..ffdf0b7c55fa 100644
> > > > --- a/include/linux/arch_topology.h
> > > > +++ b/include/linux/arch_topology.h
> > > > @@ -99,6 +99,7 @@ void update_siblings_masks(unsigned int cpu);
> > > > void remove_cpu_topology(unsigned int cpuid);
> > > > void reset_cpu_topology(void);
> > > > int parse_acpi_topology(void);
> > > > +void freq_inv_set_max_ratio(int cpu, u64 max_rate);
> > > > #endif
> > > >
> > > > #endif /* _LINUX_ARCH_TOPOLOGY_H_ */
> > > > --
> > > > 2.34.1
> > > >
Hi Pierre,
On Thu, 2 Nov 2023 at 10:07, Pierre Gondois <[email protected]> wrote:
>
> Hello Vincent,
>
> On 10/27/23 10:03, Vincent Guittot wrote:
> > Save the frequency associated to the performance that has been used when
> > initializing the capacity of CPUs.
> > Also, cppc cpufreq driver can register an artificial energy model. In such
> > case, it needs the frequency for this compute capacity.
> >
> > Signed-off-by: Vincent Guittot <[email protected]>
> > ---
> > drivers/base/arch_topology.c | 15 ++++++++++++++-
> > 1 file changed, 14 insertions(+), 1 deletion(-)
> >
> > diff --git a/drivers/base/arch_topology.c b/drivers/base/arch_topology.c
> > index 9a073c2d2086..d4bef370feb3 100644
> > --- a/drivers/base/arch_topology.c
> > +++ b/drivers/base/arch_topology.c
> > @@ -349,6 +349,7 @@ bool __init topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu)
> >
> > void topology_init_cpu_capacity_cppc(void)
> > {
> > + u64 capacity, capacity_scale = 0;
> > struct cppc_perf_caps perf_caps;
> > int cpu;
> >
> > @@ -365,6 +366,10 @@ void topology_init_cpu_capacity_cppc(void)
> > (perf_caps.highest_perf >= perf_caps.nominal_perf) &&
> > (perf_caps.highest_perf >= perf_caps.lowest_perf)) {
> > raw_capacity[cpu] = perf_caps.highest_perf;
> > + capacity_scale = max_t(u64, capacity_scale, raw_capacity[cpu]);
> > +
> > + per_cpu(capacity_ref_freq, cpu) = cppc_perf_to_khz(&perf_caps, raw_capacity[cpu]);
> > +
>
> To continue Beata's point, I think there is an issue with the following:
> cppc_perf_to_khz() and cppc_khz_to_perf() were previously used with a struct containing
> frequencies in KHz, cf. [1].
> In the original _CPC object, frequencies are in MHz. It means that the perf_caps struct
> here contains frequencies in MHz, and per_cpu(capacity_ref_freq, cpu) is in MHz aswell.
Yeah, I haven't noticed this intermediate step in cppc_cpufreq. I'm
going to fix this
>
> [1] https://github.com/torvalds/linux/blob/master/drivers/cpufreq/cppc_cpufreq.c#L682
>
>
> > pr_debug("cpu_capacity: CPU%d cpu_capacity=%u (raw).\n",
> > cpu, raw_capacity[cpu]);
> > continue;
> > @@ -375,7 +380,15 @@ void topology_init_cpu_capacity_cppc(void)
> > goto exit;
> > }
> >
> > - topology_normalize_cpu_scale();
> > + for_each_possible_cpu(cpu) {
> > + capacity = raw_capacity[cpu];
> > + capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
> > + capacity_scale);
> > + topology_set_cpu_scale(cpu, capacity);
> > + pr_debug("cpu_capacity: CPU%d cpu_capacity=%lu\n",
> > + cpu, topology_get_cpu_scale(cpu));
> > + }
> > +
> > schedule_work(&update_topology_flags_work);
> > pr_debug("cpu_capacity: cpu_capacity initialization done\n");
> >
On Thu, 2 Nov 2023 at 11:40, Vincent Guittot <[email protected]> wrote:
>
> On Thu, 2 Nov 2023 at 11:31, Beata Michalska <[email protected]> wrote:
> >
> > Hi Vincent,
> >
> > On Wed, Nov 01, 2023 at 10:04:27AM +0100, Vincent Guittot wrote:
> > > Hi Beata,
> > >
> > > On Wed, 1 Nov 2023 at 00:59, Beata Michalska <[email protected]> wrote:
> > > >
> > > > On Fri, Oct 27, 2023 at 10:04:00AM +0200, Vincent Guittot wrote:
> > > > > Use the new capacity_ref_freq to set the ratio that is used by AMU for
> > > > > computing the arch_scale_freq_capacity().
> > > > > This helps to keep everything aligned using the same reference for
> > > > > computing CPUs capacity.
> > > > >
> > >
> > > [..]
> > >
> > > > > @@ -381,6 +385,9 @@ void topology_init_cpu_capacity_cppc(void)
> > > > > }
> > > > >
> > > > > for_each_possible_cpu(cpu) {
> > > > > + freq_inv_set_max_ratio(cpu,
> > > > > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > > > > +
> > > > The capacity_ref_freq set earlier will still lead to units mismatch,
> > > > as at the point of calling topology_init_cpu_capacity_cppc the lowest & nominal
> > > > frequencies will be provided in MHz (unless I have missed smth).
> > >
> > > I don't get your point:
> > > the unit of per_cpu(capacity_freq_ref, cpu) is Khz
> > >
> > > For cppc, we have
> > > per_cpu(capacity_freq_ref, cpu) = cppc_perf_to_khz(&perf_caps,
> > > raw_capacity[cpu]);
> > >
> > > freq_inv_set_max_ratio() uses
> > > arch_timer_get_rate() which returns a freq in Hz
> > > and
> > > per_cpu(capacity_freq_ref, cpu) * HZ_PER_KHZ. to get a freq in Hz too.
> > >
> > Apologies, I should have been more verbose here.
> > Before the change made in [1] the cppc_perf_to_khz was indeed operating on
> > lowest & nominal frequency values expressed in kHZ, as those were appropriately
> > amended:
> > cppc_cpufreq_cpu_init
> > |__> cppc_cpufreq_get_cpu_data:
> > |__> ...
> > /* Convert the lowest and nominal freq from MHz to KHz */
> > cpu_data->perf_caps.lowest_freq *= 1000;
> > cpu_data->perf_caps.nominal_freq *= 1000;
> >
> > So far cppc_perf_to_khz (previously cppc_cpufreq_perf_to_khz) was being called
> > with the post-processed CPC data (through cppc_cpufreq_get_cpu_data) and thus
> > guaranteed to be operating on values in kHz.
> > With the new changes the cppc_perf_to_khz will operate on raw CPC data,
> > which are expressed in MHz.(as per acpi spec)
>
> Ok, thanks for the explanation. I haven't noticed that cppc_cpufreq
> was processing the raw CPC data (*1000) before using them. I'm going
> to fix that.
With cppc_perf_to_khz() being moved into the generic cppc_acpi.c, we
can't change perf_caps.nominal_freq and perf_caps.lowest_freq
directly. So, I'm planning to add the conversion from MHz to kHz in
the functions cppc_perf_to_khz() and cppc_khz_to_perf() and remove the
2 conversions above in cppc_cpufreq_get_cpu_data().
>
>
> >
> > ---
> > Best Regards
> > B.
> > > > This means that use of both, the capacity_ref_freq and the arch_freq_scale
> > > > will generate unexpected results, so I guess this should get amended in the
> > > > preceding patch (?) [1]
> > > >
> > > > ---
> > > > BR
> > > > B.
> > > >
> > > > [1] https://lore.kernel.org/linux-arm-kernel/[email protected]/T/#m42daa167097edc190b1cfc05382c385ed801d909
> > > >
> > > > > capacity = raw_capacity[cpu];
> > > > > capacity = div64_u64(capacity << SCHED_CAPACITY_SHIFT,
> > > > > capacity_scale);
> > > > > @@ -422,8 +429,11 @@ init_cpu_capacity_callback(struct notifier_block *nb,
> > > > >
> > > > > cpumask_andnot(cpus_to_visit, cpus_to_visit, policy->related_cpus);
> > > > >
> > > > > - for_each_cpu(cpu, policy->related_cpus)
> > > > > + for_each_cpu(cpu, policy->related_cpus) {
> > > > > per_cpu(capacity_ref_freq, cpu) = policy->cpuinfo.max_freq;
> > > > > + freq_inv_set_max_ratio(cpu,
> > > > > + per_cpu(capacity_ref_freq, cpu) * HZ_PER_KHZ);
> > > > > + }
> > > > >
> > > > > if (cpumask_empty(cpus_to_visit)) {
> > > > > topology_normalize_cpu_scale();
> > > > > diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
> > > > > index 38ca6c76af56..ffdf0b7c55fa 100644
> > > > > --- a/include/linux/arch_topology.h
> > > > > +++ b/include/linux/arch_topology.h
> > > > > @@ -99,6 +99,7 @@ void update_siblings_masks(unsigned int cpu);
> > > > > void remove_cpu_topology(unsigned int cpuid);
> > > > > void reset_cpu_topology(void);
> > > > > int parse_acpi_topology(void);
> > > > > +void freq_inv_set_max_ratio(int cpu, u64 max_rate);
> > > > > #endif
> > > > >
> > > > > #endif /* _LINUX_ARCH_TOPOLOGY_H_ */
> > > > > --
> > > > > 2.34.1
> > > > >