RedThreads: An Interface for Application-level Fault Detection/Correction through Adaptive Redundant Multithreading

TL;DR

RedThreads introduces an adaptive interface for application-level fault detection and correction using redundant multithreading, allowing dynamic control over redundancy to balance resilience and performance in high-performance computing applications.

Contribution

It presents a novel interface and runtime system for adaptive, application-level redundant multithreading to improve fault tolerance with minimal performance impact.

Findings

Adaptive RMT effectively balances resilience and overhead.

Runtime system dynamically enables/disables redundancy.

Experimental results show improved fault coverage with controlled overhead.

Abstract

In the presence of accelerated fault rates, which are projected to be the norm on future exascale systems, it will become increasingly difficult for high-performance computing (HPC) applications to accomplish useful computation. Due to the fault-oblivious nature of current HPC programming paradigms and execution environments, HPC applications are insufficiently equipped to deal with errors. We believe that HPC applications should be enabled with capabilities to actively search for and correct errors in their computations. The redundant multithreading (RMT) approach offers lightweight replicated execution streams of program instructions within the context of a single application process. However, the use of complete redundancy incurs significant overhead to the application performance. In this paper we present RedThreads, an interface that provides application-level fault detection and correction based on RMT, but applies the thread-level redundancy adaptively. We describe the RedThreads syntax and semantics, and the supporting compiler infrastructure and runtime system. Our approach enables application programmers to scope the extent of redundant computation. Additionally, the runtime system permits the use of RMT to be dynamically enabled, or disabled, based on the resiliency needs of the application and the state of the system. Our experimental results demonstrate how adaptive RMT exploits programmer insight and runtime inference to dynamically navigate the trade-off space between an application's resilience coverage and the associated performance overhead of redundant computation.