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

TL;DR

Ensuring functional safety in critical electronic chips requires extensive RTL fault simulations, which are notoriously time-consuming due to imbalanced workloads. This paper introduces RIROS, a novel parallel framework that tackles this challenge by employing a two-dimensional parallelism strategy (structural and fault-level) and a unified computation/synchronization schedule, achieving significant speedups over existing methods.

What Problem Does This Paper Address?

The increasing complexity and criticality of electronic chips in applications like autonomous driving demand rigorous functional safety verification. A key part of this verification process is RTL (Register-Transfer Level) fault simulation, where a large number of potential faults are injected into the design to assess their impact. However, performing these simulations is computationally intensive and time-consuming, significantly extending the design cycle.

Traditional parallelization techniques, like structural-level parallelism (partitioning the circuit across multiple cores), struggle with RTL fault simulation because the propagation of faults through the circuit is highly dynamic and unpredictable. This leads to significant load imbalance across different simulation tasks – some tasks are computationally heavy, while others are light. This imbalance results in underutilized processing cores and prolonged simulation times. The paper aims to overcome this bottleneck by proposing a more sophisticated parallelization approach.

Methods

RIROS introduces a multi-pronged approach to accelerate RTL fault simulation:

  • Two-Dimensional Parallelism: Instead of relying on a single parallelism dimension, RIROS combines two:
  • Structural-Level Parallelism: This is used for the numerous, low-load tasks, leveraging work-stealing mechanisms to distribute work efficiently across cores.
  • Fault-Level Parallelism: This is applied to the few, high-load tasks. Here, a single overloaded node is split into a "master-slave" structure. The master handles the "good gate" simulation, while slave tasks simulate the "bad gates" (faulty behavior), effectively distributing the heavy computational load.
  • Unified Computation/Global Synchronization Schedule: Traditional RTL simulation involves distinct phases of computation and global synchronization. RIROS integrates these by allowing synchronization tasks to execute earlier, even before all computation tasks in a cycle are finished, provided the synchronized variables are no longer needed. This "cross-phase task stealing" helps fill idle slots and reduce bubbles.
  • Fault Injection: RIROS supports a unified fault injection methodology for various fault locations (wire, register, port) and types (e.g., stuck-at-0, stuck-at-1).

The framework is implemented using the Taskflow parallel programming library, which facilitates the management of complex task dependencies.

Datasets

The paper evaluates RIROS on several benchmark designs, including:

  • RISCV Mini
  • Conv Acc (Convolution Accelerator)
  • Sodor Core
  • PicoRV32
  • GEMM (General Matrix Multiply)
  • JPEG
  • Conv2D

These benchmarks represent various complexities and functionalities relevant to safety-critical applications. The paper does not introduce new benchmarks but uses existing designs to demonstrate the effectiveness of its approach.

Key Insights and Ideas

  • Load Imbalance is the Core Bottleneck: The paper clearly identifies that the dynamic and irregular nature of fault propagation is the primary cause of load imbalance in RTL fault simulation, rendering traditional single-dimension parallelism ineffective.
  • Two Types of Tasks: A crucial insight is the categorization of tasks into "few but high-load" and "numerous but low-load." This observation directly informs the dual-dimensional parallelism strategy.
  • Exploiting Intra-Task Parallelism: By splitting high-load nodes into master-slave tasks for fault simulation, RIROS exploits parallelism within a single simulation task, which is a novel approach for this domain.
  • Computation and Synchronization Can Overlap: The idea of interleaving computation and synchronization phases, rather than strictly serializing them, is key to reducing idle time and improving overall throughput. This is achieved by identifying opportunities for early local synchronization.
  • Unified Framework for Efficiency: Combining structural and fault-level parallelism with unified scheduling creates a synergistic effect, leading to significantly better resource utilization and performance gains.

Key Results

RIROS demonstrates substantial performance improvements:

  • Speedup: On average, RIROS achieves a 7.0x speedup compared to a state-of-the-art RTL fault simulator (ERASER) and an 11.0x speedup compared to a commercial tool (VCS) using 16 cores.
  • Scalability: The framework shows strong scalability, with performance consistently improving as the number of cores increases. This is particularly evident in larger designs.
  • CPU Utilization: RIROS significantly improves CPU utilization compared to simpler parallel approaches, effectively filling bubbles and keeping cores busy. For instance, under 8-core simulation, RIROS shows much higher average CPU utilization than RIROS-- (which only uses structural parallelism).
  • Overhead: The overhead introduced by the proposed optimization strategies (fault dimension parallelism and computation-synchronization parallelism) is shown to be low, with the JPEG design having a total overhead of 5.2% at 16 cores.

Limitations and Future Work

  • Limitations:
    • The paper acknowledges that while the unified scheduling approach significantly reduces bubbles, completely eliminating them remains a challenge.
  • The effectiveness of the approach is demonstrated on specific benchmarks; its performance on extremely large and complex designs might warrant further investigation.
  • Future Work:
    • The authors suggest that further exploration of advanced scheduling techniques and more sophisticated task partitioning strategies could lead to even greater performance improvements.
  • The unified fault injection methodology is noted to support transient faults by simply overriding the FaultyVal function, hinting at potential for broader fault model support.

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