perf failed with kernel 2.6.35-rc
Subsystems (2)
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.
I located below commit:
commit 1ac62cfff252fb668405ef3398a1fa7f4a0d6d15
Author: Peter Zijlstra <[email protected]> Date: Fri Mar 26 14:08:44 2010 +0100
perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010
Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function intel_pmu_nhm_enable_all, perf could work.
A quick glance shows:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);
I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
arch/x86/kernel/cpu/perf_event_intel.c +6 -1
@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(intwrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 );wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x7 );wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +/* +* Reset the last 3 bits of global status register in case +* previous enabling causes overflows. +*/ +wrmsrl (MSR_CORE_PERF_GLOBAL_OVF_CTRL ,0x7 );for (i =0 ; i <3 ; i++) {struct perf_event *event = cpuc->events[i];
However, it still doesn't work. Current right way is to comment out the workaround.
Yanmin
Quoted 52 lines · Zhang, Yanmin
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.I located below commit:
commit1ac62cfff252fb668405ef3398a1fa7f4a0d6d15Author: Peter Zijlstra <[email protected]> Date: Fri Mar 26 14:08:44 2010 +0100perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
arch/x86/kernel/cpu/perf_event_intel.c +6
-1@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(intwrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 );wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x7 );wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +/* +* Reset the last 3 bits of global status register in case +* previous enabling causes overflows. +*/ +wrmsrl (MSR_CORE_PERF_GLOBAL_OVF_CTRL ,0x7 );for (i =0 ; i <3 ; i++) {struct perf_event *event = cpuc->events[i];
Quoted 2 lines
However, it still doesn't work. Current right way is to comment out the workaround.
Well, how about doing it like this:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); /* * Reset the last 3 bits of global status register in case * previous enabling causes overflows. */ wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7);
for (i = 0; i < 3; i++) {
struct perf_event *event = cpuc->events[i]; ... }
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0);
I.e. global-mask, overflow-clear, explicit-enable, then global-enable?
Thanks,
Ingo
Quoted 67 lines · Ingo Molnar
Quoted 52 lines · Zhang, Yanmin
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.I located below commit:
commit1ac62cfff252fb668405ef3398a1fa7f4a0d6d15Author: Peter Zijlstra <[email protected]> Date: Fri Mar 26 14:08:44 2010 +0100perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
arch/x86/kernel/cpu/perf_event_intel.c +6
-1@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(intwrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 );wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x7 );wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +/* +* Reset the last 3 bits of global status register in case +* previous enabling causes overflows. +*/ +wrmsrl (MSR_CORE_PERF_GLOBAL_OVF_CTRL ,0x7 );for (i =0 ; i <3 ; i++) {struct perf_event *event = cpuc->events[i];Quoted 2 lines
However, it still doesn't work. Current right way is to comment out the workaround.
Well, how about doing it like this:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); /* * Reset the last 3 bits of global status register in case * previous enabling causes overflows. */ wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7);for (i = 0; i < 3; i++) {
Quoted 8 lines
struct perf_event *event = cpuc->events[i]; ... }wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0);I.e. global-mask, overflow-clear, explicit-enable, then global-enable?
Ingo,
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7) is global enable. So it's global-enable, overflow-clear, explicit-enable, then global-disable?
Yanmin
Quoted 72 lines · Yanmin
Quoted 71 lines · Ingo Molnar
Quoted 52 lines · Zhang, Yanmin
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.I located below commit:
commit1ac62cfff252fb668405ef3398a1fa7f4a0d6d15Author: Peter Zijlstra <[email protected]> Date: Fri Mar 26 14:08:44 2010 +0100perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
arch/x86/kernel/cpu/perf_event_intel.c +6
-1@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(intwrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 );wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x7 );wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +/* +* Reset the last 3 bits of global status register in case +* previous enabling causes overflows. +*/ +wrmsrl (MSR_CORE_PERF_GLOBAL_OVF_CTRL ,0x7 );for (i =0 ; i <3 ; i++) {struct perf_event *event = cpuc->events[i];Quoted 2 lines
However, it still doesn't work. Current right way is to comment out the workaround.
Well, how about doing it like this:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); /* * Reset the last 3 bits of global status register in case * previous enabling causes overflows. */ wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7);for (i = 0; i < 3; i++) {
struct perf_event *event = cpuc->events[i]; ... }
Quoted 8 lines
Quoted 4 lines
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0);I.e. global-mask, overflow-clear, explicit-enable, then global-enable?
Ingo,
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7)is global enable. So it's global-enable, overflow-clear, explicit-enable, then global-disable?
It doesn't work.
I copied the PMU dumping of logical processor 0.
Besides status register's bit0 is equal to 0, PMC0 count is small. So it takes a long time to overflow.
CPU#0: ctrl: 000000070000000f CPU#0: status: 0000000000000001 CPU#0: overflow: 0000000000000000 CPU#0: fixed: 0000000000000000 CPU#0: pebs: 0000000000000000 CPU#0: active: 0000000000000001 CPU#0: gen-PMC0 ctrl: 000000000053003c CPU#0: gen-PMC0 count: 00000000549bffd9 CPU#0: gen-PMC0 left: 0000000000000002 CPU#0: gen-PMC1 ctrl: 00000000004300b1 CPU#0: gen-PMC1 count: 0000000000000000 CPU#0: gen-PMC1 left: 0000000000000000 CPU#0: gen-PMC2 ctrl: 00000000004300b5 CPU#0: gen-PMC2 count: 0000000000000000 CPU#0: gen-PMC2 left: 0000000000000000 CPU#0: gen-PMC3 ctrl: 0000000000000000 CPU#0: gen-PMC3 count: 0000000000000000 CPU#0: gen-PMC3 left: 0000000000000000
CPU#0: fixed-PMC0 count: 0000000000000000
CPU#0: fixed-PMC1 count: 0000000000000000
CPU#0: fixed-PMC2 count: 0000000000000000
SysRq : Show Regs
I instrumented function intel_pmu_nhm_enable_all to check PMC0 count register before the workaround and after disabling the 3 bits of MSR_CORE_PERF_GLOBAL_CTRL. It's changed unexpectedly. below is a debug output about processor 0.
PMU register counter is changed. before[281474976710654] after[1]
So I think the event 0x4300D2 overflows. We need do a save and restore. Below patch fixes it.
Yanmin
---
arch/x86/kernel/cpu/perf_event_intel.c +15 -2
@@ -499,21 +499,34 @@ static void intel_pmu_nhm_enable_all(int {if (added) {struct cpu_hw_events *cpuc = &__get_cpu_var (cpu_hw_events); +struct perf_event *event;int i; +for (i =0 ; i <3 ; i++) { + event = cpuc->events[i]; +if (!event) +continue ; +x86_perf_event_update (event); + }wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +0 ,0x4300D2 );wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 );wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x7 );wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +/* +* Reset the last 3 bits of global status register in case +* previous enabling causes overflows. +*/ +wrmsrl (MSR_CORE_PERF_GLOBAL_OVF_CTRL ,0x7 );for (i =0 ; i <3 ; i++) { -struct perf_event *event = cpuc->events[i]; + event = cpuc->events[i];if (!event)continue ; +x86_perf_event_set_period (event);__x86_pmu_enable_event (&event->hw,ARCH_PERFMON_EVENTSEL_ENABLE ); }
Quoted 25 lines · Yanmin
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.I located below commit:
commit1ac62cfff252fb668405ef3398a1fa7f4a0d6d15
Author: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 14:08:44 2010 +0100perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.
Quoted 9 lines
A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
What do you call the last bit? bit0 or bit63?
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 513
Quoted 13 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +5
-1@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(int wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300B1); wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B5); - wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); + wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0); + /* + * Reset the last 3 bits of global status register in case + * previous enabling causes overflows. + */
The workaround cannot cause on overflow because the associated counters won't count anything given their umask value is 0 (which does not correspond to anything for event 0xB1, event 0xB5 is undocumented). This is for the events described in table A.2. If NHM-EX has a different definition for 0xB1, 0xB5, then that's another story.
Quoted 14 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +1
-0+ wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7); for (i = 0; i < 3; i++) { struct perf_event *event = cpuc->events[i];However, it still doesn't work. Current right way is to comment out the workaround.
Yanmin
Quoted 33 lines · Stephane Eranian
Quoted 31 lines · Yanmin
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.I located below commit:
commit1ac62cfff252fb668405ef3398a1fa7f4a0d6d15Author: Peter Zijlstra <[email protected]> Date: Fri Mar 26 14:08:44 2010 +0100perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);
Quoted 4 lines
Quoted 3 lines
I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
What do you call the last bit? bit0 or bit63?
Sorry for confusing you. It's bit0, mapping to PERFMON_EVENTSEL0.
Quoted 7 lines
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +0
-0@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(int wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300B1); wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B5);
Quoted 13 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 513
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +5
-1- wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); + wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0); + /* + * Reset the last 3 bits of global status register in case + * previous enabling causes overflows. + */The workaround cannot cause on overflow because the associated counters won't count anything given their umask value is 0 (which does not correspond to anything for event
0xB1, event0xB5is undocumented). This is for the events described in table A.2. If NHM-EX has a different definition for0xB1,0xB5, then that's another story.
I found the status bit is set by triggering sysrq to dump PMU registers.
If I start perf by gdb, sometimes, perf could work. I found one processor's 1st status register is equal to 0 while other processors' are 1. If just starting perf, all 1st status registers are equal to 1.
Quoted 11 lines
Quoted 11 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +1
-0+ wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7); for (i = 0; i < 3; i++) { struct perf_event *event = cpuc->events[i];However, it still doesn't work. Current right way is to comment out the workaround.
What about running simpler commands like perf stat?
Quoted 80 lines · Yanmin
Quoted 33 lines · Stephane Eranian
Quoted 31 lines · Yanmin
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.I located below commit:
commit1ac62cfff252fb668405ef3398a1fa7f4a0d6d15
Author: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 14:08:44 2010 +0100perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);Quoted 4 lines
Quoted 3 lines
I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
What do you call the last bit? bit0 or bit63?
Sorry for confusing you. It's bit0, mapping to
PERFMON_EVENTSEL0.Quoted 7 lines
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +0
-0@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(int wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300B1); wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B5);Quoted 13 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 513
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +5
-1- wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); + wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0); + /* + * Reset the last 3 bits of global status register in case + * previous enabling causes overflows. + */The workaround cannot cause on overflow because the associated counters won't count anything given their umask value is 0 (which does not correspond to anything for event
0xB1, event0xB5is undocumented). This is for the events described in table A.2. If NHM-EX has a different definition for0xB1,0xB5, then that's another story.I found the status bit is set by triggering sysrq to dump PMU registers.
If I start perf by gdb, sometimes, perf could work. I found one processor's 1st status register is equal to 0 while other processors' are 1. If just starting perf, all 1st status registers are equal to 1.
Quoted 11 lines
Quoted 11 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +1
-0+ wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7); for (i = 0; i < 3; i++) { struct perf_event *event = cpuc->events[i];However, it still doesn't work. Current right way is to comment out the workaround.
Quoted 1 line · Stephane Eranian
What about running simpler commands like perf stat?
'perf stat ls' seems ok.
I compare the PMU register dumping info before and after 'perf stat ls'. Some processors' bit0 of status registers become 0 from 1.
I can't guarantee all 'perf stat' is ok because it seems some processors wouldn't collect perf statistics correctly while others seem ok.
'gdb perf' could work because one processor seems ok while others couldn't. So 'gdb perf' actually miss some data.
Quoted 81 lines
Quoted 77 lines · Yanmin
Quoted 33 lines · Stephane Eranian
Quoted 31 lines · Yanmin
Peter,
perf doesn't work on my Nehalem EX machine.
1) The 1st start of 'perf top' is ok;
2) Kill the 1st perf and restart it. It doesn't work. No data is showed.I located below commit:
commit1ac62cfff252fb668405ef3398a1fa7f4a0d6d15Author: Peter Zijlstra <[email protected]> Date: Fri Mar 26 14:08:44 2010 +0100perf, x86: Add Nehelem PMU programming errata workaround
workaround From: Peter Zijlstra <[email protected]>
Date: Fri Mar 26 13:59:41 CET 2010Implement the workaround for Intel Errata AAK100 and AAP53.
Also, remove the Core-i7 name for Nehalem events since there are also Westmere based i7 chips.
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);Quoted 4 lines
Quoted 3 lines
I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
What do you call the last bit? bit0 or bit63?
Sorry for confusing you. It's bit0, mapping to
PERFMON_EVENTSEL0.Quoted 7 lines
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +0
-0@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(int wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300B1); wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B5);Quoted 13 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 513
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +5
-1- wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); + wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0); + /* + * Reset the last 3 bits of global status register in case + * previous enabling causes overflows. + */The workaround cannot cause on overflow because the associated counters won't count anything given their umask value is 0 (which does not correspond to anything for event
0xB1, event0xB5is undocumented). This is for the events described in table A.2. If NHM-EX has a different definition for0xB1,0xB5, then that's another story.I found the status bit is set by triggering sysrq to dump PMU registers.
If I start perf by gdb, sometimes, perf could work. I found one processor's 1st status register is equal to 0 while other processors' are 1. If just starting perf, all 1st status registers are equal to 1.
Quoted 11 lines
Quoted 11 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +1
-0+ wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7); for (i = 0; i < 3; i++) { struct perf_event *event = cpuc->events[i];However, it still doesn't work. Current right way is to comment out the workaround.
Peter Zijlstra
maintainerQuoted 7 lines · Yanmin
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);
Correct, I've got a patch for that laying around,.. posted it several times in the struct pmu rework series.
Quoted 7 lines
I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
arch/x86/kernel/cpu/perf_event_intel.c +0
-0@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(intwrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 );
arch/x86/kernel/cpu/perf_event_intel.c static void intel_pmu_nhm_enable_all(int · line 514
Quoted 10 lines
arch/x86/kernel/cpu/perf_event_intel.c +6
-1wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x7 );wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +/* +* Reset the last 3 bits of global status register in case +* previous enabling causes overflows. +*/ +wrmsrl (MSR_CORE_PERF_GLOBAL_OVF_CTRL ,0x7 );
Like Stephane already pointed out (and the comment above this function mentions), these counters should be non-counting, and thus should not cause an overflow (and this function gets called with GLOBAL_CTRL cleared, so it shouldn't be counting to begin with).
The Nehalem-EX errata BA72 seems to agree (assuming Xeon-7500 is indeed the EX, Intel really should do something about this naming madness)
http://www.intel.com/Assets/en_US/PDF/specupdate/323344.pdf
[ Also see the trace outout below, PERFCTR[12] stay 0 ]
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c +0
-0for (i =0 ; i <3 ; i++) {struct perf_event *event = cpuc->events[i];However, it still doesn't work. Current right way is to comment out the workaround.
So I frobbed the below patchlet to debug things, as it appears I can indeed reproduce on my westmere.
--- arch/x86/kernel/cpu/perf_event.c | 24 +++++++++++++++++++++++- arch/x86/kernel/cpu/perf_event_intel.c | 2 +- 2 files changed, 24 insertions(+), 2 deletions(-)
arch/x86/kernel/cpu/perf_event.c +23 -1
@@ -31,7 +31,7 @@#include <asm/nmi.h> #include <asm/compat.h> -#if 0 +#if 1 #undef wrmsrl#define wrmsrl (msr, val) \ do { \
@@ -42,6 +42,16 @@ do { \ } while (0)#endif +#if 1 +#undef rdmsrl +#define rdmsrl (msr, val) \ +do { \ + (val) = native_read_msr(msr); \ + trace_printk("rdmsrl(%lx, %lx)\n", (unsigned long)(msr),\ + (unsigned long)(val)); \ +} while (0) +#endif +/* * best effort, GUP based copy_from_user() that assumes IRQ or NMI context */
@@ -583,6 +593,14 @@ static void x86_pmu_disable_all(void) } } +static void noinline check_status(void) +{ +u64 status; +rdmsrl (MSR_CORE_PERF_GLOBAL_STATUS , status); +if (WARN_ON (status)) +perf_event_print_debug (); +} +void hw_perf_disable (void ) {struct cpu_hw_events *cpuc = &__get_cpu_var (cpu_hw_events);
@@ -598,6 +616,8 @@ void hw_perf_disable(void)barrier (); x86_pmu.disable_all (); + +check_status (); }static void x86_pmu_enable_all (int added)
@@ -816,6 +836,8 @@ void hw_perf_enable(void)if (cpuc->enabled)return ; +check_status (); +if (cpuc->n_added) {int n_running = cpuc->n_events - cpuc->n_added;/*
arch/x86/kernel/cpu/perf_event_intel.c +1 -1
@@ -505,7 +505,7 @@ static void intel_pmu_nhm_enable_all(int added)wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 );wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x7 );wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 );for (i =0 ; i <3 ; i++) {
---
It results in the below trace (edited out some superfluous stack traces:
<...>-1871 [000] 96.759853: intel_pmu_disable_all: wrmsrl(38f, 0)
<...>-1871 [000] 96.759853: <stack trace>
=> hw_perf_disable
=> perf_disable
=> perf_ctx_adjust_freq
=> perf_event_task_tick
=> scheduler_tick
=> update_process_times
=> tick_sched_timer
=> __run_hrtimer
<...>-1871 [000] 96.759872: check_status: rdmsrl(38e, 1)
<...>-1871 [000] 96.759872: <stack trace>
=> hw_perf_disable
=> perf_disable
=> perf_ctx_adjust_freq
=> perf_event_task_tick
=> scheduler_tick
=> update_process_times
=> tick_sched_timer
=> __run_hrtimer
<...>-1871 [000] 96.760180: perf_event_print_debug: rdmsrl(38f, 0)
<...>-1871 [000] 96.760186: perf_event_print_debug: rdmsrl(38e, 1)
<...>-1871 [000] 96.760191: perf_event_print_debug: rdmsrl(390, 0)
<...>-1871 [000] 96.760196: perf_event_print_debug: rdmsrl(38d, 0)
<...>-1871 [000] 96.760201: perf_event_print_debug: rdmsrl(3f1, 0)
<...>-1871 [000] 96.760248: perf_event_print_debug: rdmsrl(186, 53003c)
<...>-1871 [000] 96.760258: perf_event_print_debug: rdmsrl(c1, d1e91)
<...>-1871 [000] 96.760285: perf_event_print_debug: rdmsrl(187, 4300b1)
<...>-1871 [000] 96.760290: perf_event_print_debug: rdmsrl(c2, 0)
<...>-1871 [000] 96.760320: perf_event_print_debug: rdmsrl(188, 4300b5)
<...>-1871 [000] 96.760340: perf_event_print_debug: rdmsrl(c3, 0)
<...>-1871 [000] 96.760359: perf_event_print_debug: rdmsrl(189, 0)
<...>-1871 [000] 96.760379: perf_event_print_debug: rdmsrl(c4, 0)
<...>-1871 [000] 96.760398: perf_event_print_debug: rdmsrl(309, 0)
<...>-1871 [000] 96.760417: perf_event_print_debug: rdmsrl(30a, 0)
<...>-1871 [000] 96.760432: perf_event_print_debug: rdmsrl(30b, 0)
<...>-1871 [000] 96.760432: <stack trace> => check_status
=> hw_perf_disable
=> perf_disable
=> perf_ctx_adjust_freq
=> perf_event_task_tick
=> scheduler_tick
=> update_process_times
=> tick_sched_timer
Which seems to indicate we somehow disable the PMU (clear GLOBAL_CTRL) with a pending overflow (as indicated by GLOBAL_STATUS and PERFCTR0).
So there's two questions:
1) how can we end up in the above state
2) why does the fixup change things
most confusing..
Quoted 184 lines · Peter Zijlstra
Quoted 7 lines · Yanmin
If I comment out the workaround in function
intel_pmu_nhm_enable_all, perf could work.A quick glance shows:
wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3);
should be:wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7);Correct, I've got a patch for that laying around,.. posted it several times in the struct pmu rework series.
Quoted 7 lines
I triggered sysrq to dump PMU registers and found the last bit of global status register is 1. I added a status reset operation like below patch:
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +0
-0@@ -505,8 +505,13 @@ static void intel_pmu_nhm_enable_all(int wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300B1);arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 514
Quoted 10 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +6
-1wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B5); - wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); + wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0); + /* + * Reset the last 3 bits of global status register in case + * previous enabling causes overflows. + */ + wrmsrl(MSR_CORE_PERF_GLOBAL_OVF_CTRL, 0x7);Like Stephane already pointed out (and the comment above this function mentions), these counters should be non-counting, and thus should not cause an overflow (and this function gets called with
GLOBAL_CTRLcleared, so it shouldn't be counting to begin with).The Nehalem-EX errata BA72 seems to agree (assuming Xeon-7500 is indeed the EX, Intel really should do something about this naming madness)
http://www.intel.com/Assets/en_US/PDF/specupdate/323344.pdf[ Also see the trace outout below, PERFCTR[12] stay 0 ]
Quoted 7 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 14:41:42.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-07-14 09:38:11.000000000 +0800 +0
-0for (i = 0; i < 3; i++) { struct perf_event *event = cpuc->events[i];However, it still doesn't work. Current right way is to comment out the workaround.
So I frobbed the below patchlet to debug things, as it appears I can indeed reproduce on my westmere.
---
arch/x86/kernel/cpu/perf_event.c | 24 +++++++++++++++++++++++-arch/x86/kernel/cpu/perf_event_intel.c| 2 +-2 files changed, 24 insertions(+), 2 deletions(-)arch/x86/kernel/cpu/perf_event.c +23
-1@@ -31,7 +31,7 @@ #include <asm/nmi.h> #include <asm/compat.h> -#if 0 +#if 1 #undef wrmsrl #define wrmsrl(msr, val) \ do { \@@ -42,6 +42,16 @@ do { \ } while (0) #endif +#if 1 +#undef rdmsrl +#define rdmsrl (msr, val) \ +do { \ + (val) = native_read_msr(msr); \ + trace_printk("rdmsrl(%lx, %lx)\n", (unsigned long)(msr),\ + (unsigned long)(val)); \ +} while (0) +#endif + /** best effort, GUP based copy_from_user() that assumes IRQ or NMI context */ @@ -583,6 +593,14 @@ static void x86_pmu_disable_all(void) } } +static void noinline check_status(void) +{ + u64 status; + rdmsrl(MSR_CORE_PERF_GLOBAL_STATUS, status); + if (WARN_ON(status)) + perf_event_print_debug(); +} + void hw_perf_disable(void) { struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events);@@ -598,6 +616,8 @@ void hw_perf_disable(void) barrier(); x86_pmu.disable_all(); + + check_status(); } static void x86_pmu_enable_all(int added)@@ -816,6 +836,8 @@ void hw_perf_enable(void) if (cpuc->enabled) return; + check_status(); + if (cpuc->n_added) { int n_running = cpuc->n_events - cpuc->n_added; /*arch/x86/kernel/cpu/perf_event_intel.c +1
-2@@ -505,7 +505,7 @@ static void intel_pmu_nhm_enable_all(int added) wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300B1); wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B5); - wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); + wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x7); wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0); for (i = 0; i < 3; i++) { ---It results in the below trace (edited out some superfluous stack traces:
<...>-1871 [000] 96.759853:
intel_pmu_disable_all:wrmsrl(38f, 0)<...>-1871 [000] 96.759853: <stack trace>
=>hw_perf_disable
=>perf_disable
=>perf_ctx_adjust_freq
=>perf_event_task_tick
=>scheduler_tick
=>update_process_times
=>tick_sched_timer
=>__run_hrtimer
<...>-1871 [000] 96.759872:check_status:rdmsrl(38e, 1)<...>-1871 [000] 96.759872: <stack trace>
=>hw_perf_disable
=>perf_disable
=>perf_ctx_adjust_freq
=>perf_event_task_tick
=>scheduler_tick
=>update_process_times
=>tick_sched_timer
=>__run_hrtimer
<...>-1871 [000] 96.760180:perf_event_print_debug:rdmsrl(38f, 0)<...>-1871 [000] 96.760186:perf_event_print_debug:rdmsrl(38e, 1)<...>-1871 [000] 96.760191:perf_event_print_debug:rdmsrl(390, 0)<...>-1871 [000] 96.760196:perf_event_print_debug:rdmsrl(38d, 0)<...>-1871 [000] 96.760201:perf_event_print_debug:rdmsrl(3f1, 0)<...>-1871 [000] 96.760248:perf_event_print_debug:rdmsrl(186, 53003c)<...>-1871 [000] 96.760258:perf_event_print_debug:rdmsrl(c1, d1e91)<...>-1871 [000] 96.760285:perf_event_print_debug:rdmsrl(187, 4300b1)<...>-1871 [000] 96.760290:perf_event_print_debug:rdmsrl(c2, 0)<...>-1871 [000] 96.760320:perf_event_print_debug:rdmsrl(188, 4300b5)<...>-1871 [000] 96.760340:perf_event_print_debug:rdmsrl(c3, 0)<...>-1871 [000] 96.760359:perf_event_print_debug:rdmsrl(189, 0)<...>-1871 [000] 96.760379:perf_event_print_debug:rdmsrl(c4, 0)<...>-1871 [000] 96.760398:perf_event_print_debug:rdmsrl(309, 0)<...>-1871 [000] 96.760417:perf_event_print_debug:rdmsrl(30a, 0)<...>-1871 [000] 96.760432:perf_event_print_debug:rdmsrl(30b, 0)<...>-1871 [000] 96.760432: <stack trace>
=>check_status
=>hw_perf_disable
=>perf_disable
=>perf_ctx_adjust_freq
=>perf_event_task_tick
=>scheduler_tick
=>update_process_times
=>tick_sched_timer
Quoted 3 lines
Which seems to indicate we somehow disable the PMU (clear
GLOBAL_CTRL) with a pending overflow (as indicated byGLOBAL_STATUSand PERFCTR0).
At the time you stop the PMU, you could have an in-flight overflow, i.e., it may take some time to set the overflow status bit. But this seems far fetched because
it would be very hard to reproduce. Do you get the same problem is you restrict the event to counting at the user level, for instance?
Another good source of infos is the Intel VTUNE/PTU driver, called SEP. The source is provided when you download PTU. I checked the code and they do have a fix for the same errata. It seems to issue many more wrmsrl().
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): 1280905701.1923.717.camel@laptop
A message that is not in the archive (sent off-list or not yet received): [email protected]
A message that is not in the archive (sent off-list or not yet received): 1281004361.1923.1750.camel@laptop
Quoted 3 lines · Peter Zijlstra
Quoted 1 line · Yanmin
Here is the new patch.
I did more tracing. It seems only PMC0 overflows unexpectedly with the Errata.
Quoted 13 lines
Quoted 13 lines
---
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-08-02 06:11:14.000000000 +0800 +2
-0@@ -499,21 +499,40 @@ static void intel_pmu_nhm_enable_all(int { if (added) { struct cpu_hw_events *cpuc = &__get_cpu_var(cpu_hw_events); + struct perf_event *event; + int num_counters; int i;
Quoted 8 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 507
Quoted 5 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-08-02 06:11:14.000000000 +0800 +2
-3- wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 0, 0x4300D2); - wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300B1); - wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B5); + /* We always operate 4 pairs of PERF Counters */ + num_counters = 4;Either hardcode 4 (its a model specific errata after all), or use x86_pmu.num_counters.
Ok.
Quoted 2 lines
Also, please update the comment describing the new work-around.
I will add detailed steps.
Quoted 46 lines
Quoted 8 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-08-02 06:11:14.000000000 +0800 +6
-0+ for (i = 0; i < num_counters; i++) { + event = cpuc->events[i]; + if (!event) + continue; + x86_perf_event_update(event); + }arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 523
Quoted 10 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-08-02 06:11:14.000000000 +0800 +9
-1- wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x3); + wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 0, 0x4300B5); + wrmsrl(MSR_ARCH_PERFMON_PERFCTR0 + 0, 0x0); + wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 1, 0x4300D2); + wrmsrl(MSR_ARCH_PERFMON_PERFCTR0 + 1, 0x0); + wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 2, 0x4300B1); + wrmsrl(MSR_ARCH_PERFMON_PERFCTR0 + 2, 0x0); + wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + 3, 0x4300B1); + wrmsrl(MSR_ARCH_PERFMON_PERFCTR0 + 3, 0x0); +Maybe write that as:
static const unsigned long magic[4] = { 0x4300B5, 0x4300D2, 0x4300B1, 0x4300B1 }; for (i = 0; i < 4; i++) { wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + i, magic[i]); wrmsrl(MSR_ARCH_PERFMON_PERFCTR0 + i, 0); }arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 531
Quoted 11 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-08-02 06:11:14.000000000 +0800 +5
-3+ wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0xf); wrmsrl(MSR_CORE_PERF_GLOBAL_CTRL, 0x0); - for (i = 0; i < 3; i++) { - struct perf_event *event = cpuc->events[i]; + for (i = 0; i < num_counters; i++) { + event = cpuc->events[i]; - if (!event) + if (!event) { + wrmsrl(MSR_ARCH_PERFMON_EVENTSEL0 + i, 0x0);Indeed, if they are counting we need to at least stop them, and clearing them is indeed the simplest way.
Quoted 3 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-08-02 06:11:14.000000000 +0800 +1
-0continue; + }
Quoted 6 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 static void intel_pmu_nhm_enable_all(int · line 538
Quoted 4 lines
arch/x86/kernel/cpu/perf_event_intel.c 2010-08-06 13:43:34.000000000 +0800 renamed from arch/x86/kernel/cpu/perf_event_intel.c 2010-08-02 06:11:14.000000000 +0800 +1
-0+ x86_perf_event_set_period(event); __x86_pmu_enable_event(&event->hw, ARCH_PERFMON_EVENTSEL_ENABLE); }Please send the updated patch for inclusion, Thanks!
Below is the patch against 2.6.35.
Fix Errata AAK100/AAP53/BD53.
---
arch/x86/kernel/cpu/perf_event_intel.c +58 -17
@@ -492,32 +492,73 @@ static void intel_pmu_enable_all(int add* Intel Errata BD53 (model 44) * * These chips need to be 'reset' when adding counters by programming -* the magic three (non counting) events 0x4300D2, 0x4300B1 and 0x4300B5 +* the magic three (non counting) events 0x4300B5, 0x4300D2, and 0x4300B1 * either in sequence on the same PMC or on different PMCs. */ -static void intel_pmu_nhm_enable_all (int added) +static void intel_pmu_nhm_workaround (void ) { -if (added) { -struct cpu_hw_events *cpuc = &__get_cpu_var (cpu_hw_events); -int i; - -wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +0 ,0x4300D2 ); -wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 ); -wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); +struct cpu_hw_events *cpuc = &__get_cpu_var (cpu_hw_events); +static const unsigned long nhm_magic[4 ] = { +0x4300B5 , +0x4300D2 , +0x4300B1 , +0x4300B1 + }; +struct perf_event *event; +int i; + +/* +* The Errata requires below steps: +* 1) Clear MSR_IA32_PEBS_ENABLE and MSR_CORE_PERF_GLOBAL_CTRL; +* 2) Configure 4 PERFEVTSELx with the magic number and clear +* the corresponding PMCx; +* 3) set bit0~bit3 of MSR_CORE_PERF_GLOBAL_CTRL; +* 4) Clear MSR_CORE_PERF_GLOBAL_CTRL; +* 5) Clear 4 pairs of ERFEVTSELx and PMCx; +*/ -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +/* +* The real steps we choose are a little different from above. +* A) To reduce MSR operations, we don't run step 1) as they +* are already cleared before this function is called; +* B) Call x86_perf_event_update to save PMCx before configuring +* PERFEVTSELx with magic number; +* C) With step 5), we do clear only when the PERFEVTSELx is +* not used currently. +* D) Call x86_perf_event_set_period to restore PMCx; +*/ -for (i =0 ; i <3 ; i++) { -struct perf_event *event = cpuc->events[i]; +/* We always operate 4 pairs of PERF Counters */ +for (i =0 ; i <4 ; i++) { + event = cpuc->events[i]; +if (event) +x86_perf_event_update (event); + } -if (!event) -continue ; +for (i =0 ; i <4 ; i++) { +wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 + i, nhm_magic[i]); +wrmsrl (MSR_ARCH_PERFMON_PERFCTR0 + i,0x0 ); + } +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0xf ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); + +for (i =0 ; i <4 ; i++) { + event = cpuc->events[i]; + +if (event) { +x86_perf_event_set_period (event);__x86_pmu_enable_event (&event->hw, -ARCH_PERFMON_EVENTSEL_ENABLE ); - } +ARCH_PERFMON_EVENTSEL_ENABLE ); + }else +wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 + i,0x0 ); } +} + +static void intel_pmu_nhm_enable_all (int added) +{ +if (added) +intel_pmu_nhm_workaround ();intel_pmu_enable_all (added); }
[tip:perf/urgent] perf, x86: Fix Intel-nhm PMU programming errata workaround
Commit-ID: 351af0725e5222e35741011d1ea62215c1ed06db Gitweb: http://git.kernel.org/tip/351af0725e5222e35741011d1ea62215c1ed06db Author: Zhang, Yanmin <[email protected]> AuthorDate: Fri, 6 Aug 2010 13:39:08 +0800 Committer: Ingo Molnar <[email protected]> CommitDate: Wed, 18 Aug 2010 11:17:39 +0200
perf, x86: Fix Intel-nhm PMU programming errata workaround
Fix the Errata AAK100/AAP53/BD53 workaround, the officialy documented workaround we implemented in:
11164cd: perf, x86: Add Nehelem PMU programming errata workaround
doesn't actually work fully and causes a stuck PMU state under load and non-functioning perf profiling.
A functional workaround was found by trial & error.
Affects all Nehalem-class Intel PMUs.
LKML-Reference: <[email protected]>
--- arch/x86/kernel/cpu/perf_event_intel.c | 81 +++++++++++++++++++++++++------- 1 files changed, 63 insertions(+), 18 deletions(-)
arch/x86/kernel/cpu/perf_event_intel.c +63 -18
@@ -491,33 +491,78 @@ static void intel_pmu_enable_all(int added)* Intel Errata AAP53 (model 30) * Intel Errata BD53 (model 44) * -* These chips need to be 'reset' when adding counters by programming -* the magic three (non counting) events 0x4300D2, 0x4300B1 and 0x4300B5 -* either in sequence on the same PMC or on different PMCs. +* The official story: +* These chips need to be 'reset' when adding counters by programming the +* magic three (non-counting) events 0x4300B5, 0x4300D2, and 0x4300B1 either +* in sequence on the same PMC or on different PMCs. +* +* In practise it appears some of these events do in fact count, and +* we need to programm all 4 events. */ -static void intel_pmu_nhm_enable_all (int added) +static void intel_pmu_nhm_workaround (void ) { -if (added) { -struct cpu_hw_events *cpuc = &__get_cpu_var (cpu_hw_events); -int i; +struct cpu_hw_events *cpuc = &__get_cpu_var (cpu_hw_events); +static const unsigned long nhm_magic[4 ] = { +0x4300B5 , +0x4300D2 , +0x4300B1 , +0x4300B1 + }; +struct perf_event *event; +int i; + +/* +* The Errata requires below steps: +* 1) Clear MSR_IA32_PEBS_ENABLE and MSR_CORE_PERF_GLOBAL_CTRL; +* 2) Configure 4 PERFEVTSELx with the magic events and clear +* the corresponding PMCx; +* 3) set bit0~bit3 of MSR_CORE_PERF_GLOBAL_CTRL; +* 4) Clear MSR_CORE_PERF_GLOBAL_CTRL; +* 5) Clear 4 pairs of ERFEVTSELx and PMCx; +*/ + +/* +* The real steps we choose are a little different from above. +* A) To reduce MSR operations, we don't run step 1) as they +* are already cleared before this function is called; +* B) Call x86_perf_event_update to save PMCx before configuring +* PERFEVTSELx with magic number; +* C) With step 5), we do clear only when the PERFEVTSELx is +* not used currently. +* D) Call x86_perf_event_set_period to restore PMCx; +*/ -wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +0 ,0x4300D2 ); -wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +1 ,0x4300B1 ); -wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 +2 ,0x4300B5 ); +/* We always operate 4 pairs of PERF Counters */ +for (i =0 ; i <4 ; i++) { + event = cpuc->events[i]; +if (event) +x86_perf_event_update (event); + } -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x3 ); -wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); +for (i =0 ; i <4 ; i++) { +wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 + i, nhm_magic[i]); +wrmsrl (MSR_ARCH_PERFMON_PERFCTR0 + i,0x0 ); + } -for (i =0 ; i <3 ; i++) { -struct perf_event *event = cpuc->events[i]; +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0xf ); +wrmsrl (MSR_CORE_PERF_GLOBAL_CTRL ,0x0 ); -if (!event) -continue ; +for (i =0 ; i <4 ; i++) { + event = cpuc->events[i]; +if (event) { +x86_perf_event_set_period (event);__x86_pmu_enable_event (&event->hw, -ARCH_PERFMON_EVENTSEL_ENABLE ); - } +ARCH_PERFMON_EVENTSEL_ENABLE ); + }else +wrmsrl (MSR_ARCH_PERFMON_EVENTSEL0 + i,0x0 ); } +} + +static void intel_pmu_nhm_enable_all (int added) +{ +if (added) +intel_pmu_nhm_workaround ();intel_pmu_enable_all (added); }