Granular Redundant Multithreading for High Integrity Computing
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Modern multicore processor architectures face challenges in achieving high integrity computing due to increased integration complexity, internal clock domain crossings, and interference latencies, making granular lockstep synchronization difficult without custom hardware or software, especially in commercial off-the-shelf devices.
Innovation Solution
A multicore processing environment (MCPE) employing granular redundant multithreading, where a hypervisor generates and dispatches multiple critical application threads across homogenous processing cores for cross-comparison to ensure operational correctness, using a scheduler or hypervisor to manage and verify results through consensus or majority vote.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If hardware lockstep with two physically independent processor instances is used, then high integrity computation is achieved, but device complexity and synchronization difficulty increase
Solution Approach 1:
The patent creates virtual copies of processing threads through software-based redundant multithreading. Instead of requiring two physical processor instances, the system generates multiple software threads that execute the same critical application code on a single processor, comparing results to detect errors. This achieves the reliability of hardware lockstep with the simplicity of software implementation.
Solution Approach 2:
The patent replaces the mechanical hardware lockstep synchronization mechanism with a software-based virtualized threading system. The hypervisor creates and manages redundant software threads that mimic hardware lockstep behavior, substituting physical processor pairing with virtual thread replication and result comparison.
2Measurement precision
If granular lockstep synchronization is implemented at hardware level, then instruction level synchronization accuracy is maintained, but adaptability to modern processor architectures decreases
Solution Approach 1:
The patent creates a universal software-based synchronization mechanism that can adapt to various modern processor architectures including multicore, manycore, and heterogeneous systems. The virtualized threading approach works across different instruction sets and hardware configurations, making the high-integrity solution architecture-agnostic and broadly applicable.
Solution Approach 2:
The patent changes the fundamental parameter of synchronization from hardware-level cycle-accurate timing to software-level result comparison. By shifting from time-based synchronization to outcome-based verification, the system achieves adaptability to modern processors with out-of-order execution, speculative execution, and complex cache hierarchies while maintaining synchronization accuracy through post-execution result validation.
3Ease of manufacture
If COTS devices are used without custom hardware or software, then ease of manufacture and cost are improved, but high integrity operation capability deteriorates
Solution Approach 1:
The patent enables COTS devices to provide their own high-integrity operation through software-based redundant multithreading implemented on the existing processor. The system uses its own computational resources to create and execute redundant threads, performing self-verification without requiring external custom hardware or specialized components.
Solution Approach 2:
The patent discards the requirement for custom hardware modifications and recovers high-integrity operation capability through software implementation. By abandoning hardware lockstep in favor of software-based virtualized threading, the system achieves integrity verification using only standard COTS processor resources.
4Reliability
If redundant critical application threads are generated and dispatched across multiple cores, then resilience against soft errors is improved, but processing time and overhead increase
Solution Approach 1:
The patent applies partial redundancy by generating redundant threads only for critical application tasks identified through scheduling requests, rather than duplicating all processing. The hypervisor selectively forks redundant threads based on integrity requirements, applying verification overhead only where necessary and allowing non-critical tasks to execute without redundancy, thus balancing reliability with performance.
Data Source
AI summary
A system and method for granular redundant multithreading in a high integrity multicore processing environment (MCPE) generates redundant critical application threads incorporating executable instructions and input data relevant to a critical process when a user application running on a homogenous core of the MCPE encounters the critical process and issues a system call. The critical application threads are forked to different processing cores environments for execution, and the result sets of each executed critical application threads are forked to different cores for cross-comparison (different from the cores on which the result sets were generated). The result sets are cross-checked to the desired degree of integrity (e.g., consensus agreement or majority vote of all comparing cores) and the hypervisor returns the execution returned to the calling user application with the final result set (or with a fault, if the evaluation was unsuccessful and the desired level of agreement not reached).