Supporting User-directed Fault Tolerance over Standard MPI

Failures are normal rather than exceptional in cloud computing environments, high fault tolerance issue is one of the major obstacles for opening up a new era of high serviceability cloud computing as fault tolerance plays a key role in ensuring cloud serviceability. Fault tolerant service is an essential part of Service Level Objectives (SLOs) in clouds. To achieve high level of cloud serviceability and to meet high level of cloud SLOs, a foolproof fault tolerance strategy is needed. In this paper, the definitions of fault, error, and failure in a cloud are given, and the principles for high fault tolerance objectives are systematically analyzed by referring to the fault tolerance theories suitable for large-scale distributed computing environments. Based on the principles and semantics of cloud fault tolerance, a dynamic adaptive fault tolerance strategy DAFT is put forward. It includes: (i) analyzing the mathematical relationship between different failure rates and two different fault tolerance strategies, which are checkpointing fault tolerance strategy and data replication fault tolerance strategy; (ii) building a dynamic adaptive checkpointing fault tolerance model and a dynamic adaptive replication fault tolerance model by combining the two fault tolerance models together to maximize the serviceability and meet the SLOs; and (iii) evaluating the dynamic adaptive fault tolerance strategy under various conditions in large-scale cloud data centers and consider different system centric parameters, such as fault tolerance degree, fault tolerance overhead, response time, etc. Theoretical as well as experimental results conclusively demonstrate that the dynamic adaptive fault tolerance strategy DAFT has high potential as it provides efficient fault tolerance enhancements, significant cloud serviceability improvement, and great SLOs satisfaction. It efficiently and effectively achieves a trade-off for fault tolerance objectives in cloud computing environments.

Fault tolerance is an important requirement for long-running parallel programs. This paper presents a different approach to fault-tolerance support in message-passing parallel programs based on their structural and behavioral characteristics, commonly known as patterns. A classification of these patterns and their applicable fault-tolerance strategies is aimed to facilitate an application developer to incorporate appropriate fault-tolerance strategies to an application. Fault-tolerance strategies for two of the patterns are discussed, and one specific strategy is elaborated and analyzed. The presented strategies have been incorporated into a fault-tolerance support framework called FT-PAS. One objective of the framework is to separate the fault tolerance related details from an application developer's main objectives (separation-of-concerns). The paper presents the additional key features of the framework, and concludes with a discussion on current and future research directions.

Due to modern technology trends such as decreasing feature sizes and lower voltage levels, fault tolerance (FT) is becoming increasingly important in computing systems. Several schemes have been proposed to enable a user to configure the FT at the application level, thereby enabling the user to trade stronger FT for performance or vice versa. In this paper, we propose supporting instruction-level rather than application-level configurability of FT, since different parts of some applications (e.g., multimedia) can have different reliability requirements. Weak or no FT will be applied to less critical parts, resulting in time and/or resource gains. These gains can be used to apply stronger FT techniques to the more critical parts; hence increasing the overall reliability. The paper shows how some existing FT techniques can be adapted to support instruction-level FT configurability, how a programmer can specify the desired FT level of the instructions, and how the compiler can manage it automatically. A comparison between the existing FT scheme EDDI (which duplicates all instructions) and the proposed approach is performed both at the kernel and at full application levels. The simulation results show that both the performance and the energy consumption are significantly improved (up to 50% at the kernel and up to 16% at full application level), while the fault coverage depends on the application. For the full application (JPEG encoder), our approach is only applied to one kernel in order to avoid increasing the programming effort significantly.

This paper develops a modulation based fault-tolerant (FT) strategy for restoring the operation of three-phase modular multilevel converters (MMCs) with faulty switches. This FT strategy is based on a proposed modified space vector modulation (SVM) technique that generates balanced line-to-line (line) voltages even in the case of a fault occurrence. In the postfault operation, the proposed strategy is able to restore the fundamental amplitude of the line to the neutral (load) voltages to that of the normal operation condition with a slightly increased voltage stress over the switches in the faulty phase. In this paper, first a brief background about MMCs and SVM technique is provided. Then, the proposed FT strategy and the modified SVM technique are presented. Finally, several simulation and experimental results are provided to validate operation of the proposed strategy.

Currently, using commercial off-the-shelf (COTS) components and constructing parallel system becomes the main way to improve satellite system performance remarkably. System reliability relying on its structure rather than devices makes system fault-tolerant architecture and strategy increasingly important. As centralized fault-tolerant solution has the inherent drawback of single point of failure (SPOF), it can not guarantee system reliability well. Distributed fault- tolerant method, due to its complexity and large overhead, has not been maturely used. In this paper, we propose a new distributed fault-tolerant scheme with high reliability and flexibility, in which an equal symmetric distributed fault- tolerant (ESDFt) architecture is constructed. Based on the structure, functional module framework of system nodes and autonomous fault-tolerant strategy are designed. The ESDFt scheme creates favorable conditions for flexible implementation of system fault tolerance. It utilizes the master election mechanism, which eliminates the risks of SPOF and chooses master node intelligently based on user's configuration, making fault-tolerant complexity and processing overhead flexibly adjustable. The verification and evaluation of ESDFt scheme has been performed on a prototype system. The experiment results prove that ESDFt scheme not only ensures system reliability well, but also enhances system flexibility and practicality at the same time.

This paper focuses on insufficient perception in blind scenes and the failures of the actuator and sensor of vehicle suspension. The safe speed is designed and the fault-tolerant strategy based on the observer is designed when the actuator and sensor fail simultaneously. A speed planning strategy to ensure that vehicles operate at a safe speed is proposed. The Markov suspension fault jump model considering the suspension sensor and actuator faults is established. Based on the fault estimation obtained by the fault observer, a fault tolerance control strategy of sensor signal reconstruction and actuator fault compensation is adopted. The measurement index for evaluating fault tolerance effectiveness has been established, and an exploration of fault tolerance control is conducted across various fault levels, to identify the preferred fault tolerance strategies corresponding to different levels of fault tolerance. The simulation results show that the designed speed control strategy can improve vehicle safety by decelerating in advance, the fault observer is capable of accurately estimating the true values of actuator and sensor faults. The simulation and vehicle test results demonstrate that similar suspension performance has been obtained by fault-tolerant control strategy and preferred fault tolerance under different fault tolerance levels compared with normal fault tolerance.

Fault tolerant system based on non-integers order observers: Application in a heat exchanger

Due to the poor accessibility, poor operating conditions, high failure rate, long maintenance time, and difficult maintenance of wind hybrid generators, the economic loss is huge once the failure stops. To this end, the fault adaptive fault-tolerant control of distributed wind and wind hybrid generators is studied, the historical operation data of offshore wind and wind hybrid generators and onshore wind and wind hybrid generators are counted and compared, and the fault characteristics of key components of offshore wind and wind hybrid generators are analyzed. The generator sets are summarized, and the common electrical faults of wind turbines and their impacts on the system are analyzed. This paper summarizes the current research status of fault-tolerant operation of existing offshore wind and wind complementary generators in terms of software fault tolerance and hardware fault tolerance, summarizes the current fault tolerance schemes for offshore wind and wind complementary generators, and analyzes the application feasibility of existing fault tolerance schemes. In addition, the main problems of fault-tolerant offshore wind and solar complementary generator sets are pointed out, and future research hotspots are foreseen.

Critical infrastructure applications provide services upon which society depends heavily; such applications require constant, dependable operation in the face of various failures, natural disasters, and other disruptive events that might cause a loss of service. These applications are themselves dependent on distributed information systems for all aspects of their operation, so survivability of these critical information systems is an important issue. Survivability is the ability of a system to continue to provide service, though possibly alternate or degraded, in the face of various types of failure and disruption. A fundamental mechanism by which survivability can be achieved in critical information systems is fault tolerance. Much of the literature on fault-tolerant distributed systems focuses on tolerance of local faults by detecting and masking the effects of those faults. I describe a direction for fault tolerance in the face of non-local faults—faults whose effects have significant non-local impact, sometimes widespread and sometimes catastrophic—where often the effects of these faults cannot be masked using available resources. The goal is to recognize these non-local faults through detection and analysis, then to provide continued service (possibly alternate or degraded) by reconfiguring the system in response to these faults. A specification-based approach to fault tolerance, called RAPTOR, is presented that enables systematic structuring of formal specifications for error detection and recovery, utilizes a translator to synthesize portions of the implementation from the formal specifications, and provides an implementation architecture supporting fault-tolerance activities. The RAPTOR approach consists of three specifications describing the fault-tolerant system, the errors to be detected, and the actions to take to recover from those errors. The RAPTOR System includes a synthesizer, the Fault Tolerance Translator, to generate implementation of code components from the specifications to perform error detection and recovery activities. In addition, a novel implementation architecture incorporates the generated code as part of an infrastructure supporting fault tolerance at both the node and system levels. Finally, the solution approach is explored and evaluated through the use of case studies and experiments in two critical infrastructure application domains.

This paper discusses fault tolerance in discrete-time dynamic systems, such as finite-state controllers or computer simulations, with focus on the use of coding techniques to efficiently provide fault tolerance to linear finite-state machines (LFSMs). Unlike traditional fault tolerance schemes, which rely heavily-particularly for dynamic systems operating over extended time horizons-on the assumption that the error-correcting mechanism is fault free, we are interested in the case when all components of the implementation are fault prone. The paper starts with a paradigmatic fault tolerance scheme that systematically adds redundancy into a discrete-time dynamic system in a way that achieves tolerance to transient faults in both the state transition and the error-correcting mechanisms. By combining this methodology with low-complexity error-correcting coding, we then obtain an efficient way of providing fault tolerance to k identical unreliable LFSMs that operate in parallel on distinct input sequences. The overall construction requires only a constant amount of redundant hardware per machine (but sufficiently large k) to achieve an arbitrarily small probability of overall failure for any prespecified (finite) time interval, leading in this way to a lower bound on the computational capacity of unreliable LFSMs.

Given that the reliability of a very large-scaled system is inversely related to the number of computing elements, fault tolerance has become a major concern in high performance computing including the most recent deployments with graphic processing units (GPUs). Many fault tolerance strategies, such as the checkpoint/restart mechanism, have been studied to mitigate failures within such systems. However, fault tolerance mechanisms generate additional costs and these may cause a significant performance drop if it is not used carefully. This paper presents a novel fault tolerance scheduling model that explores the interplay between the GPGPU application performance and the reliability of a large GPU system. This work focuses on the checkpoint scheduling model that aims to minimize fault tolerance costs. Additionally, a GPU performance analysis is conducted. Furthermore, the effect of a checkpoint/restart mechanism on the application performance is thoroughly studied and discussed.

AMATISTA is a European IST project whose main target is the development of a fault tolerant (FT) set of tools. These include an automatic FT Insertion (FTI) tool and a FT injection and simulation (FTIS) tool. This paper presents the AMATISTA project from a user perspective. FT experience and current non-automatic techniques and methodologies used in Alcatel Espacio (AEO) are described. The advantages of having tools for automatic FTI and FT injection and simulation are summarised. The AEO requirements for both tools are also described.

We shall regard a computer system as a whole which comprises software, hardware and mixed components each of which can, in its turn, present a system. Then the entire system is a multilevel hierarchy.The purpose of this paper is to single out and generalize about the essential features and properties of synchronization and to argue in favour of the idea of designing and developing fault-tolerance (FT) for distributed systems on the basis of a multilevel synchronization system. Getting aware of and constructing a synchronization system like this can be, and often is, a basis for providing system FT (with masking, recovery, voting, reconfiguration, migration, warm-starting, etc. subsequently built over). The synchronization system controls and coordinates the operation of all main and redundant components and it is by controlling redundancy that FT is achieved. Thus, error recovery can be done precisely at that system level where there is some redundancy; to do this, the operation of the main component and of the redundant ones has to be synchronized. Besides, for that purpose all those components have to be in a certain known state (e.g. active, backup, fault, identical, alive, etc.) and providing this is just what synchronization is meant to do.We propose to consider designing and developing a hierarchical system of synchronizing (HSS) redundant components in distributed systems the first and foremost stage in providing FT in application systems. In this way the entire FT system can be structuralized naturally. HSS can be used as a basis underlying the implementation of any of the known FT schemes in which redundant components are controlled by different CPUs or can be active on their own (disk-drivers, plants, processes, etc.).Our idea and approach is a special case of the approach developed in [1]. We hope to add to the practical applicability of the latter (for FT design, particularly in Distributed OSs - DOSs) and at the same time to single out and analyse the most essential, underlying feature (i.e. component synchronization) in providing FT.

An open-end winding induction motor drive system fed by two boost inverters with fault-tolerant capability is presented to improve the reliability and safety of the drive system. The boost inverters consist of an impedance-source network and a two-level inverter. It can realize the boost/buck function. An analysis of its fault-tolerance is presented in detail. Short circuits and open circuits are commonly considered as the two main types of faults. Therefore, the fault types of the dual boost inverters are analyzed and diagnosed. Then, two different fault-tolerant schemes are presented. The presented fault-tolerant inverters are restructured through the power switch itself. In addition, different SVPWM methods are addressed. A simulation model and an experimental platform are constructed. Simulation and experimental results verify the fault tolerance of the drive system.

The reliable execution of mobile agents is a very important design issue in building mobile agent systems and many fault-tolerant schemes have been proposed so far. Security is a major problem of mobile agent systems, especially when monetary transactions are concerned. Security for the partners involved is handled by encryption methods based on a public key authentication mechanism and by secret key encryption of the communication. To achieve fault tolerance for the agent system, especially for the agent transfer to a new host, we use distributed transaction processing. We propose a fault-tolerant approach for mobile agents design which offers a user transparent fault tolerance that can be activated on request, according to the needs of the task. We also discuss how transactional agents with different types of commitment constraints can commit transactions. Furthermore, we present a solution for effective agent deployment using dynamic agent domains.