DAFT: Decoupled Acyclic Fault Tolerance

Abstract

Higher transistor counts, lower voltage levels, and reduced noise margin increase the susceptibility of multicore processors to transient faults. Redundant hardware modules can detect such errors, but software transient fault detection techniques are more appealing for their low cost and flexibility. Recent software proposals double register pressure or memory usage, or are too slow in the absence of hardware extensions, preventing widespread acceptance. This paper presents DAFT, a fast, safe, and memory efficient transient fault detection framework for commodity multicore systems. DAFT replicates computation across multiple cores and schedules fault detection off the critical path. Where possible, values are speculated to be correct and only communicated to the redundant thread at essential program points. DAFT is implemented in the LLVM compiler framework and evaluated using SPEC CPU2000 and SPEC CPU2006 benchmarks on a commodity multicore system. Results demonstrate DAFT's high performance and broad fault coverage. Speculation allows DAFT to reduce the performance overhead of software redundant multithreading from an average of 200% to 38% with no degradation of fault coverage.

ROSE::FTTransform - A source-to-source translation framework for exascale fault-tolerance research

“…Each run is categorized as correct output, fail silent, access fault (invalid memory access), arithmetic error (e.g., divide by zero), or invalid instruction (in the current evaluation, the latter two categories were not applicable to the mentioned kernels or the fault-injection configuration used). This is similar to the approach used by Zhang et al [15]. Figure 5 illustrates the results of the evaluation.…”

“…Given that not all Single Event Upset (SEU) events [15], [24] lead to a fault, we are currently looking into minimizing the number of redundant computations by taking into account the failure probability of the operation and its sensitivity to input changes. Finally, introducing redundancy at the highlevel source may have the drawback that preserving the redundant computation may require that compiler optimizations be disabled or made more complicated, which could seriously hamper the introduction of resiliency transformations.…”

CASTED: Core-Adaptive Software Transient Error Detection for Tightly Coupled Cores

“…This is why the sphere of replication(SoR) in CASTED is limited within the processor only. This is common practice in the majority of software-based error detection methodologies [9][23][34] [36].…”

“…Since they can be easily caught by a custom exception handler, they are usually part of the detected errors (as in [36]). In our case however, we show them as a separate type of errors for clarity.…”

“…In these approaches, the communication overhead becomes performance bottleneck. DAFT [36] improves this by decoupling the execution of the main thread from the checker. All schemes are summarized and compared against CASTED in Table III.…”