💻 computer science

OneDSE: Metric-Conditioned Inverse Modeling and Active Search for Sample-Efficient DSE

This paper introduces OneDSE, a sample-efficient framework for CPU and hardware design space exploration that unifies metric-conditioned inverse design (MIND) and a surrogate-assisted active search loop (SAIL) to rapidly identify high-quality designs with significantly fewer evaluations than existing methods.

Original authors: Ritik Raj, Akshat Ramachandran, Danny Samuel, Jeff Nye, Shashank Nemawarkar, Tushar Krishna

Published 2026-08-19

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Ritik Raj, Akshat Ramachandran, Danny Samuel, Jeff Nye, Shashank Nemawarkar, Tushar Krishna

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Modern computers are the engines of our digital world, powering everything from the smartphones in our pockets to the massive data centers that run the internet. For decades, these machines got faster and more efficient simply by shrinking the tiny transistors inside their chips, a trend known as Moore's Law. However, that physical shrinking has hit a wall; we can no longer make the components much smaller without running into fundamental limits of physics and power consumption. To keep improving performance, engineers must now innovate in the design itself, rearranging the internal architecture of the processor to do more work with the same amount of energy. This process, called design space exploration, involves testing countless combinations of settings—such as the size of memory caches or the width of data pathways—to find the perfect configuration. The problem is that the number of possible combinations is so vast, roughly a trillion trillion, that testing them one by one is impossible, even with the fastest supercomputers.

For years, the standard approach to this problem has been to guess a design, run a detailed simulation to see how it performs, and then use that result to guess the next design. It is a forward-looking process: "If I build it this way, what will happen?" But this method is incredibly slow and often gets stuck in local traps, missing better solutions that require changing many parts of the design at once. A team of researchers at Georgia Tech, the University of Michigan, and Condor Computing has proposed a radical shift in strategy. Instead of asking what a design will achieve, they ask the reverse question: "What design do I need to build to achieve these specific performance goals?" By flipping the problem around, they created a system called OneDSE that can find high-quality processor designs with a fraction of the computational effort previously required.

The core of this new system relies on a deep understanding of how a processor interacts with the software it runs. A processor's performance is not just about its own internal settings; it is also heavily dependent on the specific tasks it is asked to perform. The researchers found that if you tell the system exactly what kind of work the processor will be doing—by feeding it a detailed record of the instructions the software executes—the system can predict the necessary hardware design with remarkable accuracy. They trained a sophisticated computer model, a type of artificial intelligence known as a transformer, on a large collection of random processor designs and their performance results. This model learned to map specific performance targets, such as a desired speed and a limit on physical size, directly back to the specific hardware settings needed to hit those targets.

In their tests, this inverse approach proved to be startlingly efficient. When the researchers asked the system to find designs for five different complex workloads, it identified top-tier configurations after running only a handful of detailed simulations, sometimes as few as one to fifty-eight. In contrast, traditional methods, which rely on evolutionary algorithms that slowly mutate designs over thousands of attempts, needed dozens or even hundreds of times more simulations to find designs of comparable quality. For example, on one specific workload, the new system found a design in just a few minutes that the traditional method took nearly a thousand times longer to match. The system works by sweeping through a range of desired performance goals and instantly generating the corresponding hardware blueprint, bypassing the need to wander blindly through the vast landscape of possibilities.

However, the researchers recognized that a single prediction, no matter how good, might not be perfect. To ensure they could reach the absolute best possible designs, they built a second layer around their prediction model called a measurement loop. This system uses the initial predictions as a starting point but then employs a set of coordinated tools to make larger, more strategic changes to the design. Traditional search methods often fail because they try to improve a design by changing just one small part at a time. But in processor design, a better solution often requires changing many parts simultaneously—like widening the data intake while also expanding the memory storage and the processing queue to match. If you change only one part, the system often performs worse, creating a valley that traps the search. The new system's coordinated tools allow it to jump across these valleys by adjusting multiple settings at once, guided by the initial predictions to stay on the right path.

The results of this combined approach were decisive. Using only 512 detailed simulations, the system reached a level of performance that was 98% of the best possible design found by a traditional method that ran 6,400 simulations. In some cases, it even surpassed the traditional method's best results. Crucially, the designs it found were entirely new; the system discovered configurations that the traditional method had never even considered. The researchers also demonstrated that this approach is not limited to just central processors. They successfully applied the same technique to design controllers for computer memory and even for specialized chips used in artificial intelligence, showing that the method is flexible enough to handle different types of hardware challenges.

This work represents a significant step forward in how engineers approach the future of computing. By reversing the traditional design process and using the workload itself as a guide, the researchers have shown that it is possible to navigate the immense complexity of modern chip design with far fewer resources. The system does not just save time; it opens up new possibilities for finding optimal designs that were previously hidden because the search methods were too slow or too rigid to find them. As the demand for faster and more efficient computing continues to grow, tools like this will be essential for unlocking the next generation of technological innovation without waiting for the laws of physics to change.

Technical Summary: OneDSE

Problem Statement

Modern high-performance processor design is hindered by the slowing of Moore's Law and tightening power constraints, necessitating complex microarchitectural innovation. However, the resulting Design Space Exploration (DSE) faces two critical challenges:

Directional Mismatch (Short-Horizon): Existing approaches rely on forward-only prediction models ( $f: (\theta, w) \to m$ ) that estimate metrics ( $m$ ) from design parameters ( $\theta$ ) for a given workload ( $w$ ). Designers, however, start with metric targets and need to find the corresponding designs. Inverting this relationship is statistically difficult because multiple design-workload pairs can alias to the same metrics, and prior methods often ignore workload context or treat it as a fixed set.
Sample Inefficiency (Long-Horizon): Cycle-accurate simulators (e.g., gem5) are computationally expensive (approx. 212 seconds per evaluation). The design space for modern out-of-order cores is vast (approx. $10^{34}$ combinations for 64 parameters). Traditional metaheuristics like Genetic Algorithms (GA) require thousands of evaluations to converge. Furthermore, high-fitness designs often lie beyond "mutation barriers," requiring coordinated changes to multiple parameters (e.g., widening the front end while scaling back-end resources) to yield improvements. Local search methods often receive negative reinforcement when traversing these valleys, stalling exploration.

Methodology

The paper presents OneDSE, a framework that unifies short-horizon prediction and long-horizon optimization by reframing DSE as an inverse design problem. It consists of two primary components:

1. OneDSE-MIND (Metric-conditioned INverse Design)

OneDSE-MIND learns the inverse map $g: (m, w) \to \theta$ , predicting the design configuration required to achieve specific target metrics on a specific workload.

Workload Conditioning: Instead of using a static workload ID, the model conditions on the execution trace itself. The workload is tokenized into instruction chunks, embedded, and processed by an encoder-only transformer using instruction-window attention. This attention mechanism mirrors the out-of-order execution window, capturing the interactions between in-flight instructions that determine latency.
Information-Theoretic Basis: The authors demonstrate that conditioning on the workload increases the mutual information between metrics and design parameters by 12–32%. This resolves the ambiguity of the inverse problem, making the mapping tractable.
Reward-Guided Fine-Tuning: The initial supervised regression model is conservative, predicting designs near the mean of the training corpus. To reach the Pareto frontier, the model undergoes fine-tuning using a REINFORCE objective. A gradient-boosted surrogate acts as a reward function, pushing predictions toward high-fitness designs without requiring cycle-accurate simulation during the training loop.

2. OneDSE-SAIL (Surrogate-Assisted Inverse Loop)

OneDSE-SAIL embeds OneDSE-MIND into a measurement loop to address the long-horizon exploration challenge.

Hybrid Proposal Generation: The loop generates a candidate pool of 20,000 designs per round using:
- Metric-Targeted Inverse Proposals: OneDSE-MIND predicts designs for target metrics derived from the current Pareto frontier and extrapolated targets.
- Coordinated Operators: To cross "barriers" where single-parameter mutations fail, the system employs operators that change multiple parameters simultaneously, such as elite crossover, path-relinking, and balanced width-group scaling (e.g., scaling all superscalar widths together).
- Local Mutations: Standard mutations of top-performing designs for exploitation.
Distance-Aware Acquisition: A tree-ensemble surrogate evaluates the candidate pool. To compensate for the collapse of uncertainty estimates in tree ensembles outside the training support, the acquisition function includes a distance-aware term. This rewards candidates that are far from previously measured data, ensuring exploration in uncharted regions.
Online Adaptation: The inverse model is fine-tuned every four rounds using accumulated online measurements and stratified corpus replay to prevent catastrophic forgetting.

Key Contributions

Inverse Design Framework: OneDSE-MIND is the first framework to condition inverse design on execution traces, quantitatively demonstrating that workload awareness makes the inversion of CPU design spaces tractable.
Reward-Guided Fine-Tuning: A technique to shift inverse model predictions from the dense interior of the training distribution to the high-fitness frontier, achieving a 12% geometric mean improvement in design quality with negligible training cost.
Surrogate-Assisted Inverse Loop (SAIL): A measurement loop that combines metric-targeted proposals with coordinated multi-parameter operators and distance-aware acquisition. This approach effectively navigates the "valleys" in the design space that defeat mutation-based search.
Generality: The framework is demonstrated to be applicable beyond CPU cores, successfully extending to DRAM memory controller and AI accelerator (FEATHER) design spaces.

Results

Evaluated on five TailBench workloads using gem5 and McPAT:

Sample Efficiency of Prediction: OneDSE-MIND reaches design quality in 1–58 validations that ArchGym's Genetic Algorithm requires 11×–357× more evaluations (median 68×) to match. On four of five workloads, ArchGym-PPO fails to match OneDSE-MIND's performance even with a full 6,400-evaluation budget.
Optimization Performance: OneDSE-SAIL achieves a geometric mean of 0.98× the full 6,400-evaluation ArchGym-GA optimum using only 512 online evaluations. It exceeds the full-budget GA optimum on the sphinx workload and matches it on moses.
Baseline Comparison: At the same 512-evaluation budget, the strongest baseline (SMAC) achieves only 0.83× of the full-budget optimum. OneDSE-SAIL finds new configurations not evaluated by ArchGym, specifically crossing coordinated multi-parameter barriers.
Extensions:
- DRAM Controller: OneDSE-MIND finds near-optimal designs up to 300,000× faster than GA/PPO baselines.
- AI Accelerator (FEATHER): OneDSE-MIND retains 97.3% of the performance of a population-64 GA while being 29.9× faster, and 91.8% of a population-128 GA while being 50.9× faster.

Significance

The paper argues that the prevailing "forward-only" recipe for DSE is fundamentally misaligned with designer needs and statistically inefficient. By inverting the problem and conditioning on workload traces, OneDSE makes the search space tractable. The framework demonstrates that metric-conditioned inverse modeling can drastically reduce the simulation budget required to find high-quality designs, overcoming the limitations of mutation-based search and the high cost of cycle-accurate simulation. The results suggest a paradigm shift from exhaustive or random exploration toward targeted, inverse-driven design synthesis.