RedThreads: An Interface for Application-Level Fault Detection/Correction Through Adaptive Redundant Multithreading

Hukerikar, Saurabh; Teranishi, Keita; Diniz, Pedro C.; Lucas, Robert F.

doi:10.1007/s10766-017-0492-3

Cited by 14 publications

(36 citation statements)

References 30 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Software fault detection with recovery studies are promising. Latest approaches [18,19] presented applicationlevel fault correction models. The programming model proposed in [18] adopts n cores to execute code redundantly.…”

Section: B Redundant Muti-threading and Motivationmentioning

confidence: 99%

“…Note that memory store operations are also inside the vulnerable window because they are not protected by any way. RedThreads [19] adopts optimizations of adaptive SOR [29] and lazy fault detection [30], but it also suffers from the same vulnerable window. What's more, both [18] and [19] cannot recover other register values and control flow errors.…”

Section: B Redundant Muti-threading and Motivationmentioning

confidence: 99%

“…If applying Triple-Modular Redundancy (TMR) or N-Modular Redundancy (NMR), transient fault correction can be achieved. In [18], [19] application-level transient fault tolerance models, numbers of n threads compare the parameters at the detection point and use the majority voting principle to correct the wrong result. FISHER [20] points out that fault cannot be aware if it occurs on memory store instructions after the majority voting and presents a compiler level soft error tolerance scheme.…”

Section: Introductionmentioning

confidence: 99%

“…In the real world, the multiple fault model [3], [39]- [41] is more accurate, which means each core can have the possibility of suffering from transient faults during the execution. Under the multiple faults model, fault detection in [18], [19] neither cover memory store instructions nor detect control flow errors. The scheme in [20] treats the whole architectural state as one entity, which can cause wrong soft error recovery, leading to silent data corruption (SDC).…”

Section: Introductionmentioning

confidence: 99%

See 3 more Smart Citations

FERNANDO: A Software Transient Fault Tolerance Approach for Embedded Systems Based on Redundant Multi-Threading

Guo

2021

IEEE Access

View full text Add to dashboard Cite

As semiconductor technology scales, modern microprocessors are more vulnerable to transient faults. Software-level fault tolerance schemes are promising because they can improve reliability effectively without extra hardware. Redundant Multi-threading (RMT) uses off-the-shelf cores as redundancy to achieve error resilience. Latest software RMT fault-tolerance models do not effectively cope with transient faults occurring on multiple components during the application execution, resulting in a large number of silent data corruptions (SDC). To address this challenge, we propose FERNANDO, a software-level RMT runtime fault tolerance scheme which provides enhanced error detection and comprehensive error recovery by Triple-Modular Redundancy (TMR). On an ARM Cortex-A57 like simulated microprocessor, we performed probability model transient fault injection experiments in different components of all cores. The results demonstrate that, compared to the state-of-the-art technique, FERNANDO can reduce the SDC rate by about 86.67 percent and optimize the execution time overhead by about 19.64 percent.

show abstract

Section: B Redundant Muti-threading and Motivationmentioning

confidence: 99%

Section: B Redundant Muti-threading and Motivationmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

FERNANDO: A Software Transient Fault Tolerance Approach for Embedded Systems Based on Redundant Multi-Threading

Guo

2021

IEEE Access

View full text Add to dashboard Cite

show abstract

“…These software approaches introduce large size and performance overheads that have to be taken into consideration. In this sense, [13], [16] and [17] use high-level libraries such as OpenMP and PThreads to generate software redundancy, or [18], where a modification of PThreads (RedThreads) is used to generate reliability-oriented redundancy with performance overheads close to 3×. However, all of them emphasize a clear performance overhead due to the complexity introduced by the mentioned libraries.…”

Section: Introductionmentioning

confidence: 99%

Multi-Threaded Mitigation of Radiation-Induced Soft Errors in Bare-Metal Embedded Systems

Serrano-Cases¹,

Restrepo-Calle

Cuenca-Asensi³

et al. 2019

J Electron Test

View full text Add to dashboard Cite

This article presents a software protection technique against radiation-induced faults which is based on a multi-threaded strategy. Data triplication and instructions flow duplication or triplication techniques are used to improve system reliability and thus, ensure a correct system operation. To achieve this objective, a relaxed lockstep model to synchronize the execution of both, redundant threads and variables under protection on different processing units is defined. The evaluation was performed by means of simulated fault injection campaigns in a multi-core ARM system. Results show that despite being considered techniques that imply an evident overhead in memory and instructions (Duplication With Comparison and Re-Execution -DWC-R and Triple Modular Redundancy -TMR), spreading the replicas in different instruction flows not only produce similar results than classic techniques, but also improves the computational and recovery time in presence of soft-errors. In addition, this paper highlights the importance of protecting memory-allocated data, since the instruction flow triplication is not enough to improve the overall system reliability.

show abstract

Efficient thread‐to‐core mapping alternatives for application‐level redundant multithreading

Arslan

Ünsal

2023

Concurrency and Computation

View full text Add to dashboard Cite

SummaryRedundant multithreading (RMT) is an effective thread‐level replication method to improve the reliability requirements of applications. Although it significantly improves the robustness of applications, it comes with additional performance overhead since the redundant threads might share the same core resources. In our previous study [Efficient selective replication of critical code regions for SDC mitigation leveraging redundant multithreading. J Supercomput 2021;77:14130‐14160], we presented an efficient software‐level RMT approach, where we execute the most critical code regions with three threads to correct errors. In this study, we focus on further improving the performance of our software‐level RMT method by presenting a set of different thread‐to‐core mapping alternatives. We provide different static mapping methods, which require preliminary information about the applications, such as execution time, instruction‐per‐cycle (IPC), or cache usage patterns, and a set of dynamic mapping methods, which map threads to cores dynamically at runtime without requiring any additional information. The dynamic mapping methods decide which threads are mapped to which cores at each scheduling point based on the IPC, cache miss rate, or cache access values of each thread as well as each core. Experimental results show that the dynamic mapping method, which maps threads to cores based on IPC values, outperforms all other static and dynamic methods. It also outperforms our baseline model, where the operating system handles the thread‐to‐core mappings by 8%, 7%, and 20% based on average speedup, harmonic speedup, and mean slowdown metrics.

show abstract

RedThreads: An Interface for Application-Level Fault Detection/Correction Through Adaptive Redundant Multithreading

Cited by 14 publications

References 30 publications

FERNANDO: A Software Transient Fault Tolerance Approach for Embedded Systems Based on Redundant Multi-Threading

FERNANDO: A Software Transient Fault Tolerance Approach for Embedded Systems Based on Redundant Multi-Threading

Multi-Threaded Mitigation of Radiation-Induced Soft Errors in Bare-Metal Embedded Systems

Efficient thread‐to‐core mapping alternatives for application‐level redundant multithreading

Contact Info

Product

Resources

About