01 / 06 · Start with the compute resource

Analog Arrays

The central goal of analog accelerator design is to keep the analog array performing matrix–vector multiplications (MVMs), $y = Wx$, as continuously as possible. Its speed matters only if weights and inputs can be delivered and outputs removed fast enough to sustain execution.

Starting from the array, we quantify how much data must move and how long each step takes. We then consider how these steps can overlap and what memory bandwidth is needed to keep the arrays busy.

For an array with $m$ rows and $n$ columns, each MVM consumes $n$ input values and produces $m$ output values. Buffers hold these vectors at the array, while the scratchpad (SPM) supplies inputs and receives outputs.

Four Stages of an Analog MVM

Each MVM follows a sequence of data movement and computation. The matrix is programmed once, followed by load → compute → store for each input vector. The animation shows the sequence of operations, not their execution time.

1. Program weights

   Set the matrix weights in the analog array. Once programmed, the weights can be reused across subsequent input vectors.

   Latency sources

   • Transferring the m × n weights to the array
   • Programming the array

   $T_{\text{program weights}} =$ $T_{\text{transfer}}(4mn)$ $+ T_{\text{array program}}(mn)$

2. Load input

   Load the input vector into the input buffer used by the analog array.

   Latency sources

   • Transferring the input vector of size n to the input buffer

   $T_{\text{load}} = T_{\text{transfer}}(4n)$

3. Compute

   Execute the matrix-vector multiplication using the programmed matrix and loaded input vector.

   Latency sources

   • Analog execution

   $T_{\text{MVM}}$— analog execution time

4. Store output

   Transfer the completed output vector out of the output buffer.

   Latency sources

   • Transferring the m resulting values from the output buffer

   $T_{\text{store}} = T_{\text{transfer}}(4m)$

Three Costs Determine the Timing

The timing of an analog MVM depends on moving data, programming the array, and performing the computation. All times are measured in cycles, and transfers assume 32-bit floating-point values (4 bytes per element).

Cost	Meaning
$T_{\text{transfer}}(D)$	Move $D$ bytes into or out of the array.
$T_{\text{program}}(mn)$	Program the delivered $m \times n$ weights into the array.
$T_{\text{MVM}}$	Perform an analog MVM.