Software Fault Tolerance Research Articles

A Fuzzy Approach for Component Selection amongst Different Versions of Alternatives for a Fault Tolerant Modular Software System under Recovery Block Scheme Incorporating Build-or-Buy Strategy

Software projects generally have to deal with producing and managing large and complex software products. As the functionality of computer operations become more essential and yet more critical, there is a great need for the development of modular software system. Component-Based Software Engineering concerned with composing, selecting and designing components to satisfy a set of requirements while minimizing cost and maximizing reliability of the software system. This paper discusses the fuzzy approach for component selection using “Build-or-Buy” strategy in designing a software structure. We introduce a framework that helps developers to decide whether to buy or build components. In case a commercial off-the-shelf (COTS) component is selected then different versions are available for each alternative of a module and only one version will be selected. If a component is an in-house built component, then the alternative of a module is selected. Numerical illustrations are provided to demonstrate the model developed.

Extending Ada to support multi-core based monitoring and fault tolerance

Monitoring-Oriented Programming (MOP) and Software Fault Tolerance(SFT) are two important approaches to guarantee the reliablity of software systems, especially for those running online for long term. However, the introduction of monitoring or fault tolerance module will bring in high overhead. With the prevalence of multi-core platform, we can find the trade off between the reliablity and the efficiency. As one of the most reliable programming languages, Ada is used to a significant degree in many fields. Providing the support of MOP and SFT in Ada can help the programmers enhance the reliablity of software systems. In this paper, we present an approach to extending Ada to support multi-core based monitoring and fault tolerance. First we introduce the framework of multi-core based MOP and SFT. Based on this framework, programmers can design the components of MOP and SFT with tasks parallel to main tasks in Ada programming. All these tasks can be allocated to different physical cores to run concurrently. Then, we give a proposal for enabling multi-core based MOP and SFT in Ada. In this proposal, we design two packages System.MOP_Elements and System.SFT_Elements for programmers to indicate various monitoring and fault tolerance components. With the packages,programmers can also assign computation resources for each component. Finally we animate this proposal via a prototype tool called MCAda and use two case studies to show our approach.

Optimal Fault Tolerance Strategy Selection for Web Services

Service-oriented systems are usually composed by heterogeneous Web services, which are distributed across the Internet and provided by organizations. Building highly reliable service-oriented systems is a challenge due to the highly dynamic nature of Web services. In this paper, the authors apply software fault tolerance techniques for Web services, where the component failures are handled by fault tolerance strategies. In this paper, a distributed fault tolerance strategy evaluation and selection framework is proposed based on versatile fault tolerance techniques. The authors provide a systematic comparison of various fault tolerance strategies by theoretical formulas, as well as real-world experiments. This paper also presents the optimal fault tolerance strategy selection algorithm, which employs both the QoS performance of Web services and the requirements of service users for selecting optimal fault tolerance strategy. A prototype is implemented and real-world experiments are conducted to illustrate the advantages of the evaluation framework. In these experiments, users from six different locations perform evaluation of Web services distributed in six countries, where over 1,000,000 test cases are executed in a collaborative manner to demonstrate the effectiveness of this approach.

Optimization of WS-BPEL Workflows through Business Process Re-Engineering Patterns

With the advent of XML-based SOA, WS-BPEL swiftly became a widely accepted standard for modeling business processes. Although SOA is said to embrace the principle of business agility, BPEL process definitions are still manually crafted into their final executable version. While SOA has proven to be a giant leap forward in building flexible IT systems, this static BPEL workflow model should be enhanced to better sustain continual process evolution. In this paper, the authors discuss the potential for adding business intelligence with respect to business process re-engineering patterns to the system to allow for automatic business process optimization. Furthermore, the paper examines how these re-engineering patterns may be implemented, leveraging techniques that were applied successfully in computer science. Several practical examples illustrate the benefit of such adaptive process models. These preliminary findings indicate that techniques like the re-sequencing and parallelization of instructions, further optimized by introspection, as well as techniques for achieving software fault tolerance, are particularly valuable for optimizing business processes. Finally, the authors elaborate on the design of people-oriented business processes using common human-centric re-engineering patterns.

OPTIMAL COMPONENT SELECTION OF COTS BASED SOFTWARE SYSTEM UNDER CONSENSUS RECOVERY BLOCK SCHEME INCORPORATING EXECUTION TIME

Computer based systems have increased dramatically in scope, complexity, pervasiveness. Most industries are highly dependent on computers for their basic day to day functioning. Safe & reliable software operations are an essential requirement for many systems across different industries. The number of functions to be included in a software system is decided during the software development. Any software system must be constructed in such a way that execution can resume even after the occurrence of failure with minimal loss of data and time. Such software systems which can continue execution even in presence of faults are called fault tolerant software. When failure occurs one of the redundant software modules get executed and prevent system failure. The fault tolerant software systems are usually developed by integrating COTS (commercial off-the-shelf) software components. The motivation for using COTS components is that they will reduce overall system development costs and reduce development time. In this paper, reliability models for fault tolerant consensus recovery blocks are analyzed. In first optimization model, we formulate joint optimization problem in which reliability maximization of software system and execution time minimization for each function of software system are considered under budgetary constraint. In the second model the issue of compatibility among alternatives available for different modules, is discussed. Numerical illustrations are provided to demonstrate the developed models.

Optimal component selection of COTS based software system under recovery block scheme incorporating execution time

For the effective development of the faulttolerant software system, cost, reliability and time are the important aspects to be considered. Ideally, any software system must be constructed in such a way that execution can resume even after failure without the loss of data and time. Such software systems which can continue execution even after the occurrence of faults are called fault tolerant software. Software is developed to perform a pre-decided number of functions that can be executed by the software system. When fault occurs, one of the redundant components get executed and prevents system failure. Advancement of technology and increasing software development cost has made the use of commercial off-the-shelf (COTS) software which builds system with reduced risk, cost and development time while increasing functionality and capability of the system. In this paper, two reliability models for fault tolerant recovery blocks are discussed. In the first optimization model, we formulate a joint optimization problem in which reliability maximization of software system and execution time minimization for each function of software system are considered under budgetary constraint. In the second model the issue of compatibility among alternatives available for different modules, is discussed. Numerical illustrations are provided to demonstrate the models developed in this paper.

Neonatal Informatics—Dream of a Paperless NICU: Part Three: Complex Crashes

Tracking changes over time is key for clinical decision-making in intensive care units (ICUs). Critical caregivers need fast data from the laboratory and monitoring and treatment machines as well as time-stamped drug and fluids information. Workflow interactions with temporal urgencies complicated by multiple handovers and delays in return of laboratory results and delivery of care products are common in all ICUs. Temporally and physiologically integrating critical clinical information, spotting deteriorating trends, and conveying the information asynchronously to the health-care team in ICUs historically was accomplished by redundant, overlapping human workflow systems. Current computerized information systems for “charting” and “ordering” have fragmented capabilities for recording and managing date/time elements, falling far behind fast-moving events because they require time-consuming typed data entry. These facts contribute to slow recognition of subtly deteriorating patient conditions. Root cause analysis of problem situations often leads to discovery of the reason(s) for a poor outcome. Problem situations develop progressively from delays in generating and moving information. There is no predictable lull in the action in most critical care units; perinatal emergencies cannot wait for computers. Human workarounds continue to support ongoing clinical processes, including family visits, despite the information flow chaos that emerges when emergencies occur at change of shift. Expert neonatal clinicians cope by using teamwork-based, multilayered methods. Existing clinical computer systems rarely are capable of supporting multitasking clinicians effectively. Decision support could assist caregivers in critical care situations with a computer system that “watches” for expected laboratory results via an institutional protocol that differs by care unit, then notifies the correct covering person when the time limit is exceeded. Adequate critical care decision support requires highly robust HISs; fail-over servers; fault-tolerant software architecture designs; and modular, maintainable, standards-based, integrated utility systems (eg, laboratory, pharmacy, radiology, blood bank) that communicate time-stamped information in real-time using “standardized” health-care messaging. An engineering solution is needed, with attention to human factors engineering. The United States health-care computerization effort needs a parallel project to define and develop political and business management systems solutions to ascertain adequate funding for developing, disseminating, implementing, and maintaining airplane quality, real-time hospital information management systems for neonates and other critical patients.

Separation of Fault Tolerance and Non-Functional Concerns: Aspect Oriented Patterns and Evaluation

Dependable computer based systems employing fault tolerance and robust software development techniques demand additional error detection and recovery related tasks. This results in tangling of core functionality with these cross cutting non-functional concerns. In this regard current work identifies these dependability related non-functional and cross-cutting concerns and proposes design and implementation solutions in an aspect oriented framework that modularizes and separates them from core functionality. The degree of separation has been quantified using software metrics. A Lego NXT Robot based case study has been completed to evaluate the proposed design framework.

Spherical Robot Control System Based on Fault-tolerant Strategy

Based on the fault-tolerant strategy,the control system with high reliability is researched for a type of spherical robot. The control problem is decomposed into eight local controllers according to the task requirement of autonomous movement of the spherical robot,and thereby the embedded control system of the spherical robot with multi-sensors is implemented according to the structure of the local controllers proposed above. These local controllers are provided with the abilities of communication and information exchange among them,and a certain degree of autonomy in task assignment and collaboration. In order to improve the reliability of the control system,the dual-redundant backup servo control subsystem of the spherical robot is designed based on the redundant and fault-tolerant control technology. The dual-redundant backup servo control subsystem,which is composed of two same backup modules,realizes fault-tolerant tasks through methods of fault detection,fault location and system recovery and redundant restructuring according to the fault conditions. The operation of the fault-tolerant software system based on the time fault-tolerant and information fault-tolerant technology is monitored by the designed monitoring software. The results of the motion control experiment of the spherical robot show that the control system of the spherical robot based on the fault-tolerant strategy is feasible and effective.

Formalization of an architectural model for exception handling coordination based on CA action concepts

Architectures based on Coordinated Atomic action (CA action) concepts have been used to build concurrent fault-tolerant systems. This conceptual model combines concurrent exception handling with action nesting to provide a general mechanism for both enclosing interactions among system components and coordinating forward error recovery measures. This article presents an architectural model to guide the formal specification of concurrent fault-tolerant systems. This architecture provides built-in Communicating Sequential Processes (CSPs) and predefined channels to coordinate exception handling of the user-defined components. Hence some safety properties concerning action scoping and concurrent exception handling can be proved by using the FDR (Failure Divergence Refinement) verification tool. As a result, a formal and general architecture supporting software fault tolerance is ready to be used and proved as users define components with normal and exceptional behaviors.

Adaptive Fault Tolerance for Scalable Cluster Computing in Space

Future missions of deep-space exploration face the challenge of building more capable autonomous spacecraft and planetary rovers. Given the communication latencies and bandwidth limitations for such missions, the need for increased autonomy becomes mandatory, along with the requirement for enhanced on-board computational capabilities while in deep-space or time-critical situations. This will result in dramatic changes in the way missions are conducted and supported by on-board computing systems. Specifically, the traditional approach of relying exclusively on radiation-hardened hardware and modular redundancy will not be able to deliver the required computational power. As a consequence, such systems are expected to include high-capability low-power components based on emerging commercial-off-the-shelf (COTS) multi-core technology. In this paper we describe the design of a generic framework for introspection that supports runtime monitoring and analysis of program execution as well as a feedback-oriented recovery from faults. Our focus is on providing flexible software fault tolerance matched to the requirements and properties of applications by exploiting knowledge that is either contained in an application knowledge base, provided by users, or automatically derived from specifications. A prototype implementation is currently in progress at the Jet Propulsion Laboratory, California Institute of Technology, targeting a cluster of cell broadband engines.

On Architecting Software Fault Tolerance using Abstractions

In this position paper, we argue how architectural abstractions can be effective in developing fault-tolerant software systems. Depending on the fault model and the resources available, different abstractions can be employed for representing architectural issues related to fault tolerance. These architectural abstractions, and their internal views, can be instantiated into concrete components and connectors for designing fault-tolerant software architectures. Since structural and behavioural properties associated with these abstractions are formally specified, the process of verifying and validating software architectures can be automated. In this paper, we focus on two architectural abstractions: the idealised fault-tolerant architectural element (iFTE), which is based on exception handling, and the halt-on-failure architectural element (HoFE), which assumes crash failure semantics.

Architecting Fault Tolerance with Exception Handling: Verification and Validation

When building dependable systems by integrating untrusted software components that were not originally designed to interact with each other, it is likely the occurrence of architectural mismatches related to assumptions in their failure behaviour. These mismatches, if not prevented during system design, have to be tolerated during runtime. This paper presents an architectural abstraction based on exception handling for structuring fault-tolerant software systems. This abstraction comprises several components and connectors that promote an existing untrusted software element into an idealised fault-tolerant architectural element. Moreover, it is considered in the context of a rigorous software development approach based on formal methods for representing the structure and behaviour of the software architecture. The proposed approach relies on a formal specification and verification for analysing exception propagation, and verifying important dependability properties, such as deadlock freedom, and scenarios of architectural reconfiguration. The formal models are automatically generated using model transformation from UML diagrams: component diagram representing the system structure, and sequence diagrams representing the system behaviour. Finally, the formal models are also used for generating unit and integration test cases that are used for assessing the correctness of the source code. The feasibility of the proposed architectural approach was evaluated on an embedded critical case study.

As-if-serial exception handling semantics for Java futures

Exception handling enables programmers to specify the behavior of a program when an exceptional event occurs at runtime. Exception handling, thus, facilitates software fault tolerance and the production of reliable and robust software systems. With the recent emergence of multi-processor systems and parallel programming constructs, techniques are needed that provide exception handling support in these environments that are intuitive and easy to use. Unfortunately, extant semantics of exception handling for concurrent settings is significantly more complex to reason about than their serial counterparts. In this paper, we investigate a similarly intuitive semantics for exception handling for the future parallel programming construct in Java. Futures are used by programmers to identify potentially asynchronous computations and to introduce parallelism into sequential programs. The intent of futures is to provide some performance benefits through the use of method-level concurrency while maintaining as-if-serial semantics that novice programmers can easily understand — the semantics of a program with futures is the same as that for an equivalent serial version of the program. We extend this model to provide as-if-serial exception handling semantics. Using this model our runtime delivers exceptions to the same point it would deliver them if the program was executed sequentially. We present the design and implementation of our approach and evaluate its efficiency using an open source Java virtual machine.

Car Park System: A Review of Smart Parking System and its Technology

Service technology such as Web services has been one of the mainstream technologies in today’s software development. Distributed services may suffer from communication problems or contain faults themselves, and hence service consumers may experience service interruption. A solution is to create services which can tolerate faults so that failures can be made transparent to the consumers. Since there are many patterns of software fault tolerance available, we end up with a question of which pattern should be applied to a particular service. This paper attempts to recommend to service developers the patterns for fault tolerant services. A recommendation model is proposed based on characteristics of the service itself and of the service provision environment. Once a fault tolerance pattern is chosen, a fault tolerant version of the service can be created as a WS-BPEL service. A software tool is developed to assist in pattern recommendation and generation of the fault tolerant service version.

Run‐time error detection of space‐robot based on adaptive redundancy

PurposeThe purpose of this paper is to present a novel algorithm to handle space environment induced errors in the space‐robot software.Design/methodology/approachThe radiations in outer space may induce transient errors in micro‐processors, this phenomena will make software behavior unpredictable, and the existing software fault tolerance methods have been restricted in non‐multi‐threaded operation systems, non‐component‐based frameworks, non‐cacheable micro‐processors, non‐distributed environments, etc. A software model for space‐robot software, based on adaptive redundancy, is developed and a corresponding run‐time error detection algorithm is presented in this paper. Software was monitored and run‐time transient error would be detected and processed.FindingsExperiments indicate that this method introduces about 30‐35 percent time overhead and about 200‐230 percent memory overhead. It also increases the fault detection rate to 84‐92.5 percent. Moreover, the model and algorithm is effective in a realistic space robot environment.Originality/valueA redundancy model is developed and an error detection algorithm is introduced in this paper. Experiments demonstrate it can provide space‐robot software with good protection against the radiation induced transient errors.

ORTEGA: An Efficient and Flexible Online Fault Tolerance Architecture for Real-Time Control Systems

Fault tolerance is an important aspect in real-time computing. In real-time control systems, tasks could be faulty due to various reasons. Faulty tasks may compromise the performance and safety of the whole system and even cause disastrous consequences. In this paper, we describe On-demand real-time guard (ORTEGA), a new software fault tolerance architecture for real-time control systems. ORTEGA has high fault coverage and reliability. Compared with existing real-time fault tolerance architectures, such as Simplex, ORTEGA allows more efficient resource utilizations and enhances flexibility. These advantages are achieved through the on-demand detection and recovery of faulty tasks. ORTEGA is applicable to most industrial control applications where both efficient resource usage and high fault coverage are desired.

A survey of linguistic structures for application-level fault tolerance

Structures for the expression of fault-tolerance provisions in application software comprise the central topic of this article. Structuring techniques answer questions as to how to incorporate fault tolerance in the application layer of a computer program and how to manage the fault-tolerant code. As such, they provide the means to control complexity, the latter being a relevant factor for the introduction of design faults. This fact and the ever-increasing complexity of today's distributed software justify the need for simple, coherent, and effective structures for the expression of fault-tolerance in the application software. In this text we first define a “base” of structural attributes with which application-level fault-tolerance structures can be qualitatively assessed and compared with each other and with respect to the aforementioned needs. This result is then used to provide an elaborated survey of the state-of-the-art of application-level fault-tolerance structures.

Managing redundancy in CAN-based networks supporting N-Version Programming

Software is a major source of reliability degradation in dependable systems. One of the classical remedies is to provide software fault tolerance by using N-Version Programming (NVP). However, due to requirements on non-standard hardware and the need for changes and additions at all levels of the system, NVP solutions are costly, and have only been used in special cases. In a previous work, a low-cost architecture for NVP execution was developed. The key features of this architecture are the use of off-the-shelf components including communication standards and that the fault tolerance functionality, including voting, error detection, fault-masking, consistency management, and recovery, is moved into a separate redundancy management circuitry (one for each redundant computing node). In this article we present an improved design of that architecture, specifically resolving some potential inconsistencies that were not treated in detail in the original design. In particular, we present novel techniques for enforcing replica determinism. Our improved architecture is based on using the Controller Area Network (CAN). This choice goes beyond the obvious interest of using standards in order to reduce the cost, since all the rest of the architecture is designed to take full advantage of the CAN standard features, such as data consistency, in order to significantly reduce the complexity, the efficiency and the cost of the resultant system. Although initially developed for NVP, our redundancy management circuitry also supports other software replication techniques, such as active replication.

Fault Tolerance via Diversity for Off-the-Shelf Products: A Study with SQL Database Servers

If an off-the-shelf software product exhibits poor dependability due to design faults, then software fault tolerance is often the only way available to users and system integrators to alleviate the problem. Thanks to low acquisition costs, even using multiple versions of software in a parallel architecture, which is a scheme formerly reserved for few and highly critical applications, may become viable for many applications. We have studied the potential dependability gains from these solutions for off-the-shelf database servers. We based the study on the bug reports available for four off-the-shelf SQL servers plus later releases of two of them. We found that many of these faults cause systematic noncrash failures, which is a category ignored by most studies and standard implementations of fault tolerance for databases. Our observations suggest that diverse redundancy would be effective for tolerating design faults in this category of products. Only in very few cases would demands that triggered a bug in one server cause failures in another one, and there were no coincident failures in more than two of the servers. Use of different releases of the same product would also tolerate a significant fraction of the faults. We report our results and discuss their implications, the architectural options available for exploiting them, and the difficulties that they may present.