scholarly journals Fault Tolerance Assistant (FTA): An Exception Handling Programming Model for MPI Applications

2016 ◽  
Author(s):  
Aiman Fang ◽  
Ignacio Laguna ◽  
Kento Sato ◽  
Tanzima Islam ◽  
Kathryn Mohror
Author(s):  
Raja Ramanathan

Enterprises that implement Service-driven applications face challenges relating to unprecedented scale, high availability, and fault-tolerance. There is exponential growth with respect to request volume in Service-driven systems, requiring the ability to provide multipoint access to shared services and data while preserving a single system image. Maintaining fault-tolerance in business services is a significant challenge due to their compositional nature, which instills dependencies among the services in the composition. This causes the dependability of the business services to be based on the reliability of the individual services in the composition. This chapter explores the architectural approaches such as service redundancy and design diversity, scaling, clustering, distributed data caching, in-memory data grid, and asynchronous messaging, for improving the dependability of services. It also explores the data scaling bottleneck in data centralization paradigms and illustrates how that presents significant scalability and fault-tolerance challenges in service-driven environments. Prevalent strategies to handle failure recovery such as backward and forward recovery mechanisms as well as the built-in mechanisms in WS-BPEL for exception handling and transactional compensation are discussed.


Author(s):  
Vincenzo De Florio

After having described the main characteristics of dependability and fault-tolerance, it is analyzed here in more detail what it means that a program is fault-tolerant and what are the properties expected from a fault-tolerant program. The main objective of this chapter is introducing two sets of design assumptions that shape the way our fault-tolerant software is structured—the system and the fault models. Often misunderstood or underestimated, those models describe • what is expected from the execution environment in order to let our software system function correctly, and • what are the faults that our system is going to consider. Note that a fault-tolerant program shall (try to) tolerate only those faults stated in the fault model, and will be as defenseless against all other faults as any non fault-tolerant program. Together with the system specification, the fault and system models represent the foundation on top of which our computer services are built. It is not surprising that weak foundations often result in failing constructions. What is really surprising is that in so many cases, little or no attention had been given to those important factors in fault-tolerant software engineering. To give an idea of this, three wellknown accidents are described—the Ariane 5 flight 501, Mariner-1 disasters, and the Therac-25 accidents. In each case it is stressed what went wrong, what were the biggest mistakes, and how a careful understanding of fault models and system models would have helped highlighting the path to avoid catastrophic failures that cost considerable amounts of money and even the lives of innocent people. The other important objective of this chapter is introducing the core subject of this book: Software fault-tolerance situated at the level of the application layer. First of all, it is explained why targeting (also) the application layer is not an open option but a mandatory design choice for effective fault-tolerant software engineering. Secondly, given the peculiarities of the application layer, three properties to measure the quality of the methods to achieve fault-tolerant application software are introduced: 1. Separation of design concerns, that is, how good the method is in keeping the functional aspects and the fault-tolerance aspects separated from each other. 2. Syntactical adequacy, namely how versatile the employed method is in including the wider spectrum of fault-tolerance strategies. 3. Adaptability: How good the employed fault-tolerance method is in dealing with the inevitable changes characterizing the system and its run-time environment, including the dynamics of faults that manifest themselves at service time. Finally, this chapter also defines a few fundamental fault-tolerance services, namely watchdog timers, exception handling, transactions, and checkpointingand- rollback.


Author(s):  
Ignacio Laguna ◽  
David F Richards ◽  
Todd Gamblin ◽  
Martin Schulz ◽  
Bronis R de Supinski ◽  
...  

2015 ◽  
Vol 2015 ◽  
pp. 1-7 ◽  
Author(s):  
Yang Liu ◽  
Wei Wei

MapReduce is a programming model and an associated implementation for processing and generating large data sets with a parallel, distributed algorithm on a cluster. In cloud environment, node and task failure are no longer accidental but a common feature of large-scale systems. Current rescheduling-based fault tolerance method in MapReduce framework failed to fully consider the location of distributed data and the computation and storage overhead of rescheduling failure tasks. Thus, a single node failure will increase the completion time dramatically. In this paper, a replication-based mechanism is proposed, which takes both task and node failure into consideration. Experimental results show that, compared with default mechanism in Hadoop, our mechanism can significantly improve the performance at failure time, with more than 30% decreasing in execution time.


Author(s):  
Miwako Tsuji ◽  
Hitoshi Murai ◽  
Taisuke Boku ◽  
Mitsuhisa Sato ◽  
Serge G. Petiton ◽  
...  

AbstractThis chapter describes a multi-SPMD (mSPMD) programming model and a set of software and libraries to support the mSPMD programming model. The mSPMD programming model has been proposed to realize scalable applications on huge and hierarchical systems. It has been evident that simple SPMD programs such as MPI, XMP, or hybrid programs such as OpenMP/MPI cannot exploit the postpeta- or exascale systems efficiently due to the increasing complexity of applications and systems. The mSPMD programming model has been designed to adopt multiple programming models across different architecture levels. Instead of invoking a single parallel program on millions of processor cores, multiple SPMD programs of moderate sizes can be worked together in the mSPMD programming model. As components of the mSPMD programming model, XMP has been supported. Fault-tolerance features, correctness checks, and some numerical libraries’ implementations in the mSPMD programming model have been presented.


Sign in / Sign up

Export Citation Format

Share Document