[Paper Review] Rolex: Resilience-Oriented Language Extensions for Extreme-Scale Systems

Saurabh Hukerikar, Robert F. Lucas|ArXiv.org|May 6, 2016

Distributed systems and fault tolerance21 references4 citations

TL;DR

Rolex introduces resilience-oriented language extensions for HPC applications to encode programmer knowledge of fault tolerance at the language level, enabling compilers and runtime systems to detect, contain, and mask errors without crashing. By integrating type qualifiers, directives, and library routines, Rolex significantly improves application resilience, reduces reliance on checkpointing, and enhances fault tolerance in extreme-scale systems.

ABSTRACT

Future exascale high-performance computing (HPC) systems will be constructed from VLSI devices that will be less reliable than those used today, and faults will become the norm, not the exception. This will pose significant problems for system designers and programmers, who for half-a-century have enjoyed an execution model that assumed correct behavior by the underlying computing system. The mean time to failure (MTTF) of the system scales inversely to the number of components in the system and therefore faults and resultant system level failures will increase, as systems scale in terms of the number of processor cores and memory modules used. However every error detected need not cause catastrophic failure. Many HPC applications are inherently fault resilient. Yet it is the application programmers who have this knowledge but lack mechanisms to convey it to the system. In this paper, we present new Resilience Oriented Language Extensions (Rolex) which facilitate the incorporation of fault resilience as an intrinsic property of the application code. We describe the syntax and semantics of the language extensions as well as the implementation of the supporting compiler infrastructure and runtime system. Our experiments show that an approach that leverages the programmer's insight to reason about the context and significance of faults to the application outcome significantly improves the probability that an application runs to a successful conclusion.

Motivation & Objective

• Address the growing challenge of hardware faults in exascale HPC systems, where component failure rates are expected to rise dramatically due to scaling and shrinking transistor geometries.
• Overcome the limitations of traditional checkpoint-and-rollback recovery by enabling application-level fault resilience that is more efficient and less disruptive.
• Provide HPC programmers with a practical, extensible mechanism to express their domain-specific knowledge about fault tolerance and error resilience in application code.
• Integrate language-level resilience semantics with compiler infrastructure and a runtime inference system to enable cross-layer error detection, masking, and recovery.
• Demonstrate that leveraging programmer insight through language extensions can significantly increase the probability of successful application completion despite system-level faults.

Proposed method

• Introduce a set of language extensions—type qualifiers, directives, and library routines—enabling programmers to annotate code with resilience semantics such as tolerance, robustness, and amelioration.
• Design a front-end source-to-source compiler infrastructure that transforms annotated source code to insert resilience-aware instrumentation and error-handling logic.
• Implement a runtime inference system that monitors execution, detects faults, and applies resilience strategies based on the semantics encoded via Rolex extensions.
• Support three resilience modes: tolerance (continue execution), robustness (re-execute safely), and amelioration (correct errors via stabilization or checksums).
• Integrate with existing HPC programming models (e.g., C, C++, Fortran) to ensure backward compatibility and ease of adoption.
• Use accelerated fault injection to evaluate resilience across common HPC kernels like DGEMM, CG, and SS-CG under realistic fault rates.

Experimental results

Research questions

• RQ1 Can language-level extensions effectively encode application-level fault resilience knowledge that is currently implicit and inaccessible to the system?
• RQ2 To what extent can compiler and runtime systems leverage programmer-provided resilience semantics to improve fault tolerance without relying on traditional checkpointing?
• RQ3 How does the performance overhead of resilience mechanisms (especially amelioration) compare to the benefits in resilience and reduced recovery cost?
• RQ4 Can resilience-aware programming models reduce the frequency of checkpointing and redundant computation in extreme-scale HPC workloads?
• RQ5 How effective are Rolex’s constructs in improving application resilience across diverse HPC kernels under injected fault conditions?

Key findings

• Rolex enables HPC applications to continue execution after faults by leveraging programmer knowledge of fault resilience, significantly increasing the likelihood of successful completion.
• The use of resilience-oriented language extensions reduces dependency on checkpoint-and-rollback recovery, thereby decreasing redundant computation and energy consumption.
• The SS-CG kernel achieved the best efficiency among tested codes due to its lightweight stabilization-based amelioration, while DGEMM and CG showed lower efficiency due to expensive checksum operations.
• Amelioration-based constructs incurred higher overhead, but most of this was due to algorithmic cost rather than compiler or runtime inefficiencies.
• Fault injection experiments confirmed that Rolex-enhanced applications maintained correctness and continued execution under fault conditions where traditional systems would crash.
• The integration of Rolex with compiler and runtime systems enabled cross-layer error detection, masking, and recovery, demonstrating a viable path toward resilient exascale execution.