Multiversion Programming Research Articles

Workings of science

Falsifiability is a cornerstone of science. It states that scientific claims---propositions, hypotheses, theories---must be testable by experiment. A scientific claim is falsified if an empirical test contradicts it; if a claim withstands repeated attempts at falsification, it is accepted as fact. This article discusses three examples of falsified theories about software. They address the reliability of multi-version programs, the prediction of program bugs by means of software metrics, and the advantages of software models (UML). These examples demonstrate how falsifiability can eliminate incorrect theories and help reorient research and practice.

Multi-attribute decomposition technique for fault tolerant multiversion systems

The article proposes an original method for decomposition of fault-tolerant multiversion systems based on multi-attribute analysis. Decomposition into functional subsystems is carried out taking into account the generality of functions performed by software modules. In this work, the attribute of the importance of functions is determined based on the general function of the unmanned aerial vehicle and the set of tasks that it must perform. The division of software modules into types allows you to determine possible ways to improve reliability that are applicable to them. These are, for example, multi-version programming, recovery blocks, t/(n-1)-variant programming.

Software package for the implementation of bioinspired algorithms for the design of fault-tolerant control systems

The article considers a software package that allows you to form the composition of multiversion software for fault-tolerant control systems. The software implementation is based on a modified ant colony algorithm, which belongs to the class of bioinspired algorithms. The algorithm implements the search direction in order to minimize the cost of a program consisting of a set of modules. For each module, there are several versions of its implementation, developed within the framework of the multiversion programming methodology. The search direction is also implemented in order to maximize the reliability of the modular program in multiversion execution. The software implementation of the algorithm allows a number of experiments to be performed to obtain data that can be used to compare the performance of the standard and modified ant colony algorithms.

N-version programming approach with implicit safety guarantee for complex dynamic system stabilization applications

Safety-critical systems are widely used in many sectors to prevent fatal accidents and prevent loss of life, damage of property, or deterioration of the environment. Implementation of software safety standards as part of the development of safety-critical software is generally considered an essential element of any safety program. Therefore, it has become more critical to produce highly reliable software to meet the safety requirements established by functional safety standards, such as IEC 61508, ISO 26262, and EN 50128. IEC 61508 supports well-known safety mechanisms such as design diversity like N-version (multi-version) programming. N-version (multi-version) programming is a method where multiple functionally equivalent programs are independently developed from the same software specifications. N-version (multi-version) programming is particularly an effective approach to increase the quality of software in a safety-critical system. In this paper, one of the well-known and widely used algorithms in the field of N-version (multi-version) programming, the majority voting algorithm, has been modified with an online stability checker where the decisions of the voter are judged against the stability of the underlying system. The plant where all the theoretical results are implemented is a tilt-rotor system with the proposed N-version (multi-version) programming–based controller. The experimental results show that the modified majority voter-based N-version (multi-version) programming controller provides more reliable control of the plant.

Implementation of multiversion software based on an object-oriented approach

The article discusses the concept of redundant programming and its implementation based on an object-oriented approach. Three components of multiversion programming, which are basic in the synthesis of fault-tolerant software, are identified. In comparison with the standard software life cycle, the basic procedures of the multiversion programming methodology are considered. The concept of abstract state of the multiversion software components version is based on the object-oriented approach.

Simulation environment for the choice of the decision making algorithm in multi-version real-time system

Abstract Context Nowadays the most effective way to improve the reliability of software is an approach with the introduction of software redundancy - multi-version programming. The reliability of a multi-version system is determined not only by the reliability of the versions that make it up, but to a greater degree by the decision making algorithm. Objective Our objective is evaluation and selection of the most reliable voting algorithms in multi-version environments. In order to get this objective there is a need to check all the algorithms in the execution environment, simulating characteristic of the developed system. Thus, we obtain the characteristics of the quality of the algorithm operation in precisely those conditions in which it will work in the system that is developed. Method The article suggests weighted voting algorithms with a forgetting element, as well as modifications of existing voting algorithms. To be able to check the quality of their work, the simulation environment has been implemented that simulates the operation of the software multi-version execution environment. Results The article substantiates the use of the most reliable decision making algorithms in the decision block of the real-time operating system. A comparative analysis of decision making algorithms for the operation of the decision making block of the multi-version real-time execution environment has been carried out. Conclusions The software implementation of the simulation environment that implements the simulations of versions with given characteristics is considered, not only classical decision making algorithms, but also the author's modifications are investigated. The environment allows to obtain the quality characteristics of all implemented decision making algorithms with given system characteristics. The modeling results are considered, the dependence of the system reliability indicators on its input parameters is shown, a comparative analysis of various decision making algorithms based on the modeling results is made.

Model implementation of the simulation environment of voting algorithms, as a dynamic system for increasing the reliability of the control complex of autonomous unmanned objects

In the article the question of application of redundant schemes for the development of fault-tolerant software, in particular multiversion programming, is considered with reference to the task increasing the reliability of the control complex of autonomous unmanned objects. Modifications of the basic voting algorithms by an agreed majority and its fuzzy version are proposed. The software implementation of the simulation environment that implements the described approach and the proposed modified algorithms is considered. The results of the simulation the dependence of the reliability indicators of the system on its input parameters are shown by authors.

A Dependent Model for Fault Tolerant Software Systems During Debugging

This paper proposes a special redundant model for describing the s-dependency of multi-version programming software during testing and debugging. N-version programming (NVP) is one of the most important software fault tolerance techniques. Many papers have studied the issue of fault correlation among versions. However, only a few of them consider this issue during the testing and debugging part of the software development life cycle. During testing and debugging, faults may not be successfully removed. Imperfect debugging may result in unsuccessful removal, and the introduction of new faults. Different from existing NVP models, the model proposed in this paper allows an assessment of s-dependency when correlated failures may not necessarily occur at the same execution time point. The model focuses on 2 VP systems. It is developed to be a bivariate counting process by assuming positive s-dependency among versions. Considering imperfect debugging, this bivariate process characterizes dynamic changes of fault contents for each version during testing and debugging. The system reliability, expected number of faults, probability of perfect debugging, and parameter estimation of model parameters are presented. An application example is given to illustrate the proposed model. The paper provides an alternative approach for evaluating the reliability of 2 VP software systems when there is positive s -dependency between versions.

A model for correlated failures in N-version programming

The multi-version programming technique is a method to increase the reliability of safety critical software. In this technique a number of versions are developed and a voting scheme is used before a final result is provided. In the analysis of this type of systems, a common assumption is the independence of the different versions. However, the different versions are usually interdependent and failures are correlated due to the nature of the product design and development. One version may fail simultaneously with another version because of a common cause. In this paper, a model for these dependent failures is developed and studied. Using the developed model, a reliability function can be easily computed. A method is also proposed to estimate the parameters of the model. Finally, as an application of the developed model, an optimal testing resource allocation problem is formulated and a genetic algorithm is presented to solve the problem.

An approach to the reliability optimization of software with redundancy

An approach to the optimization of software reliability is proposed. The emphasis is put on the software redundancy to achieve fault tolerance, i.e. the results of the optimization process are used to determine the optimal structure of the software to be developed. Two optimization models are formulated covering, respectively, modified recovery block scheme and multiversion programming approaches. Both cases are illustrated by simple examples. The models show that it is possible to formulate and solve some software related reliability optimization problems. They further show that the concept of redundancy to achieve fault tolerance (basic for the traditional theory of reliability) can be used in the field of software reliability optimization. >

An experimental evaluation of the assumption of independence in multiversion programming

N-version programming has been proposed as a method of incorporating fault tolerance into software. Multiple versions of a program (i.e. `N') are prepared and executed in parallel. Their outputs are collected and examined by a voter, and, if they are not identical, it is assumed that the majority is correct. This method depends for its reliability improvement on the assumption that programs that have been developed independently will fail independently. An experiment is described in which the fundamental axiom is tested. In all, 27 versions of a program were prepared independently from the same specification at two universities and then subjected to one million tests. The results of the tests revealed that the programs were individually extremely reliable but that the number of tests in which more than one program failed was substantially more than expected. The results of these tests are presented along with an analysis of some of the faults that were found in the programs. Background information on the programmers used is also summarized.

Fault-Tree Analysis Using a Binary Decision Tree

A new algorithm for the production of a short disjoint-products form of a fault-tree output function is presented and discussed. This algorithm consists of a sequential binary decision process to find first big, then smaller sets of elementary system-failure states which correspond to disjoint-product terms. The identification of bad and good system states can be eased by a simple ternary (3-state) decision for which an auxiliary procedure is presented. The main advantages of this algorithm appear to be its efficiency, simplicity, and usefulness as an alternative (in the sense of multiversion programming for software fault tolerance) for the Shannon decomposition algorithm.

Managing Multi-Version Programs with an Editor

When more than one version of a program must be maintained, generally much of the code is repeated unchanged in many versions. Techniques such as “deltas” and conditional compilation are commonly used to avoid duplicating these common parts. In addition to saving storage, these methods aid the programmer greatly in managing updates to the versions. Unfortunately, these representations of multi-version programs can appear very unlike a program, making them difficult to edit. Described here is a new method of automating much of the bookkeeping involved in dealing with multi-version programs. It entails use of a special editor that enables a multi-version program to be seen and modified in a fashion that is far closer to that normally permitted for a single-version program.

Program Development by Stepwise Refinement and Related Topics

Computer program development by stepwise refinement has been advocated by many people. We take another look at stepwise refinement in light of recent developments in programming languages and programming methodology such as abstract data types, correctness proofs and formal specifications, parallel programs and multiversion programs. We offer suggestions for the refinement process and discuss program maintainability.