Spatial Dataflow Architectures

18 concepts15 papers1 proposal

The Core Shift: From Time to Space

In a traditional temporal architecture—such as a standard CPU or GPU—computation is organized around time. The physical hardware remains static, while a sequence of instructions streams through it clock cycle by clock cycle. To execute an algorithm, data must be repeatedly fetched from memory, loaded into registers, operated on by an Arithmetic Logic Unit (ALU), and written back. This constant shuffling of data creates a massive energy and latency bottleneck known as the von Neumann bottleneck.

Spatial dataflow architectures invert this paradigm. Instead of streaming instructions through fixed hardware, they configure the hardware logic itself to match the specific data flow of an algorithm. As Wenqi Jiang et al. outline in Data Processing with FPGAs on Modern Architectures, spatial computing maps different stages of a computation to dedicated, physical resources across a chip. The computational graph is laid out directly onto a grid of processing elements (PEs). Data streams through this physical pipeline, transforming at each step and flowing directly from one compute unit to the next without needing to return to a centralized register file or main memory.

Chuliang Weng et al. note in The impact of data flow computing thinking on the development of computer architecture that this spatial dataflow approach drastically cuts down energy consumption and boosts throughput. By eliminating the overhead of instruction fetching and decoding, and by keeping data moving along localized physical paths, spatial architectures achieve extreme efficiency for workloads with highly predictable data movement patterns, such as deep learning and signal processing.

Eliminating Caches via Localized Memory

Why does this spatial arrangement save so much energy? In traditional architectures, a significant fraction of the power budget is spent not on computation itself, but on moving data through complex, multi-tiered cache hierarchies. Spatial architectures replace these generic, reactive hierarchies with application-specific, proactive dataflows.

The authors of Transformations of High-Level Synthesis Codes for High-Performance Computing explain that spatial architectures manage data locality by using localized structures like shift registers and line buffers to stream data directly between processing elements. This keeps information "in motion" through the chip logic, minimizing the energy cost and latency associated with repeated memory fetches.

Traditional (Temporal):  [Memory/Cache] <---> [Registers] <---> [ALU] (Repeated over time)

Spatial Dataflow:        [Input Stream] ---> [PE 1] ---> [PE 2] ---> [PE 3] ---> [Output Stream]
                                               ^          ^          ^
                                            [Local]    [Local]    [Local]
                                            [Mem]      [Mem]      [Mem]

Vivienne Sze et al. emphasize in Hardware for machine learning: Challenges and opportunities that embedding localized memory directly within individual processing elements optimizes data movement by performing computations closer to where data is stored. Similarly, Maurizio Capra explains in Hardware and Software Optimizations for Accelerating Deep Neural Networks: Survey of Current Trends, Challenges, and the Road Ahead that arrays of processing elements facilitate direct data movement between units. This design minimizes energy-intensive memory access by keeping data local to the compute units during execution.

To push this efficiency further, hardware layouts can leverage direct memory sharing between adjacent compute tiles. Endri Taka et al. demonstrate in MaxEVA: Maximizing the Efficiency of Matrix Multiplication on Versal AI Engine that this direct sharing bypasses the overhead of Direct Memory Access (DMA) or complex stream switches. By utilizing specific hardware layout patterns, neighboring cores can transfer data efficiently and avoid routing congestion.

The Compilation Challenge: Mapping Graphs to Physical Grids

Because a spatial architecture relies on the physical layout of its hardware to execute logic, running software requires a fundamentally different type of compiler. Instead of compiling code into a linear sequence of instructions, a spatial compiler must translate an abstract software-defined dataflow graph into a physical hardware layout.

Huanchen Zhang describes this in The End of the x86 Dominance in Databases? as establishing a near one-to-one correspondence between software nodes and physical processing elements. When the compiler maps software logic directly to a grid of heterogeneous processing elements, the hardware acts as a direct extension of the software logic, allowing performance to scale automatically with improvements in software-level code generation.

This mapping requires solving complex placement and routing problems. As Hongwu Peng et al. observe in Evaluating Emerging AI/ML Accelerators: IPU, RDU, and NVIDIA/AMD GPUs, spatial compilers must carefully manage the placement and routing of data between processing elements to ensure efficient utilization of parallel resources.

Furthermore, this mapping can happen across both space and time. Florian Dittmann demonstrates in Temporal Graph Placement on Mesh-Based Coarse Grain Reconfigurable Systems Using the Spectral Method that integrating spatial optimization with temporal scheduling ensures data-dependent tasks remain in physical proximity even as the underlying hardware reconfigures over time. This synergy reduces the number of hops data must travel between processing elements, minimizing communication overhead.

Historically, this concept extends back to early hardware-software co-design tools. For instance, M. Freericks et al. developed a retargetable toolchain in Implementation of Complex DSP Systems Using High-Level Design Tools that maps abstract control-data-flow graphs to specific hardware instructions through automated expansion, chaining, and scheduling, allowing software and hardware to be updated in tandem.

Data-Centric Orchestration and Memory Alignment

Laying out the compute units is only half the battle; the system must also orchestrate how data enters the chip from external memory. If the data-fetching pattern does not match the physical layout of memory, the processing elements will stall, starving the pipeline.

To address this, Gong Chen et al. propose a compiler-directed strategy in Exploiting On-Chip Data Transfers for Improving Performance of Chip-Scale Multiprocessors that prioritizes physical memory layout over individual processor requirements. By fetching contiguous blocks collectively to maximize spatial locality at the memory interface and then redistributing them via fast on-chip links, the system minimizes expensive off-chip traffic and bus contention.

To formalize and reason about these complex data movements, Hyoukjun Kwon et al. introduced a data-centric directive notation in MAESTRO: A Data-Centric Approach to Understand Reuse, Performance, and Hardware Cost of DNN Mappings. This framework uses explicit spatial and temporal mapping primitives to capture data distribution and reuse across hardware resources without relying on implicit loop-nest representations, allowing hardware designers to easily explore the design space.

Application Domains: From Vision to Modern AI

When properly aligned, spatial dataflow architectures can easily outperform high-performance, general-purpose processors on memory-bound workloads. Tiziano De Matteis et al. demonstrate in FBLAS: Streaming Linear Algebra on FPGA that by utilizing direct data flow between processing units, spatial architectures outperform high-performance CPUs in linear algebra routines even with comparable memory bandwidth, yielding massive energy savings.

This paradigm dates back to early real-time vision systems. A. Benedetti et al. showed in A novel system architecture for real-time low-level vision that aligning physical hardware routing with the raster-scan sequence of streaming data maximizes throughput. This approach exploits the inherent spatial locality of image processing by matching the memory architecture directly to the sequential flow of pixel data.

Modern workloads, however, require more complex data routing than simple raster scans. For example, State-Space Models (SSMs) require fast Fourier transforms (FFTs) and scan operations. To handle this, Sho Ko introduces an enhanced reconfigurable architecture in SSM-RDU: A Reconfigurable Dataflow Unit for Long-Sequence State-Space Models that adds specialized "butterfly" and "cross-lane" interconnects to a grid of compute and memory units. This allows the hardware to be dynamically rewired to match the specific dataflow of long-sequence models, enabling spatial execution that completely bypasses discrete instruction fetching and temporal processing overhead.

Key Foundational Work

A novel system architecture for real-time low-level vision (1999) — contributed 2 concept elements to this direction.
Implementation of Complex DSP Systems Using High-Level Design Tools (1995) — contributed 1 concept elements to this direction.
History & citationVersion 1 · 2026-10-04

Current · Permanent link

View frozen version 1

Cite this direction

Latest version (a living page):

@misc{lacuna_spatial_computing_380c2d46,
  title = {spatial computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/spatial-computing/rdr_380c2d460d1d4cb8b7a5d3ee9a6926e8},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-20},
}

This exact version (version 1, frozen text):

@misc{lacuna_spatial_computing_380c2d46_v1,
  title = {spatial computing},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/spatial-computing/rdr_380c2d460d1d4cb8b7a5d3ee9a6926e8/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-20},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake