RIROS: A Parallel RTL Fault SImulation FRamework with TwO-Dimensional Parallelism and Unified Schedule

Jiaping Tang, Jianan Mu, Zizhen Liu, Ge Yu, Tenghui Hua, Bin Sun, Silin Liu, Jing Ye, Huawei Li

Abstract

With the rapid development of safety-critical applications such as autonomous driving and embodied intelligence, the functional safety of electronic chips has become paramount. Ensuring this safety requires exhaustive Register Transfer Level (RTL) fault simulations during the design phase, which significantly extends the verification cycle. Traditional parallel methods often fail to accelerate this process effectively due to highly imbalanced task loads caused by dynamic fault propagation. This paper introduces RIROS, a parallel RTL fault simulation framework that utilizes two-dimensional parallelism—combining structural-level and fault-level parallelism—alongside a unified computation and synchronization schedule. Experimental results demonstrate that RIROS achieves a performance improvement of 7.0x over state-of-the-art academic simulators and 11.0x over leading commercial tools.

Introduction

In the era of autonomous systems, chip reliability is governed by rigorous standards like ISO 26262. Meeting these standards necessitates RTL fault simulation, where thousands of artificial faults (e.g., "stuck-at" faults) are injected into a circuit to evaluate the system's detection and survival capabilities. However, fault simulation is notoriously slow. Unlike standard RTL simulation, fault propagation is unpredictable: some faults dissipate immediately, while others trigger extensive activity across the circuit.

Traditional parallelization strategies typically rely on structural partitioning, which splits the circuit across CPU cores. However, the dynamic nature of fault propagation leads to massive load imbalances. Most cores often sit idle—creating "bubbles" in the execution pipeline—while waiting for a few high-load tasks to complete. Furthermore, the requirement for global synchronization between simulation cycles creates a performance bottleneck that limits scalability.

The RIROS Framework

RIROS addresses these bottlenecks through three core innovations designed to eliminate execution bubbles and maximize CPU utilization.

1. Two-Dimensional (2D) Parallelism

Through an analysis of fault propagation paths, the researchers identified a duality in task loads: tasks are either few in number but high in load ("heavy" tasks), or numerous but low in load ("light" tasks). RIROS employs a 2D strategy to handle both:

  • Structural-Level Parallelism: Used to manage the high volume of light tasks across the circuit structure.
  • Fault-Level Parallelism: When the system identifies a "heavy-load" node, it applies fault-level parallelism. This involves splitting the simulation of different faults within that specific node across multiple cores using a master-slave model, effectively breaking down the bottleneck.

2. Unified Scheduling

Standard simulators follow a rigid "compute-then-synchronize" model, where all cores must reach a global barrier before proceeding. RIROS deviates from this by proposing a unified computation/global synchronization schedule. In this model, local synchronization tasks are treated as standard computation tasks with their own dependencies. This allows the framework to "hide" synchronization overhead by performing sync operations for one part of the circuit while other parts are still computing.

3. Dynamic Monitoring and Work-Stealing

To maintain balance, RIROS utilizes a real-time monitor to identify heavy nodes as they emerge. For the thousands of smaller tasks, it employs a work-stealing mechanism (leveraging the TaskFlow library). This ensures that if a core finishes its assigned structural partition early, it can "steal" pending tasks from busier cores, minimizing idle time.

Experimental Evaluation

RIROS was evaluated on a 16-core Intel i7 system using a variety of hardware benchmarks, including RISC-V processors (Mini, Sodor, PicoRV32) and specialized accelerators (JPEG encoders, GEMM, and Convolution units). The study focused on tens of thousands of "stuck-at" (SA0/SA1) faults.

Performance Results

  • Speedup: RIROS achieved an average speedup of 7.0x compared to ERASER (a state-of-the-art academic simulator) and 11.4x compared to Synopsys VCS (a leading commercial tool).
  • Peak Efficiency: On the JPEG benchmark, RIROS reached an 11.3x speedup over ERASER.
  • Resource Utilization: Traditional methods often see CPU utilization drop below 40% due to synchronization barriers. RIROS significantly narrowed the gap between maximum and minimum core usage, maintaining high utilization throughout the simulation.
  • Low Management Overhead: The complex 2D parallelism and scheduling logic introduced minimal overhead, typically accounting for only 5.2% of the total execution time.

Conclusion and Future Work

RIROS demonstrates that by treating synchronization as a task rather than a barrier and combining structural and fault-level parallelism, the massive load imbalances inherent in RTL fault simulation can be overcome. While the framework shows excellent scaling on 16-core systems, future research will focus on scaling to higher core counts where task management overhead may increase. Additionally, while the current focus is on stuck-at faults on CPUs, extending the framework to support transient faults and heterogeneous hardware (like GPUs) represents a promising path for further accelerating functional safety verification.

Summary updated

Abstract

With the rapid development of safety-critical applications such as autonomous driving and embodied intelligence, the functional safety of the corresponding electronic chips becomes more critical. Ensuring chip functional safety requires performing a large number of time-consuming RTL fault simulations during the design phase, significantly increasing the verification cycle. To meet time-to-market demands while ensuring thorough chip verification, parallel acceleration of RTL fault simulation is necessary. Due to the dynamic nature of fault propagation paths and varying fault propagation capabilities, task loads in RTL fault simulation are highly imbalanced, making traditional singledimension parallel methods, such as structural-level parallelism, ineffective. Through an analysis of fault propagation paths and task loads, we identify two types of tasks in RTL fault simulation: tasks that are few in number but high in load, and tasks that are numerous but low in load. Based on this insight, we propose a two-dimensional parallel approach that combines structurallevel and fault-level parallelism to minimize bubbles in RTL fault simulation. Structural-level parallelism combining with workstealing mechanism is used to handle the numerous low-load tasks, while fault-level parallelism is applied to split the high-load tasks. Besides, we deviate from the traditional serial execution model of computation and global synchronization in RTL simulation by proposing a unified computation/global synchronization scheduling approach, which further eliminates bubbles. Finally, we implemented a parallel RTL fault simulation framework, RIROS. Experimental results show a performance improvement of 7.0 times and 11.0 times compared to the state-of-the-art RTL fault simulation and a commercial tool.
BibTeX
@inproceedings{tang2025riros,
  author = {Jiaping Tang and Jianan Mu and Zizhen Liu and Ge Yu and Tenghui Hua and Bin Sun and Silin Liu and Jing Ye and Huawei Li},
  title = {{RIROS: A Parallel RTL Fault SImulation FRamework with TwO-Dimensional Parallelism and Unified Schedule}},
  booktitle = {ICCAD},
  year = {2025},
  doi = {10.1109/iccad66269.2025.11240786},
}
Figure