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:
- Instruction Buffering: Rather than relying on power-hungry hardware cache controllers to manage loops, architectures designed by Joonas Multanen et al. in Energy Efficient Low Latency Multi-issue Cores for Intelligent Always-On IoT Applications utilize a software-managed Instruction Register File (I-R-F). The compiler explicitly manages the presence of instructions within this low-power local buffer, avoiding the energy costs of hardware cache lookups and main memory fetches.
- On-Chip Routing: This software-defined routing extends beyond individual cores to the interconnect network. Bo Wang et al. demonstrate in Shenjing: A low power reconfigurable neuromorphic accelerator with partial-sum and spike networks-on-chip that offloading routing logic to a software compiler enables the use of ultra-lightweight, bufferless routers. Static scheduling replaces complex hardware flow control, maximizing communication efficiency.
- Pipeline Synthesis: At the microarchitectural level, optimizations can be tightly integrated with hardware synthesis. Yiping Fan et al. show in Architecture-level synthesis for automatic interconnect pipelining how incorporating autonomous pipeline registers along global interconnects simplifies control logic during synthesis. Complementing this, compiler optimizations like operation chaining across conditional boundaries—explored by Sumit Gupta et al. in Coordinated parallelizing compiler optimizations and high-level synthesis—link operations across basic blocks without intermediate registers, further reducing register pressure.
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.