| *** Variables *** | |
| ${PLATFORM} SEPARATOR= | |
| ... """ ${\n} | |
| ... cpu: CPU.ARMv7A @ sysbus ${\n} | |
| ... ${SPACE*4}cpuType: "cortex-a9" ${\n} | |
| ... ${\n} | |
| ... pmu: Miscellaneous.ArmPerformanceMonitoringUnit @ cpu ${\n} | |
| ... ${\n} | |
| ... memory: Memory.MappedMemory @ sysbus 0x0 ${\n} | |
| ... ${SPACE*4}size: 0x20000 ${\n} | |
| ... """ | |
| ${BOGUS_EVENT_1} 0x1 | |
| ${BOGUS_EVENT_2} 0xAB | |
| ${SOFTWARE_INCREMENT_EVENT} 0x00 | |
| ${INSTRUCTIONS_EVENT} 0x8 | |
| ${CYCLES_EVENT} 0x11 | |
| *** Keywords *** | |
| Create Machine | |
| # Some keywords expect numbers to be printed as hex. | |
| Execute Command numbersMode Hexadecimal | |
| Execute Command using sysbus | |
| Execute Command mach create | |
| Execute Command machine LoadPlatformDescriptionFromString ${PLATFORM} | |
| # Create infinite loop | |
| Execute Command sysbus WriteDoubleWord 0x1000 0xE320F000 # nop | |
| Execute Command sysbus WriteDoubleWord 0x1004 0xEAFFFFFD # b to 0x1000 | |
| # Set predefined PerformanceInMips, so it's possible to calculate | |
| # the number of expected instructions to execute in the given time frame | |
| Execute Command cpu PerformanceInMips 100 | |
| Execute Command cpu PC 0x1000 | |
| Set Register Bits | |
| [Arguments] ${regName} ${value} | |
| ${enabledCounters}= Execute Command cpu.pmu GetRegister ${regName} | |
| ${mask}= Evaluate hex(int($enabledCounters, 16) | int($value)) | |
| Execute Command cpu.pmu SetRegister ${regName} ${mask} | |
| Clear Register Bits | |
| [Arguments] ${regName} ${value} | |
| ${enabledCounters}= Execute Command cpu.pmu GetRegister ${regName} | |
| ${mask}= Evaluate hex(int($enabledCounters, 16) & ~int($value)) | |
| Execute Command cpu.pmu SetRegister ${regName} ${mask} | |
| Assert Bit Set | |
| [Arguments] ${value} ${bit} | |
| ${isSet}= Evaluate (${value} & (1 << ${bit})) > 0 | |
| Should Be True ${isSet} | |
| Assert Bit Unset | |
| [Arguments] ${value} ${bit} | |
| ${isNotSet}= Evaluate (${value} & (1 << ${bit})) == 0 | |
| Should Be True ${isNotSet} | |
| Enable PMU | |
| Set Register Bits "PMCR" 1 | |
| Disable PMU | |
| Clear Register Bits "PMCR" 1 | |
| Reset PMU Counters | |
| Set Register Bits "PMCR" 2 | |
| Reset PMU Cycle Counter | |
| Set Register Bits "PMCR" 4 | |
| Set Cycles Divisor 64 | |
| [Arguments] ${divisor} | |
| IF ${divisor} | |
| Set Register Bits "PMCR" 8 | |
| ELSE | |
| Clear Register Bits "PMCR" 8 | |
| END | |
| Switch Privilege Mode | |
| [Arguments] ${privileged} | |
| # use CPSR to switch between PL0/PL1 | |
| IF ${privileged} # PL1 - SVC mode | |
| ${cpsr}= Execute Command cpu CPSR | |
| ${cpsr}= Evaluate (int(${cpsr}) & ~0x1F ) | 0x13 | |
| Execute Command cpu CPSR ${cpsr} | |
| ELSE # PL0 | |
| ${cpsr}= Execute Command cpu CPSR | |
| ${cpsr}= Evaluate (int(${cpsr}) & ~0x1F ) | 0x10 | |
| Execute Command cpu CPSR ${cpsr} | |
| END | |
| Enable PMU Counter | |
| [Arguments] ${counter} | |
| ${value}= Evaluate (1 << int($counter)) | |
| Set Register Bits "PMCNTENSET" ${value} | |
| Disable PMU Counter | |
| [Arguments] ${counter} | |
| ${value}= Evaluate (1 << int($counter)) | |
| Execute Command cpu.pmu SetRegister "PMCNTENCLR" ${value} | |
| Enable Overflow Interrupt For PMU Counter | |
| [Arguments] ${counter} | |
| ${value}= Evaluate (1 << int($counter)) | |
| Execute Command cpu.pmu SetRegister "PMINTENSET" ${value} | |
| Disable Overflow Interrupt For PMU Counter | |
| [Arguments] ${counter} | |
| ${value}= Evaluate (1 << int($counter)) | |
| Execute Command cpu.pmu SetRegister "PMINTENCLR" ${value} | |
| Increment Software PMU Counter | |
| [Arguments] ${counter} | |
| ${value}= Evaluate (1 << int($counter)) | |
| Execute Command cpu.pmu SetRegister "PMSWINC" ${value} | |
| Assert PMU Counter Is Equal To | |
| [Arguments] ${counter} ${value} | |
| ${cnt}= Execute Command cpu.pmu GetCounterValue ${counter} | |
| Should Be Equal As Integers ${cnt} ${value} | |
| Assert Executed Instructions Equal To | |
| [Arguments] ${value} | |
| ${executedInstructions}= Execute Command cpu ExecutedInstructions | |
| Should Be Equal As Integers ${executedInstructions} ${value} | |
| Assert PMU Cycle Counter Equal To | |
| [Arguments] ${value} | |
| ${cycles}= Execute Command cpu.pmu GetCycleCounterValue | |
| Should Be Equal As Integers ${cycles} ${value} | |
| Assert PMU IRQ Is Set | |
| ${irqState}= Execute Command cpu.pmu IRQ | |
| Should Contain ${irqState} GPIO: set | |
| Assert PMU IRQ Is Unset | |
| ${irqState}= Execute Command cpu.pmu IRQ | |
| Should Contain ${irqState} GPIO: unset | |
| Assert PMU Counter Overflowed | |
| [Arguments] ${counter} | |
| # n-th bit denotes overflow status for the n-th PMU counter | |
| ${overflowStatus}= Execute Command cpu.pmu GetRegister "PMOVSR" | |
| Assert Bit Set ${overflowStatus} ${counter} | |
| Assert PMU Counter Not Overflowed | |
| [Arguments] ${counter} | |
| ${overflowStatus}= Execute Command cpu.pmu GetRegister "PMOVSR" | |
| Assert Bit Unset ${overflowStatus} ${counter} | |
| *** Test Cases *** | |
| Should Count Cycles | |
| Create Machine | |
| Enable PMU | |
| Enable PMU Counter 31 # Cycle counter | |
| Execute Command emulation RunFor "00:00:01.12" | |
| # Given a known PerformanceInMIPS, it can be assumed that 112 000 000 instructions have been executed | |
| Assert PMU Cycle Counter Equal To 112 000 000 | |
| Assert Executed Instructions Equal To 112 000 000 | |
| Should Count Cycles With Divisor | |
| Create Machine | |
| Enable PMU Counter 31 # Cycle counter | |
| Enable PMU | |
| Set Cycles Divisor 64 ${True} | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert Executed Instructions Equal To 1000000 | |
| Assert PMU Cycle Counter Equal To 15625 | |
| Set Cycles Divisor 64 ${False} | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert Executed Instructions Equal To 2000000 | |
| Assert PMU Cycle Counter Equal To 1015625 | |
| Should Program PMU Counter To Count Cycles | |
| Create Machine | |
| Enable PMU | |
| Execute Command cpu.pmu SetCounterEvent 0 ${CYCLES_EVENT} | |
| Enable PMU Counter 0 | |
| Execute Command emulation RunFor "00:00:01.12" | |
| # As above, given PerformanceInMIPS, we know how many instructions to expect | |
| # One cycle is equal to one instruction, this is not a mistake | |
| Assert Executed Instructions Equal To 112 000 000 | |
| Assert PMU Counter Is Equal To 0 112 000 000 | |
| # Now, an instruction should be equal to 1.25 cycles | |
| Execute Command cpu CyclesPerInstruction 1.25 | |
| Execute Command emulation RunFor "00:00:00.01" | |
| # Executed 1 000 000 instructions, so 1 250 000 cycles | |
| Assert Executed Instructions Equal To 113 000 000 | |
| Assert PMU Counter Is Equal To 0 113 250 000 | |
| Should Program PMU Counter To Count Instructions | |
| Create Machine | |
| # Cycles value will be used in dependent tests | |
| Enable PMU Counter 31 | |
| Enable PMU | |
| Execute Command cpu.pmu SetCounterEvent 0 ${INSTRUCTIONS_EVENT} | |
| Enable PMU Counter 0 | |
| Execute Command emulation RunFor "00:00:01.12" | |
| Assert Executed Instructions Equal To 112 000 000 | |
| Assert PMU Counter Is Equal To 0 112 000 000 | |
| Provides program-counter | |
| Should Reset PMU counters | |
| Requires program-counter | |
| Assert PMU Counter Is Equal To 0 112 000 000 | |
| Reset PMU Counters | |
| Assert PMU Counter Is Equal To 0 0 | |
| Assert PMU Cycle Counter Equal To 112 000 000 | |
| Reset PMU Cycle Counter | |
| Assert PMU Cycle Counter Equal To 0 | |
| Should Kick Software Increment | |
| Create Machine | |
| # Configure PMU counters, only Counter 0 subscribes to Software Increment event, Counter 1 subscribes to non-implemented event | |
| # So only Counter 0 is expected to be incremented | |
| Execute Command cpu.pmu SetCounterEvent 0 ${SOFTWARE_INCREMENT_EVENT} | |
| Execute Command cpu.pmu SetCounterEvent 1 ${BOGUS_EVENT_1} | |
| # Verify the configured events by reading their event ids | |
| ${ev1}= Execute Command cpu.pmu GetCounterEvent 1 | |
| ${ev0}= Execute Command cpu.pmu GetCounterEvent 0 | |
| Should Be Equal As Integers ${ev1} 1 | |
| Should Be Equal As Integers ${ev0} 0 | |
| Increment Software PMU Counter 0 | |
| Increment Software PMU Counter 1 | |
| # Counters and PMU are disabled, should not count | |
| Assert PMU Counter Is Equal To 0 0 | |
| Assert PMU Counter Is Equal To 1 0 | |
| Enable PMU Counter 0 | |
| Increment Software PMU Counter 1 | |
| Increment Software PMU Counter 0 | |
| # Still not counting, PMU is not enabled | |
| Assert PMU Counter Is Equal To 0 0 | |
| Assert PMU Counter Is Equal To 1 0 | |
| Enable PMU | |
| Increment Software PMU Counter 0 | |
| Increment Software PMU Counter 1 | |
| # PMU Counter 1 is not a Software Increment, so it shouldn't increment at all | |
| # Counter 0 is incremented only once, after "Enable PMU". Previous increments were invalid, since PMU was disabled | |
| Assert PMU Counter Is Equal To 0 1 | |
| Assert PMU Counter Is Equal To 1 0 | |
| Should Respect PMU Counter Pasue And Resume | |
| Create Machine | |
| Enable PMU | |
| Execute Command cpu.pmu SetCounterEvent 1 ${CYCLES_EVENT} | |
| Enable PMU Counter 1 | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert PMU Counter Is Equal To 1 1000000 | |
| Assert Executed Instructions Equal To 1000000 | |
| # Shouldn't count with disabled PMU | |
| Disable PMU | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert PMU Counter Is Equal To 1 1000000 | |
| Assert Executed Instructions Equal To 2000000 | |
| Enable PMU | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert PMU Counter Is Equal To 1 2000000 | |
| Assert Executed Instructions Equal To 3000000 | |
| # Shouldn't count when the counter is disabled | |
| Disable PMU Counter 1 | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert PMU Counter Is Equal To 1 2000000 | |
| Assert Executed Instructions Equal To 4000000 | |
| Enable PMU Counter 1 | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert PMU Counter Is Equal To 1 3000000 | |
| Assert Executed Instructions Equal To 5000000 | |
| Should Trigger Cycles Overflow | |
| Create Machine | |
| Enable PMU | |
| ## Counter 2 | |
| # The performance in MIPS is known, so it's possible to calculate the exact moment the counter should overflow | |
| # Configure counter, so after 3 000 000 instructions it should have overflowed and have the value 2 stored | |
| # so it's set to "UINT32_MAX - value + 3" | |
| Execute Command cpu.pmu SetCounterEvent 2 ${CYCLES_EVENT} | |
| Execute Command cpu.pmu SetCounterValue 2 0xFFD23942 | |
| Enable Overflow Interrupt For PMU Counter 2 | |
| Enable PMU Counter 2 | |
| ## Counter 1 | |
| Execute Command cpu.pmu SetCounterEvent 1 ${CYCLES_EVENT} | |
| # expected to execute 1 000 000 instructions, so load "UINT32_MAX - value" to counter | |
| # it is expected to overflow one instruction after | |
| Execute Command cpu.pmu SetCounterValue 1 0xFFF0BDBF | |
| Enable Overflow Interrupt For PMU Counter 1 | |
| Enable PMU Counter 1 | |
| # See that it didn't overflow too soon | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert Executed Instructions Equal To 1000000 | |
| # The value is counter's base value "0xFFF0BDBF" + 1 000 000 expected instructions to execute | |
| Assert PMU Counter Is Equal To 1 0xFFFFFFFF | |
| Assert PMU Counter Not Overflowed 1 | |
| Assert PMU IRQ Is Unset | |
| # It will overflow 1 instruction after, we now execute 100 000, so overflow bit has to be set | |
| Execute Command emulation RunFor "00:00:00.001" | |
| Assert PMU Counter Overflowed 1 | |
| Assert PMU IRQ Is Set | |
| Provides cycles-overflow | |
| Should Resume Execution After Cycles Overflow | |
| Requires cycles-overflow | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert Executed Instructions Equal To 2100000 | |
| # instructions are counted from 0 after overflow, so instead from 1 000 000 + 100 000 subtract 1 | |
| Assert PMU Counter Is Equal To 1 1099999 | |
| Provides resumed-after-overflow | |
| Should Overflow Second Time | |
| Requires resumed-after-overflow | |
| # Clear overflow bit for counter 1 | |
| Execute Command cpu.pmu SetRegister "PMOVSR" 0x2 | |
| Execute Command emulation RunFor "00:00:00.009" | |
| Assert Executed Instructions Equal To 3000000 | |
| Assert PMU Counter Is Equal To 2 2 | |
| Assert PMU Counter Overflowed 2 | |
| Should Increment Bogus Event From Monitor | |
| # The event is unimplemented, and there will be warnings in the logs | |
| # but still can be used it in a test scenario | |
| Create Machine | |
| Enable PMU | |
| Execute Command cpu.pmu SetCounterEvent 1 ${BOGUS_EVENT_2} | |
| Enable PMU Counter 1 | |
| Execute Command cpu.pmu BroadcastEvent ${BOGUS_EVENT_2} 5 | |
| Assert PMU Counter Is Equal To 1 5 | |
| # now, let's overflow | |
| Enable Overflow Interrupt For PMU Counter 1 | |
| Execute Command cpu.pmu BroadcastEvent ${BOGUS_EVENT_2} 0xFFFFFFFF | |
| Assert PMU Counter Is Equal To 1 4 | |
| Assert PMU Counter Overflowed 1 | |
| Assert PMU IRQ Is Set | |
| Should Count Instructions With PL Masking | |
| Create Machine | |
| Enable PMU Counter 0 | |
| Execute Command cpu.pmu SetCounterEvent 0 ${INSTRUCTIONS_EVENT} ignoreCountAtPL0=false ignoreCountAtPL1=true | |
| Enable PMU | |
| Enable Overflow Interrupt For PMU Counter 0 | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert Executed Instructions Equal To 1000000 | |
| # The counter doesn't count at PL1, so should be zero | |
| Assert PMU Counter Is Equal To 0 0 | |
| Switch Privilege Mode ${False} | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert Executed Instructions Equal To 2000000 | |
| # The PMU counter only counted in PL0, so only 1 000 000 instructions | |
| Assert PMU Counter Is Equal To 0 1000000 | |
| Execute Command cpu.pmu SetCounterEvent 0 ${INSTRUCTIONS_EVENT} ignoreCountAtPL0=true ignoreCountAtPL1=true | |
| # Now, counting at PL0 is disabled too, so PMU counter should not progress | |
| Execute Command emulation RunFor "00:00:00.01" | |
| Assert Executed Instructions Equal To 3000000 | |
| Assert PMU Counter Is Equal To 0 1000000 | |
| # See that the counter doesn't count and doesn't trigger overflow | |
| # Configure counter, so after 3 000 000 instructions it should have overflowed and have the value 2 stored | |
| # so it's set to "UINT32_MAX - value + 3" | |
| # But it shouldn't count anything at PL0 | |
| Execute Command cpu.pmu SetCounterValue 0 0xFFD23942 | |
| Execute Command emulation RunFor "00:00:00.03" | |
| Assert Executed Instructions Equal To 6000000 | |
| # No progress for the couner | |
| Assert PMU Counter Is Equal To 0 0xFFD23942 | |
| Assert PMU Counter Not Overflowed 0 | |
| Assert PMU IRQ Is Unset | |
| # Now, switch the mode back to PL1 and enable counting events there | |
| Execute Command cpu.pmu SetCounterEvent 0 ${INSTRUCTIONS_EVENT} ignoreCountAtPL0=true ignoreCountAtPL1=false | |
| Switch Privilege Mode ${True} | |
| # The counter hadn't progressed at all, so it's not necessary to set it's value again | |
| Execute Command emulation RunFor "00:00:00.03" | |
| Assert Executed Instructions Equal To 9000000 | |
| Assert PMU Counter Is Equal To 0 2 | |
| Assert PMU Counter Overflowed 0 | |
| Assert PMU IRQ Is Set |