arm: pmu: Add support for PMUv3p5
v2 cover arm: pmu: Add support for PMUv3p5
The first commit fixes the tests when running on PMUv3p5. The issue is that PMUv3p5 uses 64-bit counters irrespective of whether the PMU is configured for overflowing at 32 or 64-bits. Tests are currently failing [0] on PMUv3p5 because of this. They wrongly assume that values will be wrapped around 32-bits, but they overflow into the other half of the 64-bit counters.
The second and third commits add new tests for 64-bit overflows, a feature added with PMUv3p5 (PMCR_EL0.LP == 1). This is done by running all overflow-related tests in two modes: with 32-bit and 64-bit overflows. The fourt commit changes the value reporting to use %lx instead of %ld.
This series was tested on PMUv3p5 and PMUv3p4 using the ARM Fast Model and kvmtool. All tests pass on both PMUv3p5 and PMUv3p4 when using Marc's PMUv3p5 series [0], plus the suggestion made at [1]. Didn't test AArch32.
Changes from v1 (all suggested by Alexandru):
- report counter values in hexadecimal
- s/overflow_at_64bits/unused for all chained tests
- check that odd counters do not increment when using overflow_at_64bits (pmcr.LP=1)
- test 64-bit odd counters overflows
- switch confusing var names in test_chained_sw_incr(): cntr0 <-> cntr1
[0] https://lore.kernel.org/kvmarm/[email protected]/
[1] https://lore.kernel.org/kvmarm/[email protected]/
Ricardo Koller (4):
arm: pmu: Fix overflow checks for PMUv3p5 long counters
arm: pmu: Prepare for testing 64-bit overflows
arm: pmu: Add tests for 64-bit overflows
arm: pmu: Print counter values as hexadecimals
arm/pmu.c | 240 +++++++++++++++++++++++++++++++++--------------------- 1 file changed, 149 insertions(+), 91 deletions(-)
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
PATCH v2 1/4 arm: pmu: Fix overflow checks for PMUv3p5 long counters
PMUv3p5 uses 64-bit counters irrespective of whether the PMU is configured for overflowing at 32 or 64-bits. The consequence is that tests that check the counter values after overflowing should not assume that values will be wrapped around 32-bits: they overflow into the other half of the 64-bit counters on PMUv3p5.
Fix tests by correctly checking overflowing-counters against the expected 64-bit value.
--- arm/pmu.c | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-)
arm/pmu.c +25 -12
@@ -54,10 +54,13 @@#define EXT_COMMON_EVENTS_LOW 0x4000#define EXT_COMMON_EVENTS_HIGH 0x403F -#define ALL_SET 0xFFFFFFFF -#define ALL_CLEAR 0x0 -#define PRE_OVERFLOW 0xFFFFFFF0 -#define PRE_OVERFLOW2 0xFFFFFFDC +#define ALL_SET 0x00000000FFFFFFFFULL +#define ALL_SET_64 0xFFFFFFFFFFFFFFFFULL +#define ALL_CLEAR 0x0000000000000000ULL +#define PRE_OVERFLOW 0x00000000FFFFFFF0ULL +#define PRE_OVERFLOW2 0x00000000FFFFFFDCULL + +#define ALL_SET_AT (_64b) (_64b ? ALL_SET_64 : ALL_SET)#define PMU_PPI 23
@@ -538,6 +541,7 @@ static void test_mem_access(void)static void test_sw_incr (void ) {uint32_t events[] = {SW_INCR ,SW_INCR }; +uint64_t cntr0;int i;if (!satisfy_prerequisites (events,ARRAY_SIZE (events)))
@@ -572,9 +576,11 @@ static void test_sw_incr(void)write_sysreg (0x3 , pmswinc_el0);isb (); -report (read_regn_el0 (pmevcntr,0 ) ==84 ,"counter #1 after + 100 SW_INCR" ); -report (read_regn_el0 (pmevcntr,1 ) ==100 , -"counter #0 after + 100 SW_INCR" ); + cntr0 = (pmu.version <ID_DFR0_PMU_V3_8_5 ) ? + (uint32_t )PRE_OVERFLOW +100 : + (uint64_t )PRE_OVERFLOW +100 ; +report (read_regn_el0 (pmevcntr,0 ) == cntr0,"counter #0 after + 100 SW_INCR" ); +report (read_regn_el0 (pmevcntr,1 ) ==100 ,"counter #1 after + 100 SW_INCR" );report_info ("counter values after 100 SW_INCR #0=%ld #1=%ld" ,read_regn_el0 (pmevcntr,0 ),read_regn_el0 (pmevcntr,1 )); report(read_sysreg(pmovsclr_el0) == 0x1,
@@ -584,6 +590,7 @@ static void test_sw_incr(void)static void test_chained_counters (void ) {uint32_t events[] = {CPU_CYCLES ,CHAIN }; +uint64_t all_set =ALL_SET_AT (pmu.version >=ID_DFR0_PMU_V3_8_5 );if (!satisfy_prerequisites (events,ARRAY_SIZE (events)))return ;
@@ -614,17 +621,19 @@ static void test_chained_counters(void)report (read_sysreg (pmovsclr_el0) ==0x1 ,"overflow recorded for chained incr #2" );write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); -write_regn_el0 (pmevcntr,1 ,ALL_SET ); +write_regn_el0 (pmevcntr,1 , all_set);precise_instrs_loop (22 , pmu.pmcr_ro |PMU_PMCR_E );report_info ("overflow reg = 0x%lx" ,read_sysreg (pmovsclr_el0)); -report (!read_regn_el0 (pmevcntr,1 ),"CHAIN counter #1 wrapped" ); +report (read_regn_el0 (pmevcntr,1 ) ==0 ,"CHAIN counter #1 wrapped" ); +report (read_sysreg (pmovsclr_el0) ==0x3 ,"overflow on even and odd counters" ); }static void test_chained_sw_incr (void ) {uint32_t events[] = {SW_INCR ,CHAIN }; +uint64_t cntr0, cntr1;int i;if (!satisfy_prerequisites (events,ARRAY_SIZE (events)))
@@ -665,10 +674,14 @@ static void test_chained_sw_incr(void)write_sysreg (0x1 , pmswinc_el0);isb (); + cntr0 = (pmu.version <ID_DFR0_PMU_V3_8_5 ) ? + (uint32_t )PRE_OVERFLOW +100 : + (uint64_t )PRE_OVERFLOW +100 ; + cntr1 = (pmu.version <ID_DFR0_PMU_V3_8_5 ) ?0 :ALL_SET +1 ;report ((read_sysreg (pmovsclr_el0) ==0x3 ) && - (read_regn_el0 (pmevcntr,1 ) ==0 ) && - (read_regn_el0 (pmevcntr,0 ) ==84 ), -"expected overflows and values after 100 SW_INCR/CHAIN" ); + (read_regn_el0 (pmevcntr,0 ) == cntr0) && + (read_regn_el0 (pmevcntr,1 ) == cntr1), +"expected overflows and values after 100 SW_INCR/CHAIN" );report_info ("overflow=0x%lx, #0=%ld #1=%ld" ,read_sysreg (pmovsclr_el0),read_regn_el0 (pmevcntr,0 ),read_regn_el0 (pmevcntr,1 )); }
Signature · 1 line
2.39.0.314.g84b9a713c41-goog
Re: [kvm-unit-tests PATCH v2 1/4] arm: pmu: Fix overflow checks for PMUv3p5 long counters
Hi Ricardo,
Quoted 23 lines · Ricardo Koller
PMUv3p5 uses 64-bit counters irrespective of whether the PMU is configured for overflowing at 32 or 64-bits. The consequence is that tests that check the counter values after overflowing should not assume that values will be wrapped around 32-bits: they overflow into the other half of the 64-bit counters on PMUv3p5.
Fix tests by correctly checking overflowing-counters against the expected 64-bit value.
Signed-off-by Ricardo Koller <[email protected]>--- arm/pmu.c | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-)arm/pmu.c +0
-1@@ -54,10 +54,13 @@#define EXT_COMMON_EVENTS_LOW 0x4000#define EXT_COMMON_EVENTS_HIGH 0x403F -#define ALL_SET 0xFFFFFFFF
arm/pmu.c line 63
Quoted 10 lines
arm/pmu.c +7
-3-#define ALL_CLEAR 0x0 -#define PRE_OVERFLOW 0xFFFFFFF0 -#define PRE_OVERFLOW2 0xFFFFFFDC +#define ALL_SET 0x00000000FFFFFFFFULL +#define ALL_SET_64 0xFFFFFFFFFFFFFFFFULL +#define ALL_CLEAR 0x0000000000000000ULL +#define PRE_OVERFLOW 0x00000000FFFFFFF0ULL +#define PRE_OVERFLOW2 0x00000000FFFFFFDCULL + +#define ALL_SET_AT (_64b) (_64b ? ALL_SET_64 : ALL_SET)
AFAICT, ALL_SET is mostly used to toggle all PMCs in a configuration register. Using it for PMEVCNTR<n> seems a bit odd to me. How about introducing a helper for getting the counter mask to avoid the open-coded version check?
static uint64_t pmevcntr_mask(void)
{
/*
* Bits [63:0] are always incremented for 64-bit counters,
* even if the PMU is configured to generate an overflow at
* bits [31:0]
*
* See DDI0487I.a, section D11.3 ("Behavior on overflow") for
* more details.
*/
if (pmu.version >= ID_DFR0_PMU_V3_8_5)
return ~0;
return (uint32_t)~0;
}I've always found the PMU documentation to be a bit difficult to grok, and the above citation only mentions the intended behavior in passing. Please feel free to update with a better citation if it exists.
Quoted 11 lines
arm/pmu.c +1
-0#define PMU_PPI 23@@ -538,6 +541,7 @@ static void test_mem_access(void)static void test_sw_incr (void ) {uint32_t events[] = {SW_INCR ,SW_INCR }; +uint64_t cntr0;int i;if (!satisfy_prerequisites (events,ARRAY_SIZE (events)))
arm/pmu.c static void test_sw_incr(void) · line 581
Quoted 9 lines
arm/pmu.c +3
-3@@ -572,9 +576,11 @@ static void test_sw_incr(void)write_sysreg (0x3 , pmswinc_el0);isb (); -report (read_regn_el0 (pmevcntr,0 ) ==84 ,"counter #1 after + 100 SW_INCR" ); -report (read_regn_el0 (pmevcntr,1 ) ==100 , -"counter #0 after + 100 SW_INCR" ); + cntr0 = (pmu.version <ID_DFR0_PMU_V3_8_5 ) ? + (uint32_t )PRE_OVERFLOW +100 : + (uint64_t )PRE_OVERFLOW +100 ;
With the above suggestion, it would be nice to rewrite like so:
cntr0 = (PRE_OVERFLOW + 100) & pmevcntr_mask();
If you do go this route, then you'll probably want to drop all the other open-coded PMUv3p5 checks in favor of the helper.
--
Thanks,
Oliver
Re: [kvm-unit-tests PATCH v2 1/4] arm: pmu: Fix overflow checks for PMUv3p5 long counters
Quoted 25 lines · Oliver Upton
Hi Ricardo,
Quoted 22 lines · Ricardo Koller
PMUv3p5 uses 64-bit counters irrespective of whether the PMU is configured for overflowing at 32 or 64-bits. The consequence is that tests that check the counter values after overflowing should not assume that values will be wrapped around 32-bits: they overflow into the other half of the 64-bit counters on PMUv3p5.
Fix tests by correctly checking overflowing-counters against the expected 64-bit value.
Signed-off-by Ricardo Koller <[email protected]>--- arm/pmu.c | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-)arm/pmu.c +0
-0@@ -54,10 +54,13 @@#define EXT_COMMON_EVENTS_LOW 0x4000#define EXT_COMMON_EVENTS_HIGH 0x403F
Quoted 14 lines
arm/pmu.c line 63
Quoted 11 lines
arm/pmu.c +7
-4-#define ALL_SET 0xFFFFFFFF -#define ALL_CLEAR 0x0 -#define PRE_OVERFLOW 0xFFFFFFF0 -#define PRE_OVERFLOW2 0xFFFFFFDC +#define ALL_SET 0x00000000FFFFFFFFULL +#define ALL_SET_64 0xFFFFFFFFFFFFFFFFULL +#define ALL_CLEAR 0x0000000000000000ULL +#define PRE_OVERFLOW 0x00000000FFFFFFF0ULL +#define PRE_OVERFLOW2 0x00000000FFFFFFDCULL + +#define ALL_SET_AT (_64b) (_64b ? ALL_SET_64 : ALL_SET)AFAICT,
ALL_SETis mostly used to toggle all PMCs in a configuration register.
It's also used as a pre-overflow counter value. And that's mainly the use of the newly introduced ALL_SET_AT(), and PRE_OVERFLOW_AT(). The ALL_SET_AT() changes in this commit should be moved to commit 3; I will do that plus use pmevcntr_mask() instead of ALL_SET_AT():
uint64_t all_set = pmevcntr_mask(); ... /* overflow on odd counter */ write_regn_el0(pmevcntr, 0, pre_overflow); write_regn_el0(pmevcntr, 1, all_set);
Quoted 47 lines
Using it for PMEVCNTR<n> seems a bit odd to me. How about introducing a helper for getting the counter mask to avoid the open-coded version check?
static
uint64_tpmevcntr_mask(void){ /* * Bits [63:0] are always incremented for 64-bit counters, * even if the PMU is configured to generate an overflow at * bits [31:0] * * See DDI0487I.a, section D11.3 ("Behavior on overflow") for * more details. */ if (pmu.version >= ID_DFR0_PMU_V3_8_5) return ~0; return (uint32_t)~0; }I've always found the PMU documentation to be a bit difficult to grok, and the above citation only mentions the intended behavior in passing. Please feel free to update with a better citation if it exists.
Quoted 11 lines
arm/pmu.c +1
-0#define PMU_PPI 23@@ -538,6 +541,7 @@ static void test_mem_access(void)static void test_sw_incr (void ) {uint32_t events[] = {SW_INCR ,SW_INCR }; +uint64_t cntr0;int i;if (!satisfy_prerequisites (events,ARRAY_SIZE (events)))arm/pmu.c static void test_sw_incr(void) · line 581
Quoted 9 lines
arm/pmu.c +3
-3@@ -572,9 +576,11 @@ static void test_sw_incr(void)write_sysreg (0x3 , pmswinc_el0);isb (); -report (read_regn_el0 (pmevcntr,0 ) ==84 ,"counter #1 after + 100 SW_INCR" ); -report (read_regn_el0 (pmevcntr,1 ) ==100 , -"counter #0 after + 100 SW_INCR" ); + cntr0 = (pmu.version <ID_DFR0_PMU_V3_8_5 ) ? + (uint32_t )PRE_OVERFLOW +100 : + (uint64_t )PRE_OVERFLOW +100 ;With the above suggestion, it would be nice to rewrite like so:
Quoted 4 lines
cntr0 = (PRE_OVERFLOW + 100) & pmevcntr_mask();If you do go this route, then you'll probably want to drop all the other open-coded PMUv3p5 checks in favor of the helper.
Will also use this instead of the uintxx_t casting.
Thanks~
Ricardo
Quoted 4 lines
--
Thanks,
Oliver
Re: [kvm-unit-tests PATCH v2 1/4] arm: pmu: Fix overflow checks for PMUv3p5 long counters
In reply to Oliver UptonQuoted 58 lines · Oliver Upton
Hi Ricardo,
Quoted 23 lines · Ricardo Koller
PMUv3p5 uses 64-bit counters irrespective of whether the PMU is configured for overflowing at 32 or 64-bits. The consequence is that tests that check the counter values after overflowing should not assume that values will be wrapped around 32-bits: they overflow into the other half of the 64-bit counters on PMUv3p5.
Fix tests by correctly checking overflowing-counters against the expected 64-bit value.
Signed-off-by Ricardo Koller <[email protected]>--- arm/pmu.c | 37 +++++++++++++++++++++++++------------ 1 file changed, 25 insertions(+), 12 deletions(-)arm/pmu.c +0
-1@@ -54,10 +54,13 @@#define EXT_COMMON_EVENTS_LOW 0x4000#define EXT_COMMON_EVENTS_HIGH 0x403F -#define ALL_SET 0xFFFFFFFFarm/pmu.c line 63
Quoted 10 lines
arm/pmu.c +7
-3-#define ALL_CLEAR 0x0 -#define PRE_OVERFLOW 0xFFFFFFF0 -#define PRE_OVERFLOW2 0xFFFFFFDC +#define ALL_SET 0x00000000FFFFFFFFULL +#define ALL_SET_64 0xFFFFFFFFFFFFFFFFULL +#define ALL_CLEAR 0x0000000000000000ULL +#define PRE_OVERFLOW 0x00000000FFFFFFF0ULL +#define PRE_OVERFLOW2 0x00000000FFFFFFDCULL + +#define ALL_SET_AT (_64b) (_64b ? ALL_SET_64 : ALL_SET)AFAICT,
ALL_SETis mostly used to toggle all PMCs in a configuration register. Using it for PMEVCNTR<n> seems a bit odd to me. How about introducing a helper for getting the counter mask to avoid the open-coded version check?static
uint64_tpmevcntr_mask(void){ /* * Bits [63:0] are always incremented for 64-bit counters, * even if the PMU is configured to generate an overflow at * bits [31:0] * * See DDI0487I.a, section D11.3 ("Behavior on overflow") for * more details. */ if (pmu.version >= ID_DFR0_PMU_V3_8_5) return ~0; return (uint32_t)~0; }
Quoted 3 lines
I've always found the PMU documentation to be a bit difficult to grok, and the above citation only mentions the intended behavior in passing. Please feel free to update with a better citation if it exists.
For this particular case, "Bits [63:0] are always incremented for 64-bit counters", I find AArch64.IncrementEventCounter() a bit easier.
Quoted 32 lines
Quoted 12 lines
arm/pmu.c +1
-0#define PMU_PPI 23@@ -538,6 +541,7 @@ static void test_mem_access(void)static void test_sw_incr (void ) {uint32_t events[] = {SW_INCR ,SW_INCR }; +uint64_t cntr0;int i;if (!satisfy_prerequisites (events,ARRAY_SIZE (events)))arm/pmu.c static void test_sw_incr(void) · line 581
Quoted 9 lines
arm/pmu.c +3
-3@@ -572,9 +576,11 @@ static void test_sw_incr(void)write_sysreg (0x3 , pmswinc_el0);isb (); -report (read_regn_el0 (pmevcntr,0 ) ==84 ,"counter #1 after + 100 SW_INCR" ); -report (read_regn_el0 (pmevcntr,1 ) ==100 , -"counter #0 after + 100 SW_INCR" ); + cntr0 = (pmu.version <ID_DFR0_PMU_V3_8_5 ) ? + (uint32_t )PRE_OVERFLOW +100 : + (uint64_t )PRE_OVERFLOW +100 ;With the above suggestion, it would be nice to rewrite like so:
cntr0 = (PRE_OVERFLOW + 100) & pmevcntr_mask();If you do go this route, then you'll probably want to drop all the other open-coded PMUv3p5 checks in favor of the helper.
--
Thanks,
Oliver
PATCH v2 2/4 arm: pmu: Prepare for testing 64-bit overflows
In reply to Ricardo KollerPMUv3p5 adds a knob, PMCR_EL0.LP == 1, that allows overflowing at 64-bits instead of 32. Prepare by doing these 3 things:
1. Add a "bool overflow_at_64bits" argument to all tests checking overflows.
2. Extend satisfy_prerequisites() to check if the machine supports "overflow_at_64bits".
3. Refactor the test invocations to use the new "run_test()" which adds a report prefix indicating whether the test uses 64 or 32-bit overflows.
A subsequent commit will actually add the 64-bit overflow tests.
--- arm/pmu.c | 92 ++++++++++++++++++++++++++++++++----------------------- 1 file changed, 53 insertions(+), 39 deletions(-)
arm/pmu.c +53 -39
@@ -167,13 +167,13 @@ static void pmu_reset(void)/* event counter tests only implemented for aarch64 */ static void test_event_introspection (void ) {}static void test_event_counter_config (void ) {} -static void test_basic_event_count (void ) {} -static void test_mem_access (void ) {} -static void test_sw_incr (void ) {} -static void test_chained_counters (void ) {} -static void test_chained_sw_incr (void ) {} -static void test_chain_promotion (void ) {} -static void test_overflow_interrupt (void ) {} +static void test_basic_event_count (bool overflow_at_64bits) {} +static void test_mem_access (bool overflow_at_64bits) {} +static void test_sw_incr (bool overflow_at_64bits) {} +static void test_chained_counters (bool unused) {} +static void test_chained_sw_incr (bool unused) {} +static void test_chain_promotion (bool unused) {} +static void test_overflow_interrupt (bool overflow_at_64bits) {}#elif defined(__aarch64__)#define ID_AA64DFR0_PERFMON_SHIFT 8
@@ -419,16 +419,28 @@ static bool satisfy_prerequisites(uint32_t *events, unsigned int nb_events)return false; } } + +return true; +} + +static bool check_overflow_prerequisites (bool overflow_at_64bits) +{ +if (overflow_at_64bits && pmu.version <ID_DFR0_PMU_V3_8_5 ) { +report_skip ("Skip test as 64 overflows need FEAT_PMUv3p5" ); +return false; + } +return true; } -static void test_basic_event_count (void ) +static void test_basic_event_count (bool overflow_at_64bits) {uint32_t implemented_counter_mask, non_implemented_counter_mask;uint32_t counter_mask;uint32_t events[] = {CPU_CYCLES ,INST_RETIRED }; -if (!satisfy_prerequisites (events,ARRAY_SIZE (events))) +if (!satisfy_prerequisites (events,ARRAY_SIZE (events)) || + !check_overflow_prerequisites (overflow_at_64bits))return ; implemented_counter_mask =BIT (pmu.nb_implemented_counters) -1 ;
@@ -502,12 +514,13 @@ static void test_basic_event_count(void) "check overflow happened on #0 only"); } -static void test_mem_access (void ) +static void test_mem_access (bool overflow_at_64bits) {void *addr =malloc (PAGE_SIZE );uint32_t events[] = {MEM_ACCESS ,MEM_ACCESS }; -if (!satisfy_prerequisites (events,ARRAY_SIZE (events))) +if (!satisfy_prerequisites (events,ARRAY_SIZE (events)) || + !check_overflow_prerequisites (overflow_at_64bits))return ;pmu_reset ();
@@ -538,13 +551,14 @@ static void test_mem_access(void) read_sysreg(pmovsclr_el0)); } -static void test_sw_incr (void ) +static void test_sw_incr (bool overflow_at_64bits) {uint32_t events[] = {SW_INCR ,SW_INCR };uint64_t cntr0;int i; -if (!satisfy_prerequisites (events,ARRAY_SIZE (events))) +if (!satisfy_prerequisites (events,ARRAY_SIZE (events)) || + !check_overflow_prerequisites (overflow_at_64bits))return ;pmu_reset ();
@@ -587,7 +601,7 @@ static void test_sw_incr(void) "overflow on counter #0 after 100 SW_INCR"); } -static void test_chained_counters (void ) +static void test_chained_counters (bool unused) {uint32_t events[] = {CPU_CYCLES ,CHAIN };uint64_t all_set =ALL_SET_AT (pmu.version >=ID_DFR0_PMU_V3_8_5 );
@@ -630,7 +644,7 @@ static void test_chained_counters(void)report (read_sysreg (pmovsclr_el0) ==0x3 ,"overflow on even and odd counters" ); } -static void test_chained_sw_incr (void ) +static void test_chained_sw_incr (bool unused) {uint32_t events[] = {SW_INCR ,CHAIN };uint64_t cntr0, cntr1;
@@ -686,7 +700,7 @@ static void test_chained_sw_incr(void) read_regn_el0(pmevcntr, 0), read_regn_el0(pmevcntr, 1)); } -static void test_chain_promotion (void ) +static void test_chain_promotion (bool unused) {uint32_t events[] = {MEM_ACCESS ,CHAIN };void *addr =malloc (PAGE_SIZE );
@@ -835,13 +849,14 @@ static bool expect_interrupts(uint32_t bitmap)return true; } -static void test_overflow_interrupt (void ) +static void test_overflow_interrupt (bool overflow_at_64bits) {uint32_t events[] = {MEM_ACCESS ,SW_INCR };void *addr =malloc (PAGE_SIZE );int i; -if (!satisfy_prerequisites (events,ARRAY_SIZE (events))) +if (!satisfy_prerequisites (events,ARRAY_SIZE (events)) || + !check_overflow_prerequisites (overflow_at_64bits))return ;gic_enable_defaults ();
@@ -1065,6 +1080,19 @@ static bool pmu_probe(void)return true; } +static void run_test (char *name,void (*test)(bool ),bool overflow_at_64bits) +{ +const char *prefix = overflow_at_64bits ?"64-bit overflows" :"32-bit overflows" ; + +report_prefix_push (name); +report_prefix_push (prefix); + +test (overflow_at_64bits); + +report_prefix_pop (); +report_prefix_pop (); +} +int main (int argc,char *argv[]) {int cpi =0 ;
@@ -1097,33 +1125,19 @@ int main(int argc, char *argv[])test_event_counter_config ();report_prefix_pop (); }else if (strcmp (argv[1 ],"pmu-basic-event-count" ) ==0 ) { -report_prefix_push (argv[1 ]); -test_basic_event_count (); -report_prefix_pop (); +run_test (argv[1 ], test_basic_event_count, false); }else if (strcmp (argv[1 ],"pmu-mem-access" ) ==0 ) { -report_prefix_push (argv[1 ]); -test_mem_access (); -report_prefix_pop (); +run_test (argv[1 ], test_mem_access, false); }else if (strcmp (argv[1 ],"pmu-sw-incr" ) ==0 ) { -report_prefix_push (argv[1 ]); -test_sw_incr (); -report_prefix_pop (); +run_test (argv[1 ], test_sw_incr, false); }else if (strcmp (argv[1 ],"pmu-chained-counters" ) ==0 ) { -report_prefix_push (argv[1 ]); -test_chained_counters (); -report_prefix_pop (); +run_test (argv[1 ], test_chained_counters, false); }else if (strcmp (argv[1 ],"pmu-chained-sw-incr" ) ==0 ) { -report_prefix_push (argv[1 ]); -test_chained_sw_incr (); -report_prefix_pop (); +run_test (argv[1 ], test_chained_sw_incr, false); }else if (strcmp (argv[1 ],"pmu-chain-promotion" ) ==0 ) { -report_prefix_push (argv[1 ]); -test_chain_promotion (); -report_prefix_pop (); +run_test (argv[1 ], test_chain_promotion, false); }else if (strcmp (argv[1 ],"pmu-overflow-interrupt" ) ==0 ) { -report_prefix_push (argv[1 ]); -test_overflow_interrupt (); -report_prefix_pop (); +run_test (argv[1 ], test_overflow_interrupt, false); }else {report_abort ("Unknown sub-test '%s'" , argv[1 ]); }
Signature · 6 lines
2.39.0.314.g84b9a713c41-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v2 3/4 arm: pmu: Add tests for 64-bit overflows
In reply to Ricardo KollerModify all tests checking overflows to support both 32 (PMCR_EL0.LP == 0) and 64-bit overflows (PMCR_EL0.LP == 1). 64-bit overflows are only supported on PMUv3p5.
Note that chained tests do not implement "overflow_at_64bits == true". That's because there are no CHAIN events when "PMCR_EL0.LP == 1" (for more details see AArch64.IncrementEventCounter() pseudocode in the ARM ARM DDI 0487H.a, J1.1.1 "aarch64/debug").
--- arm/pmu.c | 97 ++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 64 insertions(+), 33 deletions(-)
arm/pmu.c +64 -33
@@ -28,6 +28,7 @@#define PMU_PMCR_X (1 << 4)#define PMU_PMCR_DP (1 << 5)#define PMU_PMCR_LC (1 << 6) +#define PMU_PMCR_LP (1 << 7)#define PMU_PMCR_N_SHIFT 11#define PMU_PMCR_N_MASK 0x1f#define PMU_PMCR_ID_SHIFT 16
@@ -58,9 +59,11 @@#define ALL_SET_64 0xFFFFFFFFFFFFFFFFULL#define ALL_CLEAR 0x0000000000000000ULL#define PRE_OVERFLOW 0x00000000FFFFFFF0ULL +#define PRE_OVERFLOW_64 0xFFFFFFFFFFFFFFF0ULL#define PRE_OVERFLOW2 0x00000000FFFFFFDCULL -#define ALL_SET_AT (_64b) (_64b ? ALL_SET_64 : ALL_SET) +#define PRE_OVERFLOW_AT (_64b) (_64b ? PRE_OVERFLOW_64 : PRE_OVERFLOW) +#define ALL_SET_AT (_64b) (_64b ? ALL_SET_64 : ALL_SET)#define PMU_PPI 23
@@ -436,8 +439,10 @@ static bool check_overflow_prerequisites(bool overflow_at_64bits)static void test_basic_event_count (bool overflow_at_64bits) {uint32_t implemented_counter_mask, non_implemented_counter_mask; -uint32_t counter_mask; +uint64_t pre_overflow =PRE_OVERFLOW_AT (overflow_at_64bits); +uint64_t pmcr_lp = overflow_at_64bits ?PMU_PMCR_LP :0 ;uint32_t events[] = {CPU_CYCLES ,INST_RETIRED }; +uint32_t counter_mask;if (!satisfy_prerequisites (events,ARRAY_SIZE (events)) || !check_overflow_prerequisites (overflow_at_64bits))
@@ -459,13 +464,13 @@ static void test_basic_event_count(bool overflow_at_64bits)* clear cycle and all event counters and allow counter enablement * through PMCNTENSET. LC is RES1. */ -set_pmcr (pmu.pmcr_ro |PMU_PMCR_LC |PMU_PMCR_C |PMU_PMCR_P ); +set_pmcr (pmu.pmcr_ro |PMU_PMCR_LC |PMU_PMCR_C |PMU_PMCR_P | pmcr_lp);isb (); -report (get_pmcr () == (pmu.pmcr_ro |PMU_PMCR_LC ),"pmcr: reset counters" ); +report (get_pmcr () == (pmu.pmcr_ro |PMU_PMCR_LC | pmcr_lp),"pmcr: reset counters" );/* Preset counter #0 to pre overflow value to trigger an overflow */ -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); -report (read_regn_el0 (pmevcntr,0 ) ==PRE_OVERFLOW , +write_regn_el0 (pmevcntr,0 , pre_overflow); +report (read_regn_el0 (pmevcntr,0 ) == pre_overflow,"counter #0 preset to pre-overflow value" );report (!read_regn_el0 (pmevcntr,1 ),"counter #1 is 0" );
@@ -518,6 +523,8 @@ static void test_mem_access(bool overflow_at_64bits) {void *addr =malloc (PAGE_SIZE );uint32_t events[] = {MEM_ACCESS ,MEM_ACCESS }; +uint64_t pre_overflow =PRE_OVERFLOW_AT (overflow_at_64bits); +uint64_t pmcr_lp = overflow_at_64bits ?PMU_PMCR_LP :0 ;if (!satisfy_prerequisites (events,ARRAY_SIZE (events)) || !check_overflow_prerequisites (overflow_at_64bits))
@@ -529,7 +536,7 @@ static void test_mem_access(bool overflow_at_64bits)write_regn_el0 (pmevtyper,1 ,MEM_ACCESS |PMEVTYPER_EXCLUDE_EL0 );write_sysreg_s (0x3 ,PMCNTENSET_EL0 );isb (); -mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E ); +mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp);report_info ("counter #0 is %ld (MEM_ACCESS)" ,read_regn_el0 (pmevcntr,0 ));report_info ("counter #1 is %ld (MEM_ACCESS)" ,read_regn_el0 (pmevcntr,1 ));/* We may measure more than 20 mem access depending on the core */
@@ -539,11 +546,11 @@ static void test_mem_access(bool overflow_at_64bits)pmu_reset (); -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); -write_regn_el0 (pmevcntr,1 ,PRE_OVERFLOW ); +write_regn_el0 (pmevcntr,0 , pre_overflow); +write_regn_el0 (pmevcntr,1 , pre_overflow);write_sysreg_s (0x3 ,PMCNTENSET_EL0 );isb (); -mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E ); +mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp);report (read_sysreg (pmovsclr_el0) ==0x3 ,"Ran 20 mem accesses with expected overflows on both counters" ); report_info("cnt#0 = %ld cnt#1=%ld overflow=0x%lx",
@@ -553,6 +560,8 @@ static void test_mem_access(bool overflow_at_64bits)static void test_sw_incr (bool overflow_at_64bits) { +uint64_t pre_overflow =PRE_OVERFLOW_AT (overflow_at_64bits); +uint64_t pmcr_lp = overflow_at_64bits ?PMU_PMCR_LP :0 ;uint32_t events[] = {SW_INCR ,SW_INCR };uint64_t cntr0;int i;
@@ -568,7 +577,7 @@ static void test_sw_incr(bool overflow_at_64bits)/* enable counters #0 and #1 */ write_sysreg_s (0x3 ,PMCNTENSET_EL0 ); -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); +write_regn_el0 (pmevcntr,0 , pre_overflow);isb ();for (i =0 ; i <100 ; i++)
@@ -576,14 +585,14 @@ static void test_sw_incr(bool overflow_at_64bits)isb ();report_info ("SW_INCR counter #0 has value %ld" ,read_regn_el0 (pmevcntr,0 )); -report (read_regn_el0 (pmevcntr,0 ) ==PRE_OVERFLOW , +report (read_regn_el0 (pmevcntr,0 ) == pre_overflow,"PWSYNC does not increment if PMCR.E is unset" );pmu_reset (); -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); +write_regn_el0 (pmevcntr,0 , pre_overflow);write_sysreg_s (0x3 ,PMCNTENSET_EL0 ); -set_pmcr (pmu.pmcr_ro |PMU_PMCR_E ); +set_pmcr (pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp);isb ();for (i =0 ; i <100 ; i++)
@@ -591,8 +600,8 @@ static void test_sw_incr(bool overflow_at_64bits)isb (); cntr0 = (pmu.version <ID_DFR0_PMU_V3_8_5 ) ? - (uint32_t )PRE_OVERFLOW +100 : - (uint64_t )PRE_OVERFLOW +100 ; + (uint32_t )pre_overflow +100 : + (uint64_t )pre_overflow +100 ;report (read_regn_el0 (pmevcntr,0 ) == cntr0,"counter #0 after + 100 SW_INCR" );report (read_regn_el0 (pmevcntr,1 ) ==100 ,"counter #1 after + 100 SW_INCR" ); report_info("counter values after 100 SW_INCR #0=%ld #1=%ld",
@@ -851,6 +860,9 @@ static bool expect_interrupts(uint32_t bitmap)static void test_overflow_interrupt (bool overflow_at_64bits) { +uint64_t pre_overflow =PRE_OVERFLOW_AT (overflow_at_64bits); +uint64_t all_set =ALL_SET_AT (overflow_at_64bits); +uint64_t pmcr_lp = overflow_at_64bits ?PMU_PMCR_LP :0 ;uint32_t events[] = {MEM_ACCESS ,SW_INCR };void *addr =malloc (PAGE_SIZE );int i;
@@ -869,16 +881,16 @@ static void test_overflow_interrupt(bool overflow_at_64bits)write_regn_el0 (pmevtyper,0 ,MEM_ACCESS |PMEVTYPER_EXCLUDE_EL0 );write_regn_el0 (pmevtyper,1 ,SW_INCR |PMEVTYPER_EXCLUDE_EL0 );write_sysreg_s (0x3 ,PMCNTENSET_EL0 ); -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); -write_regn_el0 (pmevcntr,1 ,PRE_OVERFLOW ); +write_regn_el0 (pmevcntr,0 , pre_overflow); +write_regn_el0 (pmevcntr,1 , pre_overflow);isb ();/* interrupts are disabled (PMINTENSET_EL1 == 0) */ -mem_access_loop (addr,200 , pmu.pmcr_ro |PMU_PMCR_E ); +mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp);report (expect_interrupts (0 ),"no overflow interrupt after preset" ); -set_pmcr (pmu.pmcr_ro |PMU_PMCR_E ); +set_pmcr (pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp);isb ();for (i =0 ; i <100 ; i++)
@@ -893,12 +905,12 @@ static void test_overflow_interrupt(bool overflow_at_64bits)pmu_reset_stats (); -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); -write_regn_el0 (pmevcntr,1 ,PRE_OVERFLOW ); +write_regn_el0 (pmevcntr,0 , pre_overflow); +write_regn_el0 (pmevcntr,1 , pre_overflow);write_sysreg (ALL_SET , pmintenset_el1);isb (); -mem_access_loop (addr,200 , pmu.pmcr_ro |PMU_PMCR_E ); +mem_access_loop (addr,200 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp);for (i =0 ; i <100 ; i++)write_sysreg (0x3 , pmswinc_el0);
@@ -907,25 +919,40 @@ static void test_overflow_interrupt(bool overflow_at_64bits)report (expect_interrupts (0x3 ),"overflow interrupts expected on #0 and #1" ); -/* promote to 64-b */ +/* +* promote to 64-b: +* +* This only applies to the !overflow_at_64bits case, as +* overflow_at_64bits doesn't implement CHAIN events. The +* overflow_at_64bits case just checks that chained counters are +* not incremented when PMCR.LP == 1. +*/ pmu_reset_stats ();write_regn_el0 (pmevtyper,1 ,CHAIN |PMEVTYPER_EXCLUDE_EL0 ); -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); +write_regn_el0 (pmevcntr,0 , pre_overflow);isb (); -mem_access_loop (addr,200 , pmu.pmcr_ro |PMU_PMCR_E ); -report (expect_interrupts (0x1 ), -"expect overflow interrupt on 32b boundary" ); +mem_access_loop (addr,200 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp); +report (expect_interrupts (0x1 ),"expect overflow interrupt" );/* overflow on odd counter */ pmu_reset_stats (); -write_regn_el0 (pmevcntr,0 ,PRE_OVERFLOW ); -write_regn_el0 (pmevcntr,1 ,ALL_SET ); +write_regn_el0 (pmevcntr,0 , pre_overflow); +write_regn_el0 (pmevcntr,1 , all_set);isb (); -mem_access_loop (addr,400 , pmu.pmcr_ro |PMU_PMCR_E ); -report (expect_interrupts (0x3 ), - "expect overflow interrupt on even and odd counter"); +mem_access_loop (addr,400 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp); +if (overflow_at_64bits) { +report (expect_interrupts (0x1 ), +"expect overflow interrupt on even counter" ); +report (read_regn_el0 (pmevcntr,1 ) == all_set, +"Odd counter did not change" ); + }else { +report (expect_interrupts (0x3 ), +"expect overflow interrupt on even and odd counter" ); +report (read_regn_el0 (pmevcntr,1 ) != all_set, +"Odd counter wrapped" ); + } }#endif
@@ -1126,10 +1153,13 @@ int main(int argc, char *argv[])report_prefix_pop (); }else if (strcmp (argv[1 ],"pmu-basic-event-count" ) ==0 ) {run_test (argv[1 ], test_basic_event_count, false); +run_test (argv[1 ], test_basic_event_count, true); }else if (strcmp (argv[1 ],"pmu-mem-access" ) ==0 ) {run_test (argv[1 ], test_mem_access, false); +run_test (argv[1 ], test_mem_access, true); }else if (strcmp (argv[1 ],"pmu-sw-incr" ) ==0 ) {run_test (argv[1 ], test_sw_incr, false); +run_test (argv[1 ], test_sw_incr, true); }else if (strcmp (argv[1 ],"pmu-chained-counters" ) ==0 ) {run_test (argv[1 ], test_chained_counters, false); }else if (strcmp (argv[1 ],"pmu-chained-sw-incr" ) ==0 ) {
@@ -1138,6 +1168,7 @@ int main(int argc, char *argv[])run_test (argv[1 ], test_chain_promotion, false); }else if (strcmp (argv[1 ],"pmu-overflow-interrupt" ) ==0 ) {run_test (argv[1 ], test_overflow_interrupt, false); +run_test (argv[1 ], test_overflow_interrupt, true); }else {report_abort ("Unknown sub-test '%s'" , argv[1 ]); }
Signature · 6 lines
2.39.0.314.g84b9a713c41-goog _______________________________________________ kvmarm mailing list [email protected] https://lists.cs.columbia.edu/mailman/listinfo/kvmarm
PATCH v2 4/4 arm: pmu: Print counter values as hexadecimals
In reply to Ricardo KollerThe arm/pmu test prints the value of counters as %ld. Most tests start with counters around 0 or UINT_MAX, so having something like -16 instead of 0xffff_fff0 is not very useful.
Report counter values as hexadecimals.
--- arm/pmu.c | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-)
arm/pmu.c +10 -10
@@ -537,8 +537,8 @@ static void test_mem_access(bool overflow_at_64bits)write_sysreg_s (0x3 ,PMCNTENSET_EL0 );isb ();mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp); -report_info ("counter #0 is %ld (MEM_ACCESS)" ,read_regn_el0 (pmevcntr,0 )); -report_info ("counter #1 is %ld (MEM_ACCESS)" ,read_regn_el0 (pmevcntr,1 )); +report_info ("counter #0 is 0x%lx (MEM_ACCESS)" ,read_regn_el0 (pmevcntr,0 )); +report_info ("counter #1 is 0x%lx (MEM_ACCESS)" ,read_regn_el0 (pmevcntr,1 ));/* We may measure more than 20 mem access depending on the core */ report((read_regn_el0(pmevcntr, 0) == read_regn_el0(pmevcntr, 1)) && (read_regn_el0(pmevcntr, 0) >= 20) && !read_sysreg(pmovsclr_el0),
@@ -553,7 +553,7 @@ static void test_mem_access(bool overflow_at_64bits)mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E | pmcr_lp);report (read_sysreg (pmovsclr_el0) ==0x3 ,"Ran 20 mem accesses with expected overflows on both counters" ); -report_info ("cnt#0 = %ld cnt#1=%ld overflow=0x%lx" , +report_info ("cnt#0=0x%lx cnt#1=0x%lx overflow=0x%lx" ,read_regn_el0 (pmevcntr,0 ),read_regn_el0 (pmevcntr,1 ),read_sysreg (pmovsclr_el0)); }
@@ -584,7 +584,7 @@ static void test_sw_incr(bool overflow_at_64bits)write_sysreg (0x1 , pmswinc_el0);isb (); -report_info ("SW_INCR counter #0 has value %ld" ,read_regn_el0 (pmevcntr,0 )); +report_info ("SW_INCR counter #0 has value 0x%lx" ,read_regn_el0 (pmevcntr,0 ));report (read_regn_el0 (pmevcntr,0 ) == pre_overflow,"PWSYNC does not increment if PMCR.E is unset" );
@@ -604,7 +604,7 @@ static void test_sw_incr(bool overflow_at_64bits) (uint64_t )pre_overflow +100 ;report (read_regn_el0 (pmevcntr,0 ) == cntr0,"counter #0 after + 100 SW_INCR" );report (read_regn_el0 (pmevcntr,1 ) ==100 ,"counter #1 after + 100 SW_INCR" ); -report_info ("counter values after 100 SW_INCR #0=%ld #1=%ld" , +report_info ("counter values after 100 SW_INCR #0=0x%lx #1=0x%lx" ,read_regn_el0 (pmevcntr,0 ),read_regn_el0 (pmevcntr,1 ));report (read_sysreg (pmovsclr_el0) ==0x1 ,"overflow on counter #0 after 100 SW_INCR" );
@@ -680,7 +680,7 @@ static void test_chained_sw_incr(bool unused)report ((read_sysreg (pmovsclr_el0) ==0x1 ) && (read_regn_el0 (pmevcntr,1 ) ==1 ),"overflow and chain counter incremented after 100 SW_INCR/CHAIN" ); -report_info ("overflow=0x%lx, #0=%ld #1=%ld" ,read_sysreg (pmovsclr_el0), +report_info ("overflow=0x%lx, #0=0x%lx #1=0x%lx" ,read_sysreg (pmovsclr_el0),read_regn_el0 (pmevcntr,0 ),read_regn_el0 (pmevcntr,1 ));/* 64b SW_INCR and overflow on CHAIN counter*/
@@ -705,7 +705,7 @@ static void test_chained_sw_incr(bool unused) (read_regn_el0 (pmevcntr,0 ) == cntr0) && (read_regn_el0 (pmevcntr,1 ) == cntr1), "expected overflows and values after 100 SW_INCR/CHAIN"); -report_info ("overflow=0x%lx, #0=%ld #1=%ld" ,read_sysreg (pmovsclr_el0), +report_info ("overflow=0x%lx, #0=0x%lx #1=0x%lx" ,read_sysreg (pmovsclr_el0),read_regn_el0 (pmevcntr,0 ),read_regn_el0 (pmevcntr,1 )); }
@@ -737,11 +737,11 @@ static void test_chain_promotion(bool unused)mem_access_loop (addr,20 , pmu.pmcr_ro |PMU_PMCR_E );report (!read_regn_el0 (pmevcntr,1 ) && (read_sysreg (pmovsclr_el0) ==0x1 ),"odd counter did not increment on overflow if disabled" ); -report_info ("MEM_ACCESS counter #0 has value %ld" , +report_info ("MEM_ACCESS counter #0 has value 0x%lx" ,read_regn_el0 (pmevcntr,0 )); -report_info ("CHAIN counter #1 has value %ld" , +report_info ("CHAIN counter #1 has value 0x%lx" ,read_regn_el0 (pmevcntr,1 )); -report_info ("overflow counter %ld" ,read_sysreg (pmovsclr_el0)); +report_info ("overflow counter 0x%lx" ,read_sysreg (pmovsclr_el0));/* start at 0xFFFFFFDC, +20 with CHAIN enabled, +20 with CHAIN disabled */ pmu_reset ();
Signature · 1 line
2.39.0.314.g84b9a713c41-goog