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