Parallel Program Execution for Fault Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The complexity of instrumenting programs can lead to under-instrumented source code, potential faults, and failure to achieve desired functionality, complicating compliance with functional safety standards, such as ISO26262, due to instrumentation-related issues.
Innovation Solution
A supervisory control system that executes a non-instrumented version of a program in parallel with an instrumented version to identify fault conditions by analyzing execution cycles and adding No-Op instructions to match execution times, allowing for real-time monitoring and comparison to detect mismatched states indicative of faults.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If instrumentation is added to a program to provide runtime checks and fault protection, then reliability is improved, but device complexity increases and potential faults are introduced
Solution Approach 1:
The system segments the monitoring function by running the instrumented program and extended program as separate parallel processes. Each program executes independently with its own execution environment, allowing fault isolation. The supervisory control system monitors both programs separately and compares their execution states, enabling targeted fault detection without requiring complete re-architecture of the original program.
Solution Approach 2:
The extended program acts as an intermediary reference implementation. It is a modified version of the original program with added No-Op instructions to match execution timing, but without the instrumentation code. This intermediary program provides a clean reference execution path that the supervisory system uses to compare against the instrumented program, enabling fault detection without directly modifying the original program's execution flow.
2Reliability
If instrumentation is added to ensure compliance with safety standards, then reliability is improved, but the difficulty of detecting and measuring faults increases
Solution Approach 1:
The system makes execution state differences visible by comparing the execution states of two programs. When mismatches occur in execution cycles, intermediate values, or output values, these differences are detected and flagged by the supervisory control system. This transforms invisible internal program states into detectable comparison points, enabling easy identification of faults in the instrumented program.
Solution Approach 2:
The supervisory control system continuously monitors both the instrumented program and extended program, comparing their execution states in real-time. When a mismatch is detected, the system provides feedback by identifying the specific execution cycle and nature of the discrepancy. This continuous feedback loop enables automatic fault detection and reporting, simplifying compliance verification with safety standards.
3Reliability
If parallel execution of multiple program versions is implemented, then fault detection capability is improved, but productivity decreases due to increased execution time
Solution Approach 1:
The instrumented program and extended program execute in parallel continuously from the same starting point. Both programs process the same input data simultaneously through their respective execution paths. This continuous parallel execution ensures that fault detection occurs in real-time without requiring separate test runs or additional processing cycles, maintaining productivity while enabling comprehensive fault detection.
Solution Approach 2:
The extended program is prepared in advance by adding No-Op instructions to match the execution timing of the instrumented program. This preliminary timing synchronization ensures that both programs complete their execution in the same time frame, eliminating the need for waiting or re-synchronization. The parallel execution therefore incurs minimal overhead while providing continuous fault detection capability.
Data Source
AI summary
System, methods, and other embodiments described herein relate to improving detection of program faults. In one embodiment, a method includes executing, in parallel, an extended program and an instrumented program. The instrumented program is an instrumented version of a baseline program that implements runtime checks. The extended program is an extended version of the baseline program with intentional delays inserted into source code of the baseline program to match an execution time with the instrumented program. The method includes supervising execution states of the instrumented program to identify an occurrence of mismatched states between the extended program and the instrumented program. The method includes managing the mismatched states to mitigate effects of the program faults on the functioning of an associated device.


