Concurrent correspondent modules: a fault tolerant Ada implementation

Two complementary techniques have evolved for providing fault-tolerance in software: forward error recovery and backward error recovery. Few implementations permit both approaches to be combined within a particular application. Fewer techniques are available for the construction of fault-tolerant software for systems involving concurrent processes and multiple processors. Many schemes for supporting forward or backward recovery are based on some concept of an atomic action. The authors propose a mechanism for supporting an atomic action in a system of communicating sequential processes (CSP). The atomic action is used as the basic unit for providing fault-tolerance. The atomic action is called an FT-action, and both forward and backward error recovery are performed in the context of an FT-action.

Cloud computing offers new computing paradigms, capacity and flexible solutions to high performance computing (HPC) applications. For example, Hardware as a Service (HaaS) allows users to provide a large number of virtual machines (VMs) for computation-intensive applications using the HaaS model. Due to the large number of VMs and electronic components in HPC system in the cloud, any fault during the execution would result in re-running the applications, which will cost time, money and energy. In this paper we presented a proactive fault tolerance (FT) approach to HPC systems in the cloud to reduce the wall-clock execution time and dollar cost in the presence of faults. We also developed a generic FT algorithm for HPC systems in the cloud. Our algorithm does not rely on a spare node prior to prediction of a failure. We also developed a cost model for executing computation-intensive applications on HPC systems in the cloud. We analysed the dollar cost of provisioning spare nodes and checkpointing FT to assess the value of our approach. Our experimental results obtained from a real cloud execution environment show that the wall-clock execution time and cost of running computation-intensive applications in cloud can be reduced by as much as 30%. The frequency of checkpointing of computation-intensive applications can be reduced up to 50% with our FT approach for HPC in the cloud compared with current FT approaches.

Practical exception handling and resolution in concurrent programs

We describe a novel approach for software-implemented fault tolerance that separates error detection from error recovery and offers a distinct programming and processing context for the latter. This allows the application developer to address separately the non-functional aspects of error recovery from those pertaining to the functional behaviour that the user application is supposed to have in the absence of faults. We conjecture that this way only a limited amount of non-functional code intrusion affects the user application, while the bulk of the strategy to cope with errors is to be expressed by the user in a "recovery script", conceptually as well physically distinct from the functional application layer. Such script is to be written in what we call a "recovery language", i.e. a specialised linguistic framework devoted to the management of the fault tolerance strategies that allows to express scenarios of isolation, reconfiguration, and recovery. These are to be executed on meta-entities of the application with physical or logical counterparts (processing nodes, tasks, or user-defined groups of tasks). The developer is therefore made able to modify the fault tolerance strategy with only a few or no modifications in the application part, or vice-versa, tackling more easily and effectively any of these two fronts. This can result in a better maintainability of the target fault-tolerant application and in support for reaching portability of the service while moving the application to different unfavourable environments. The paper positions and discusses the recovery language approach and a prototypal implementation for embedded applications developed within project TIRAN on a number of distributed platforms.

This article is the second part of a two-part tutorial article on the design of fault-tolerant digital systems. The first part, published in November, presented the general principles of fault tolerance and discussed the use of redundancy to increase system reliability and availability. The article also commented on the design of self-testing logic circuits. In this second part, we concentrate more on what has been achieved in practice, and the article describes the JPL-Star computer. This is an experimental computer designed to evaluate many of the strategies for enhancing fault-tolerance, and it is already obsolete. This article concludes, therefore, with a brief survey of other fault-tolerant proposals and implementations

Today networks are too cumbersome due to the incoherent integration of various technologies developed over time. Convergence of data, voice, and video has caused the retro-fitting of a network to support non-native traffic types and this has led to sub-par performance for every traffic type. Fundamental changes are warranted to support high bandwidth traffic. The network must guarantee end-to-end delivery and provide inherent protection within the physical structure. We propose that the main traffic types of today's applications should be carried using the following features: connection-oriented service, traffic grooming to fill those connection oriented pipes, and forward error recovery with protection provided in the physical layer. We present some of our research results.

This paper presents a new approach to provide fault tolerance in MPLS multicast networks. MPLS has been used to provide faster forwarding; combining with multicasting it further supports applications with improved service. Fault tolerance is therefore important for such networks. Our approach for fault tolerance is to divide and encode the traffic into multiple disjoint trees using a modified (k, n) Threshold Sharing scheme. Our approach can reconstruct the original traffic from any k out of n trees available. Therefore, in the event of node/link failure(s) of any (n-k) trees, our approach provides fault tolerance without introducing any recovery delay and packet loss. Moreover, our objective is also to minimize bandwidth utilization for protection purposes.

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.

Existing fault tolerance approaches in the cloud are broadly based on replication and checkpointing. Each of these approaches has its advantages and limitations. This paper presents an adaptable fault tolerance method for determining which of the two approaches will be appropriate for the successful execution of a task in the given cloud conditions. The proposed method classifies the failure risk of host machines available for task execution based on their failure history. Subsequently, fuzzy logic is used to determine the appropriate fault tolerance approach by considering a host's failure risk, user-defined task's priority, and level of resource redundancy. Setting a task's priority provides a user with control to solicit a desired fault tolerance level while the availability of resources reflects a cloud provider's capability to offer fault tolerance. Simulation experiments have verified that the proactive selection of a fault-tolerance method increases the number of tasks that complete successfully.

Fault tolerance is of great importance for big data systems. Although several software-based application-level techniques exist for fault security in big data systems, there is a potential research space at the hardware level. Big data needs to be processed inexpensively and efficiently, for which traditional hardware architectures are, although adequate, not optimum for this purpose. In this paper, we propose a hardware-level fault tolerance scheme for big data and cloud computing that can be used with the existing software-level fault tolerance for improving the overall performance of the systems. The proposed scheme uses the concurrent error detection (CED) method to detect hardware-level faults, with the help of Scalable Error Detecting Codes (SEDC) and its checker. SEDC is an all unidirectional error detection (AUED) technique capable of detecting multiple unidirectional errors. The SEDC scheme exploits data segmentation and parallel encoding features for assigning code words. Consequently, the SEDC scheme can be scaled to any binary data length “n” with constant latency and less complexity, compared to other AUED schemes, hence making it a perfect candidate for use in big data processing hardware. We also present a novel area, delay, and power efficient, scalable fault secure checker design based on SEDC. In order to show the effectiveness of our scheme, we (1) compared the cost of hardware-based fault tolerance with an existing software-based fault tolerance technique used in HDFS and (2) compared the performance of the proposed checker in terms of area, speed, and power dissipation with the famous Berger code and m-out-of-2m code checkers. The experimental results show that (1) the proposed SEDC-based hardware-level fault tolerance scheme significantly reduces the average cost associated with software-based fault tolerance in a big data application, and (2) the proposed fault secure checker outperforms the state-of-the-art checkers in terms of area, delay, and power dissipation.

Purpose The purpose of this paper is to propose an adaptive neural-sliding mode-based observer for the estimation and reconstruction of unknown faults and disturbances for time-varying nonlinear systems such as aircraft, to ensure preciseness in the diagnosis of fault magnitude as well as the shape without enhancement of system complexity and cost. Fault-tolerant control (FTC) strategy based on adaptive neural-sliding mode is also proposed in the existence of faults for ensuring the stability of the faulty system. Design/methodology/approach In this paper, three strategies are presented: adaptive radial basis functions neural network (ARBFNN), conventional radial basis functions neural network (CRBFNN) and integral-chain differentiator. For the purpose of enhancement of fault diagnosis and isolation, a new sliding mode-based concept is introduced for the weight updating parameters of radial basis functions neural network (RBFNN).The main objective of updating the weight parameters adaptively is to enhance the effectiveness of fault diagnosis and isolation without increasing the computational complexities of the system. Results depict the effectiveness of the proposed ARBFNN approach in fault detection (FD) and approximation compared to CRBFNN, integral-chain differentiator and schemes existing in literature. In the second step, the FTC strategy is presented separately for each observer in the presence of unknown faults and failures for ensuring the stability of the system, which is validated on Boeing 747 100/200 aircraft. Findings The proposed adaptive neural-sliding mode approach is investigated, which depicts more effectiveness in numerous situations such as faults, disturbances and uncertainties compared to algorithms used in literature. In this paper, both the fault approximation and isolation and the fault tolerance approaches are studied. Practical implications For the enhancement of safety level as well as for avoiding any kind of damage, timely FD and fault tolerance have always had a significant role; therefore, the algorithms proposed in this research ensure the tolerance of faults and failures, which plays a vital role in practical life for avoiding any kind of damage. Originality/value In this study, a new neural-sliding mode concept is adopted for the adaptive faults approximation and reconstruction, and then the FTC algorithms are studied for each observer separately, whereas in previous studies, only the fault detection and isolation (FDI) or the fault tolerance problems were studied. Results demonstrate the effectiveness of the proposed strategy compared to the approaches given in the literature.

A wireless sensor network (WSN) is a collection of various tiny devices known as sensor nodes, which are also called motes. Due to high-energy consumption, the possibility of hardware, link or node failure, and some malicious attacks, sensor networks are considered error-prone networks. Hence, fault tolerance (FT) in WSN is one of the prominent issues. This article presents a novel FT approach named node-link failure fault tolerance model (NLFFT Model) in WSN, to handle the faults that occur either by link or node failure during data transmission from the sensor to the sink or base station. The NLFFT model consists of an improved quadratic minimum spanning tree (Imp-QMST) approach. This approach helps in finding the alternate link whenever it fails due to various situations and also an improved-handoff (Imp-Handoff) algorithm to support the node failure to the fault tolerance. Improved QMST presents a novel mechanism to find an alternate edge in place of the broken or failed edge in the spanning tree, to improve the fault tolerance in WSN. Imp-Handoff suggests a novel way to find the faulty node owing to less battery power and replaces a defective node by an appropriate neighbor to shift the tasks performed by a faulty node in WSN. Simulation results clearly state that as compared to the basic techniques i.e. Q-MST and Handoff algorithm, the proposed NLFFT model improvises the performance of WSN around by 7%. The results prove that the Imp-QMST gives about 6% improved throughput, 5% less end-to-end delay, and 6% less power consumption than the QMST algorithm. Similarly, Imp-Handoff improves about 4% throughput, 6% less end-to-end delay, and utilizes 7% less power consumption.

Fault tolerance, performance, and throughput have been major areas of research and development since the evolution of large-scale networks. Internet-based applications are rapidly growing, including large-scale computations, search engines, high-definition video streaming, e-commerce, and video on demand. In recent years, energy efficiency and fault tolerance have gained significant importance in data center networks and various studies directed the attention towards green computing. Data centers consume a huge amount of energy and various architectures and techniques have been proposed to improve the energy efficiency of data centers. However, there is a tradeoff between energy efficiency and fault tolerance. The objective of this study is to highlight a better tradeoff between the two extremes: (a) high energy efficiency and (b) ensuring high availability through fault tolerance and redundancy. The main objective of the proposed Energy-Aware Fault-Tolerant (EAFT) approach is to keep one level of redundancy for fault tolerance while scheduling resources for energy efficiency. The resultant energy-efficient data center network provides availability as well as fault tolerance at reduced operating cost. The main contributions of this article are: (a) we propose an Energy-Aware Fault-Tolerant (EAFT) data center network scheduler; (b) we compare EAFT with energy efficient resource scheduling techniques to provide analysis of parameters such as, workload distribution, average task per servers, and energy consumption; and (c) we highlight effects of energy efficiency techniques on the network performance of the data center.

Cloud data centers, realizing that the amount of unused resources is significant, have started offering them as transient resources with unpredictable, irreversible revocation. The use of transient resources indicates many relevant issues still pose critical challenges, including security, strong and reliable connectivity and fault-tolerance approaches. To effectively use transient cloud servers to fulfill user requests, it is necessary to define an appropriate fault-tolerant mechanism and its respective parameters to avoid data loss if an unexpected failure occurs. We present an agent-based framework, namely BRA2Cloud, for integrating bag-of-tasks enabled systems using unreliable transient resources. To guarantee application execution and better use of idle resources, it is necessary to create an execution plan through fault tolerance definitions to increase reliability. To do this, BRA2Cloud agents combine features to predict failures in a multi-agent architecture that dynamically creates fault-tolerant multi-strategies, considering the current availability scenario and providing a resilient environment according to users’ application needs. Our approach was validated using real data retrieved between 2017 and 2019 from Amazon Spot Instances. Exhaustive experiments achieved high accuracy levels, reaching a 91% survival prediction success rate, which indicates the model is effective under realistic working conditions. We consider the results promising, decreasing up to 74.48% in total execution time when compared to other approaches in the literature. As the main requirements of our proposal, we have defined a series of features that BRA2Cloud should have in order to address the impact of these definitions on resiliency provision, application execution time reduction, and monetary cost reduction.

The integration of software COTS components into safety-critical real-time systems raises serious problems from a dependability viewpoint. Wrappers can be used to assist such an integration by providing additional error detection mechanisms. We recently defined a framework to automatically develop such a type of wrappers from temporal logic specifications. In this paper, we extend this framework to endow wrappers with forward error recovery capabilities based on the concept of recovery actions. Recovery actions consist of variants of basic functions of the target system that are run concurrently to help correct errors. We apply these comprehensive wrappers to a real-time COTS microkernel. Software implemented fault injection (SWIFI) is then used to evaluate the efficiency of the wrappers. This step helped identify the sets of wrappers that maximize the error detection and recovery coverage while meeting hard task deadlines.