Software Fault Tolerance Research Articles

A model for error recovery with global checkpointing

The paper proposes a new technique for providing software fault tolerance in concurrent systems. It combines the traditional global checkpointing mechanism with the recovery block concept in order to come up with an easily implementable error recovery mechanism. This mechanism involves smaller overhead in case of moderate to high process interaction than the schemes considered in past, which are based upon the idea of local checkpointing. A model for computing the optimum checkpointing interval is also presented. A particular distribution is hypothesized for the coverage of the recovery, and the behavior of the model is studied in detail for this case.

A Framework for Software Fault Tolerance in Real-Time Systems

Real-time systems often have very high reliability requirements and are therefore prime candidates for the inclusion of fault tolerance techniques. In order to provide tolerance to software faults, some form of state restoration is usually advocated as a means of recovery. State restoration can be expensive and the cost is exacerbated for systems which utilize concurrent processes. The concurrency present in most real-time systems and the further difficulties introduced by timing constraints suggest that providing tolerance for software faults may be inordinately expensive or complex. We believe that this need not be the case, and propose a straightforward pragmatic approach to software fault tolerance'which is believed to be applicable to many real-time systems. The approach takes advantage of the structure of real-time systems to simplify error recovery, and a classification scheme for errors is introduced. Responses to each type of error are proposed which allow service to be maintained.

Efficient local checkpointing for software fault tolerance

The Recovery Block (RB) concept proposed by Randell [1] for implementing software fault tolerance involves the establishment of local checkpoints (LCP) whenever a process enters a RB. In order for the scheme to be practical, it is important that the overhead of this checkpointing be small both in time and storage. Therefore, we must look into alternatives to simply caching the complete process state at the point of entry to a RB. Since the checkpointing mechanism need be concerned with only those variables that are modified within a RB, an obvious approach is to keep only the previous (i.e. unmodified) values of these variables. In this note, we examine some implementation difficulties with this approach and then propose a somewhat unusual scheme which saves only the modified values at the end of a RB execution.

The Model 706 side‐scan mapping system: A marine geophysical survey instrument

A radically new side‐scan mapping system, featuring an evolutionary approach, has integrated multiprocessors for future growth and custom expansion, while maintaining compatibility with proven technology in transducers, towfish bodies, and electrographic chart recorders. The balance between hardware and software solutions has produced a relatively small, modular, easily maintained machine with features that extend beyond the total spectrum of previous side‐scan systems. These features include the ability to generate true scale mosaics of the sea floor while simultaneously displaying bathymetric, subbottom, and altitude tracking data on a 19‐in.‐wide, dry paper, electrographic chart recorder. All processing is performed in real time with additional signal processing possible from magnetic tape during playback. Menu driven user programming simplifies operational use and includes self‐test fault diagnosis. Fault tolerant software recovery insures minimum downtime, during surveys. The features and design philosophy are examined in detail followed by a discussion of operational performance data gathered during the last year. Custom enhancement capabilities for specific applications will be covered with details on typical configurations.

Exception Handling and Software Fault Tolerance

Some basic concepts underlying the issue of fault-tolerant software design are investigated. Relying on these concepts, a unified point of view on programmed exception handling and default exception handling based on automatic backward recovery is constructed. The cause–effect relationship between software design faults and failure occurrences is explored and a class of faults for which default exception handling can provide effective fault tolerance is characterized. It is also shown that there exists a second class of design faults which cannot be tolerated by using default exception handling. The role that software verification methods can play in avoiding the production of such faults is discussed.

Some Critical Comments on the Paper "An Optimal Approach to Fault Tolerant Software Systems Design" by Gannon and Shapiro

Some Critical Comments on the Paper "An Optimal Approach to Fault Tolerant Software Systems Design" by Gannon and Shapiro

A case study in fault tolerant software

AbstractThe addition of redundancy to data structures can be used to improve the ability of a software system to detect and correct errors, and to continue to operate according to its specifications. A case study is presented which indicates how such redundancy can be deployed and exploited at reasonable cost to improve software fault tolerance. Experimental results are reported for the small data base system considered.

Redundancy in Data Structures: Some Theoretical Results

A companion paper, "Redundancy in Data Structures: Improving Software Fault Tolerance," provides an infonnal introduction to robust data structures. Here, we present the underlying theory for them, and use it to discuss the synthesis and cost effectiveness of robust data structures.

Fault tolerance and digital systems

The paper surveys recent techniques for incorporating selftest and fault-tolerant features into digital systems and comments on their applicability to designs containing VLSI components, such as microprocessors and microcomputers. In particular, the paper covers coding techniques and the design of totally self-checking code checkers; the design of fault-tolerant computer subsystems such as clock generators and semiconductor memory; and techniques for including built-in test facilities and the development of self-test checkout routines. In conclusion, it is suggested that the next major area for research must be the design of fault-tolerant software.

Fault-Tolerant Software

Limitations in the current capabilities for verifying programs by formal proof or by exhaustive testing have led to the investigation of fault-tolerance techniques for applications where the consequence of failure is particularly severe. Two current approaches, N-version programming and the recovery block, are described. A critical feature in the latter is the acceptance test, and a number of useful techniques for constructing these are presented. A system model for the recovery block is introduced, and conclusions derived from this model that affect the design of fault-tolerant software are discussed.

System structure for software fault tolerance

This paper presents and discusses the rationale behind a method for structuring complex computing systems by the use of what we term recovery blocks, conversations, and fault tolerant interfa...

System structure for software fault tolerance

The paper presents, and discusses the rationale behind, a method for structuring complex computing systems by the use of what we term “recovery blocks”, “conversations” and “fault-tolerant interfaces”. The aim is to facilitate the provision of dependable error detection and recovery facilities which can cope with errors caused by residual design inadequacies, particularly in the system software, rather than merely the occasional malfunctioning of hardware components.