Compiler-Inserted Fingerprinting for Redundant Thread Comparison
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Redundant multithreading systems incur significant overhead due to frequent comparisons of results from redundant threads, degrading performance in error detection and correction processes, especially in general-purpose applications requiring higher fault tolerance.
Innovation Solution
Implementing a compiler-based transformation of program code to selectively bypass comparisons of redundant threads' results based on a configurable number of event triggers since the last comparison, using fingerprinting and hashing to reduce overhead while maintaining error detection accuracy, and employing a voting scheme for error correction.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If frequent comparisons of results from redundant threads are performed to detect errors, then reliability is improved, but productivity deteriorates due to significant overhead
Solution Approach 1:
The patent implements periodic comparison of redundant thread results by introducing a configurable threshold parameter. Instead of comparing results at every operation, the system accumulates a certain number of operations (default threshold) before performing a comparison. This periodic action significantly reduces the frequency of comparisons and associated overhead while still maintaining error detection capability through regular sampling of results.
Solution Approach 2:
The patent applies partial action by selectively comparing results based on operation types. Not all operations trigger comparisons - the system chooses to compare only certain operations (e.g., memory operations) while skipping others (e.g., simple arithmetic operations). This partial comparison strategy reduces overhead while maintaining adequate error detection for critical operations where errors would have significant impact.
2Reliability
If redundant multithreading is implemented to improve fault tolerance, then reliability is improved, but device complexity increases
Solution Approach 1:
The patent implements self-service by automatically generating and managing redundant threads through compiler transformations. The compiler automatically creates multiple copies of the same thread with different seed values, automatically injects comparison logic at appropriate points, and automatically manages the synchronization and coordination of redundant threads. This automation eliminates the need for manual thread management and reduces the complexity burden on programmers.
Solution Approach 2:
The patent applies universality by designing a comparison mechanism that handles multiple operation types through a unified interface. The same comparison infrastructure is used for different operation types (arithmetic, memory, logical operations) by selectively enabling comparisons based on operation characteristics. This universal approach simplifies the overall system architecture compared to having separate error detection mechanisms for each operation type.
Data Source
Figure 1
Figure 2
Figure 3
AI summary
A first processing element is configured to execute a first thread and one or more second processing elements are configured to execute one or more second threads that are redundant to the first thread. The first thread and the one or more second threads are to selectively bypass one or more comparisons of results of operations performed by the first thread and the one or more second threads depending on whether an event trigger for the comparison has occurred a configurable number of times since a previous comparison of previously encoded values of the results. The comparison is performed, for example, based on hashed (or encoded) values of the results of a current operation and one or more previous operations.