Skip to contentSkip to conversation

intel_pstate: fix turbo not being used after a processor is rebooted

PATCH In review Pratyush Yadav 4 participants 19 messages Dec 21, 2022 – Dec 27, 2022

Subsystems (4)
lore
Share & tools
lore
#0 lore raw

cover intel_pstate: fix turbo not being used after a processor is rebooted

When a processor is brought offline and online again, it is unable to use Turbo mode because the _PSS table does not contain the whole turbo frequency range, but only +1 MHz above the max non-turbo frequency. This causes problems when ACPI processor driver tries to set frequency constraints. See patch 2 for more details.

Pratyush Yadav (2):
acpi: processor: allow fixing up the frequency for a performance state
cpufreq: intel_pstate: use acpi perflib to update turbo frequency

 drivers/acpi/processor_perflib.c | 40 ++++++++++++++++++++++++++++++++
 drivers/cpufreq/intel_pstate.c   |  5 ++--
 include/acpi/processor.h         |  2 ++
 3 files changed, 45 insertions(+), 2 deletions(-)

--
2.38.1

#1 lore raw

PATCH 1/2 acpi: processor: allow fixing up the frequency for a performance state

In some cases the ACPI table can have an incorrect frequency populated for a performance state. For example, in Intel platforms, the Turbo frequency is just listed as +1 MHz above the max non-turbo frequency. The frequency can actually go much higher based on various factors like temperature, voltage, etc.

Allow drivers like intel_pstate to fix up performance state frequencies with the actual maximum value. While at it, also update the QoS constraints if needed to match the new frequency values.

---
 drivers/acpi/processor_perflib.c | 40 ++++++++++++++++++++++++++++++++
 include/acpi/processor.h         |  2 ++
 2 files changed, 42 insertions(+)
drivers/acpi/processor_perflib.c +40 -0
index 970f04a958cd..4958aee4c024 100644
@@ -766,3 +766,43 @@ void acpi_processor_unregister_performance(unsigned int cpu)
 	mutex_unlock(&performance_mutex);
 }
 EXPORT_SYMBOL(acpi_processor_unregister_performance);
+
+int acpi_processor_fixup_perf_state(unsigned int cpu, unsigned int state,
+				    unsigned int frequency)
+{
+	struct acpi_processor *pr;
+	int ret;
+
+	mutex_lock(&performance_mutex);
+
+	pr = per_cpu(processors, cpu);
+	if (!pr) {
+		mutex_unlock(&performance_mutex);
+		return -ENODEV;
+	}
+
+	if (!pr->performance) {
+		mutex_unlock(&performance_mutex);
+		return -EINVAL;
+	}
+
+	if (state >= pr->performance->state_count) {
+		mutex_unlock(&performance_mutex);
+		return -EINVAL;
+	}
+
+	pr->performance->states[state].core_frequency = frequency;
+
+	if (ignore_ppc != 1 && state == pr->performance_platform_limit &&
+	    freq_qos_request_active(&pr->perflib_req)) {
+		ret = freq_qos_update_request(&pr->perflib_req,
+					      frequency * 1000);
+		if (ret < 0)
+			pr_warn("Failed to update perflib freq constraint: CPU%d (%d)\n",
+				pr->id, ret);
+	}
+
+	mutex_unlock(&performance_mutex);
+	return 0;
+}
+EXPORT_SYMBOL(acpi_processor_fixup_perf_state);
include/acpi/processor.h +2 -0
index 94181fe9780a..daff978cfa7d 100644
@@ -258,6 +258,8 @@ extern int acpi_processor_preregister_performance(struct
 extern int acpi_processor_register_performance(struct acpi_processor_performance
 					       *performance, unsigned int cpu);
 extern void acpi_processor_unregister_performance(unsigned int cpu);
+extern int acpi_processor_fixup_perf_state(unsigned int cpu, unsigned int state,
+					   unsigned int frequency);
 
 int acpi_processor_pstate_control(void);
 /* note: this locks both the calling module and the processor module
Signature · 1 line
2.38.1
#2 lore raw

Re: [PATCH 1/2] acpi: processor: allow fixing up the frequency for a performance state

Quoted 4 lines · Pratyush Yadav

In some cases the ACPI table can have an incorrect frequency populated for a performance state. For example, in Intel platforms, the Turbo frequency is just listed as +1 MHz above the max non-turbo frequency.

Which is a known convention based on compatibility with some older OSes.

Quoted 2 lines

The frequency can actually go much higher based on various factors like temperature, voltage, etc.

It can.

Quoted 2 lines

Allow drivers like intel_pstate to fix up performance state frequencies with the actual maximum value.

Why do you want to do that?

Quoted 73 lines

While at it, also update the QoS
constraints if needed to match the new frequency values.

---
 drivers/acpi/processor_perflib.c | 40 ++++++++++++++++++++++++++++++++
 include/acpi/processor.h         |  2 ++
 2 files changed, 42 insertions(+)
drivers/acpi/processor_perflib.c +40 -0
index 970f04a958cd..4958aee4c024 100644
@@ -766,3 +766,43 @@ void acpi_processor_unregister_performance(unsigned int cpu)
        mutex_unlock(&performance_mutex);
 }
 EXPORT_SYMBOL(acpi_processor_unregister_performance);
+
+int acpi_processor_fixup_perf_state(unsigned int cpu, unsigned int state,
+                                   unsigned int frequency)
+{
+       struct acpi_processor *pr;
+       int ret;
+
+       mutex_lock(&performance_mutex);
+
+       pr = per_cpu(processors, cpu);
+       if (!pr) {
+               mutex_unlock(&performance_mutex);
+               return -ENODEV;
+       }
+
+       if (!pr->performance) {
+               mutex_unlock(&performance_mutex);
+               return -EINVAL;
+       }
+
+       if (state >= pr->performance->state_count) {
+               mutex_unlock(&performance_mutex);
+               return -EINVAL;
+       }
+
+       pr->performance->states[state].core_frequency = frequency;
+
+       if (ignore_ppc != 1 && state == pr->performance_platform_limit &&
+           freq_qos_request_active(&pr->perflib_req)) {
+               ret = freq_qos_update_request(&pr->perflib_req,
+                                             frequency * 1000);
+               if (ret < 0)
+                       pr_warn("Failed to update perflib freq constraint: CPU%d (%d)\n",
+                               pr->id, ret);
+       }
+
+       mutex_unlock(&performance_mutex);
+       return 0;
+}
+EXPORT_SYMBOL(acpi_processor_fixup_perf_state);
include/acpi/processor.h +2 -1
index 94181fe9780a..daff978cfa7d 100644
@@ -258,6 +258,8 @@ extern int acpi_processor_preregister_performance(struct
 extern int acpi_processor_register_performance(struct acpi_processor_performance
                                               *performance, unsigned int cpu);
 extern void acpi_processor_unregister_performance(unsigned int cpu);
+extern int acpi_processor_fixup_perf_state(unsigned int cpu, unsigned int state,
+                                          unsigned int frequency);
 
 int acpi_processor_pstate_control(void);
 /* note: this locks both the calling module and the processor module
--

2.38.1

#3 lore raw

Re: [PATCH 1/2] acpi: processor: allow fixing up the frequency for a performance state

Quoted 7 lines · Rafael J. Wysocki
Quoted 4 lines · Pratyush Yadav

In some cases the ACPI table can have an incorrect frequency populated for a performance state. For example, in Intel platforms, the Turbo frequency is just listed as +1 MHz above the max non-turbo frequency.

Which is a known convention based on compatibility with some older OSes.

Interesting. I did not know that.

Quoted 10 lines
Quoted 3 lines

The frequency can actually go much higher based on various factors like temperature, voltage, etc.

It can.

Quoted 2 lines

Allow drivers like intel_pstate to fix up performance state frequencies with the actual maximum value.

Why do you want to do that?

To be able to use my processors at the full frequency they are capable of. See [0] for more details.

[0] https://lore.kernel.org/linux-pm/mafs0k02jd8oh.fsf_-_@dev-dsk-ptyadav-1c-37607b33.eu-west-1.amazon.com/

Quoted 1 line

[...]

Signature · 12 lines
Regards,
Pratyush Yadav



Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss
Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
#4 lore raw

PATCH 2/2 cpufreq: intel_pstate: use acpi perflib to update turbo frequency

In reply to Pratyush Yadav

The _PSS table does not contain the whole turbo frequency range, but only +1 MHz above the max non-turbo frequency. The pstate driver then updates the ACPI perf data with the actual max frequency. But doing this here directly would mean that frequency QoS constraints that acpi perflib imposes do not get updated.

This is a problem when a CPU is brought offline and online again. When the CPU first comes online, cpufreq is not initialized. So PPC constraints are not applied (because ignore_ppc == -1). This leads to the frequency QoS allowing all values from acpi perflib side.

Once everything is initialized and then userspace brings a CPU down and up again, intel_pstate_init_acpi_perf_limits() calls acpi_processor_register_performance(), which then eventually calls acpi_processor_get_platform_limit(). There PPC is state 0, the turbo state, but the frequency has not been updated yet. So when acpi_processor_get_platform_limit() sets QoS constraints, it sets them with the max_non_turbo + 1 value.

Now even though intel_pstate says it can support the full turbo speed, cpufreq only asks for up to max_non_turbo + 1 MHz since that is what satisfies all constraints.

Call into acpi perflib's function to update the frequency so it can also update the QoS constraints with the new value.

---
 drivers/cpufreq/intel_pstate.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)
drivers/cpufreq/intel_pstate.c +3 -2
index fd73d6d2b808..b312f87ff522 100644
@@ -464,8 +464,9 @@ static void intel_pstate_init_acpi_perf_limits(struct cpufreq_policy *policy)
 	 * Also need to convert to MHz as _PSS freq is in MHz.
 	 */
 	if (!global.turbo_disabled)
-		cpu->acpi_perf_data.states[0].core_frequency =
-					policy->cpuinfo.max_freq / 1000;
+		acpi_processor_fixup_perf_state(policy->cpu, 0,
+						policy->cpuinfo.max_freq / 1000);
+
 	cpu->valid_pss_table = true;
 	pr_debug("_PPC limits will be enforced\n");
 
Signature · 1 line
2.38.1
#5 lore raw
In reply to Pratyush Yadav
Quoted 8 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to use Turbo mode because the _PSS table does not contain the whole turbo
frequency range, but only +1 MHz above the max non-turbo frequency. This
causes problems when ACPI processor driver tries to set frequency constraints. See patch 2 for more details.

Are you using some _PPC constraint to force to limit frequency? I did a offline/online with PPC=0 with no HWP, I can get to full turbo range.

[  121.237752] smpboot: CPU 1 is now offline
[  125.734886] x86: Booting SMP configuration:
[  125.734892] smpboot: Booting Node 0 Processor 1 APIC 0x2
[  125.741007] intel_pstate: CPU 1 going online
[  125.741692] intel_pstate: CPU1 - ACPI _PSS perf data
[  125.741698] intel_pstate:      *P0: 2301 MHz, 28000 mW, 0x2a00
[  125.741703] intel_pstate:       P1: 2300 MHz, 28000 mW, 0x1700
[  125.741705] intel_pstate:       P2: 2200 MHz, 26297 mW, 0x1600
[  125.741707] intel_pstate:       P3: 2000 MHz, 23263 mW, 0x1400
[  125.741710] intel_pstate:       P4: 1900 MHz, 21924 mW, 0x1300
[  125.741712] intel_pstate:       P5: 1800 MHz, 20612 mW, 0x1200
[  125.741714] intel_pstate:       P6: 1600 MHz, 17812 mW, 0x1000
[  125.741716] intel_pstate:       P7: 1500 MHz, 16581 mW, 0xf00
[  125.741718] intel_pstate:       P8: 1300 MHz, 13946 mW, 0xd00
[  125.741720] intel_pstate:       P9: 1200 MHz, 12796 mW, 0xc00
[  125.741722] intel_pstate:       P10: 1100 MHz, 11426 mW, 0xb00
[  125.741724] intel_pstate:       P11: 900 MHz, 9250 mW, 0x900
[  125.741726] intel_pstate:       P12: 800 MHz, 7965 mW, 0x800
[  125.741729] intel_pstate:       P13: 700 MHz, 6940 mW, 0x700
[  125.741731] intel_pstate:       P14: 500 MHz, 4738 mW, 0x500
[  125.741733] intel_pstate:       P15: 400 MHz, 3787 mW, 0x400
[  125.741735] intel_pstate: _PPC limits will be enforced
[  125.741740] intel_pstate: policy->max > max non turbo frequency
[  125.741742] intel_pstate: cpu:1 min_policy_perf:4 max_policy_perf:42
[  125.741745] intel_pstate: cpu:1 global_min:4 global_max:42
[  125.741747] intel_pstate: cpu:1 max_perf_ratio:42 min_perf_ratio:4
[  125.742243] intel_pstate: policy->max > max non turbo frequency
[  125.742247] intel_pstate: cpu:1 min_policy_perf:4 max_policy_perf:42
[  125.742251] intel_pstate: cpu:1 global_min:4 global_max:42
[  125.742255] intel_pstate: cpu:1 max_perf_ratio:42 min_perf_ratio:4

It is not clear how to get to this non turbo situation.

Thanks,
Srinivas

Quoted 14 lines

Pratyush Yadav (2):
  acpi: processor: allow fixing up the frequency for a performance state
  cpufreq: intel_pstate: use acpi perflib to update turbo frequency

 drivers/acpi/processor_perflib.c | 40
++++++++++++++++++++++++++++++++
 drivers/cpufreq/intel_pstate.c   |  5 ++--
 include/acpi/processor.h         |  2 ++

 3 files changed, 45 insertions(+), 2 deletions(-)

--
2.38.1

#6 lore raw

Hi Srinivas,

Quoted 45 lines · srinivas pandruvada
Quoted 8 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to use Turbo mode because the _PSS table does not contain the whole turbo
frequency range, but only +1 MHz above the max non-turbo frequency. This
causes problems when ACPI processor driver tries to set frequency constraints. See patch 2 for more details.

Are you using some _PPC constraint to force to limit frequency? I did a offline/online with PPC=0 with no HWP, I can get to full turbo range.

[  121.237752] smpboot: CPU 1 is now offline
[  125.734886] x86: Booting SMP configuration:
[  125.734892] smpboot: Booting Node 0 Processor 1 APIC 0x2
[  125.741007] intel_pstate: CPU 1 going online
[  125.741692] intel_pstate: CPU1 - ACPI _PSS perf data
[  125.741698] intel_pstate:      *P0: 2301 MHz, 28000 mW, 0x2a00
[  125.741703] intel_pstate:       P1: 2300 MHz, 28000 mW, 0x1700
[  125.741705] intel_pstate:       P2: 2200 MHz, 26297 mW, 0x1600
[  125.741707] intel_pstate:       P3: 2000 MHz, 23263 mW, 0x1400
[  125.741710] intel_pstate:       P4: 1900 MHz, 21924 mW, 0x1300
[  125.741712] intel_pstate:       P5: 1800 MHz, 20612 mW, 0x1200
[  125.741714] intel_pstate:       P6: 1600 MHz, 17812 mW, 0x1000
[  125.741716] intel_pstate:       P7: 1500 MHz, 16581 mW, 0xf00
[  125.741718] intel_pstate:       P8: 1300 MHz, 13946 mW, 0xd00
[  125.741720] intel_pstate:       P9: 1200 MHz, 12796 mW, 0xc00
[  125.741722] intel_pstate:       P10: 1100 MHz, 11426 mW, 0xb00
[  125.741724] intel_pstate:       P11: 900 MHz, 9250 mW, 0x900
[  125.741726] intel_pstate:       P12: 800 MHz, 7965 mW, 0x800
[  125.741729] intel_pstate:       P13: 700 MHz, 6940 mW, 0x700
[  125.741731] intel_pstate:       P14: 500 MHz, 4738 mW, 0x500
[  125.741733] intel_pstate:       P15: 400 MHz, 3787 mW, 0x400
[  125.741735] intel_pstate: _PPC limits will be enforced
[  125.741740] intel_pstate: policy->max > max non turbo frequency
[  125.741742] intel_pstate: cpu:1 min_policy_perf:4 max_policy_perf:42
[  125.741745] intel_pstate: cpu:1 global_min:4 global_max:42
[  125.741747] intel_pstate: cpu:1 max_perf_ratio:42 min_perf_ratio:4
[  125.742243] intel_pstate: policy->max > max non turbo frequency
[  125.742247] intel_pstate: cpu:1 min_policy_perf:4 max_policy_perf:42
[  125.742251] intel_pstate: cpu:1 global_min:4 global_max:42
[  125.742255] intel_pstate: cpu:1 max_perf_ratio:42 min_perf_ratio:4
Quoted 1 line

It is not clear how to get to this non turbo situation.

Look at the scaling_max_freq before and after rebooting the CPU. Before you do it, it should be the max turbo frequency (say 2500 MHz). After rebooting the CPU, it should now be 2301 MHz. So the kernel will now not ask for anything above 2301 MHz, so you will never get to 2500 MHz.

Another interesting thing I observed is that if I reboot only 1 CPU, its scaling_max_freq goes down to 2301, but it still keeps working at 2500 MHz. This might be something to do with how turbo works, I don't understand that very well. But if you reboot say 20 CPUs, then you see the frequency drop.

I use the below steps to reproduce this bug on my system, which has 40 CPUs with a base frequency of 2500 MHz and turbo frequency of 3300 MHz:

$ grep 'cpu MHz' /proc/cpuinfo
cpu MHz         : 3300.000
cpu MHz         : 1199.652
cpu MHz         : 3300.000
cpu MHz         : 3300.000
cpu MHz         : 3300.000
cpu MHz         : 3300.000
cpu MHz         : 3300.000
cpu MHz         : 3300.000
cpu MHz         : 3300.000
cpu MHz         : 3300.000
[ repeat 30 times ]
$ cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_max_freq | sort -n | uniq -c
     40 3300000
$ for i in `seq 1 20`; do echo 0 | sudo tee /sys/devices/system/cpu/cpu$i/online; done
[...]
$ for i in `seq 1 20`; do echo 1 | sudo tee /sys/devices/system/cpu/cpu$i/online; done
[...]
$ grep 'cpu MHz' /proc/cpuinfo
cpu MHz         : 3300.000
cpu MHz         : 2500.000
cpu MHz         : 2500.000
cpu MHz         : 2500.000
cpu MHz         : 2500.000
cpu MHz         : 2500.000
[ repeat 15 times ]
cpu MHz         : 3300.000
cpu MHz         : 3300.000
[ repeat 17 times ]
$ cat /sys/devices/system/cpu/cpu*/cpufreq/scaling_max_freq | sort -n | uniq -c
     20 2501000
     20 3300000
Quoted 19 lines

Thanks,
Srinivas

Quoted 14 lines

Pratyush Yadav (2):
acpi: processor: allow fixing up the frequency for a performance
state
cpufreq: intel_pstate: use acpi perflib to update turbo frequency

 drivers/acpi/processor_perflib.c | 40
++++++++++++++++++++++++++++++++
 drivers/cpufreq/intel_pstate.c   |  5 ++--
 include/acpi/processor.h         |  2 ++
 3 files changed, 45 insertions(+), 2 deletions(-)

--
2.38.1

Signature · 12 lines
Regards,
Pratyush Yadav



Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss
Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
#7 lore raw

Hi Pratyush,

Quoted 15 lines · Pratyush Yadav

Hi Srinivas,

Quoted 11 lines · srinivas pandruvada
Quoted 10 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to
use Turbo mode because the _PSS table does not contain the whole turbo
frequency range, but only +1 MHz above the max non-turbo frequency.
This
causes problems when ACPI processor driver tries to set frequency constraints. See patch 2 for more details.

I can reproduce on a Broadwell server platform. But not on a client system with acpi_ppc usage.

Need to check what change broke this.

Thanks,
Srinivas

Quoted 22 lines
Quoted 21 lines

Thanks,
Srinivas

Quoted 16 lines

Pratyush Yadav (2):
  acpi: processor: allow fixing up the frequency for a performance
state
  cpufreq: intel_pstate: use acpi perflib to update turbo frequency

 drivers/acpi/processor_perflib.c | 40
++++++++++++++++++++++++++++++++
 drivers/cpufreq/intel_pstate.c   |  5 ++--
 include/acpi/processor.h         |  2 ++

 3 files changed, 45 insertions(+), 2 deletions(-)

--
2.38.1

#8 lore raw
Quoted 18 lines · srinivas pandruvada

Hi Pratyush,

Quoted 15 lines · Pratyush Yadav

Hi Srinivas,

Quoted 11 lines · srinivas pandruvada
Quoted 10 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to
use Turbo mode because the _PSS table does not contain the whole turbo
frequency range, but only +1 MHz above the max non-turbo frequency.
This
causes problems when ACPI processor driver tries to set frequency constraints. See patch 2 for more details.

Quoted 4 lines

I can reproduce on a Broadwell server platform. But not on a client system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously acpi_processor_get_platform_limit() was not enforcing any limits. It was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call

	ret = freq_qos_update_request(&pr->perflib_req,
			pr->performance->states[ppc].core_frequency *

1000);

if the PPC is not changed. When PPC is changed, this gets called again, so then we can call the above function to update cpufreq limit.

The below change fixed for me.

(quoted diff) +0 -0

b/drivers/acpi/processor_perflib.c
index 757a98f6d7a2..c6ced89c00dd 100644

drivers/acpi/processor_perflib.c +0 -0
@@ -75,6 +75,11 @@ static int acpi_processor_get_platform_limit(struct

acpi_processor *pr)

        pr_debug("CPU %d: _PPC is %d - frequency %s limited\n", pr->id,
                       (int)ppc, ppc ? "" : "not");

+ if (ppc == pr->performance_platform_limit) {
+ pr_debug("CPU %d: _PPC is %d - frequency not
changed\n", pr->id, ppc);
+ return 0;
+ }
+

        pr->performance_platform_limit = (int)ppc;
 
        if (ppc >= pr->performance->state_count ||

Thanks,
Srinivas

Quoted 27 lines

Thanks,
Srinivas

Quoted 22 lines
Quoted 21 lines

Thanks,
Srinivas

Quoted 16 lines

Pratyush Yadav (2):
  acpi: processor: allow fixing up the frequency for a performance
state
  cpufreq: intel_pstate: use acpi perflib to update turbo frequency

 drivers/acpi/processor_perflib.c | 40
++++++++++++++++++++++++++++++++
 drivers/cpufreq/intel_pstate.c   |  5 ++--
 include/acpi/processor.h         |  2 ++

 3 files changed, 45 insertions(+), 2 deletions(-)

--
2.38.1

#9 lore raw

Hi Srinivas,

Quoted 31 lines · srinivas pandruvada
Quoted 18 lines · srinivas pandruvada

Hi Pratyush,

Quoted 15 lines · Pratyush Yadav

Hi Srinivas,

Quoted 11 lines · srinivas pandruvada
Quoted 10 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to
use Turbo mode because the _PSS table does not contain the whole turbo
frequency range, but only +1 MHz above the max non-turbo frequency.
This
causes problems when ACPI processor driver tries to set frequency constraints. See patch 2 for more details.

Quoted 4 lines

I can reproduce on a Broadwell server platform. But not on a client system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously acpi_processor_get_platform_limit() was not enforcing any limits. It was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call

Quoted 8 lines
        ret = freq_qos_update_request(&pr->perflib_req,
                        pr->performance->states[ppc].core_frequency *

1000);

if the PPC is not changed. When PPC is changed, this gets called again, so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Right. Should I re-roll my patches with your diff below then? Or do you think my patches should be good to merge as-is?

Quoted 21 lines
drivers/acpi/processor_perflib.c +5 -0
index 757a98f6d7a2..c6ced89c00dd 100644
@@ -75,6 +75,11 @@ static int acpi_processor_get_platform_limit(struct
 acpi_processor *pr)
        pr_debug("CPU %d: _PPC is %d - frequency %s limited\n", pr->id,
                       (int)ppc, ppc ? "" : "not");
 
+       if (ppc == pr->performance_platform_limit) {
+               pr_debug("CPU %d: _PPC is %d - frequency not
 changed\n", pr->id, ppc);
+               return 0;
+       }
+
        pr->performance_platform_limit = (int)ppc;
        if (ppc >= pr->performance->state_count ||
Signature · 12 lines
Regards,
Pratyush Yadav



Amazon Development Center Germany GmbH
Krausenstr. 38
10117 Berlin
Geschaeftsfuehrung: Christian Schlaeger, Jonathan Weiss
Eingetragen am Amtsgericht Charlottenburg unter HRB 149173 B
Sitz: Berlin
Ust-ID: DE 289 237 879
#10 lore raw
Quoted 40 lines · Pratyush Yadav

Hi Srinivas,

Quoted 35 lines · srinivas pandruvada
Quoted 18 lines · srinivas pandruvada

Hi Pratyush,

Quoted 15 lines · Pratyush Yadav

Hi Srinivas,

Quoted 11 lines · srinivas pandruvada
Quoted 10 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to
use Turbo mode because the _PSS table does not contain the whole turbo
frequency range, but only +1 MHz above the max non-turbo frequency.
This
causes problems when ACPI processor driver tries to set frequency constraints. See patch 2 for more details.

Quoted 4 lines

I can reproduce on a Broadwell server platform. But not on a client system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously acpi_processor_get_platform_limit() was not enforcing any limits. It was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call

        ret = freq_qos_update_request(&pr->perflib_req,
                        pr->performance->states[ppc].core_frequency *

1000);

Quoted 7 lines
Quoted 4 lines

if the PPC is not changed. When PPC is changed, this gets called again, so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Right. Should I re-roll my patches with your diff below then? Or do you think my patches should be good to merge as-is?

No, they are not good to merge.

#11 lore raw
In reply to Pratyush Yadav
Quoted 45 lines · Pratyush Yadav

Hi Srinivas,

Quoted 41 lines · srinivas pandruvada
Quoted 20 lines · srinivas pandruvada

Hi Pratyush,

Quoted 17 lines · Pratyush Yadav

Hi Srinivas,

Quoted 13 lines · srinivas pandruvada
Quoted 12 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to
use Turbo mode because the _PSS table does not contain the whole
turbo
frequency range, but only +1 MHz above the max non-turbo frequency.
This
causes problems when ACPI processor driver tries to set frequency
constraints. See patch 2 for more details.

Quoted 5 lines

I can reproduce on a Broadwell server platform. But not on a client
system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously
acpi_processor_get_platform_limit() was not enforcing any limits. It
was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call
        ret = freq_qos_update_request(&pr->perflib_req, pr->performance->states[ppc].core_frequency *
1000);

Quoted 7 lines
Quoted 5 lines

if the PPC is not changed. When PPC is changed, this gets called again,
so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Right.

I think, this is the only change you require to fix this. In addition set pr->performance_platform_limit = 0 in acpi_processor_unregister_performance().

Thanks,
Srinivas

Quoted 27 lines

Should I re-roll my patches with your diff below then? Or do you think my patches should be good to merge as-is?

Quoted 23 lines
drivers/acpi/processor_perflib.c +0 -0
index 757a98f6d7a2..c6ced89c00dd 100644
@@ -75,6 +75,11 @@ static int

acpi_processor_get_platform_limit(struct
acpi_processor *pr)
        pr_debug("CPU %d: _PPC is %d - frequency %s limited\n", pr-

Quoted 1 line

id,

                       (int)ppc, ppc ? "" : "not");

+       if (ppc == pr->performance_platform_limit) { +               pr_debug("CPU %d: _PPC is %d - frequency not changed\n", pr->id, ppc);
+               return 0;
+       }
+
        pr->performance_platform_limit = (int)ppc;

        if (ppc >= pr->performance->state_count ||

#12 lore raw
Quoted 51 lines · srinivas pandruvada
Quoted 49 lines · Pratyush Yadav

Hi Srinivas,

Quoted 45 lines · srinivas pandruvada
Quoted 20 lines · srinivas pandruvada

Hi Pratyush,

Quoted 17 lines · Pratyush Yadav

Hi Srinivas,

Quoted 13 lines · srinivas pandruvada
Quoted 12 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to
use Turbo mode because the _PSS table does not contain the whole
turbo
frequency range, but only +1 MHz above the max non-turbo frequency.
This
causes problems when ACPI processor driver tries to set frequency
constraints. See patch 2 for more details.

Quoted 5 lines

I can reproduce on a Broadwell server platform. But not on a client
system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously
acpi_processor_get_platform_limit() was not enforcing any limits. It
was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call

        ret = freq_qos_update_request(&pr->perflib_req,
                        pr->performance->states[ppc].core_frequency

*
1000);

if the PPC is not changed. When PPC is changed, this gets called again,
so then we can call the above function to update cpufreq limit.

Quoted 6 lines
Quoted 3 lines
Quoted 1 line

The below change fixed for me.

Right.

I think, this is the only change you require to fix this. In addition set pr->performance_platform_limit = 0 in acpi_processor_unregister_performance().

Not really, because if the limit is set to a lower frequency and then reset to _PSS[0], it needs to be set back to "no limit".

I'll send a patch for that in a while.

#13 lore raw
Quoted 56 lines · CET Rafael J. Wysocki
Quoted 54 lines · srinivas pandruvada
Quoted 52 lines · Pratyush Yadav

Hi Srinivas,

Quoted 38 lines · srinivas pandruvada
Quoted 20 lines · srinivas pandruvada

Hi Pratyush,

Quoted 17 lines · Pratyush Yadav

Hi Srinivas,

Quoted 13 lines · srinivas pandruvada
Quoted 12 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to
use Turbo mode because the _PSS table does not contain the whole
turbo
frequency range, but only +1 MHz above the max non-turbo frequency.
This
causes problems when ACPI processor driver tries to set frequency
constraints. See patch 2 for more details.

Quoted 5 lines

I can reproduce on a Broadwell server platform. But not on a client
system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously
acpi_processor_get_platform_limit() was not enforcing any limits. It
was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call

        ret = freq_qos_update_request(&pr->perflib_req,
                        pr->performance->states[ppc].core_frequency
Quoted 8 lines

*
1000);

if the PPC is not changed. When PPC is changed, this gets called again,
so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Right.

Quoted 8 lines
Quoted 3 lines

I think, this is the only change you require to fix this. In addition set pr->performance_platform_limit = 0 in acpi_processor_unregister_performance().

Not really, because if the limit is set to a lower frequency and then reset to _PSS[0], it needs to be set back to "no limit".

I'll send a patch for that in a while.

This has not been tested beyond compilation, so please be careful.

---
 drivers/acpi/processor_perflib.c |   27 +++++++++++++++++++++------
 1 file changed, 21 insertions(+), 6 deletions(-)
drivers/acpi/processor_perflib.c +21 -6
Index: linux-pm/drivers/acpi/processor_perflib.c
===================================================================
@@ -53,6 +53,8 @@ static int acpi_processor_get_platform_l
 {
 	acpi_status status = 0;
 	unsigned long long ppc = 0;
+	s32 qos_value;
+	int index;
 	int ret;
 
 	if (!pr)
@@ -72,17 +74,30 @@ static int acpi_processor_get_platform_l
 		}
 	}
 
+	index = ppc;
+
+	if (pr->performance_platform_limit == index ||
+	    ppc >= pr->performance->state_count)
+		return 0;
+
 	pr_debug("CPU %d: _PPC is %d - frequency %s limited\n", pr->id,
-		       (int)ppc, ppc ? "" : "not");
+		 index, index ? "is" : "is not");
 
-	pr->performance_platform_limit = (int)ppc;
+	pr->performance_platform_limit = index;
 
-	if (ppc >= pr->performance->state_count ||
-	    unlikely(!freq_qos_request_active(&pr->perflib_req)))
+	if (unlikely(!freq_qos_request_active(&pr->perflib_req)))
 		return 0;
 
-	ret = freq_qos_update_request(&pr->perflib_req,
-			pr->performance->states[ppc].core_frequency * 1000);
+	/*
+	 * If _PPC returns 0, it means that all of the available states can be
+	 * used ("no limit").
+	 */
+	if (index == 0)
+		qos_value = FREQ_QOS_MAX_DEFAULT_VALUE;
+	else
+		qos_value = pr->performance->states[index].core_frequency * 1000;
+
+	ret = freq_qos_update_request(&pr->perflib_req, qos_value);
 	if (ret < 0) {
 		pr_warn("Failed to update perflib freq constraint: CPU%d (%d)\n",
 			pr->id, ret);
#14 lore raw
In reply to Rafael J. Wysocki
Quoted 61 lines · Rafael J. Wysocki
Quoted 59 lines · srinivas pandruvada
Quoted 57 lines · Pratyush Yadav

Hi Srinivas,

Quoted 52 lines · srinivas pandruvada
Quoted 23 lines · srinivas pandruvada

Hi Pratyush,

Quoted 20 lines · Pratyush Yadav

Hi Srinivas,

Quoted 16 lines · srinivas pandruvada
Quoted 15 lines · Pratyush Yadav

When a processor is brought offline and online again, it is
unable to
use Turbo mode because the _PSS table does not contain the
whole
turbo
frequency range, but only +1 MHz above the max non- turbo
frequency.
This
causes problems when ACPI processor driver tries to set frequency
constraints. See patch 2 for more details.

Quoted 5 lines

I can reproduce on a Broadwell server platform. But not on a client
system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously
acpi_processor_get_platform_limit() was not enforcing any limits.
It
was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call
        ret = freq_qos_update_request(&pr->perflib_req, pr->performance-

Quoted 1 line

states[ppc].core_frequency

*
1000);

if the PPC is not changed. When PPC is changed, this gets called
again,
so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Quoted 9 lines
Quoted 5 lines
Quoted 1 line

Right.

I think, this is the only change you require to fix this. In addition
set pr->performance_platform_limit = 0 in acpi_processor_unregister_performance().

Not really, because if the limit is set to a lower frequency and then reset to _PSS[0], it needs to be set back to "no limit".

If PPC becomes 0 again after ppc > 0 during dynamic PPC change, pr-

Quoted 1 line

performance_platform_limit will not match current PPC, so will set to

PPC 0 performance ( which is already patched by driver after return from acpi_register_performance_state()).

But fine, you can always set freq qos to FREQ_QOS_MAX_DEFAULT_VALUE for PPC 0 as you are doing in your patch.

Thanks,
Srinivas

Quoted 1 line

I'll send a patch for that in a while.

#15 lore raw
Quoted 69 lines · srinivas pandruvada
Quoted 67 lines · Rafael J. Wysocki
Quoted 64 lines · srinivas pandruvada
Quoted 50 lines · Pratyush Yadav

Hi Srinivas,

Quoted 46 lines · srinivas pandruvada
Quoted 23 lines · srinivas pandruvada

Hi Pratyush,

Quoted 20 lines · Pratyush Yadav

Hi Srinivas,

Quoted 16 lines · srinivas pandruvada
Quoted 15 lines · Pratyush Yadav

When a processor is brought offline and online again, it is
unable to
use Turbo mode because the _PSS table does not contain the
whole
turbo
frequency range, but only +1 MHz above the max non- turbo
frequency.
This
causes problems when ACPI processor driver tries to set frequency
constraints. See patch 2 for more details.

Quoted 5 lines

I can reproduce on a Broadwell server platform. But not on a client
system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously
acpi_processor_get_platform_limit() was not enforcing any limits.
It
was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call

        ret = freq_qos_update_request(&pr->perflib_req,
                        pr->performance-
Quoted 1 line

states[ppc].core_frequency

*
1000);

Quoted 8 lines
Quoted 6 lines

if the PPC is not changed. When PPC is changed, this gets called
again,
so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Right.

I think, this is the only change you require to fix this. In addition
set pr->performance_platform_limit = 0 in acpi_processor_unregister_performance().

Quoted 8 lines
Quoted 3 lines

Not really, because if the limit is set to a lower frequency and then reset to _PSS[0], it needs to be set back to "no limit".

If PPC becomes 0 again after ppc > 0 during dynamic PPC change, pr-

Quoted 1 line

performance_platform_limit will not match current PPC, so will set to

PPC 0 performance ( which is already patched by driver after return from acpi_register_performance_state()).

I see.

Quoted 2 lines

But fine, you can always set freq qos to FREQ_QOS_MAX_DEFAULT_VALUE for PPC 0 as you are doing in your patch.

I think that using the "no limit" value to represent the "no limit" condition makes sense.

Also, I'm wondering if the patching of states[0].core_frequency will still be necessary after this change.

#16 lore raw
Quoted 89 lines · Rafael J. Wysocki
Quoted 81 lines · srinivas pandruvada
Quoted 69 lines · Rafael J. Wysocki
Quoted 67 lines · srinivas pandruvada
Quoted 65 lines · Pratyush Yadav

Hi Srinivas,

Quoted 52 lines · srinivas pandruvada
Quoted 27 lines · srinivas pandruvada

Hi Pratyush,

Quoted 24 lines · Pratyush Yadav

Hi Srinivas,

Quoted 20 lines · srinivas pandruvada
Quoted 18 lines · Pratyush Yadav

When a processor is brought offline and online again,
it is
unable to
use Turbo mode because the _PSS table does not contain
the
whole
turbo
frequency range, but only +1 MHz above the max non- turbo
frequency.
This
causes problems when ACPI processor driver tries to set
frequency
constraints. See patch 2 for more details.

Quoted 6 lines

I can reproduce on a Broadwell server platform. But not on a
client
system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously
acpi_processor_get_platform_limit() was not enforcing any limits.
It
was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call
        ret = freq_qos_update_request(&pr->perflib_req, pr->performance-

Quoted 1 line

states[ppc].core_frequency

*
1000);

Quoted 7 lines

if the PPC is not changed. When PPC is changed, this gets called
again,
so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Right.

Quoted 9 lines
Quoted 4 lines

I think, this is the only change you require to fix this. In addition
set pr->performance_platform_limit = 0 in acpi_processor_unregister_performance().

Not really, because if the limit is set to a lower frequency and then
reset to _PSS[0], it needs to be set back to "no limit".

Quoted 5 lines

If PPC becomes 0 again after ppc > 0 during dynamic PPC change, pr-

Quoted 2 lines

performance_platform_limit will not match current PPC, so will set to

PPC 0 performance ( which is already patched by driver after return from acpi_register_performance_state()).

Quoted 8 lines

I see.

Quoted 3 lines

But fine, you can always set freq qos to FREQ_QOS_MAX_DEFAULT_VALUE for
PPC 0 as you are doing in your patch.

I think that using the "no limit" value to represent the "no limit" condition makes sense.

Agree.

Quoted 3 lines

Also, I'm wondering if the patching of states[0].core_frequency will still be necessary after this change.

I don't think so. We can remove the patching.

#17 lore raw
Quoted 99 lines · srinivas pandruvada
Quoted 89 lines · Rafael J. Wysocki
Quoted 81 lines · srinivas pandruvada
Quoted 69 lines · Rafael J. Wysocki
Quoted 67 lines · srinivas pandruvada
Quoted 65 lines · Pratyush Yadav

Hi Srinivas,

Quoted 52 lines · srinivas pandruvada
Quoted 27 lines · srinivas pandruvada

Hi Pratyush,

Quoted 24 lines · Pratyush Yadav

Hi Srinivas,

Quoted 20 lines · srinivas pandruvada
Quoted 18 lines · Pratyush Yadav

When a processor is brought offline and online again,
it is
unable to
use Turbo mode because the _PSS table does not contain
the
whole
turbo
frequency range, but only +1 MHz above the max non- turbo
frequency.
This
causes problems when ACPI processor driver tries to set
frequency
constraints. See patch 2 for more details.

Quoted 6 lines

I can reproduce on a Broadwell server platform. But not on a
client
system with acpi_ppc usage.

Need to check what change broke this.

When PPC limits enforcement changed to PM QOS, this broke. Previously
acpi_processor_get_platform_limit() was not enforcing any limits.
It
was just setting variable. So any update done after acpi_register_performance_state() call to pr->performance-

Quoted 1 line

states[ppc].core_frequency, was effective.

We don't really need to call

        ret = freq_qos_update_request(&pr->perflib_req,
                        pr->performance-
Quoted 1 line

states[ppc].core_frequency

*
1000);

Quoted 7 lines

if the PPC is not changed. When PPC is changed, this gets called
again,
so then we can call the above function to update cpufreq limit.

The below change fixed for me.

Right.

Quoted 9 lines
Quoted 4 lines

I think, this is the only change you require to fix this. In addition
set pr->performance_platform_limit = 0 in acpi_processor_unregister_performance().

Not really, because if the limit is set to a lower frequency and then
reset to _PSS[0], it needs to be set back to "no limit".

Quoted 5 lines

If PPC becomes 0 again after ppc > 0 during dynamic PPC change, pr-

Quoted 2 lines

performance_platform_limit will not match current PPC, so will set to

PPC 0 performance ( which is already patched by driver after return from acpi_register_performance_state()).

Quoted 8 lines

I see.

Quoted 3 lines

But fine, you can always set freq qos to FREQ_QOS_MAX_DEFAULT_VALUE for
PPC 0 as you are doing in your patch.

I think that using the "no limit" value to represent the "no limit" condition makes sense.

Quoted 7 lines

Agree.

Quoted 3 lines

Also, I'm wondering if the patching of states[0].core_frequency will still be necessary after this change.

I don't think so. We can remove the patching.

OK, let me cut the patches.

#18 lore raw
In reply to Pratyush Yadav
Quoted 4 lines · Pratyush Yadav

When a processor is brought offline and online again, it is unable to use Turbo mode because the _PSS table does not contain the whole turbo frequency range, but only +1 MHz above the max non-turbo frequency.

That's because of the way P-state limits in the turbo range are handled by the given processor.

Some of them restrict the P-state even if the limit is located within the turbo range and some of them don't (that is, requesting any P-state in the turbo range gives the processor a license to use the whole of it).

Quoted 2 lines

This causes problems when ACPI processor driver tries to set frequency constraints.

The problem is that acpi_processor_get_platform_limit() sets the limit to the frequency for all of the _PSS states including the last special one and it should update the QoS to "no limit" in that case.