Cross-Core PMU Access on ARM Cortex-A53: Debugging and Implementation Guide

ARM Cortex-A53 PMU Access Across Cores: Understanding the Challenge

The Performance Monitoring Unit (PMU) in ARM Cortex-A53 processors is a critical component for profiling and optimizing system performance. Each core in a multi-core Cortex-A53 system has its own PMU, which can be accessed using the MRS and MSR instructions. However, a common challenge arises when attempting to access the PMU of one core (e.g., Core 0) from another core (e.g., Core 1). This cross-core PMU access is not straightforward due to the architecture’s design, which isolates PMU registers to their respective cores. The PMU registers are memory-mapped, but their accessibility from another core depends on the system’s memory mapping and the debug state of the target core.

The primary issue revolves around whether the PMU registers of one core can be accessed from another core without putting the target core into a debug state. The ARM Cortex-A53 Technical Reference Manual (TRM) provides some insights into the memory-mapped addresses of the PMU registers, but it does not explicitly state whether cross-core access is permitted under normal operating conditions. This ambiguity often leads to confusion and experimentation, as seen in the discussion.

To address this issue, we must first understand the memory-mapped architecture of the PMU registers, the role of the ROM table in determining their physical addresses, and the conditions under which cross-core access might be possible. The following sections will delve into the possible causes of access failures and provide detailed troubleshooting steps to enable cross-core PMU access.

---

Memory-Mapped PMU Registers and ROM Table Addressing

The ARM Cortex-A53 PMU registers are memory-mapped, meaning they are accessible through specific physical addresses. The base address for these registers is determined by the ROM table, which is a hardware structure that provides the offsets for various debug components, including the PMU. The ROM table is located at a known physical address, and the PMU registers for each core are located at fixed offsets from this base address.

For example, the PMU registers for Core 0 are located at an offset of 0x008 from the ROM table base address. This offset is defined in the ROMENTRY2 field of the ROM table, as shown in Table 11-28 of the ARM Cortex-A53 TRM. The physical address of the PMU registers is calculated by shifting the ROMENTRY2 value 12 places to the left and adding it to the base address of the ROM table.

Once the physical address of the PMU registers is determined, individual PMU registers can be accessed using their respective offsets. For instance, the PMEVTYPER0_EL0 register, which configures the event type for performance counter 0, is located at an offset of 0x400 from the PMU base address.

However, accessing these registers from another core requires careful consideration of the memory mapping and the system’s memory management unit (MMU). If the MMU is enabled, the physical addresses of the PMU registers must be mapped into the virtual address space of the accessing core. Additionally, the target core must be in a state that allows its PMU registers to be accessed externally. This is where the debug state comes into play.

---

Debug State Requirements and Cross-Core PMU Access

One of the key considerations for cross-core PMU access is whether the target core needs to be in a debug state. The debug state is a special mode in which a core halts normal execution and allows external access to its internal registers, including the PMU. While the ARM Cortex-A53 TRM does not explicitly state that the debug state is required for cross-core PMU access, it is a common requirement for accessing internal registers of another core.

If the target core is not in a debug state, its PMU registers may not be accessible from another core due to hardware isolation mechanisms. These mechanisms are designed to prevent unintended interference between cores and ensure the integrity of each core’s internal state. Therefore, attempting to access the PMU registers of a core that is actively executing code may result in access failures or undefined behavior.

To enable cross-core PMU access, the target core must be halted and placed in a debug state. This can be achieved using the ARM Debug Interface (ADI), which provides the necessary control signals to halt the core and enable external access to its registers. Once the target core is in a debug state, its PMU registers can be accessed from another core using their memory-mapped addresses.

---

Implementing Cross-Core PMU Access: Step-by-Step Guide

To implement cross-core PMU access on an ARM Cortex-A53 system, follow these steps:

1. Determine the Physical Address of the PMU Registers:
   Start by locating the base address of the ROM table in the ARM Cortex-A53 TRM. Use the ROMENTRY2 value to calculate the physical address of the PMU registers for the target core. For example, if the ROMENTRY2 value is 0x00030003, the PMU base address for Core 0 is calculated as follows:

   PMU Base Address = ROM Table Base Address + (ROMENTRY2 << 12)
   

2. Map the PMU Registers into the Virtual Address Space:
   If the MMU is enabled, map the physical address of the PMU registers into the virtual address space of the accessing core. This can be done using the MMU’s page table entries. Ensure that the mapping has the appropriate permissions (e.g., read/write access).

3. Halt the Target Core and Enter Debug State:
   Use the ARM Debug Interface to halt the target core and place it in a debug state. This can be done by setting the appropriate bits in the Debug Halting Control and Status Register (DHCSR). Once the target core is halted, its PMU registers will be accessible from another core.

4. Access the PMU Registers from Another Core:
   With the target core in a debug state and the PMU registers mapped into the virtual address space, you can now access the PMU registers from another core. Use the memory-mapped addresses to read or write the PMU registers as needed. For example, to read the PMEVTYPER0_EL0 register, access the memory location at PMU Base Address + 0x400.

5. Resume the Target Core:
   After accessing the PMU registers, resume the target core by clearing the halt request in the DHCSR. The core will exit the debug state and continue normal execution.

By following these steps, you can successfully access the PMU registers of one core from another core on an ARM Cortex-A53 system. This approach ensures that the target core is in a stable state during access and prevents unintended interference with its operation.

---

Common Pitfalls and Troubleshooting Tips

While implementing cross-core PMU access, you may encounter several common pitfalls. Here are some troubleshooting tips to help you resolve these issues:

1. Incorrect Physical Address Calculation:
   Ensure that the physical address of the PMU registers is calculated correctly using the ROMENTRY2 value and the ROM table base address. A mistake in this calculation will result in accessing the wrong memory location.

2. MMU Configuration Errors:
   If the MMU is enabled, verify that the PMU registers are mapped into the virtual address space with the correct permissions. An incorrect mapping will result in access failures or segmentation faults.

3. Debug State Not Entered:
   If the target core is not halted and placed in a debug state, its PMU registers may not be accessible. Verify that the halt request is set in the DHCSR and that the core has entered the debug state.

4. Concurrency Issues:
   Be mindful of concurrency issues when accessing PMU registers from another core. Ensure that the target core is not actively modifying the PMU registers while they are being accessed. This can be achieved by halting the core or using synchronization mechanisms.

5. Hardware Limitations:
   Some ARM Cortex-A53 implementations may have hardware limitations that prevent cross-core PMU access. Consult the specific documentation for your processor to determine if such limitations exist.

By addressing these common pitfalls, you can ensure a smooth and successful implementation of cross-core PMU access on your ARM Cortex-A53 system.

---

Conclusion

Accessing the PMU registers of one core from another core on an ARM Cortex-A53 system is a complex but achievable task. By understanding the memory-mapped architecture of the PMU registers, the role of the ROM table, and the requirements for entering the debug state, you can successfully implement cross-core PMU access. Follow the step-by-step guide provided in this post, and be mindful of the common pitfalls and troubleshooting tips to ensure a successful implementation. With careful planning and attention to detail, you can leverage the full power of the ARM Cortex-A53 PMU for performance monitoring and optimization across multiple cores.