Software Fault-Tolerance with Off-the-Shelf SQL Servers

Chances of occurrence of fault increases when program goes beyond few thousand lines, even with the use of formal methods for fault prevention. These faults need very exhaustive testing to be removed, which is infeasible. This implies the indispensability of software fault tolerance (SFT) before facing the consequences of faults. Since 1972, several different SFT techniques have been proposed. But still occurrence of failures imply the failure of existing SFT techniques in considering all the required parameters. In this paper we analyze 16 replication based SFT techniques proposed after 1972 that have long-term influence or some paramount significance. We put them in classification based upon diversity they offer, adjudication mechanism they use & whether or not they are adaptive. Then we catalog the essential parameters for optimal adjudication, diversity & adaptiveness along with suggestions to incorporate those parameters. Finally, we map the listed techniques on these parameters. We came up with the result that none amongst the existing technique addresses all the essential parameters. This paper serves as a touch stone to evaluate any SFT technique & provides substantial guide for the researchers in proposing new SFT technique.

The N-Version Programming (NVP) approach applies the idea of design diversity to obtain fault-tolerant software units, called N-Version Software (NVS) units. The effectiveness of this approach is examined by the software diversity achieved in the member versions of an NVS unit. We define and formalize the concept of design diversity and software diversity in this paper. Design diversity is a property naturally applicable to the NVP process to increase its fault-tolerance attributes. The baseline design diversity is characterized by the employment of independent programming teams in the NVP. More design diversity investigations could be enforced in the NVP design process, including different languages, different tools, different algorithms, and different methodologies. Software diversity is the resulting dissimilarities appearing in the NVS member versions. We characterize it from four different points of view that are designated as: structural diversity, fault diversity, tough-spot diversity, and failure diversity. Our goals are to find a way to quantify software diversity and to investigate the measurements which can be applied during the life cycle of NVS to gain confidence that operation will be dependable when NVS is actually employed. The versions from a six-language N-Version Programming project for fault-tolerant flight control software were used in the software diversity measurement.

As computing capabilities continue to advance, there will be a concurrent rise in the number of both hardware and software faults. These will be caused by the greater volume of more complex software, by the increased number of untested software states, and by more incidents of hardware/software interaction faults as a result of increased hardware speed and density. The traditional software implemented fault tolerance approaches have been successfully utilized in life-critical systems, such as digital flight controls, where their additional costs can be easily justified. Examples include N-Version Programming and Recovery Block approaches. However, there is still a need for dependable computing for mission-critical applications as well. Often, these traditional techniques are avoided for mission-critical systems due to the difficulty in justifying their extra upfront development cost. We provide an alternative for the high sunk cost of traditional software fault tolerance techniques. The methodology, called Data Fusion Integrity Processes (DFIPs), is a simple, yet effective technique for mission critical systems. In addition, the approach establishes a framework from which other costlier, more extensive traditional techniques can be added. We present details of the DFIP methodology and a DFIP framework for Ada programs. We also briefly discuss development of a DFIP code generation system which exploits Java that will enable users to quickly build a DFIP framework in Ada, and select reusable DFIP component methods.

Recently, software verification using model checkers has achieved widespread success. It can locate hard-to-find bugs in software by exhaustively searching executing paths. In this paper, we propose a new software design method that enables the evaluation of the fault tolerance of software behavior at the specification level: we can check software behavior, not only when the hardware and network are in good order, but also when they are out of order; we can then improve fault tolerance of the target software using the model checker. We can test software under environments in which we destroy hardware and/or networks intentionally, not in situ, but in silico (in computer simulation).

This paper addresses the practical implementation of means of tolerating residual software faults in complex software systems, especially concurrent and distributed ones. There are several inherent difficulties in implementing such fault-tolerant software systems, including the controlled use of extra redundancy and the mixture of different design concerns. In an attempt to minimise these difficulties, we present a generic implementation approach, composed of a multi-layered reference architecture, a configuration method and an architectural pattern. We evaluate our implementation approach using an industrial control application whose control software we equip with the ability to tolerate a variety of software faults. The preliminary evidence shows that our approach can simplify the implementation process, reduce repetitive development effort and provide high flexibility through a generic interface for a wide range of fault tolerance schemes.

An adaptive approach to achieving hardware and software fault tolerance in a distributed computing environment

A fault is any type of bug or error or failure that occurs in the system when any hardware is failed and requires replacement or strained to reboot or software fails to give the result. System failure occurs when the fault in system is not revealed and corrected in time. Software fault tolerance is the major research area in software development industry. Software fault tolerance enables a system to operate efficiently if any fault exists in the system and makes 011.0210 s a system capable to protect against any type of accidental or malicious destruction of the information in system. Many techniques of fault tolerance and recovery have been proposed in work of literatures in order to ensure efficient working of software. The main objective of this paper is to propose fault-tolerant framework based on N-version and recovery block mechanism for automatic test case generation. Simulation results show that proposed framework improves the reliability in terms of elapsed time, classification accuracy, and mean square error.KeywordsSoftware testingSoftware fault predictionSoftware fault toleranceSoftware fault tolerance techniquesReal-time systems

In fault tolerant software systems, the Level of Decomposition (LoD) where design diversity is applied has a major impact on software system reliability. By disregarding this impact, current fault tolerance techniques are prone to reliability decrease due to the inappropriate application level of design diversity. In this paper, we quantify the effect of the LoD on system reliability during software recomposition when the functionalities of the system are redistributed across its components. We discuss the LoD in fault tolerant software architectures according to three component failure transitions: component failure occurrence, component failure propagation, and component failure impact. We illustrate the component aspects that relate the LoD to each of these failure transitions. Finally, we quantify the effect of the LoD on system reliability according to a series of decomposition and/or merge operations that may occur during software recomposition.

N-version programming is one of the most common techniques which is used to improve the reliability of software by building in fault tolerance, redundancy and decreasing common cause failures. N different equivalent software versions are developed by N different and isolated workgroups by considering the same software specifications. The versions solve the same task and return results that have to be compared to determine the correct result. Decisions of N different versions are evaluated by a voting algorithm or the so-called voter. In this paper, two of the most commonly used software voting algorithms such as the majority voting algorithm and the consensus voting algorithm are studied. The distinctive features of Nversion programming with majority voting and N-version programming with consensus voting are described. These two algorithms make a decision about the correct result on the base of the agreement matrix. However, if the equivalence relation on the agreement matrix is not satisfied it is impossible to make a decision. It is shown that the agreement matrix can be transformed into an appropriate form by using the Boolean compositions when the equivalence relation is satisfied.

This paper contributes an analysis of possible pitfalls of automated test execution and provides an novel approach for TTCN-3 test system to manage and recover from errors occurred in the System Under Test (SUT) during test execution. The research problem addressed in this paper is how to facilitate recovery of distributed test system to recover from cascading errors caused by software faults in the SUT. This research problem is addressed by applying the software fault tolerance techniques in the implementation of the testing environment. Provided solutions for error recovery and management are derived from the software fault tolerance research work carried out during last decades. The presented approach is validated in a prototype TTCN-3 test environment supporting testing of distributed communication systems.

Dependability modeling and evaluation (encompassing reliability and safety issues) of the two major fault tolerance software approaches-recovery blocks (RBs) and N version programming (NVP)-are presented. The study is based on the detailed analysis of software fault-tolerance architectures able to tolerate a single fault (RB: two alternates and an acceptance test; NVP: three versions and a decider). For each approach a detailed model based on the software production process is established and then simplified by assuming that only a single fault type may manifest during execution of the fault-tolerant software and that no error compensation may take place within the software. The analytical results obtained make it possible to identify the improvement, compared to a non-fault-tolerant software, that could result from the use of RB (the acceptance test has to be more reliable from the alternates) and NVP (related faults among the versions and the decider have to be minimized) and to determine the most critical types of related faults. Nested RBs are studied, showing that the proposed analysis approach can be applied to such realistic software structures and that when an alternate is itself an RB, the results are analogous to the case of the addition of a third alternate. The reliability analysis shows that only a small improvement can be expected.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>

The aim of this paper is to provide a personal perspective on the subject of design fault tolerance, and in particular software fault tolerance, as it has developed at Newcastle and elsewhere, and to speculate briefly on how the subject might advance in the future. The principal topics covered are the search for an appropriate set of basic concepts and definitions, the differing styles of fault masking provided by recovery blocks and N-version programs, the growing sophistication of error recovery techniques, particularly in distributed systems, and the problems of assessing the cost/effectiveness of design fault tolerance.KeywordsFormal VerificationDesign FaultError RecoveryException HandlingErroneous StateThese keywords were added by machine and not by the authors. This process is experimental and the keywords may be updated as the learning algorithm improves.

Several advances in fault tree models have been developed as an aid in the analysis of computer systems. Such advances include the ability to model sequence dependencies, the application of fault trees to the analysis of hardware and software fault tolerant systems, the ability to include details of the recovery process in the fault tree solution, and the use of modularization and binary decision diagrams as an aid in solution. In this paper we present a software package (DIFtree) that implements these advances into a single methodology that can solve both dynamic and static fault trees, and which is applicable to the analysis of hardware, software and humanware in complex computer-based systems.

This paper shows how modern structuring techniques can be employed in integrating complex web applications such as travel agency systems. The main challenges the developers of such systems face are dealing with legacy web services and incorporating means for tolerating errors. Because of the very nature of such systems, exception handling is the main recovery technique to be applied in their development. We employ coordinated atomic actions to allow disciplined handling of such abnormal situations by recursively structuring the integrated system and by associating handlers with such actions. We use protective wrappers in such a way that each operation on legacy components is transformed into an atomic action with a well-defined interface. To accommodate a combined use of several ready-made environments (such as communication packages, services and run-time supports), we employ a multilevel exception handling. We believe that these techniques are generally applicable for both: structuring integrated web applications and providing their fault tolerance.

On Architecting Software Fault Tolerance using Abstractions