Cache prefetching - Alchetron, The Free Social Encyclopedia

Cache prefetching is a technique used by computer processors to boost execution performance by fetching instructions or data from their original storage in slower memory to a faster local memory before it is actually needed (hence the term 'prefetch'). Most modern computer processors have fast and local cache memory in which prefetched data is held till it is required. The source for the prefetch operation is usually main memory. Because of their design, accessing cache memories is typically much faster than accessing main memory, so prefetching data and then accessing it from caches is usually many orders of magnitude faster than accessing it directly from main memory.

Metrics of cache prefetching

There are three main metrics to judge cache prefetching

Coverage

Coverage is the fraction of total misses that are eliminated because of prefetching, i.e

C o v e r a g e = C a c h e M i s s e s e l i m i n a t e d d u e t o P r e f e t c h i n g T o t a l C a c h e M i s s e s ,

where, T o t a l C a c h e M i s s e s = ( C a c h e m i s s e s e l i m i n a t e d b y p r e f e t c h i n g ) + ( C a c h e m i s s e s n o t e l i m i n a t e d b y p r e f e t c h i n g )

Accuracy

Accuracy is the fraction of total prefetches that were useful - i.e. the ratio of the number of memory addresses prefetched were actually referenced by the program to the total prefetches done.

P r e f e t c h A c c u r a c y = C a c h e M i s s e s e l i m i n a t e d b y p r e f e t c h i n g ( U s e l e s s C a c h e P r e f e t c h e s ) + ( C a c h e M i s s e s e l i m i n a t e d b y p r e f e t c h i n g )

While it appears that having perfect accuracy might imply that there are no misses, this is not the case. The prefetches themselves might result in new misses if the prefetched blocks are placed directly into the cache. Although these are a very small fraction of the total number of misses we might see without any prefetching, this is still a small non-zero finite number of misses.

Timeliness

The qualitative definition of timeliness is how early a block is prefetched versus when it is actually referenced. An example to further explain timeliness is as follows :

Consider a for loop where each iteration takes 12 cycles to execute and the 'prefetch' operation takes 3 cycles. This implies that for the prefetched data to be useful, we must start the prefetch 12 / 3 = 4 iterations prior to its usage to maintain timeliness.

Types of cache prefetching

There are two main types of cache prefetching,

Hardware based prefetching

Hardware based prefetching is typically accomplished by having a dedicated hardware mechanism in the processor that watches the stream of instructions or data being requested by the executing program, recognizes the next few elements that the program might need based on this stream and prefetches into the processor's cache.

Software based prefetching

Software based prefetching is typically accomplished by having the compiler analyze the code and insert additional "prefetch" instructions in the program during compilation itself.

Stream buffers

Stream buffers were developed based on the concept of "one block lookahead (OBL) scheme" proposed by Alan Jay Smith.

Stream buffers are one of the most common hardware based prefetching techniques in use. This technique was originally proposed by Norman Jouppi in 1990 and many variations of this method have been developed since. The basic idea is that the cache miss address (and k subsequent addresses) are fetched into a separate buffer of depth k . This buffer is called a stream buffer and is separate from cache. The processor then consumes data/instructions from the stream buffer if the address associated with the prefetched blocks match the requested address generated by the program executing on the processor. The figure below illustrates this setup:

Whenever the prefetch mechanism detects a miss on an memory block, say A, it allocates a stream to begin prefetching successive blocks from the missed block onward. If the stream buffer can hold 4 blocks, then we would prefetch A+1, A+2, A+3, A+4 and hold those in the allocated stream buffer. If the processor consumes A+1 next, then it shall be moved "up" from the stream buffer to the processor's cache. The first entry of the stream buffer would now be A+2 and so on. This pattern of prefetching successive blocks is called Sequential Prefetching. It is mainly used when contiguous locations are to be prefetched. For example, it is used when prefetching instructions.

This mechanism can be scaled up by adding multiple such 'stream buffers' - each of which would maintain a separate prefetch stream. For each new miss, there would be a new stream buffer allocated and it would operate in a similar way as described above.

The ideal depth of the stream buffer is something that is subject to experimentation against various benchmarks and depends on the rest of the microarchitecture involved.

Another pattern of prefetching instructions is to prefetch addresses that are s addresses ahead in the sequence. It is mainly used when the consecutive blocks that are to be prefetched are s addresses apart. This is termed as Strided Prefetching.

Compiler directed prefetching

Compiler directed prefetching is widely used within loops with a large number of iterations. In this technique, the compiler predicts future cache misses and inserts a prefetch instruction based on the miss penalty and execution time of the instructions.

These prefetches are non-blocking memory operations, i.e these memory accesses do not interfere with actual memory accesses. They do not change the state of the processor or cause page faults.

One main advantage of software prefetching is that it reduces the number of compulsory cache misses.

The following example shows the how a prefetch instruction will be added into a code to improve cache performance.

Consider a for loop as shown below:

At each iteration, the i^th element of the array "array1" is accessed. Therefore, we can prefetch the elements that are going to be accessed in future iterations by inserting a "prefetch" instruction as shown below:

Here, the prefetch stride, k depends on two factors, the cache miss penalty and the time it takes to execute a single iteration of the for loop. For instance, if one iteration of the loop takes 7 cycles to execute, and the cache miss penalty is 49 cycles then we should have k = 49 / 7 = 7 - which means that we prefetch 7 elements ahead. With the first iteration, i will be 0, so we prefetch the 7th element. Now, with this arrangement, the first 7 accesses (i=0->6) will still be misses (under the simplifying assumption that each element of array1 is in a separate cache line of its own).

Comparison of hardware and software prefetching

While software prefetching requires programmer or compiler intervention, hardware prefetching requires special hardware mechanisms.

Software prefetching works well only with loops where there is regular array access as programmer has to hand code the prefetch instructions. Whereas, hardware prefetchers work dynamically based on the program's behavior at runtime.

Hardware prefetching also has less CPU overhead when compared to software prefetching.

References

Cache prefetching Wikipedia

(Text) CC BY-SA

Contents