Reduction-Free Outer-Product Dataflow

• Reduction-Free Outer-Product Dataflow is a computation model that assigns fixed ownership to each output coordinate, ensuring all partial outer products are accumulated locally.
• The method avoids inter-processor reduction by hashing output indices consistently, thereby minimizing communication overhead and synchronizations.
• Architectural realizations like O-POPE exemplify this approach by leveraging local recurrences and pipelined FPU updates to achieve high throughput and near-linear speedup.

Searching arXiv for the cited papers to ground the article and verify metadata. arXiv search: (Sai et al., 2024) "Matrix-Free Finite Volume Kernels on a Dataflow Architecture" arXiv search: (Campagna et al., 2012) "On Parallelizing Matrix Multiplication by the Column-Row Method" arXiv search: (Cammarata et al., 1 Jun 2026) "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 (Campagna et al., 2012). 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 (Sai et al., 2024).

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 $(i,j)$0 or on the structure of any particular outer product, so all terms in $(i,j)$1 arrive at the same owner (Campagna et al., 2012).

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 (Campagna et al., 2012).

A mathematically older but structurally related perspective appears in the MoA and $(i,j)$2-calculus treatment of tensor and Kronecker products. There the outer product of arrays has shape given by concatenation, $(i,j)$3, 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 $(i,j)$4 it computes only the subset of pairs whose hash lies in its assigned interval. Because the same $(i,j)$5 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 (Campagna et al., 2012).

This ownership rule would be of limited use if each processor had to inspect all $(i,j)$6 pairs in every outer product. The key technical result is that, given sparse vectors $(i,j)$7 and $(i,j)$8 with $(i,j)$9 nonzeros each and a bucket interval $(AB)_{ij}$0, the set $(AB)_{ij}$1 of entries in $(AB)_{ij}$2 hashing to $(AB)_{ij}$3 can be constructed in expected time

$(AB)_{ij}$4

The implementation sorts nonzero indices of $(AB)_{ij}$5 by $(AB)_{ij}$6, sorts nonzero indices of $(AB)_{ij}$7 by $(AB)_{ij}$8, and sweeps through the corresponding ordered lists (Campagna et al., 2012).

Load balance follows from the same hash structure. If $(AB)_{ij}$9 instances run on disjoint intervals, expected work per instance on outer product $A,B\in\mathbb{R}^{n\times n}$0 is $A,B\in\mathbb{R}^{n\times n}$1, 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 (Campagna et al., 2012).

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 (Campagna et al., 2012).

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
(Campagna et al., 2012)	Consistent hash ownership of output coordinates across outer products	Reduction-free across processors for output accumulation
(Sai et al., 2024)	Cell-based gather with owner-computes local reduction	Avoids write conflicts, not reduction-free overall
(Sun et al., 2023)	Hybrid inner/outer-product SpMM with address mapping	Explicit sparse psum accumulation
(Muñoz-Martínez et al., 2023)	Selectable IP/OP/Gust with Merger-Reduction Network	Outer product is intersection-free but merge-requiring
(Natesh et al., 2023)	Row-skipping outer products	Skips zero-induced updates, retains $A,B\in\mathbb{R}^{n\times n}$2-dimension accumulation
(Sohn et al., 2024)	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 $A,B\in\mathbb{R}^{n\times n}$3 column and computes outputs only for its own cells, so atomic updates and race conditions are avoided. However, the operator is still

$A,B\in\mathbb{R}^{n\times n}$4

for unconstrained cells, which is a local sum over neighbors, and the conjugate-gradient solver still requires whole-fabric dot-product reductions for $A,B\in\mathbb{R}^{n\times n}$5 and $A,B\in\mathbb{R}^{n\times n}$6 (Sai et al., 2024).

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

$A,B\in\mathbb{R}^{n\times n}$7

so the reduction over $A,B\in\mathbb{R}^{n\times n}$8 remains present as a local pipelined recurrence rather than disappearing algebraically (Cammarata et al., 1 Jun 2026).

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 $A,B\in\mathbb{R}^{n\times n}$9 mesh of processing elements, with row-wise broadcast of $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$0 operands, column-wise broadcast of $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$1 operands, and stationary output tiles $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$2. 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 (Cammarata et al., 1 Jun 2026).

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,

$(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$3

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 (Cammarata et al., 1 Jun 2026).

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 $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$4 is mapped to an inner-product style configuration with a two-level adder tree, while attention-value multiplication $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$5 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 $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$6, but reductions remain explicit for $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$7, softmax, and layer normalization (Wang et al., 1 Jul 2025).

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 (Cammarata et al., 1 Jun 2026, Wang et al., 1 Jul 2025).

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 $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$8 multiplies a streamed row fiber $(AB)_{ij}=\sum_{k=0}^{n-1} a_k(i)b_k(j),$9, 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 (Muñoz-Martínez et al., 2023).

IOPS reaches a similar conclusion from another direction. Its inner-outer-hybrid product shares $AB=\sum_{k=0}^{n-1} a_k b_k.$0 and $AB=\sum_{k=0}^{n-1} a_k b_k.$1 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 (Sun et al., 2023).

SegFold formalizes the same limitation at the dataflow level. It treats conventional outer product as a static $AB=\sum_{k=0}^{n-1} a_k b_k.$2 schedule with strong input reuse but poor $AB=\sum_{k=0}^{n-1} a_k b_k.$3 reuse and high irregular reductions. Its Segment dataflow introduces dynamic scheduling over an active window of $AB=\sum_{k=0}^{n-1} a_k b_k.$4 values, selects $AB=\sum_{k=0}^{n-1} a_k b_k.$5 pairs to increase $AB=\sum_{k=0}^{n-1} a_k b_k.$6-reuse while avoiding same-$AB=\sum_{k=0}^{n-1} a_k b_k.$7 conflicts, and performs on-the-fly element-wise redistribution into a compressed virtual coordinate space for $AB=\sum_{k=0}^{n-1} a_k b_k.$8. This reduces irregular reduction overhead, but the design remains explicitly reduction-aware rather than reduction-free (Wu et al., 25 Jun 2026).

Rosko occupies a narrower point in this landscape. It preserves the standard outer-product decomposition

$AB=\sum_{k=0}^{n-1} a_k b_k.$9

but observes that if $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$0, then the entire row $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$1 of the $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$2-th outer product is zero and can be skipped. Packing time compacts nonzeros column by column into $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$3 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 (Natesh et al., 2023).

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 $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$4, a rescaling factor $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$5, a running scalar normalizer $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$6, and a running vector numerator $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$7. The optimized formulation computes SDPA at full throughput while using constant $h(i,j)=\big(h_a(i)+h_b(j)\big)\bmod \kappa,$8 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 (Sohn et al., 2024).

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 (Wang et al., 29 May 2025).

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 (Sai et al., 2024).

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 (Campagna et al., 2012, Cammarata et al., 1 Jun 2026, Sohn et al., 2024).