CPS220 Computer System Organization Lecture 18: The Memory Hierarchy

1. CPS220Computer System Organization Lecture 18: The Memory Hierarchy Alvin R. Lebeck Fall 1999

2. Outline of Today’s Lecture • The Memory Hierarchy • Review: Direct Mapped Cache. • Review: Two-Way Set Associative Cache • Review: Fully Associative cache • Review: Replacement Policies • Review: Cache Write Strategies • Reducing cache misses • Choosing Block size • Associativity and the 2:1 rule. • Victim Buffer. • Prefetching • Software techniques

3. Review: Who Cares About the Memory Hierarchy? • Processor Only Thus Far in Course: • CPU cost/performance, ISA, Pipelined Execution • CPU-DRAM Gap • 1980: no cache in µproc; 1995 2-level cache, 60% trans. on Alpha 21164 µproc (150 clock cycles for a miss!)

4. Four Questions for Memory Hierarchy Designers • Q1: Where can a block be placed in the upper level? (Block placement) • Q2: How is a block found if it is in the upper level?(Block identification) • Q3: Which block should be replaced on a miss? (Block replacement) • Q4: What happens on a write? (Write strategy)

5. 32-M bits M-L bits L bits Tag Cache Index block offset Data Address Direct Mapped Cache • Direct Mapped cache is an array of fixed size blocks. • Each block holds consecutive bytes of main memory data. • The Tag Array holds the Block Memory Address. • A valid bit associated with each cache block tells if the data is valid. • Cache Index: The location of a block (and it’s tag) in the cache. • Block Offset: The byte location in the cache block. Cache-Index = (<Address> Mod (Cache_Size))/ Block_Size Block-Offset = <Address> Mod (Block_Size) Tag= <Address> / (Cache_Size)

6. Cache Data Cache Tag Valid Cache Block 0 : : : Compare A N-way Set Associative Cache • N-way set associative: N entries for each Cache Index • N direct mapped caches operating in parallel • Example: Two-way set associative cache • Cache Index selects a “set” from the cache • The two tags in the set are compared in parallel • Data is selected based on the tag result Cache Index Valid Cache Tag Cache Data Cache Block 0 : : : Adr. Tag Adr. Tag Compare 1 0 Mux SEL1 SEL0 OR Cache Block Hit

7. And yet Another Extreme Example:Fully Associative cache • Fully Associative Cache -- push the set associative idea to its limit! • Forget about the Cache Index • Compare the Cache Tags of all cache tag entries in parallel • Example: Block Size = 32B blocks, we need N 27-bit comparators • By definition: Conflict Miss = 0 for a fully associative cache 31 4 0 Cache Tag (27 bits long) Byte Select Ex: 0x01 Cache Tag Valid Bit Cache Data : X Byte 31 Byte 1 Byte 0 : X Byte 63 Byte 33 Byte 32 X X : : : X

8. The Need to Make a Decision! • Direct Mapped Cache: • Each memory location can only mapped to 1 cache location • No need to make any decision :-) • Current item replaced the previous item in that cache location • N-way Set Associative Cache: • Each memory location have a choice of N cache locations • Fully Associative Cache: • Each memory location can be placed in ANY cache location • Cache miss in a N-way Set Associative or Fully Associative Cache: • Bring in new block from memory • Throw out a cache block to make room for the new block • We need to make a decision on which block to throw out!

9. Cache Block Replacement Policy • Random Replacement: • Hardware randomly selects a cache item and throw it out • Least Recently Used: • Hardware keeps track of the access history • Replace the entry that has not been used for the longest time. • For two way set associative cache one needs one bit for LRU replacement. • Example of a Simple “Pseudo” Least Recently Used Implementation: • Assume 64 Fully Associative Entries • Hardware replacement pointer points to one cache entry • Whenever an access is made to the entry the pointer points to: • Move the pointer to the next entry • Otherwise: do not move the pointer Entry 0 Entry 1 Replacement : Pointer Entry 63

10. Cache Write Policy: Write Through versus Write Back • Cache read is much easier to handle than cache write: • Instruction cache is much easier to design than data cache • Cache write: • How do we keep data in the cache and memory consistent? • Two options (decision time again :-) • Write Back: write to cache only. Write the cache block to memory when that cache block is being replaced on a cache miss. • Need a “dirty bit” for each cache block • Greatly reduce the memory bandwidth requirement • Control can be complex • Write Through: write to cache and memory at the same time. • What!!! How can this be? Isn’t memory too slow for this?

11. Write Buffer for Write Through Cache Processor DRAM • A Write Buffer is needed between the Cache and Memory • Processor: writes data into the cache and the write buffer • Memory controller: write contents of the buffer to memory • Write buffer is just a FIFO: • Typical number of entries: 4 • Works fine if: Store frequency (w.r.t. time) << 1 / DRAM write cycle • Memory system designer’s nightmare: • Store frequency (w.r.t. time) > 1 / DRAM write cycle • Write buffer saturation Write Buffer

12. Write Buffer Saturation Cache Processor DRAM • Store frequency (w.r.t. time) -> 1 / DRAM write cycle • If this condition exist for a long period of time (CPU cycle time too quick and/or too many store instructions in a row): • Store buffer will overflow no matter how big you make it • The CPU Cycle Time << DRAM Write Cycle Time • Solution for write buffer saturation: • Use a write back cache • Install a second level (L2) cache: • store compression Write Buffer Cache L2 Cache Processor DRAM Write Buffer

13. What is a Sub-block? • Sub-block: • Share one cache tag between all sub-blocks in a block • Each sub-block within a block has its own valid bit • Example: 1 KB Direct Mapped Cache, 32-B Block, 8-B Sub-block • Each cache entry will have: 32/8 = 4 valid bits • Write miss: only the bytes in that sub-block are brought in. • reduces cache fill bandwidth (penalty). SB3’s V Bit SB2’s V Bit SB1’s V Bit SB0’s V Bit Cache Tag Cache Data : : B31 B24 B7 B0 0 Sub-block3 Sub-block2 Sub-block1 Sub-block0 1 2 3 : : : : : : 31 Byte 1023 Byte 992

14. Cache Performance CPUtime = IC x (CPIexecution + Mem accesses per instruction x Miss rate x Miss penalty) x Clock cycle time Misses per instruction = Memory accesses per instruction x Miss rate CPUtime = IC x (CPIexecution + Misses per instruction x Miss penalty) x Clock cycle time

15. Improving Cache Performance 1. Reduce the miss rate, 2. Reduce the miss penalty, or 3. Reduce the time to hit in the cache.

16. Sources of Cache Misses • Compulsory (cold start or process migration, first reference): first access to a block(Misses in Infinite Cache) • Solutions: Prefetching? Larger blocks? • Conflict (collision): Multiple memory locations mappedto the same cache location (Misses in N-way Associative, Size X Cache) • Solution 1: increase cache size • Solution 2: increase associativity • Capacity: Cache cannot contain all blocks access by the program(Misses in Size X Cache) • Solution: increase cache size • Invalidation: other process (e.g., I/O) updates memory

17. Sources of Cache Misses Direct Mapped N-way Set Associative Fully Associative Cache Size Big Medium Small Compulsory Miss Same Same Same Conflict Miss High Medium Zero Capacity Miss Low(er) Medium High Invalidation Miss Same Same Same Note: If you are going to run “billions” of instruction, Compulsory Misses are insignificant.

18. 0 . 1 4 1 - w a y Conflict 0 . 1 2 2 - w a y 0 . 1 4 - w a y 0 . 0 8 Miss Rate per Type 8 - w a y 0 . 0 6 C a p a c i t y 0 . 0 4 0 . 0 2 1 0 2 4 8 16 64 32 128 C o m p u l s o r y C a c h e S i z e ( K B ) 3Cs Absolute Miss Rate

19. 0 . 1 4 1 - w a y Conflict 0 . 1 2 2 - w a y 0 . 1 4 - w a y 0 . 0 8 Miss Rate per Type Capacity 8 - w a y 0 . 0 6 0 . 0 4 0 . 0 2 1 0 8 2 4 16 32 64 128 Compulsory C a c h e S i z e ( K B ) 2:1 Cache Rule

20. 3Cs Relative Miss Rate 1 0 0 % 1-way Conflict 8 0 % 2-way 4-way 8-way Miss Rate per Type 6 0 % 4 0 % Capacity 2 0 % 0 % 1 2 4 8 32 64 16 128 C o m p u l s o r y C a c h e S i z e ( K B )

21. 1. Reduce Misses via Larger Block Size

22. 2. Reduce Misses via Higher Associativity • 2:1 Cache Rule: • Miss Rate DM cache size N ≈ Miss Rate 2W-SA cache size N/2 • Beware: Execution time is only final measure! • Will Clock Cycle time increase? • Hill [1988] suggested hit time external cache +10%, internal + 2% for 2-way vs. 1-way

23. Example: Avg. Memory Access Time vs. Miss Rate • Example: assume CCT = 1.10 for 2-way, 1.12 for 4-way, 1.14 for 8-way vs. CCT direct mapped Cache Size Associativity (KB) 1-way 2-way 4-way 8-way 1 2.33 2.15 2.07 2.01 2 1.98 1.86 1.76 1.68 4 1.72 1.67 1.61 1.53 8 1.46 1.48 1.47 1.43 16 1.29 1.32 1.32 1.32 32 1.20 1.24 1.25 1.27 64 1.14 1.20 1.21 1.23 128 1.10 1.17 1.18 1.20 (Red means A.M.A.T. not improved by more associativity)

24. ? ? 3. Reducing Conflict Misses via Victim Cache CPU • How to combine fast hit time of Direct Mapped yet still avoid conflict misses? • Add buffer to place data discarded from cache • Jouppi [1990]: 4-entry victim cache removed 20% to 95% of conflicts for a 4 KB direct mapped data cache DATA TAG TAG DATA Mem

25. 4. Reducing Conflict Misses via Pseudo-Associativity • How to combine fast hit time of Direct Mapped and have the lower conflict misses of 2-way SA cache? • Divide cache: on a miss, check other half of cache to see if there, if so have a pseudo-hit (slow hit) • Drawback: CPU pipeline is hard if hit takes 1 or 2 cycles • Better for caches not tied directly to processor Hit Time Miss Penalty Pseudo Hit Time Time

26. 5. Reducing Misses by HW Prefetching of Instruction & Data • E.g., Instruction Prefetching • Alpha 21064 fetches 2 blocks on a miss • Extra block placed in stream buffer • On miss check stream buffer • Works with data blocks too: • Jouppi [1990] 1 data stream buffer got 25% misses from 4KB cache; 4 streams got 43% • Palacharla & Kessler [1994] for scientific programs for 8 streams got 50% to 70% of misses from 2 64KB, 4-way set associative caches • Prefetching relies on extra memory bandwidth that can be used without penalty

27. 6. Reducing Misses by SW Prefetching Data • Data Prefetch • Load data into register (HP PA-RISC loads) binding • Cache Prefetch: load into cache (MIPS IV, PowerPC, SPARC v. 9) non-binding • Special prefetching instructions cannot cause faults;a form of speculative execution • Issuing Prefetch Instructions takes time • Is cost of prefetch issues < savings in reduced misses?

28. 7. Reducing Misses by Compiler Optimizations • Instructions • Reorder procedures in memory so as to reduce misses • Profiling to look at conflicts • McFarling [1989] reduced caches misses by 75% on 8KB direct mapped cache with 4 byte blocks • Data • Merging Arrays: improve spatial locality by single array of compound elements vs. 2 arrays • Loop Interchange: change nesting of loops to access data in order stored in memory • Loop Fusion: Combine 2 independent loops that have same looping and some variables overlap • Blocking: Improve temporal locality by accessing “blocks” of data repeatedly vs. going down whole columns or rows

29. Merging Arrays Example /* Before */ int val[SIZE]; int key[SIZE]; /* After */ struct merge { int val; int key; }; struct merge merged_array[SIZE]; Reducing conflicts between val & key

30. Loop Interchange Example /* Before */ for (k = 0; k < 100; k = k+1) for (j = 0; j < 100; j = j+1) for (i = 0; i < 5000; i = i+1) x[i][j] = 2 * x[i][j]; /* After */ for (k = 0; k < 100; k = k+1) for (i = 0; i < 5000; i = i+1) for (j = 0; j < 100; j = j+1) x[i][j] = 2 * x[i][j]; Sequential accesses Instead of striding through memory every 100 words

31. Loop Fusion Example /* Before */ for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) a[i][j] = 1/b[i][j] * c[i][j]; for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) d[i][j] = a[i][j] + c[i][j]; /* After */ for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) { a[i][j] = 1/b[i][j] * c[i][j]; d[i][j] = a[i][j] + c[i][j];} 2 misses per access to a & c vs. one miss per access

32. Blocking Example /* Before */ for (i = 0; i < N; i = i+1) for (j = 0; j < N; j = j+1) {r = 0; for (k = 0; k < N; k = k+1){ r = r + y[i][k]*z[k][j];}; x[i][j] = r; }; • Two Inner Loops: • Read all NxN elements of z[] • Read N elements of 1 row of y[] repeatedly • Write N elements of 1 row of x[] • Capacity Misses a function of N & Cache Size: • 3 NxN => no capacity misses; otherwise ... • Idea: compute on BxB submatrix that fits

33. Blocking Example /* After */ for (jj = 0; jj < N; jj = jj+B) for (kk = 0; kk < N; kk = kk+B) for (i = 0; i < N; i = i+1) for (j = jj; j < min(jj+B-1,N); j = j+1) {r = 0; for (k = kk; k < min(kk+B-1,N); k = k+1) { r = r + y[i][k]*z[k][j];}; x[i][j] = x[i][j] + r; }; • Capacity Misses reduced from 2N3 + N2 to 2N3/B +N2 • B called Blocking Factor • Conflict Misses Too?

34. Reducing Conflict Misses by Blocking • Conflict misses in caches not FA vs. Blocking size • Lam et al [1991] a blocking factor of 24 had one fifth the misses vs. 48 despite both fit in cache

35. Summary of Compiler Optimizations to Reduce Cache Misses