In the design of modern computer architecture, engineers face a fundamental "Iron Triangle" of constraints: simulation speed, timing accuracy, and design flexibility. To build a new chip, you must first simulate it. However, the more detail you include to ensure the chip actually works, the slower the simulation runs.
Traditional hardware evaluation has long been split into two camps. On one side are cycle-accurate simulators, which model every clock tick and register transfer. These are highly precise but agonizingly slow—often running at just a few kilohertz, making it impossible to simulate a full operating system or a Large Language Model (LLM) training run. On the other side are analytical models, which use mathematical equations to estimate performance. These are nearly instantaneous but often miss dynamic bottlenecks like network-on-chip (NoC) congestion or memory bandwidth contention.
A growing body of research is focused on bridging this "simulation gap" by creating frameworks that offer the speed of analytical models with the high fidelity of cycle-accurate simulation.
The Problem of the Simulation Wall
As we move toward specialized hardware—such as Domain-Specific Systems-on-Chip (DSSoCs) for AR glasses or massive tiled accelerators for AI—the design space becomes too large for traditional tools. Behzad Boroujerdian and colleagues note in their work on FARSI that designers of AR systems must balance extreme performance with tiny power budgets, a task that requires exploring thousands of configurations.
When simulators are too slow, researchers are forced to use "stuck-at" fault models or simplified bit-flip abstractions. However, as SeungJun Kim and Suhyung Kim demonstrated in their study of avionic processors, these abstractions often fail to capture the reality of physical failures, leading to overestimations of reliability and a failure to see how errors actually propagate through logic.
Predicting the Future with Transaction-Driven Models
One way to break this trade-off is to move from cycle-by-cycle simulation to transaction-level modeling (TLM). Instead of simulating every single clock edge, these models focus on "transactions"—like a memory read or a bus request.
The CATS framework, developed by Dohyung Kim and Rajesh Gupta 0001, achieves 99.99% accuracy by predicting bus event timings before they occur. By treating the hardware as a series of timed events rather than a continuous clock, GVSoC, an event-driven simulator for RISC-V IoT processors, achieves a 2500× speedup over cycle-accurate models. It works because most hardware components spend many cycles doing nothing; event-driven models simply skip to the next "interesting" moment.
Hybrid Modeling and Neural Surrogates
A more recent shift involves using Machine Learning (ML) to handle the "messy" parts of hardware interaction. Analytical models are great at calculating the raw demand of a workload, but they struggle to predict how different tasks will fight over shared resources like caches.
SYNPERF, introduced by Kaixuan Zhang and others, uses a hybrid approach. It breaks down GPU kernels into specific instruction demands and then uses a lightweight ML model to predict the resulting performance. This allows it to capture complex hardware interactions that pure math would miss, while remaining orders of magnitude faster than a full simulation.
In the world of analog circuits, where the bottleneck is the computationally heavy SPICE simulation, researchers are replacing physics equations with neural surrogates.
- Souradip Poddar and David Z. Pan developed INSIGHT, which uses Autoregressive Transformers to simulate analog circuits.
- Mohammad Saeed Abrishami and Shahin Nazarian proposed CSM-NN, which replaces massive look-up tables with compact neural networks, shifting the simulation bottleneck from slow memory access to fast parallel computation on GPUs.
Data-Centric Abstractions for Accelerators
For specialized AI hardware, the focus shifts from general-purpose instructions to "dataflows"—how data moves from memory through an array of processing elements. Hyoukjun Kwon and Angshuman Parashar developed MAESTRO, which uses a data-centric notation to describe these movements.
By abstracting the hardware into spatial and temporal mapping strategies, MAESTRO can estimate the energy and performance of a Deep Learning accelerator with 90% accuracy while running 10,000× faster than a register-transfer level (RTL) simulation. Similarly, SCALE-Sim by Ananda Samajdar provides a cycle-accurate look at systolic arrays without the overhead of a full-system simulator, allowing architects to quickly decide if a 32x32 array is better than a 16x64 one for a specific AI model.
Scaling to the Data Center
As systems grow to include chiplets, many-core arrays, and disaggregated memory (like CXL), the simulation challenge scales exponentially. Frameworks like MLDSE and CXL-DMSim by Jie Zhang address this by using recursive modeling and validated architectural templates.
These tools allow researchers to simulate "Accelerator-Rich Architectures" (ARAs) at native speeds. As Jason Cong and his team show with ARAPrototyper, by automating the "glue" logic and using FPGAs for emulation, we can achieve hardware-level speeds while maintaining the flexibility to change the design with a few lines of code.
By combining high-level abstractions with targeted low-level precision, this research direction ensures that the next generation of chips can be designed, tested, and optimized in weeks rather than years.