1. Cache Performance
Samira Khan
March 28, 2017

2. Agenda Review from last lecture Replacement Cache Performance
Cache access
Associativity
Replacement
Cache Performance

3. Cache Abstraction and Metrics
Cache hit rate = (# hits) / (# hits + # misses) = (# hits) / (# accesses)
Average memory access time (AMAT)
= ( hit-rate * hit-latency ) + ( miss-rate * miss-latency )
Address
Tag Store
(is the address
in the cache?
+ bookkeeping)
Data Store
(stores
memory
blocks)
Hit/miss?
Data

4. Direct-Mapped Cache: Placement and Access
00 | 000 | 000 -
00 | 000 | 111 A
Assume byte-addressable memory: 256 bytes, 8-byte blocks  32 blocks
Assume cache: 64 bytes, 8 blocks
Direct-mapped: A block can go to only one location
Addresses with same index contend for the same location
Cause conflict misses
01 | 000 | 000 -
01 | 000 | 111 B
tag
index
byte in block 2b
3 bits
3 bits
Tag store
Data store
Address
10 | 000 | 000 -
10 | 000 | 111 V
tag
11 | 000 | 000 -
11 | 000 | 111
byte in block =?
MUX
Hit?
Data
11 | 111 | 000 -
11 | 111 | 111
Memory

5. Direct-Mapped Cache: Placement and Access
A, B, A, B, A, B
A = 0b xxx
B = 0b xxx
Tag store
Data store 1 2
tag
index
byte in block 3 A 00
000
XXX 4 5 6 7
byte in block =?
MUX
8-bit address
tag
index
byte in block
3 bits
2 bits
Hit?
Data
MISS: Fetch A and update tag

6. Direct-Mapped Cache: Placement and Access
A, B, A, B, A, B
A = 0b xxx
B = 0b xxx
Tag store
Data store 1 00
XXXXXXXXX 1 2
tag
index
byte in block 3 A 00
000
XXX 4 5 6 7
byte in block =?
MUX
8-bit address
tag
index
byte in block
3 bits
2 bits
Hit?
Data

7. Direct-Mapped Cache: Placement and Access
A, B, A, B, A, B
A = 0b xxx
B = 0b xxx
Tag store
Data store 1 00
XXXXXXXXX 1 2
tag
index
byte in block 3 B 01
000
XXX 4 5 6 7
byte in block =?
MUX
8-bit address
tag
index
byte in block
3 bits
2 bits
Hit?
Data
Tags do not match: MISS

8. Direct-Mapped Cache: Placement and Access
A, B, A, B, A, B
A = 0b xxx
B = 0b xxx
Tag store
Data store 1 01
YYYYYYYYYY 1 2
tag
index
byte in block 3 B 01
000
XXX 4 5 6 7
byte in block =?
MUX
8-bit address
tag
index
byte in block
3 bits
2 bits
Hit?
Data
Fetch block B, update tag

9. Direct-Mapped Cache: Placement and Access
A, B, A, B, A, B
A = 0x xxx
B = 0x xxx
Tag store
Data store 1 01
YYYYYYYYYY 1 2
tag
index
byte in block 3 A 00
000
XXX 4 5 6 7
byte in block =?
MUX
8-bit address
tag
index
byte in block
3 bits
2 bits
Hit?
Data
Tags do not match: MISS

10. Direct-Mapped Cache: Placement and Access
A, B, A, B, A, B
A = 0x xxx
B = 0x xxx
Tag store
Data store 1 00
XXXXXXXXX 1 2
tag
index
byte in block 3 A 00
000
XXX 4 5 6 7
byte in block =?
MUX
8-bit address
tag
index
byte in block
3 bits
2 bits
Hit?
Data
Fetch block A, update tag

11. HIT Set Associative Cache A A, B, A, B, A, B 1 000 1 010 XXXXXXXXX
B = 0b xxx
Tag store
Data store 1 2 3 1
000 1
010
XXXXXXXXX
Data
YYYYYYYYYY
tag
index
byte in block A
000 00
XXX =? =?
MUX
MUX
Logic
byte in block
Hit?
8-bit address
tag
index
byte in block
2 bits
3 bits
HIT

12. Associativity (and Tradeoffs)
Degree of associativity: How many blocks can map to the same index (or set)?
Higher associativity
++ Higher hit rate
-- Slower cache access time (hit latency and data access latency)
-- More expensive hardware (more comparators)
Diminishing returns from higher
associativity
hit rate
associativity

13. Issues in Set-Associative Caches
Think of each block in a set having a “priority”
Indicating how important it is to keep the block in the cache
Key issue: How do you determine/adjust block priorities?
There are three key decisions in a set:
Insertion, promotion, eviction (replacement)
Insertion: What happens to priorities on a cache fill?
Where to insert the incoming block, whether or not to insert the block
Promotion: What happens to priorities on a cache hit?
Whether and how to change block priority
Eviction/replacement: What happens to priorities on a cache miss?
Which block to evict and how to adjust priorities

14. Eviction/Replacement Policy
Which block in the set to replace on a cache miss?
Any invalid block first
If all are valid, consult the replacement policy
Random
FIFO
Least recently used (how to implement?)
Not most recently used
Least frequently used
Hybrid replacement policies

15. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
LRU
MRU -1
MRU -2
MRU
Set 0
ACCESS PATTERN: ACBD

16. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
LRU
MRU -1
MRU -2
MRU
Set 0
ACCESS PATTERN: ACBDE

17. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
MRU
MRU -1
MRU -2
MRU
Set 0
ACCESS PATTERN: ACBDE

18. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
MRU
MRU -1
MRU -2
MRU -1
Set 0
ACCESS PATTERN: ACBDE

19. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
MRU
MRU -2
MRU -2
MRU -1
Set 0
ACCESS PATTERN: ACBDE

20. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
MRU
MRU -2
LRU
MRU -1
Set 0
ACCESS PATTERN: ACBDE

21. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
MRU
MRU
LRU
MRU -1
Set 0
ACCESS PATTERN: ACBDEB

22. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
MRU -1
MRU
LRU
MRU -1
Set 0
ACCESS PATTERN: ACBDEB

23. Least Recently Used Replacement PolicyB C D
Tag store
Data store =?
Logic
Hit?
4-way
MRU -1
MRU
LRU
MRU -2
Set 0
ACCESS PATTERN: ACBDEB

24. Implementing LRU Idea: Evict the least recently accessed block
Problem: Need to keep track of access ordering of blocks
Question: 2-way set associative cache:
What do you need to implement LRU perfectly?
Question: 16-way set associative cache:
What is the logic needed to determine the LRU victim?

25. Approximations of LRU
Most modern processors do not implement “true LRU” (also called “perfect LRU”) in highly-associative caches
Why?
True LRU is complex
LRU is an approximation to predict locality anyway (i.e., not the best possible cache management policy)
Examples:
Not MRU (not most recently used)

26. Cache Replacement Policy: LRU or Random
LRU vs. Random: Which one is better?
Example: 4-way cache, cyclic references to A, B, C, D, E
0% hit rate with LRU policy
Set thrashing: When the “program working set” in a set is larger than set associativity
Random replacement policy is better when thrashing occurs
In practice:
Depends on workload
Average hit rate of LRU and Random are similar
Best of both Worlds: Hybrid of LRU and Random
How to choose between the two? Set sampling
See Qureshi et al., “A Case for MLP-Aware Cache Replacement,“ ISCA 2006.

27. What’s In A Tag Store Entry?
Valid bit
Tag
Replacement policy bits
Dirty bit?
Write back vs. write through caches

28. Handling Writes (I)
When do we write the modified data in a cache to the next level?
Write through: At the time the write happens
Write back: When the block is evicted
Write-back
+ Can consolidate multiple writes to the same block before eviction
Potentially saves bandwidth between cache levels + saves energy
-- Need a bit in the tag store indicating the block is “dirty/modified”
Write-through
+ Simpler
+ All levels are up to date. Consistent
-- More bandwidth intensive; no coalescing of writes

29. Handling Writes (II) Do we allocate a cache block on a write miss?
Allocate on write miss
No-allocate on write miss
+ Can consolidate writes instead of writing each of them individually to next level
+ Simpler because write misses can be treated the same way as read misses
-- Requires (?) transfer of the whole cache block
No-allocate
+ Conserves cache space if locality of writes is low (potentially better cache hit rate)

30. Instruction vs. Data Caches
Separate or Unified?
Unified:
+ Dynamic sharing of cache space: no overprovisioning that might happen with static partitioning (i.e., split I and D caches)
-- Instructions and data can thrash each other (i.e., no guaranteed space for either)
-- I and D are accessed in different places in the pipeline. Where do we place the unified cache for fast access?
First level caches are almost always split
Mainly for the last reason above
Second and higher levels are almost always unified

31. Multi-level Caching in a Pipelined Design
First-level caches (instruction and data)
Decisions very much affected by cycle time
Small, lower associativity
Tag store and data store accessed in parallel
Second-level, third-level caches
Decisions need to balance hit rate and access latency
Usually large and highly associative; latency less critical
Tag store and data store accessed serially
Serial vs. Parallel access of levels
Serial: Second level cache accessed only if first-level misses
Second level does not see the same accesses as the first
First level acts as a filter (filters some temporal and spatial locality)
Management policies are therefore different

32. Cache Performance

33. Cache Parameters vs. Miss/Hit Rate
Cache size
Block size
Associativity
Replacement policy
Insertion/Placement policy

34. Cache Size Cache size: total data (not including tag) capacity
bigger can exploit temporal locality better
not ALWAYS better
Too large a cache adversely affects hit and miss latency
smaller is faster => bigger is slower
access time may degrade critical path
Too small a cache
doesn’t exploit temporal locality well
useful data replaced often
Working set: the whole set of data the executing application references
Within a time interval
hit rate
“working set”
size
cache size

35. Block Size
Block size is the data that is associated with an address tag
Too small blocks
don’t exploit spatial locality well
have larger tag overhead
Too large blocks
too few total # of blocks  less
temporal locality exploitation
waste of cache space and bandwidth/energy
if spatial locality is not high
Will see more examples later
hit rate
block
size

36. Associativity How many blocks can map to the same index (or set)?
Larger associativity
lower miss rate, less variation among programs
diminishing returns, higher hit latency
Smaller associativity
lower cost
lower hit latency
Especially important for L1 caches
Power of 2 associativity required?
hit rate
associativity

37. Higher Associativity 4-way =? =? =? =? 8-bit address Tag store tag
index
byte in block
1 bits
4 bits
3 bits
Logic
Hit?
Data store
MUX
byte in block
MUX

38. Higher Associativity 3-way =? =? =? 8-bit address Tag store tag index
byte in block
1 bits
4 bits
3 bits
Logic
Hit?
Data store
MUX
byte in block
MUX

39. Classification of Cache Misses
Compulsory miss
first reference to an address (block) always results in a miss
subsequent references should hit unless the cache block is displaced for the reasons below
Capacity miss
cache is too small to hold everything needed
defined as the misses that would occur even in a fully-associative cache (with optimal replacement) of the same capacity
Conflict miss
defined as any miss that is neither a compulsory nor a capacity miss

40. How to Reduce Each Miss Type
Compulsory
Caching cannot help
Prefetching
Conflict
More associativity
Other ways to get more associativity without making the cache associative
Victim cache
Hashing
Software hints?
Capacity
Utilize cache space better: keep blocks that will be referenced
Software management: divide working set such that each “phase” fits in cache

41. Cache Performance with Code Examples

42. Matrix Sum
int sum1(int matrix[4][8]) { int sum = 0; for (int i = 0; i < 4; ++i) { for (int j = 0; j < 8; ++j) { sum += matrix[i][j]; } access pattern: matrix[0][0], [0][1], [0][2], …, [1][0] …

43. Exploiting Spatial Locality
8B cache block, 4 blocks, LRU, 4B integer
Access pattern matrix[0][0], [0][1], [0][2], …, [1][0] …
[0][0]  miss
[0][1]  hit
[0][2]  miss
[0][3]  hit
[0][4]  miss
[0][5]  hit
[0][6]  miss
[0][7]  hit
[1][0]  miss
[1][1]  hit
Replace
[0][0]-[0][1]
[1][0]-[1][1]
[0][2]-[0][3]
[0][4]-[0][5]
[0][6]-[0][7]
[0][2]-[0][3]
[0][4]-[0][5]
[0][6]-[0][7]
Cache Blocks

44. Exploiting Spatial Locality
block size and spatial locality
larger blocks — exploit spatial locality
… but larger blocks means fewer blocks for same size
less good at exploiting temporal locality

45. Alternate Matrix Sum int sum2(int matrix[4][8]) { int sum = 0;
// swapped loop order
for (int j = 0; j < 8; ++j) {
for (int i = 0; i < 4; ++i) {
sum += matrix[i][j]; }
access pattern:
matrix[0][0], [1][0], [2][0], [3][0], [0][1], [1][1], [2][1], [3][1],…, …

46. Bad at Exploiting Spatial Locality
8B cache block, 4B integer
Access pattern matrix[0][0], [1][0], [2][0], [3][0], [0][1], [1][1], [2][1], [3][1],…, …
[0][0]  miss
[1][0]  miss
[2][0]  miss
[3][0]  miss
[0][1]  hit
[1][1]  hit
[2][1]  hit
[3][1]  hit
[0][2]  miss
[1][2]  miss
Replace
Replace
[0][0]-[0][1]
[0][2]-[0][3]
[1][0]-[1][1]
[2][0]-[2][1]
[3][0]-[3][1]
[0][2]-[0][3]
[1][2]-[1][3]
[2][0]-[2][1]
[3][0]-[3][1]
[1][0]-[1][1]
[2][0]-[2][1]
[3][0]-[3][1]
Cache Blocks

47. A note on matrix storage
A —> N X N matrix: represented as an 2D array
makes dynamic sizes easier:
float A_2d_array[N][N];
float *A_flat = malloc(N * N);
A_flat[i * N + j] === A_2d_array[i][j]

48. Matrix Squaring
𝐵 𝑖𝑗 = 𝑘=1 𝑛 𝐴 𝑖𝑘 ∗ 𝐴 𝑘𝑗 /* version 1: inner loop is k, middle is j */ for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) for (int k = 0; k < N; ++k) B[i*N+j] += A[i * N + k] * A[k * N + j];

49. Matrix Squaring i j 𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝑩 𝟎𝟎 𝐵 01 𝐵 02 𝐵 03
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝐴 00 𝐴 01 𝐴 02 𝐴 03 𝐴 10 𝐴 11 𝐴 12 𝐴 13 𝐴 20 𝐴 21 𝐴 22 𝐴 23 𝐴 30 𝐴 31 𝐴 32 𝐴 33
𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝐵 00 = (𝐴 00 ∗ 𝐴 00 )+ (𝐴 01 ∗ 𝐴 10 )+ (𝐴 02 ∗ 𝐴 20 )+ (𝐴 03 ∗ 𝐴 30 )

50. Matrix Squaring i j 𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝑩 𝟎𝟎 𝐵 01 𝐵 02 𝐵 03
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝐴 01 𝐴 02 𝐴 03 𝐴 10 𝐴 11 𝐴 12 𝐴 13 𝐴 20 𝐴 21 𝐴 22 𝐴 23 𝐴 30 𝐴 31 𝐴 32 𝐴 33
𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝐵 00 = (𝑨 𝟎𝟎 ∗ 𝑨 𝟎𝟎 )+ (𝐴 01 ∗ 𝐴 10 )+ (𝐴 02 ∗ 𝐴 20 )+ (𝐴 03 ∗ 𝐴 30 )

51. Matrix Squaring i j 𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝑩 𝟎𝟎 𝐵 01 𝐵 02 𝐵 03
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝑨 𝟎𝟏 𝐴 02 𝐴 03 𝑨 𝟏𝟎 𝐴 11 𝐴 12 𝐴 13 𝐴 20 𝐴 21 𝐴 22 𝐴 23 𝐴 30 𝐴 31 𝐴 32 𝐴 33
𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝐵 00 = (𝐴 00 ∗ 𝐴 00 )+ (𝑨 𝟎𝟏 ∗ 𝑨 𝟏𝟎 )+ (𝐴 02 ∗ 𝐴 20 )+ (𝐴 03 ∗ 𝐴 30 )

52. Matrix Squaring i j 𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝑩 𝟎𝟎 𝐵 01 𝐵 02 𝐵 03
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝑨 𝟎𝟏 𝑨 𝟎𝟐 𝐴 03 𝑨 𝟏𝟎 𝐴 11 𝐴 12 𝐴 13 𝑨 𝟐𝟎 𝐴 21 𝐴 22 𝐴 23 𝐴 30 𝐴 31 𝐴 32 𝐴 33
𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝐵 00 = (𝐴 00 ∗ 𝐴 00 )+ (𝐴 01 ∗ 𝐴 10 )+ (𝑨 𝟎𝟐 ∗ 𝑨 𝟐𝟎 )+ (𝐴 03 ∗ 𝐴 30 )

53. Matrix Squaring i j 𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝑩 𝟎𝟎 𝐵 01 𝐵 02 𝐵 03
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝑨 𝟎𝟏 𝑨 𝟎𝟐 𝑨 𝟎𝟑 𝑨 𝟏𝟎 𝐴 11 𝐴 12 𝐴 13 𝑨 𝟐𝟎 𝐴 21 𝐴 22 𝐴 23 𝑨 𝟑𝟎 𝐴 31 𝐴 32 𝐴 33
Aik has spatial locality
𝐵 00 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘0
𝐵 00 = (𝐴 00 ∗ 𝐴 00 )+ (𝐴 01 ∗ 𝐴 10 )+ (𝐴 02 ∗ 𝐴 20 )+ (𝑨 𝟎𝟑 ∗ 𝑨 𝟑𝟎 )

54. Matrix Squaring i j 𝐵 01 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘1
𝐵 00 𝑩 𝟎𝟏 𝐵 02 𝐵 03
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝑨 𝟎𝟏 𝑨 𝟎𝟐 𝑨 𝟎𝟑 𝐴 10 𝑨 𝟏𝟏 𝐴 12 𝐴 13 𝐴 20 𝑨 𝟐𝟏 𝐴 22 𝐴 23 𝐴 30 𝑨 𝟑𝟏 𝐴 32 𝐴 33
Aik has spatial locality
𝐵 01 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘1
𝑩 𝟎𝟏 = (𝑨 𝟎𝟎 ∗ 𝑨 𝟎𝟏 )+ (𝑨 𝟎𝟏 ∗ 𝑨 𝟏𝟏 )+ (𝑨 𝟎𝟐 ∗ 𝑨 𝟐𝟏 )+ (𝑨 𝟎𝟑 ∗ 𝑨 𝟑𝟏 )

55. Matrix Squaring i j 𝐵 02 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘2
𝐵 00 𝐵 01 𝑩 𝟎𝟐 𝐵 03
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝑨 𝟎𝟏 𝑨 𝟎𝟐 𝑨 𝟎𝟑 𝐴 10 𝐴 11 𝑨 𝟏𝟐 𝐴 13 𝐴 20 𝐴 21 𝑨 𝟐𝟐 𝐴 23 𝐴 30 𝐴 31 𝑨 𝟑𝟐 𝐴 33
Aik has spatial locality
𝐵 02 = 𝑘=0 𝑛 𝐴 0𝑘 ∗ 𝐴 𝑘2
𝑩 𝟎𝟐 = (𝑨 𝟎𝟎 ∗ 𝑨 𝟎𝟐 )+ (𝑨 𝟎𝟏 ∗ 𝑨 𝟏𝟐 )+ (𝑨 𝟎𝟐 ∗ 𝑨 𝟐𝟐 )+ (𝑨 𝟎𝟑 ∗ 𝑨 𝟑𝟐 )

56. Conclusion
Aik has spatial locality
Bij has temporal locality

57. Matrix Squaring
𝐵 𝑖𝑗 = 𝑘=1 𝑛 𝐴 𝑖𝑘 ∗ 𝐴 𝑘𝑗 /* version 2: outer loop is k, middle is j */ for (int k = 0; k < N; ++k) for (int i = 0; i < N; ++i) for (int j = 0; j < N; ++j) B[i*N+j] += A[i * N + k] * A[k * N + j]; Access pattern k = 0, i = 0 B[0][0] = A[0][0] * A[0][0] B[0][1] = A[0][0] * A[0][1] B[0][2] = A[0][0] * A[0][2] B[0][3] = A[0][0] * A[0][3]
Access pattern k = 0, i = 1
B[1][0] = A[1][0] * A[0][0]
B[1][1] = A[1][0] * A[0][1]
B[1][2] = A[1][0] * A[0][2]
B[1][3] = A[1][0] * A[0][3]

58. Matrix Squaring: kij order
𝑩 𝟎𝟎 𝑩 𝟎𝟏 𝑩 𝟎𝟐 𝑩 𝟎𝟑
𝐵 10 𝐵 11 𝐵 12 𝐵 13
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝑨 𝟎𝟏 𝑨 𝟎𝟐 𝑨 𝟎𝟑 𝐴 10 𝐴 11 𝐴 12 𝐴 13 𝐴 20 𝐴 21 𝐴 22 𝐴 23 𝐴 30 𝐴 31 𝐴 32 𝐴 33
𝑩 𝟎𝟎 = (𝑨 𝟎𝟎 ∗ 𝑨 𝟎𝟎 )+ (𝐴 01 ∗ 𝐴 10 )+ (𝐴 02 ∗ 𝐴 20 )+ (𝐴 03 ∗ 𝐴 30 )
𝑩 𝟎𝟏 = (𝑨 𝟎𝟎 ∗ 𝑨 𝟎𝟏 )+ (𝐴 01 ∗ 𝐴 11 )+ (𝐴 02 ∗ 𝐴 21 )+ (𝐴 03 ∗ 𝐴 31 )
𝑩 𝟎𝟐 = (𝑨 𝟎𝟎 ∗ 𝑨 𝟎𝟐 )+ (𝐴 01 ∗ 𝐴 12 )+ (𝐴 02 ∗ 𝐴 22 )+ (𝐴 03 ∗ 𝐴 32 )
𝑩 𝟎𝟑 = (𝑨 𝟎𝟎 ∗ 𝑨 𝟎𝟑 )+ (𝐴 01 ∗ 𝐴 13 )+ (𝐴 02 ∗ 𝐴 23 )+ (𝐴 03 ∗ 𝐴 33 )

59. Matrix Squaring: kij order
Bij , Akj have spatial locality
Aik has temporal locality i j
𝐵 00 𝐵 01 𝐵 02 𝐵 03
𝑩 𝟏𝟎 𝑩 𝟏𝟏 𝑩 𝟏𝟐 𝑩 𝟏𝟑
𝐵 20 𝐵 21 𝐵 22 𝐵 23
𝐵 30 𝐵 31 𝐵 32 𝐵 33
𝑨 𝟎𝟎 𝑨 𝟎𝟏 𝑨 𝟎𝟐 𝑨 𝟎𝟑 𝑨 𝟏𝟎 𝐴 11 𝐴 12 𝐴 13 𝐴 20 𝐴 21 𝐴 22 𝐴 23 𝐴 30 𝐴 31 𝐴 32 𝐴 33
𝑩 𝟏𝟎 = (𝑨 𝟏𝟎 ∗ 𝑨 𝟎𝟎 )+ (𝐴 11 ∗ 𝐴 10 )+ (𝐴 12 ∗ 𝐴 20 )+ (𝐴 13 ∗ 𝐴 30 )
𝑩 𝟏𝟏 = (𝑨 𝟏𝟎 ∗ 𝑨 𝟎𝟏 )+ (𝐴 11 ∗ 𝐴 11 )+ (𝐴 12 ∗ 𝐴 21 )+ (𝐴 13 ∗ 𝐴 31 )
𝑩 𝟏𝟐 = (𝑨 𝟏𝟎 ∗ 𝑨 𝟎𝟐 )+ (𝐴 11 ∗ 𝐴 12 )+ (𝐴 12 ∗ 𝐴 22 )+ (𝐴 13 ∗ 𝐴 32 )
𝑩 𝟏𝟑 = (𝑨 𝟏𝟎 ∗ 𝑨 𝟎𝟑 )+ (𝐴 11 ∗ 𝐴 13 )+ (𝐴 12 ∗ 𝐴 23 )+ (𝐴 13 ∗ 𝐴 33 )

60. Matrix Squaring kij order Bij , Akj have spatial locality
Aik has temporal locality
ijk order
Aik has spatial locality
Bij has temporal locality

61. Which order is better?
Lower is better
Order kij performs much better