2016/10/06 by Saurabh Hukerikar, Keita Teranishi, Hukerikar, Saurabh +5 · 1 voice
Computer Science · Engineering · #Cloud Computing and Resource Management #Distributed #Distributed systems and fault tolerance #FOS: Computer and information sciences #Parallel #Parallel Computing and Optimization Techniques #Radiation Effects in Electronics #Software System Performance and Reliability #and Cluster Computing (cs.DC) #cs.DC
paper · pdf · doi:10.48550/arxiv.1610.01728
Submitted to Journal
openalex publication_date 2016/10/06 · arxiv published 2016/10/06 · arxiv created 2017/01/17 · arxiv updated 2017/01/19 · openalex created_date 2022/10/06 · openalex updated_date 2026/07/28
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.