2) { acc00 = acc01 = acc10 = acc11 = 0; for (k = 0; k < N; k++) { acc00 += B[k][j + 0] * A[i + 0][k]; acc01 += B[k][j + 1] * A[i + 0][k]; acc10 += B[k][j + 0] * A[i + 1][k]; acc11 += B[k][j + 1] * A[i + 1][k]; } C[i + 0][j + 0] = acc00; C[i + 0][j + 1] = acc01; C[i + 1][j + 0] = acc10; C[i + 1][j + 1] = acc11; } } This code has had both the i and j iterations blocked by a factor of two and had both the resulting two-iteration inner loops completely unrolled. This code would run quite acceptably on a Cray Y-MP (built in the early 1980s), which can sustain 0.8 multiply–adds per memory operation to main memory. A machine like a 2.8 GHz Pentium 4, build in 2003, has slightly less memory bandwidth and vastly better floating point, so that it can sustain 16.5 multiply–adds per memory operation. As a result, the code above will run slower on the 2.8 GHz Pentium 4 than on the 166 MHz Y-MP! A machine with a longer floating-point add latency or with multiple adders would require more accumulators to run in parallel. It is easy to change the loop above to compute a 3x3 block instead of a 2x2 block, but the resulting code is not always faster. The loop requires registers to hold both the accumulators and the loaded and reused A and B values. A 2x2 block requires 7 registers. A 3x3 block requires 13, which will not work on a machine with just 8 floating point registers in the ISA. If the CPU does not have enough registers, the compiler will schedule extra loads and stores to spill the registers into stack slots, which will make the loop run slower than a smaller blocked loop. Matrix multiplication is like many other codes in that it can be limited by memory bandwidth, and that more registers can help the compiler and programmer reduce the need for memory bandwidth. This register pressure is why vendors of RISC CPUs, who intended to build machines more parallel than the general purpose x86 and 68000 CPUs, adopted 32-entry floating-point register files. The code above does not use the cache very well. During the calculation of a horizontal stripe of C results, one horizontal