N-version Software Research Articles

Software Reliability Growth Model for N-Version Fault Tolerant Software with Common and Independent Faults

Research and development teams have become increasingly focused on developing highly reliable software for safety-critical systems. It is a major challenge for real-time control systems to achieve high reliability software to meet safety standards. A reliability evaluation focuses primarily on analytical and modeling techniques for fault prediction. In safety-critical systems like nuclear plant controls, aircraft controls and railroad signalization systems, N-version programming (NVP) is an effective technique for raising software’s reliability, particularly in areas with high-risk ratios because small errors can result in hazardous incidents. It allows the software to be fault-tolerant, aiding it to produce accurate results even when the software has faults. We present an analytical method for assessing the reliability of N-version software systems. Analysis of the system’s reliability and other performance metrics is provided with closed-form expressions. As an additional extension, we conduct numerical analyses of two cases, the 2VP system and 3VP system, in which suitable parameters are used. We conduct numerical simulations using MATLAB to generate the analytical results and compare the analytical results by using numerical results and neuro-fuzzy results using fuzzy interference systems.

Selection of the optimal set of versions of N-version software using the ant colony optimization

The article discusses the problem of ensuring a high level of software reliability. A software reliability high level can be ensured using N-version programming. N-version software is distinguished by the software components redundancy, designed to solve one problem using different methods. Software redundancy requires additional resources. The challenge is thus to increase the software reliability, while at the same time minimising the resources used. In this article, ant colony optimization is used to solve the problem of choosing the optimal set of versions of N-version software.

Algorithm source codes generation for ensuring N-version software diversity

Diversity is one of the fundamental principles for N-version software development. The development of redundant versions can significantly improve the reliability of software, but it is more time and labour consuming. Business and manufacturing require a higher level of software reliability. The task of reducing the lead-time and cost effectiveness becomes more important when developing N-version software for such industries. It is proposed to use automatic source code generation to create N-version software. The use of domain-specific language for the intermediate representation of the algorithm simplifies code generation in the target programming language. The authors discuss a new conceptual model of two-step code translation for N-version software. The proposed approach will simplify the process of N-version software development and reduce the number of required resources. The paper contains an example of C code generation as a target programming language, using flowcharts as a graphical representation of the source algorithm. The described approach is intended for use in safety-critical industries.

Fuzzy voting algorithms for N-version software

The choice of the voting algorithm in N-version programming directly affects the evaluation of the results of N software versions and determines the correct result. The result of the voting algorithm is also the outcome of the N-version software. Therefore, the choice of the voting algorithm is vital. However, many voting algorithms were already developed and they may be selected for implementation, based on the specifics of the analysis of input data of these algorithms. This article presents a brief overview of major fuzzy voting algorithms.

Enhanced pushdown automaton for recognizing multi-syntax programming languages

Software used to digitize manufacturing operations should provide high degree of reliability, since its failure may cause downtime or disruption of the production process and, as a result, financial losses. One of the approaches to improve software reliability is N-version programming where data processing is performed by different functionally equivalent software components which source code can be written in various programming languages with a number of distinguishing syntactic properties. This paper presents an abstract device for recognizing multi-syntax programming languages. The synthesized device can be used for the development of language translators for N-version software systems.

Compiler-compiler of multi syntax programming languages for creating N-version software

Ensuring the reliability of the software has become increasingly complex and challenging. The most important problem is providing failure-free software operation to prevent financial losses or machinery breakdown. It can be solved with N-version programming which requires increased costs due to the use of redundant software components. In this paradigm, redundancy refers to diversity of software components. This paper discusses the implementation of software components in various languages with different syntax. We propose an efficient and time-reducing approach to the development of a multi-syntax programming language compiler. The technique of compiler parsing is based on the existing flex and bison specifications. The proposed approach makes it easier to detect errors in multi-syntax N-version software solutions, as well as reduce the likelihood of their occurrence due to the use of an automated tool, which is crucial for its implementation in an industrial setting.

The Methodology of N-Version Programming

Software Fault Tolerance is evolved as a technique to increase the dependability of computing systems. Because of limitations with producing of error free software, Majority of software errors are design faults. The root cause for software design errors is the complexity of the problem domain. Software Fault Tolerance (SFT) has become an important concern A number of Fault Tolerance techniques designed at minimizing the effect of software faults are being investigated. An N-version software (NVS) unit is a fault tolerant software unit that depends on a generic decision algorithm to determine a consensus result from the results delivered by two or more member versions of the NVS unit. Results of five consecutive experimental investigations are summarized, and a design paradigm for NVS is presented. In this paper, a critical review of NVP is presented. The advantages, current challenges, and further research areas of NVP are discussed.

Classification of voting algorithms for N-version software

A voting algorithm in N-version software is a crucial component that evaluates the execution of each of the N versions and determines the correct result. Obviously, the result of the voting algorithm determines the outcome of the N-version software in general. Thus, the choice of the voting algorithm is a vital issue. A lot of voting algorithms were already developed and they may be selected for implementation based on the specifics of the analysis of input data. However, the voting algorithms applied in N-version software are not classified. This article presents an overview of classic and recent voting algorithms used in N-version software and the authors' classification of the voting algorithms. Moreover, the steps of the voting algorithms are presented and the distinctive features of the voting algorithms in Nversion software are defined.

Application of majority voting and consensus voting algorithms in N-version software

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.

N-version programming-based protection scheme for microgrids: A multi-agent system based approach

Abstract Islanded mode and grid-connected mode are the two operational modes of a microgrid (MG). It is essential to develop a suitable protection scheme for an MG network to protect it against all types of faults in both of the modes. The fault current in an inverter-dominated MG is limited by the ratings of the semiconductor devices. Only traditional over-current protection schemes are not adequate for such inverter-based grids. In order to cover the drawbacks of conventional protection schemes, an N-version programming-based protection scheme has been proposed in this paper. An N-version software unit with N = 3 has been developed in MATLAB Simulink and all the agents in the developed multi-agent scheme have been equipped with this unit. The three developed protection versions are Clark’s transformation-based current protection, positive sequence phase differential-based protection and conventional over-current-based protection scheme. The software unit makes the final decision about the fault through a polling process. Different types of faults have been tested in both the islanded and grid-connected modes. The proposed protection scheme has given desired results in all the tested cases and hence proved to be a reliable and accurate method for fault identification in microgrid networks. Finally, a framework has been presented for possible realization of the proposed protection scheme through existing IEC 61850-based intelligent electronic devices (IEDs).

The pseudo-Boolean optimization approach to form the N-version software structure

The problem of developing an optimal structure of N-version software system presents a kind of very complex optimization problem. This causes the use of deterministic optimization methods inappropriate for solving the stated problem. In this view, exploiting heuristic strategies looks more rational. In the field of pseudo-Boolean optimization theory, the so called method of varied probabilities (MVP) has been developed to solve problems with a large dimensionality. Some additional modifications of MVP have been made to solve the problem of N-version systems design. Those algorithms take into account the discovered specific features of the objective function. The practical experiments have shown the advantage of using these algorithm modifications because of reducing a search space.

The mathematical statement for the solving of the problem of N-version software system design

The N-version programming, as a methodology of the fault-tolerant software systems design, allows successful solving of the mentioned tasks. The use of N-version programming approach turns out to be effective, since the system is constructed out of several parallel executed versions of some software module. Those versions are written to meet the same specification but by different programmers. The problem of developing an optimal structure of N-version software system presents a kind of very complex optimization problem. This causes the use of deterministic optimization methods inappropriate for solving the stated problem. In this view, exploiting heuristic strategies looks more rational. In the field of pseudo-Boolean optimization theory, the so called method of varied probabilities (MVP) has been developed to solve problems with a large dimensionality.

The links between human error diversity and software diversity: Implications for fault diversity seeking

Software diversity is known to improve fault tolerance in N-version software systems by independent development. As the leading cause of software faults, human error is considered an important factor in diversity seeking. However, there is little scientific research focusing on how to seek software fault diversity based on human error mechanisms. A literature review was conducted to extract factors that may differentiate people with respect to human error-proneness. In addition, we constructed a conceptual model of the links between human error diversity and software diversity. An experiment was designed to validate the hypotheses, in the form of a programming contest, accompanied by a survey of cognitive styles and personality traits. One hundred ninety-two programs were submitted for the identical problem, and 70 surveys were collected. Code inspection revealed 23 faults, of which 10 were coincident faults. The results show that personality traits seems not effective predictors for fault diversity as a whole model, whereas cognitive styles and program measurements moderately account for the variation of fault density. The results also show causal relations between performance levels and coincident faults: coincident faults are unlikely to occur at skill-based performance level; the coincident faults introduced in rule-based performances show a high probability of occurrence, and the coincident faults introduced in knowledge-based performances are shaped by the content and formats of the task itself. Based on these results, we have proposed a model to seek software diversity and prevent coincident faults.

Reliability assessment of N-version software fault tolerant system with common mode failures

Common mode failures create the major impact on the system reliability in many real time systems. In this paper, we incorporate the concept of common mode faults (CMF) for the reliability prediction of fault tolerant software system consisting of N-version with different failure characteristics. The common mode faults may occur simultaneously in two or more versions due to faults in the common communication buses or shared environmental factors, failure of common source of power, design mistake, etc.. The recursive algorithm based on universal generating function approach is presented to obtain the system probabilities. Various performance measures of the fault tolerant software system are established. Furthermore, by setting appropriate parameters, some special cases are illustrated numerically.

A study of N-version programming and its impact on software availability

N-version programming is a useful approach to improve the quality of software, especially for safety-critical systems. Positive performance in enhancing software availability is an expected result. In this paper, a software availability model for the study of the impact of N-version programming technique is proposed and investigated. The characteristics of the N-version software system and its operation and failure process are analysed. Based on this analysis, the time-dependent behaviour of the software system, which alternates between online and offline states, is described using a Markov chain. This model derives quantitative measures of software availability. Numerical examples and comparisons are also presented in this paper to directly illustrate N-version programming's positive impact on software availability measures. N-version programming generally provides a positive impact on the system. However, it does not always guarantee a higher availability performance. General recommendations are provided on N-version software structure design based on cost-effective criteria.

Design Fault Tolerance System Using Genetic Algorithm Employing Mutation and Back-to-Back Testing

Software system should be reliable and available failing which huge losses may incur. To achieve these objectives a thorough testing is required. Adequacy of test cases is the key to the success. Despite the availability of a number of adequacy criteria, deterministic approaches to testing are not sufficient consequential to the need of automatic random and anti-random testing. Our research uses a novel method for the development of n-version of the software by creating the different mutation in software and test cases generation using the Genetic Algorithm. Its purpose is to eliminate software faults as possible by using lesser test cases in the testing phase. The test case generated by the use of Genetic Algorithm (GA) is compared with the results of totally random generated test cases. The method was applied to the specification of a sorting of array problem. The advantage of this analysis is that when we produce multiple versions, reliability of the software is likely to be better than if a single version is developed. The N-version software testing will helps to reduce the possibility of mistakes and inconsistencies in the process of software development and testing and the number of test cases required during the testing phase of the software system. In this paper a technique of generating the test cases and doing the testing automatically, employing genetic algorithm and Back-to-Back testing has been discussed.

Multi-objective genetic algorithm for solving N-version program design problem

N-version programming (NVP) is a programming approach for constructing fault tolerant software systems. Generally, an optimization model utilized in NVP selects the optimal set of versions for each module to maximize the system reliability and to constrain the total cost to remain within a given budget. In such a model, while the number of versions included in the obtained solution is generally reduced, the budget restriction may be so rigid that it may fail to find the optimal solution. In order to ameliorate this problem, this paper proposes a novel bi-objective optimization model that maximizes the system reliability and minimizes the system total cost for designing N-version software systems. When solving multi-objective optimization problem, it is crucial to find Pareto solutions. It is, however, not easy to obtain them. In this paper, we propose a novel bi-objective optimization model that obtains many Pareto solutions efficiently. We formulate the optimal design problem of NVP as a bi-objective 0–1 nonlinear integer programming problem. In order to overcome this problem, we propose a Multi-objective genetic algorithm (MOGA), which is a powerful, though time-consuming, method to solve multi-objective optimization problems. When implementing genetic algorithm (GA), the use of an appropriate genetic representation scheme is one of the most important issues to obtain good performance. We employ random-key representation in our MOGA to find many Pareto solutions spaced as evenly as possible along the Pareto frontier. To pursue improve further performance, we introduce elitism, the Pareto-insertion and the Pareto-deletion operations based on distance between Pareto solutions in the selection process. The proposed MOGA obtains many Pareto solutions along the Pareto frontier evenly. The user of the MOGA can select the best compromise solution among the candidates by controlling the balance between the system reliability and the total cost.

N-version programming with imperfect debugging

This paper proposes a non-homogeneous Poisson process model for N-version software considering the case of imperfect debugging. The concept of linear dependency has been considered here for correlated errors. In this paper, combinatorial mathematics is used to predict the reliability of a multiversion software.

Dependable, intelligent voting for real-time control software

An intelligent and dependable voting mechanism for use in real-time control applications is presented. Strategies proposed by current safety standards advocate N-version software to minimize the effects of undetected software design faults (bugs). This requires diversity in design but presents a problem in that truly diverse code produces diverse results; that is, differences in output values, timeliness and reliability. Reaching a consensus requires an intelligent voter, especially when non-stop operation is demanded, e.g. in aerospace applications. This paper, therefore, firstly considers the applicable safety standards and the requirements for an intelligent voter service. The use of replicated voters to improve reliability is examined and a mechanism to ensure non-stop operation is presented. The formal mathematical analysis used to verify the crucial behavioural properties of the voting service design is detailed. Finally, the use of neural nets and genetic algorithms to create N- version redundant voters, is considered.

Intelligent Voting Startegies for Dependable Real-Time Control Systems

An intelligent and dependable voting mechanism for use in real-time control applications is presented. Strategies proposed by current safety standards advocate N-version software to minimise the effects from undetected software design faults (bugs). This requires diversity in design but presents a problem that truly diverse code produces diverse results, that is, differences in output values, timeliness and reliability. To reach a consensus requires an intelligent voter, especially when non stop operation is demanded, e.g. aerospace applications. This paper, therefore, firstly considers the applicable safety standards and the requirements for an intelligent voter service. The use of replicated voters to improve reliability is examined and a mechanism to ensure non stop operation is presented. The formal mathematical analysis used to verify the crucial behavioural properties of the voting service design is detailed. Finally the creation of N-version redundant voters are considered using Neural nets and Genetic Algorithms.