a systolic array
/ sis-TOL-ik /
Picture a bucket brigade fighting a fire: a line of people, each passing a bucket to the next, water flowing steadily down the chain while every person stays put and just does one simple thing — receive, hand on. Nobody runs back to the well. A systolic array is a grid of tiny processing cells wired the same way: data flows rhythmically from cell to neighboring cell like a heartbeat (that is what 'systolic' means — relating to the heart's pumping), and each cell does one small operation as the data passes through, never reaching back to distant memory.
Concretely, for matrix multiplication a systolic array is a 2-D grid of multiply-accumulate cells. The weights are pre-loaded, one per cell. Then the input values are pumped in from the left edge and partial sums flow down from the top. On each clock tick, every cell multiplies the value passing through by its stored weight, adds it to the partial sum coming from above, and passes both the input rightward and the running sum downward to its neighbors. After the wave washes across the whole grid, the completed dot products emerge at the bottom. Crucially, each number is read from memory once and then reused by many cells as it travels — the array squeezes enormous arithmetic out of very little memory traffic.
Why it matters: the systolic array is the engine inside the TPU and many neural-network accelerators, and its great virtue is exactly that data-reuse. The expensive thing in modern chips is not arithmetic but moving data; by passing each value cell-to-cell, a systolic array does thousands of multiply-adds while touching main memory comparatively little. The honest limit: this beautiful regularity only fits regular, dense, predictable computations like dense matrix multiply. Irregular or sparse work does not flow neatly through the grid, so a systolic array is a specialist, not a general computer.
To multiply two 3 by 3 matrices, a 3 by 3 systolic array pre-loads one matrix's nine weights, then streams the other matrix's columns in from the left. Values march across, partial sums accumulate downward, and after the data has rippled through, the nine output entries pour out the bottom — each input number having been read once but used along its whole path.
Data flows cell to cell like a heartbeat; each value is read once and reused along the way — minimal memory traffic.
A systolic array's strength is dense, regular dataflow with heavy reuse; it is a poor fit for sparse or irregular computation that cannot march uniformly through the grid. Its peak only counts if you can keep the wavefront full.