Software fault tolerance in real-time embedded systems

Many critical embedded systems which have very high reliability requirements operate in real time. Considering the significance of their applications, design of highly reliable software is a very important research area. In the development of reliable real-time embedded applications, fault-tolerance is a very important aspect. Embedded systems which do not include every facility to enhance reliability are unacceptable in the critical applications being considered. Particularly this research is important for systems where the consequences of any noncompliance of software with its requirements may be disastrous. Even though some techniques have been proposed to increase reliability, it is almost always that software still contains residual errors. These errors may have extremely serious consequences especially for critical applications such as military command and control, missile guidance and control system, nuclear power reactor control, transportation, patient monitoring system, etc. Software fault-tolerance techniques are useful in handling these residual errors. Research is being conducted for developing a systematic design methodology with fault-tolerant capabilities for the design of reliable software in real-time embedded applications. In particular, we are currently investigating effective error detection and recovery techniques to provide the continued service required by the embedded system. We will also investigate methodologies to design modules with good error-resistant and self-recovery capabilities. The value and nature of the research project is such that its result will be directly applicable to any practical real-time embedded systems.The serious consequences of faulty software occur in real-time systems, where either human life can be endangered or large economic losses can be incurred due to a failure. While techniques are being perfected to cope with known sources of errors in software, the growth of software complexity continues with a resultant increase in its vulnerability to errors. Although improvements in software development methodologies can undoubtedly reduce the incidence of software faults, the final line of defense rests on testing and verification. However, it is clear that neither formal verification techniques, nor extensive testing can be depended upon to provide the degree of reliability that is required for software in critical applications, especially in real-time embedded systems. Considering the lack of design methodologies which can guarantee that a complex software system does not contain residual design faults, it is surprising that fault tolerance has rarely been considered necessary. In order to achieve fault-tolerance in software, the software must possess the capabilities to detect errors and to recover from the errors.This research is primarily concerned with the development of effective techniques for achieving fault-tolerance in the large-scale embedded applications providing users with continued services in real-time operation in spite of the occurrence of partial malfunctions of the systems. Techniques are being developed using the structural properties of a software so that the techniques will be useful for programs written in different programming languages and operating in different environments. To do this, it is important for us to represent a program by a suitable structural model for analysis so that its structural properties can be conveniently exploited. We have found that the simple directed graph model is most suitable for the project. In this model, the program is represented by a directed graph consisting of a set of nodes and a set of directed branches. A node can represent a computational task, whereas a directed branch can represent possible transfer of control from a node to another. The graph model can represent a program at any level of abstraction in a way easily interpretable by the programmer. Therefore, the real-time software systems are modeled as a set of cooperating sequential processes with constraints on their execution time. Each process corresponds to the execution of program which is part of the system, and provides some subset of the necessary system outputs.The next step is to develop error-resistant programming techniques using the self-checking approach. Self-checking techniques can be implemented to check the function, the control sequence and the data of a program. There are three specific aspects in this part of the proposed research. First, an error classification scheme is being investigated. Types of errors we consider include control flow and data flow errors, module level errors, program level errors, etc.Based on the error classification scheme, developing techniques for error detection and checking data integrity is underway. A Fault-Handler is being developed and utilized to monitor the behavior of the software system for detecting errors. In order to classify errors with reasonable accuracy, it may be necessary for the Fault-Handler to retain information concerning the error history of processes in the system.Effective techniques for recovery is being investigated by making good use of the information retained in the erroneous state and in the Fault-Handler. In order to achieve resistance to errors, the program should contain enough data or information to handle all error conditions intelligently. The techniques for program design using the criteria of error-resistant modularization are also being investigated and suitable recommendations made along with the recovery techniques. Error-resistant modularization seems to involve the identification and localization of recovery data and building a module around them.