---
title: Reduction-Free Outer-Product Dataflow
url: https://www.emergentmind.com/topics/reduction-free-outer-product-dataflow
type: topic
---

# Reduction-Free Outer-Product Dataflow

Searching arXiv for the cited papers to ground the article and verify metadata.
arXiv search: 2408.03452 "Matrix-Free Finite Volume Kernels on a Dataflow Architecture"
arXiv search: 1210.0461 "On Parallelizing Matrix Multiplication by the Column-Row Method"
arXiv search: 2606.02333 "O-POPE: High-Frequency Pipelined Outer Product based GEMM acceleration with minimal buffering overhead"
Reduction-free outer-product dataflow denotes, in its strictest form, an execution model in which a computation is expressed as a stream of outer products and every output coordinate is assigned consistently to a single owner, so that all contributions to that coordinate are accumulated locally and no final inter-processor reduction of partial sums is required for that entry. The clearest formulation in the literature represented here is the column-row method for matrix multiplication, which writes
\[
AB=\sum_{k=0}^{n-1} a_k b_k
\]
and assigns output entries \((i,j)\) by a consistent hash so that all terms contributing to \((AB)_{ij}\) are processed by the same processor [1210.0461]. Much of the broader dataflow literature uses related outer-product, streaming, or output-stationary organizations, but often only in a reduction-minimized sense: local sums, sparse partial-sum merges, dot-product all-reduces, or temporal accumulations still remain [2408.03452].

## 1. Strict definition and canonical formulation

The canonical reduction-free formulation arises in sparse matrix multiplication by the column-row method. For \(A,B\in\mathbb{R}^{n\times n}\), the product entry is
\[
(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),
\]
equivalently
\[
AB=\sum_{k=0}^{n-1} a_k b_k.
\]
The defining step is not merely the outer-product decomposition itself, but the fact that output coordinates are assigned once and for all to processors by
\[
h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,
\]
with \(h_a,h_b:\mathbb{N}\to[\kappa]\) pairwise independent hash functions. Ownership of \((i,j)\) depends only on \((i,j)\), not on \(k\) or on the structure of any particular outer product, so all terms in \(\sum_k a_k(i)b_k(j)\) arrive at the same owner [1210.0461].

Under this model, reduction-free means reduction-free across processors for output accumulation. No all-to-all communication, merging of duplicate partial sums, distributed reduction trees, or shared output arrays with atomic adds are required for output entries, because each processor accumulates only the entries it owns. The model is communication-avoiding rather than communication-free overall, since every processor sees the same stream of outer products after an input broadcast [1210.0461].

A mathematically older but structurally related perspective appears in the MoA and \(\psi\)-calculus treatment of tensor and Kronecker products. There the outer product of arrays has shape given by concatenation, \(\rho(A\;op_\times\;B)=\rho A+\rho B\), and composed products are represented directly by indexed elementwise products rather than by intermediate materialized matrices. This suggests a reduction-free viewpoint for pure tensor expansion: the central operations are shape concatenation, permutation, and indexing, not contraction [0907.0796].

## 2. Ownership, extraction, and load balance

The central algorithmic mechanism is output-coordinate ownership. A processor is responsible for a disjoint interval of hash buckets, and for each streamed outer product \(ab\) it computes only the subset of pairs whose hash lies in its assigned interval. Because the same \((i,j)\) always hashes to the same processor, exact local counters would already be final values for owned coordinates; there is no later inter-processor combination step for those entries [1210.0461].

This ownership rule would be of limited use if each processor had to inspect all \(|a||b|\) pairs in every outer product. The key technical result is that, given sparse vectors \(a\) and \(b\) with \(O(t)\) nonzeros each and a bucket interval \(\mathcal L=[q,\ldots,r)\), the set \(\mathcal{E}^{ab}_{\mathcal L}\) of entries in \(ab\) hashing to \(\mathcal L\) can be constructed in expected time
\[
O(|\mathcal{E}^{ab}_{\mathcal L}|+t).
\]
The implementation sorts nonzero indices of \(a\) by \(h_a\), sorts nonzero indices of \(b\) by \(h_b\), and sweeps through the corresponding ordered lists [1210.0461].

Load balance follows from the same hash structure. If \(K\) instances run on disjoint intervals, expected work per instance on outer product \(ab\) is \(|a||b|/K\), and Theorem 1 gives a high-probability deviation bound once this work scale dominates the input-reading overhead. The paper therefore characterizes the method as achieving linear speedup down to the point where the cost is dominated by reading the input [1210.0461].

The same ownership idea also supports approximate heavy-entry tracking without merge phases. Space-Saving and Count-Sketch summaries can be maintained locally for the entries owned by each processor, so the sketching state for a coordinate never has to be reconciled across processors. At the same time, Theorem 4 states that any one-pass algorithm that always outputs the heaviest entry, or even just its weight, must encode in its state all entry weights. Exact one-pass full-output recovery therefore remains intrinsically expensive in dense-output regimes [1210.0461].

## 3. What reduction-free does and does not mean

Outer-product syntax does not by itself imply reduction-free execution. Several recent systems make this distinction explicit.

| Representative work | Core organization | Reduction status |
|---|---|---|
| [1210.0461] | Consistent hash ownership of output coordinates across outer products | Reduction-free across processors for output accumulation |
| [2408.03452] | Cell-based gather with owner-computes local reduction | Avoids write conflicts, not reduction-free overall |
| [2312.12766] | Hybrid inner/outer-product SpMM with address mapping | Explicit sparse psum accumulation |
| [2301.10852] | Selectable IP/OP/Gust with Merger-Reduction Network | Outer product is intersection-free but merge-requiring |
| [2307.03930] | Row-skipping outer products | Skips zero-induced updates, retains \(K\)-dimension accumulation |
| [2404.16629] | Streaming online-normalized SDPA | Reduction-reordered, not mathematically reduction-free |

One common misconception is that avoiding write conflicts is equivalent to eliminating reductions. In matrix-free finite-volume kernels on a dataflow architecture, each processing element owns one \((x,y)\) column and computes outputs only for its own cells, so atomic updates and race conditions are avoided. However, the operator is still
\[
(\mathbf{J}\mathbf{x})_K=\sum_{L\in \text{adj}(K)} \Upsilon_{KL}\lambda_{KL}(x_L-x_K)
\]
for unconstrained cells, which is a local sum over neighbors, and the conjugate-gradient solver still requires whole-fabric dot-product reductions for \(\alpha_k\) and \(\beta_k\) [2408.03452].

A second misconception is that output-stationary local accumulation is mathematically reduction-free. O-POPE, for example, eliminates a separate reduction tree, a separate reduction network, and a distinct reduction phase after multiplication by absorbing accumulation into successive local FMA updates inside each processing element. Yet GEMM still computes
\[
c_{ij}=\sum_k a_{ik}b_{kj},
\]
so the reduction over \(k\) remains present as a local pipelined recurrence rather than disappearing algebraically [2606.02333].

## 4. Architectural realizations of outer-product dataflow

O-POPE is a particularly clear hardware realization of reduction-network-free outer-product execution. It implements GEMM as an output-stationary outer-product dataflow on a semi-systolic \(p\times p\) mesh of processing elements, with row-wise broadcast of \(A\) operands, column-wise broadcast of \(B\) operands, and stationary output tiles \(C\). Its distinctive mechanism is to repurpose FPU pipeline registers as the buffering structure needed to align operands and partial sums, so that the running partial sum can re-enter the FPU exactly when the next rank-1 update for that output is due [2606.02333].

This design is not reduction-free in the mathematical sense, but it is reduction-network-free and reduction-phase-free in the architectural sense. The required accumulation appears as a local recurrence,
\[
c_{ij}^{(t+1)}=c_{ij}^{(t)}+a_i^{(k)}b_j^{(k)},
\]
with no separate reduction tree. In 12 nm FINFET technology, O-POPE reports 1 GHz operation at 0.72 V, less than 2% buffer area for a 2048-MACs configuration, and up to 99.97% FPU utilization [2606.02333].

VEDA illustrates a different point in the design space. It uses a flexible-product dataflow and a runtime-reconfigurable PE array for matrix-vector multiplication in LLM decoding. Attention score computation \(qK^T\) is mapped to an inner-product style configuration with a two-level adder tree, while attention-value multiplication \(s'V\) is mapped to an outer-product style configuration in which one scalar is broadcast across the array and partial outputs are accumulated locally over time. This avoids a cross-PE reduction tree for \(s'V\), but reductions remain explicit for \(qK^T\), softmax, and layer normalization [2507.00797].

These cases delimit a useful taxonomy. Strict reduction-free outer-product dataflow assigns outputs so that duplicate partial sums never need distributed reconciliation. Output-stationary accelerators instead eliminate reduction networks by localizing the recurrence. Hybrid dataflows use outer-product scheduling where it improves utilization or layout compatibility, while retaining explicit reductions elsewhere [2606.02333, 2507.00797].

## 5. Sparse matrix multiplication, merge networks, and deferred reduction

In sparse matrix multiplication accelerators, outer product is often valuable precisely because it avoids sparse intersection, but this usually shifts rather than removes reduction. Flexagon states this directly: outer product does not require intersection but does require merging hardware, and possibly extra memory traffic. In its OP(M) organization, a stationary scalar \(a_{m,k}\) multiplies a streamed row fiber \(B_{k,:}\), generating a partial output fiber. These partial fibers are stored in PSRAM and later merged row by row in a Merger-Reduction Network (MRN); if coordinates match, values are accumulated, otherwise the lower coordinate is forwarded [2301.10852].

IOPS reaches a similar conclusion from another direction. Its inner-outer-hybrid product shares \(A\) and \(B\) tiles across the PE array in an inner-product-like fashion, but within each PE it generates outer-product-like sparse partial sums. For SSMM, those irregular psums are not final outputs: after generation, the architecture sorts addresses and column indices and performs an explicit `accum(value_C_tmp, sorted_col_idx_tmp)` stage. The address mapping method is therefore designed to accumulate irregular sparse psum matrices, reducing the latency and DRAM access of psum accumulating rather than eliminating that stage [2312.12766].

SegFold formalizes the same limitation at the dataflow level. It treats conventional outer product as a static \(K\!\to\!M\!\to\!N\) schedule with strong input reuse but poor \(C\) reuse and high irregular reductions. Its Segment dataflow introduces dynamic scheduling over an active window of \(k\) values, selects \((m,k)\) pairs to increase \(B\)-reuse while avoiding same-\(m\) conflicts, and performs on-the-fly element-wise redistribution into a compressed virtual coordinate space for \(C\). This reduces irregular reduction overhead, but the design remains explicitly reduction-aware rather than reduction-free [2606.26701].

Rosko occupies a narrower point in this landscape. It preserves the standard outer-product decomposition
\[
C=\sum_{k=0}^{K-1} A[:,k]\cdot B[k,:]
\]
but observes that if \(A[m,k]=0\), then the entire row \(m\) of the \(k\)-th outer product is zero and can be skipped. Packing time compacts nonzeros column by column into \(A_p\) with metadata arrays `loc_m`, `nnz`, and `col_ind`, so runtime loops traverse only nonzero-induced row updates. This avoids useless partial products and useless accumulations, but multiple outer products still accumulate in place during matrix multiplication [2307.03930].

## 6. Streaming generalizations and adjacent formulations

The idea of replacing explicit reductions by streamed sufficient statistics extends beyond matrix multiplication, but often only in a reduction-reordered sense. In streaming implementations of scaled dot-product attention, the standard row-wise softmax reduction is transformed into online recurrences with a running max \(m_{ij}\), a rescaling factor \(\Delta_{ij}\), a running scalar normalizer \(r_{ij}\), and a running vector numerator \(\vec l_{ij}\). The optimized formulation computes SDPA at full throughput while using constant \(O(1)\) intermediate memory in sequence length, yet the underlying dot products, normalization, and weighted sums remain logically present; they are fused into scans rather than removed [2404.16629].

A related structural shift appears in diffusion Fisher information. The diffusion Fisher resides within a space spanned by outer products of score and initial data, and this outer-product structure enables efficient algorithms for the trace and matrix-vector multiplication of the diffusion Fisher. The exact formulas still contain weighted sums or integrals over outer-product terms, so the result is low-reduction and outer-product-friendly rather than fully reduction-free; practical DF access becomes a sequence of vector norms, dot products, and scaled vector additions instead of autodiff-based Hessian construction [2505.23264].

Matrix-free finite-volume kernels on wafer-scale dataflow hardware provide an adjacent example with a different boundary. The core Jacobian-vector product is a gathered stencil evaluation with local reduction over neighbors, not an outer-product decomposition over faces or edges. Write conflicts and atomics are avoided because each PE owns its output cells, but full CG scaling degrades relative to the pure matrix-free operator because of whole-fabric reductions in the Krylov iteration [2408.03452].

Taken together, these cases separate three notions that are often conflated. Strict reduction-free outer-product dataflow fixes ownership so that duplicate partial sums never require distributed reconciliation. Reduction-network-free architectures keep the algebraic sum but collapse it into local recurrences. Reduction-reordered streaming methods transform batch reductions into online scans and sufficient-statistic updates. The literature shows all three, but only the first fits the strict definition [1210.0461, 2606.02333, 2404.16629].

Source: https://www.emergentmind.com/topics/reduction-free-outer-product-dataflow