Execution Pipeline Residue Checking for Low-Overhead Error Detection
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional microprocessor error detection techniques suffer from high area and power overhead, and are inefficient in protecting execution units and register files from soft and hard errors, leading to significant silent data corruption risks.
Innovation Solution
Implementing a residue-based error detection scheme that leverages modulo-(2k−1) residues to detect errors end-to-end across the execution pipeline, delaying detection until the commit stage and using existing flush mechanisms for correction, thereby eliminating the need for multiple protection domains and reducing overhead.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If conventional error detection techniques are implemented across execution units and register files, then error detection capability is improved, but area overhead and power consumption increase significantly
Solution Approach 1:
The patent merges error detection for execution units and register files into a single unified residue-based protection domain. Instead of implementing separate error detection mechanisms for different components, the invention uses a common residue checking approach that covers the entire execution pipeline, thereby reducing total area overhead while maintaining comprehensive error detection capability.
Solution Approach 2:
The residue-based error detection mechanism serves multiple functions simultaneously: it protects execution units, protects register files, and provides end-to-end coverage across the entire pipeline. This multi-functional approach eliminates the need for multiple separate protection domains, reducing both area and power overhead while improving overall reliability.
2Reliability
If multiple protection domains are implemented for different components, then error detection coverage is improved, but device complexity and power overhead increase
Solution Approach 1:
The patent combines multiple protection domains into a single unified residue-based protection mechanism. By using a common residue checking approach for execution units, register files, and other pipeline components, the invention reduces device complexity while maintaining comprehensive error detection coverage across all protected components.
Solution Approach 2:
The invention applies the same residue-based error detection technique uniformly across all protected components (execution units, register files, etc.). This homogeneous approach simplifies the overall system architecture by using identical protection logic throughout, reducing device complexity compared to implementing different protection mechanisms for different components.
3Measurement precision
If error detection is performed at multiple stages in the pipeline, then error detection accuracy is improved, but performance overhead increases
Solution Approach 1:
The patent computes residues in advance during the execution stages and delays the actual residue checking until the commit stage. This preliminary computation approach allows error detection to be performed accurately without adding performance overhead during critical execution paths, as the checking is deferred to a stage where pipeline flushing can absorb any performance impact.
Data Source
AI summary
A processor that protects an execution pipeline includes a residue-based error detection infrastructure including a first logic for computing a first residue of a result of an executed instruction instance, and a second logic for computing a second residue of the result. The second logic applies arithmetic operations of the executed instruction instance to residues of operands of the instruction instance. The execution pipeline includes registers and one or more arithmetic execution units. A method of protecting an execution pipeline includes performing one or more operations of an instruction instance on residues of operands of the instruction instance, computing a first residue of a result of the operations on the operand residues, computing a second residue from a result of executing the instruction instance, and checking the first residue against the second residue to determine whether errors were introduced while the instruction instance was resident in the execution pipeline.