PIC32MX Prefetch Cache
The Prefetch Cache module is a performance-enhancing module included in some processors of the PIC32MX family.
It consists of a prefetch buffer, combined with a small Program Flash Memory (PFM) cache memory.
When running at high-clock rates, Wait states must be inserted into PFM read transactions to meet the access time of the PFM. Wait states can be hidden to the core by prefetching and storing instructions in a temporary holding area that the CPU can access quickly. Although the data path to the CPU is 32 bits wide, the data path to the PFM is 128 bits wide. This wide data path provides the same bandwidth to the CPU as a 32-bit path running at four times the frequency.
There are two main functions that the Prefetch Cache module performs:
- Caching instructions when they are accessed, and
- Prefetching instructions from the PFM before they are needed.
The cache holds a subset of the cacheable memory in temporary holding spaces known as cache lines. Each cache line has a tag describing what it is currently holding, and the address where it is mapped. Normally, the cache lines just hold a copy of what is currently in memory to make data available to the CPU without Wait states.
CPU-requested data may or may not be in the cache.
A cache-miss occurs if the CPU requests cacheable data that is not in the cache. In this case, a read is performed to the PFM at the correct address, the data is supplied to the cache and to the CPU.
A cache-hit occurs if the cache contains the data that the CPU requests. In the case of a cache-hit, data is supplied to the CPU without Wait states.
The second main function of the Prefetch Cache module is to prefetch cache instructions. The module calculates the address of the next cache line and performs a read of the PFM to get the next 16-byte cache line. This line is placed into a 16-byte-wide prefetch cache buffer in anticipation of executing straight-line code.
Which feature helps in which situations?
The prefetch mechanism helps to increase pure MIPS® performance when:
- The code is very linear (i.e. few jumps, loops, etc.).
- The code is being executed from KSEG1 (which can’t be cached).
The cache helps in all other cases by:
- Keeping a copy of program instructions of short, tight loops in fast cache RAM.
- Allowing frequently used code to be locked into the cache for as long as desired. This can help to ensure there is a fixed latency when executing, for example, an interrupt routine caching data, such as coefficients, data tables or text strings, in the fast cache RAM.
Data Memory SRAM accesses can’t be cached, regardless of whether it is data or program instructions that are being accessed. However, this is no big issue since the SRAM functions at core speed and therefore does not require any wait states.
Basic Configuration
The primary SFR used to control PFM wait states and configure the module is the CHECON (Cache Control) register.
The primary SFR used to control Data SRAM wait states is the BMXCON (Bus Matrix Control) register.
The following example initialization code enables the prefetch cache for KSEG0 instructions, initializes Data SRAM wait states to 0, and initializes PFM wait states to 2 as per Table 31-12 for a PIC32MX795F512L running at 80 MHz:
2
3 /* configuration settings not shown */
4 /* OSC configured for SYSCLK=80 MHz */
5
6 int main(void)
7 {
8 // System Initialization
9
10 // Data Memory SRAM wait states: Default Setting = 1; set it to 0
11 BMXCONbits.BMXWSDRM = 0;
12
13 // Flash PM Wait States: MX Flash runs at 2 wait states @ 80 MHz
14 CHECONbits.PFMWS = 2;
15
16 // Prefetch-cache: Enable prefetch for cacheable PFM instructions
17 CHECONbits.PREFEN = 1;
18
19 // Main Application
20
21 while(1);
22
23 }