Exposed Datapath Architectures

17 concepts11 papers1 proposal

In traditional processor design, the Instruction Set Architecture (I-S-A) acts as a strict abstraction layer that hides the underlying hardware implementation. The hardware is entirely responsible for managing internal execution details: it dynamically detects data hazards, schedules operations, and routes operands through internal bypass networks.

To maintain this illusion of a sequential, centralized machine, modern processors dedicate a massive amount of silicon area and power to control logic. Multi-ported centralized register files, tag-matching arrays, and complex bypass multiplexers consume a significant portion of the processor's energy budget. As Bill Dally demonstrates in An Energy-Efficient Processor Architecture for Embedded Systems, this hardware-managed overhead severely limits energy efficiency.

Exposed datapath architectures eliminate this overhead by removing the traditional I-S-A abstraction. Instead of hiding the internal routing networks, they expose them directly to the software. By shifting the responsibility of scheduling, hazard detection, and data movement from dynamic hardware controllers to the compiler, these architectures drastically reduce power consumption while unlocking fine-grained parallelism.

Transport-Triggered Execution

To understand how an exposed datapath works, it helps to contrast its programming model with a conventional operation-based processor. In a standard architecture, an instruction specifies an operation (such as an addition) and the source and destination registers:

$$\text{ADD } R_1, R_2 \rightarrow R_3$$

The hardware decoder must interpret this instruction, fetch the operands from the register file, route them to an Arithmetic Logic Unit (A-L-U), and ensure the result is written back safely.

In a Transport-Triggered Architecture (T-T-A), this paradigm is inverted. The instruction set is stripped down to a single type of command: a data move. Instructions explicitly specify the movement of data between functional unit ports rather than operations. Computation occurs as a structural side effect of moving data to a designated "trigger" port.

As Sven Gesper et al. explain in Evaluation of Different Processor Architecture Organizations for On-Site Electronics in Harsh Environments, a functional unit in a T-T-A features operand ports and a trigger port. To perform an addition, the compiler schedules two distinct moves:

$$\text{MOVE } X \rightarrow \text{ALU.operand}$$ $$\text{MOVE } Y \rightarrow \text{ALU.trigger}$$

The moment data arrives at the trigger port, the functional unit automatically executes the associated arithmetic or logic operation. This uniform programming model drastically simplifies the instruction set and eliminates the energy-intensive hardware required for instruction decoding and execution control.

Bypassing the Central Register File

In a conventional processor, when the output of one operation is required by the next, the data is typically written back to a centralized register file and subsequently read out. Even when hardware bypassing is implemented to mitigate latency, the data must still travel to and from the central register file, creating a major energy bottleneck due to high port counts and global wiring.

Exposed datapaths solve this by enabling software-managed data forwarding. Pekka Jääskeläinen and Jani Boutellier emphasize in Data Intensive Computing: From Modeling to Implementation that giving the compiler direct control over internal bypass networks allows data to move directly from the output port of one functional unit to the input port of another.

Because the compiler knows exactly when and where data is produced, it can route an operand directly to its next destination:

$$\text{MOVE } \text{ALU}_1.\text{out} \rightarrow \text{ALU}_2.\text{operand}$$

This mechanism completely bypasses the central register file for short-term data storage. As the authors note, minimizing frequent accesses to the centralized register file significantly lowers power consumption and eliminates the performance bottlenecks caused by limited register file ports.

Shifting Complexity to the Compiler

By exposing the pipeline and interconnects, the hardware no longer needs to dynamically detect data hazards or manage structural conflicts. The compiler possesses perfect knowledge of the exact latency of every functional unit and schedules moves precisely when the data is ready. This philosophy of software-managed hardware control manifests across multiple layers of the architecture:

Efficiency Gains and Automation

The primary driver behind exposing the datapath is achieving extreme energy efficiency and throughput without sacrificing programmability. For example, Mehdi Safarpour et al. leverage T-T-As in Transport Triggered Array Processor for Vision Applications to build ultra-low-power array processors for computer vision, demonstrating that exposing the internal bypass network simplifies control logic enough to operate efficiently in near-threshold voltage regimes. Similarly, in streaming accelerators, a small control core can be paired with specialized co-processors to orchestrate data movement via D-M-A engines, as demonstrated by Fabian Schuiki et al. in NTX: An Energy-efficient Streaming Accelerator for Floating-point Generalized Reduction Workloads in 22 nm FD-SOI.

Furthermore, removing the rigid I-S-A abstraction allows the hardware to be tailored precisely to application data flows. Shoaib Akram et al. show in VEBoC: Variation and error-aware design for billions of devices on a chip that replacing traditional instruction decoding with direct microcode control over functional unit arrays enables high fine-grained parallelism.

To make these architectures practical, modern High-Level Synthesis (H-L-S) tools automate the design process. As Alex Hirvonen et al. demonstrate with the AEx tool in AEx: Automated High-Level Synthesis of Compiler Programmable Co-Processors, it is possible to automatically generate compiler-programmable co-processors based on T-T-A. This bridges the gap between rigid, fixed-function hardware accelerators and general-purpose CPUs, providing a scalable path toward highly efficient, software-customized silicon.

Key Foundational Work

An Energy-Efficient Processor Architecture for Embedded Systems (2008) — contributed 3 concept elements to this direction.
VEBoC: Variation and error-aware design for billions of devices on a chip (2008) — contributed 1 concept elements to this direction.
Architecture-level synthesis for automatic interconnect pipelining (2004) — 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_exposed_datapath_architecture_1a9d257c,
  title = {exposed datapath architecture},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/exposed-datapath-architecture/rdr_1a9d257ca162485083b022bc66f8cd46},
  note = {Latest version of a living research direction; cite a version for a fixed text. Accessed 2026-11-19},
}

This exact version (version 1, frozen text):

@misc{lacuna_exposed_datapath_architecture_1a9d257c_v1,
  title = {exposed datapath architecture},
  author = {{Lacuna}},
  howpublished = {Lacuna research direction},
  year = {2026},
  url = {https://lacuna.tiptreesystems.com/direction/exposed-datapath-architecture/rdr_1a9d257ca162485083b022bc66f8cd46/v/1},
  note = {Version 1, frozen 2026-10-04. Accessed 2026-11-19},
}
About

These directions overlap with this one through shared papers.

See something wrong? Report a mistake