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
FaultyValfunction, hinting at potential for broader fault model support.
Summary updated