Options
Type-Based Software-Implemented Hardware Fault Tolerance
Publikationstyp
Doctoral Thesis
Date Issued
2012
Sprache
English
Author(s)
Advisor
Referee
Gollmann, Dieter
Title Granting Institution
Technische Universität Hamburg
Examination Date
2012
Institut
TORE-URI
Citation
TU Hamburg, Magazin, Signatur 2131-6155 (2012)
Moore’s law has correctly predicted the number of transistors in integrated circuits to double approximately every two years. This exponential growth has been made possible through the continued shrinking of individual transistors and has allowed processing speed and memory sizes to grow at similar rates. However, smaller components become increasingly vulnerable to environmental fluctuations, making software systems especially vulnerable to the new class of soft errors, originating from voltage spikes produced by cosmic radiation.
To achieve a dependable system, redundant hardware or software is needed to detect and recover from these errors. Traditionally, the implementation of hardware dependence has been a hardware-only consideration, but softwareimplemented hardware fault tolerance is now more and more advocated. Software enables a configurable solution where protection can be applied only to those regions of an application that actually need it and thereby avoids protection overhead for the non-critical regions of the application.
However, software-implemented hardware fault tolerance has yet to deliver truly configurable solutions. The hardening techniques presented so far have been introduced mostly in isolation, making integration of different mechanisms unnecessarily difficult. We propose a type-based approach and demonstrate a C++ type-library implementation that can be used to express existing hardening techniques in a way that allows straight-forward integration.
To analyze the connection between variable types and soft-error impact, we design and implement a type-based program analysis to infer low-level types in assembly listings. We apply the analysis to an existing fault-injection experiment and conclude that the soft-error impact varies greatly with type.
We leverage such type-specific behavior to design type-specific fault tolerance that provides better error coverage and better performance compared to generic fault-tolerance mechanisms. Specifically, we target one of the simplest and one of the most common data types—Booleans. Although they are often critical, the traditional representation is ill-protected against soft errors. We propose a simple modification to the standard Boolean that improves fault tolerance with no performance overhead. Additionally, we propose four efficient alternative designs, based on bit counting, rotation, and partitioning.
To achieve a dependable system, redundant hardware or software is needed to detect and recover from these errors. Traditionally, the implementation of hardware dependence has been a hardware-only consideration, but softwareimplemented hardware fault tolerance is now more and more advocated. Software enables a configurable solution where protection can be applied only to those regions of an application that actually need it and thereby avoids protection overhead for the non-critical regions of the application.
However, software-implemented hardware fault tolerance has yet to deliver truly configurable solutions. The hardening techniques presented so far have been introduced mostly in isolation, making integration of different mechanisms unnecessarily difficult. We propose a type-based approach and demonstrate a C++ type-library implementation that can be used to express existing hardening techniques in a way that allows straight-forward integration.
To analyze the connection between variable types and soft-error impact, we design and implement a type-based program analysis to infer low-level types in assembly listings. We apply the analysis to an existing fault-injection experiment and conclude that the soft-error impact varies greatly with type.
We leverage such type-specific behavior to design type-specific fault tolerance that provides better error coverage and better performance compared to generic fault-tolerance mechanisms. Specifically, we target one of the simplest and one of the most common data types—Booleans. Although they are often critical, the traditional representation is ill-protected against soft errors. We propose a simple modification to the standard Boolean that improves fault tolerance with no performance overhead. Additionally, we propose four efficient alternative designs, based on bit counting, rotation, and partitioning.