Transparent fault tolerance for scalable functional computation

Stewart, R., Maier, P. and Trinder, P. (2016) Transparent fault tolerance for scalable functional computation. Journal of Functional Programming, 26, e5. (doi:10.1017/S095679681600006X)

[img]
Preview
Text
107448.pdf - Accepted Version

517kB

Abstract

Reliability is set to become a major concern on emergent large-scale architectures. While there are many parallel languages, and indeed many parallel functional languages, very few address reliability. The notable exception is the widely emulated Erlang distributed actor model that provides explicit supervision and recovery of actors with isolated state. We investigate scalable transparent fault tolerant functional computation with automatic supervision and recovery of tasks. We do so by developing HdpH-RS, a variant of the Haskell distributed parallel Haskell (HdpH) DSL with Reliable Scheduling. Extending the distributed work stealing protocol of HdpH for task supervision and recovery is challenging. To eliminate elusive concurrency bugs, we validate the HdpH-RS work stealing protocol using the SPIN model checker. HdpH-RS differs from the actor model in that its principal entities are tasks, i.e. independent stateless computations, rather than isolated stateful actors. Thanks to statelessness, fault recovery can be performed automatically and entirely hidden in the HdpH-RS runtime system. Statelessness is also key for proving a crucial property of the semantics of HdpH-RS: fault recovery does not change the result of the program, akin to deterministic parallelism. HdpH-RS provides a simple distributed fork/join-style programming model, with minimal exposure of fault tolerance at the language level, and a library of higher level abstractions such as algorithmic skeletons. In fact, the HdpH-RS DSL is exactly the same as the HdpH DSL, hence users can opt in or out of fault tolerant execution without any refactoring. Computations in HdpH-RS are always as reliable as the root node, no matter how many nodes and cores are actually used. We benchmark HdpH-RS on conventional clusters and an High Performance Computing platform: all benchmarks survive Chaos Monkey random fault injection; the system scales well e.g. up to 1,400 cores on the High Performance Computing; reliability and recovery overheads are consistently low even at scale.

Item Type:Articles
Status:Published
Refereed:Yes
Glasgow Author(s) Enlighten ID:Trinder, Professor Phil and Maier, Dr Patrick
Authors: Stewart, R., Maier, P., and Trinder, P.
College/School:College of Science and Engineering > School of Computing Science
Journal Name:Journal of Functional Programming
Publisher:Cambridge University Press
ISSN:0956-7968
ISSN (Online):1469-7653
Published Online:17 March 2016
Copyright Holders:Copyright © 2016 Cambridge University Press
First Published:First published in Journal of Functional Programming 2016.
Publisher Policy:Reproduced in accordance with the publisher copyright policy
Data DOI:10.5525/gla.researchdata.189

University Staff: Request a correction | Enlighten Editors: Update this record

Project CodeAward NoProject NamePrincipal InvestigatorFunder's NameFunder RefLead Dept
644791Adaptive Just-In-Time Parallelisation (AJITPar)Phil TrinderEngineering & Physical Sciences Research Council (EPSRC)EP/L000687/1COM - COMPUTING SCIENCE
635431RELEASEPhil TrinderEuropean Commission (EC)287510COM - COMPUTING SCIENCE