Soft error susceptibility is a growing concern with continued CMOS scaling in modern, high-performance, general-purpose microprocessors. Smaller transistors and lower voltages achieve by contiued scaling  exacerbate the soft error problem. Previous work explores full- and partial-redundancy schemes in hardware and software for soft-fault tolerance. However, full-redundancy schemes incur high performance and energy overheads whereas partial-redundancy schemes achieve low coverage.

Value locality is well-known where values generated  in a computation fall within small neighborhoods in the value space, rather than be  spread arbitrarily   over the entire value space. Previous value-locality efforts have attempted to improve performance by  exploiting  value localityto predict values faster than they can be  computed due to inherent long latencies such as cache misses. This project  exploits value locaity to detect soft errors which would usually perturb a value making it fall outside value locality neighborhoods. Such detection does not require redundancy and therefore can avoid the corresponding overheads. To this end, the authors  employ hardware filters that capture value locality neighborhoods by capturing which bit positions are unchanging  0's or 1's and which positions change so that a new value matching in the unchanging positions does not flag an error and does otherwise. Upon detection, the authors  leverage modern processor pipeline's in-built abiltiy to roll-back computation to try to correct the error. Because the roll-back (i.e., redundant execution) occurs only when an error is flagged or on a false postiive (which are about 2% of all instructions), the proposed  method acheives lower power and performance overheads than previous full-redundancy approaches.

In contrast to value prediction for performance where the prediciton has to exactly match the actual value, exploiting value locality to detect soft errors has to  be accurate enough to detect value perturbation without   prediction the value with 100% accuracy.  An initial study, called Perturbation Based Fault Screening (PBFS), explored exploiting value locality to provide hints
of soft faults whenever a value falls outside its neighborhood.  However, PBFS achieves low coverage; straightforwardly improving the coverage results in high false-positive rates, and performance and energy overheads.

The authors propose FaultHound, a value-locality-based soft-fault tolerance scheme, which employs five novel mechanisms to address PBFS’s limitations: (1) a scheme to cluster the filters via an inverted organization of the filter tables to reinforce learning and reduce the false-positive rates; (2) a learning scheme for ignoring the delinquent bit positions that raise repeated false alarms, to reduce further the false- positive rate; (3) a light-weight predecessor replay scheme instead of a full rollback to reduce the performance and energy penalty of the remaining false positives; (4) a simple scheme to distinguish rename faults, which require rollback instead of replay for recovery, from false positives to avoid unnecessary rollback penalty; and (5) a detection scheme, which avoids rollback, for the load-store queue which is not covered by the  replay. Using simulations, the authors  show that while PBFS achieves either low coverage (30%), or high false-positive rates (8%) with high performance overheads (97%), FaultHound achieves higher coverage (75%) and lower false-positive rates (3%) with lower performance and energy overheads (10% and 25%). Further, full-redundancy schemes scaled to achieve equal coverage of 75% result in  13% performance loss and 57% energy overheads. These results are for a broad range of benchmarks which include commercial workloads (TPC-C-ilke online transaction processing, SPECjbb, and apache webserver), SPECint, SPECFP, and SPLASH.

Considering all the three metrics of coverage, performance and energy overheads, FaultHound performs better than previous redundancy-based and value-locality-based schemes which perform well against only one or two of these metrics. Because of this attractive combination of features, FaultHound will likely be important in the path of continued CMOS  scaling in modern microprocessors.

Last Modified: 09/28/2017
Modified by: T. N Vijaykumar