As Moore’s Law and Dennard scaling slow down, general-purpose processors can no longer deliver the exponential performance gains required by modern workloads. To sustain progress, the hardware industry has shifted toward domain-specific accelerators (DSAs). However, as Sabrina M. Neuman et al. observe in Invited: The Magnificent Seven Challenges and Opportunities in Domain-Specific Accelerator Design for Autonomous Systems, designing customized hardware introduces a massive engineering bottleneck.
When designing an accelerator, an engineer must choose from an astronomical number of microarchitectural configurations: the number of processing elements, cache capacities, buffer depths, loop tiling factors, and interconnect topologies. This creates an exponential configuration space—a "hardware configuration explosion." Historically, navigating this space has relied on human intuition. As Meng Liu notes, tasks like selecting specific hardware instructions to accelerate software have traditionally been manual and ad-hoc rather than formally optimized. Human designers often default to standard rules of thumb, which Deming Chen demonstrates in HIDA: A Hierarchical Dataflow Compiler for High-Level Synthesis can inadvertently prune the most optimal design points.
Automated Design Space Exploration (DSE) solves this problem by turning hardware design into an algorithmic optimization problem. To make this search tractable, automated DSE frameworks rely on three core pillars: pruning invalid designs, bypassing slow simulations with fast estimators, and navigating high-dimensional spaces using intelligent search heuristics.
Pillar 1: Pruning the Space via Formal Constraints
The configuration space for hardware accelerators is vast, but the vast majority of possible configurations are fundamentally flawed or highly inefficient. Evaluating every combination is a waste of compute.
To address this, researchers use formal constraints to filter out invalid designs before they are ever simulated. Rachit Nigam et al. demonstrate this principle in Predictable Accelerator Design with Time-Sensitive Affine Types by embedding physical hardware constraints directly into a programming language's type system. By rejecting programs that violate hardware realities—such as attempting to access a single memory port twice in the same clock cycle—the search space is drastically restricted to structurally sound architectures.
For complex, heterogeneous systems, mathematical optimization techniques can enforce these boundaries. Giovanni Agosta et al. employ Mixed-Integer Linear Programming (MILP) and Boolean Satisfiability Modulo Theories (SMT) solvers to mathematically rule out illegal network topologies and chip layouts. By formalizing physical constraints up front, the exploration engine can focus exclusively on viable, high-performance candidates.
Pillar 2: Bypassing the Simulation Bottleneck
Even within a pruned search space, evaluating a single design point using traditional, cycle-accurate Register-Transfer Level (RTL) simulation can take hours or days. To evaluate millions of configurations, automated DSE must replace slow physical simulations with rapid, high-fidelity estimators.
Analytical Cost Models
One approach is to build mathematical models that capture the physics and dataflow of the hardware. Hyoukjun Kwon et al. introduced MAESTRO: A Data-Centric Approach to Understand Reuse, Performance, and Hardware Cost of DNN Mappings, an analytical cost model that analyzes data reuse patterns. MAESTRO estimates accelerator performance and energy efficiency within 3.9% of cycle-accurate RTL simulation while running up to 4,000× faster. Similarly, Weng-Fai Wong et al. combined queuing theory with dynamic power models to co-optimize superscalar processors, bypassing cycle-accurate simulation entirely to predict power consumption within 11% accuracy of industry tools. At the system level, the Daedalus framework, presented by Hristo N. Nikolov et al., uses high-level architectural simulation to rapidly evaluate application-to-hardware mappings and processor counts before physical implementation.
Data-Driven Surrogate Models
Instead of deriving mathematical formulas for hardware behavior, machine learning can be used to predict performance based on historical data. Aviral Kumar et al. developed PRIME, an offline optimization method that learns a "conservative" surrogate model using only logged simulation data. This eliminates the need to query active simulators during the search process, reducing total simulation time by 93% to 99%. In heterogeneous systems, Rekha Singhal et al. utilized active learning to build surrogate models that predict performance-power trade-offs, avoiding the need to exhaustively simulate every possible execution plan.
However, as Yunsheng Bai et al. point out in Towards a Comprehensive Benchmark for High-Level Synthesis Targeted to FPGAs, the ultimate goal is to move away from static quality prediction and integrate these fast surrogate models directly into active, iterative search loops.
Pillar 3: Intelligent Space Traversal
Once evaluation takes milliseconds rather than hours, the framework needs an intelligent strategy to navigate the remaining high-dimensional space. Blind grid searches or random walks are highly inefficient.
Bottleneck-Guided Search
General-purpose optimization algorithms often lack hardware awareness. To solve this, Atefeh Sohrabizadeh et al. developed AutoDSE: Enabling Software Programmers Design Efficient FPGA Accelerators, which introduces a "bottleneck-guided" optimizer. Instead of randomly tweaking parameters, the algorithm identifies the primary factor limiting performance—such as a memory stall or a compute bottleneck—and specifically adjusts the parameters tied to that issue. This semantic awareness allows the search engine to navigate massive design spaces far more effectively than generic optimization routines.
Black-Box and Heuristic Optimization
When analytical gradients are unavailable, black-box optimization algorithms are highly effective:
- Bayesian Optimization: Used by Chongxiao Li et al. in the AGON framework to automatically balance microarchitectural trade-offs, such as cache sizes and buffer depths, when customizing out-of-order processors.
- Genetic Algorithms: Applied by Haoyi Zhang et al. in EasyACIM to handle the noisy, multi-objective design space of analog computing-in-memory layouts, balancing signal-to-noise ratios against area and power.
- Greedy Approaches: Zhewen Yu et al. demonstrated that a greedy approach can successfully navigate the complex trade-offs between compute, on-chip memory, and off-chip bandwidth in weight-streaming DNN accelerators.
- Neighbor-Traversing Heuristics: Integrated by Hanchen Ye et al. into ScaleHLS to rapidly evaluate millions of configurations within minutes.
Structural Rewriting
Optimization can also occur at the structural level. Samuel Coward et al. developed ROVER, a tool that uses equality graphs (e-graphs) to optimize circuits. By treating power-saving techniques like clock gating and operand isolation as local "rewrites," ROVER explores an expansive space of equivalent circuits to find non-intuitive architectures that optimize power and area simultaneously.
Applications and End-to-End Frameworks
Automated DSE frameworks have proven that algorithmic search can discover Pareto-optimal hardware configurations that surpass the performance of expert human designs.
+-------------------------+
| High-Level Framework | (e.g., PyTorch, MLIR, Natural Language)
+------------+------------+
|
v
+-------------------------+ +-------------------------+
| Automated Design Space | <--> | Fast Surrogate Models / |
| Exploration Engine | | Analytical Estimators |
+------------+------------+ +-------------------------+
|
v
+-------------------------+
| Optimized Hardware RTL | (e.g., Synthesizable Verilog/VHDL)
+-------------------------+
In the domain of deep learning, Pengfei Xu et al. developed AutoDNNchip, an end-to-end framework that compiles high-level PyTorch models into optimized, synthesizable RTL for FPGAs and ASICs, outperforming expert-crafted accelerators. Similarly, Petros Toupas et al. developed HARFLOW3D to automatically determine optimal tiling and folding factors for 3D-CNNs on FPGAs. For graph workloads, Yi-Chien Lin et al. built HitGNN, which automatically configures processing element counts to match the memory access patterns of specific graph neural networks. For edge deployments, Shvetank Prakash et al. introduced CFU Playground, an open-source framework that automates the search for optimal cache and functional unit configurations to accelerate TinyML applications on RISC-V soft cores. Bruno Sá et al. applied similar microarchitectural exploration to optimize buffer sizes and ISA extensions for RISC-V virtualization.
Beyond raw performance, automated DSE is highly effective for hardware security. Chiara Muscari Tomajoli et al. introduced ALICE, a framework for embedded FPGA (eFPGA) redaction that protects intellectual property by hiding critical logic inside reconfigurable fabrics. ALICE explores thousands of configurations to maximize security resilience while minimizing hardware overhead. Luca Collini et al. extended this work with ARIANNA, proving that heuristic search strategies can achieve area and power efficiencies nearly identical to exhaustive searches when customizing logic block parameters.
Future Directions
The field is currently moving toward autonomous, natural-language-driven hardware design. Zhuolun He et al. introduced ChatEDA, an autonomous agent powered by Large Language Models (LLMs). Instead of requiring hardware engineers to manually write optimization scripts, ChatEDA allows designers to express high-level performance constraints in natural language. The agent then autonomously generates scripts containing loops and conditional logic to explore the underlying Electronic Design Automation (EDA) toolchains.
While automation has advanced significantly for dataflow and microarchitectural tuning, gaps still remain. Mengyuan Yin et al. point out that higher-level architectural decisions—such as automatically choosing between traditional arithmetic computation and lookup-table-based acceleration based on model characteristics—are not yet fully automated. Expanding DSE frameworks to handle these hybrid, structural paradigm shifts represents the next major frontier in automated hardware design.
Key Foundational Work
Co-optimization of Performance and Power in a Superscalar Processor Design (2006) — contributed 1 concept elements to this direction.
ILP and heuristic techniques for system-level design on network processor architectures (2007) — contributed 1 concept elements to this direction.