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

https://doi.org/10.1016/j.ress.2005.11.045Get rights and content

Abstract

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.

Introduction

N-version programming (NVP) is a programming approach to construct fault tolerant software systems employing functionally equivalent, yet independently developed software components [1]. 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. No improvement in any objective function is possible without sacrificing the performance of at least one of the other objective functions. In this paper, we propose a novel bi-objective optimization model that obtains many Pareto solutions efficiently.

First, we point out the problem of the single-objective mathematical model and 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. It requires, however, that we search for as many Pareto solutions as possible evenly along the Pareto frontier, which is a surface formed by Pareto solutions, and it is time consuming. Deb mentioned that elitism could provide good performance to the evolution process in MOGAs [2]. Therefore, we follow his idea and introduce strong elitism, i.e., the Pareto-based selection to accelerate evolution, into the evolution process of MOGA. In order to search Pareto solutions as evenly as possible along the Pareto frontier, we propose the Pareto-insertion operation based on distance between Pareto solutions in the selection process. When implementing genetic algorithms (GAs), using an appropriate genetic representation scheme is one of the most important choices required to obtain good performance in genetic search. We employ random-key representation in our MOGA to provide effective genetic search ability. We also show the results of numerical experiments to demonstrate the performance of the proposed method, and discuss the efficiency of the proposed method.

The structure of the balance of this paper is as follows: Section 2 describes the background of this research and introduces the related research. In Section 3, we describe the basic concept of NVP. Following these sections, we formulate the design problems of NVP in the cases of both single-objective and bi-objective models in Section 4. In Section 5, we describe the implementation of the proposed MOGA. Then we show the numerical experiments and discuss efficiency of the MOGA in Section 6. Finally, we conclude this research work and give future directions in Section 7.

Section snippets

Fault tolerant software and N-version program

Since early 1970s, it has become clear that design faults are fatal problems in software products, because high-reliability software systems are required. In the early 1975, Avizienis at UCLA started a research effort to attain tolerance of design faults by means of multiple version software. The method was first called “redundant programming”, and was later renamed “N-version programming” [3]. Levitin investigated the processing time of software versions in constructing his optimal NVP design

Basic concept of N-version fault tolerant software system

NVP is a fault tolerance technique that involves the execution of multiple, s-independently generated, N equivalent versions of a single program. These N versions receive identical input (task) and each produces its own output. A voting scheme matches the outputs, and then recognizes the majority as correct outputs. Fig. 1 shows the basic concept of NVP.

A task usually consists of n subtasks as shown in Fig. 2. Therefore, NVP is applied for every subtask in a module. As each version has its own

Preliminaries

An optimization model is used for selecting the optimal set of versions for each module such that the optimal set of versions maximize system's overall reliability. We presume the following three assumptions.

Assumptions

  • 1.

    Several functionally equivalent versions for each module are available.

  • 2.

    Each version has an estimated reliability and cost.

  • 3.

    Failures of versions for each module (subtask or subsystem) are s-independent.

We use the following notations in this paper.

Notations

    n

    number of subtasks

Implementation of Pareto distance-based MOGA

In this section, we explain the implementation of the proposed MOGA. The main features of the method are the random-key representation scheme and the Pareto-based selection that provide evolution derived from only Pareto solutions.

Numerical experiments and discussions

As the numerical experiments, we use two NVP design problems, one is prepared by Ashrafi et al. [5] and the other is provided by Levitin [6].

We consider the following six cases for numerical experiments:

Method 1: Selection with Strong Pareto optimality, without insertion and deletion.

This case employs Pareto-based elite selection using Strong Pareto optimality defined in Section 4.3. The insertion and deletion operations are not used.

Method 2: Weak Pareto optimality, without insertion and

Conclusions

In this paper, we propose a Multi-objective genetic algorithm (MOGA) to solve the optimal design problem of NVP formulated as a bi-objective 0–1 nonlinear integer programming problem. A MOGA is recognized as a powerful method to solve multi-objective optimization problems. We employ the random-key representation in our MOGA to provide effective genetic search ability. We introduce the Pareto-based selection, which follows Deb's elitism, to evolve the Pareto solutions directly. In order to

Acknowledgements

This project is supported by Nippon Institute of Technology, Japan, from April 2002 to March 2005. The authors gratefully acknowledge the contributions of Tsukasa Hashimoto and Masahito Kurita for the implementation of the experiments.

References (20)

  • Avizienis A, Chen L. On the implementation of N-version programming for software fault-tolerance during program...
  • K. Deb
    (2001)
  • Levitin G. Fault-tolerant programs as multi-state systems. In: Proceedings of fourth international conference on...
  • N. Ashrafi et al.

    Optimal design of large software-systems using N-version programming

    IEEE Trans Reliab

    (1994)
  • G. Levitin

    Optimal Version sequencing in fault-tolerant programs

    Asia Pac J Oper Res

    (2005)
  • Imamura K, Foster JA. Fault tolerant computing with N-version genetic programming. In: Proceedings of GECCO, Morgan...
  • Tsujimura Y, Yamamoto H, Takeno T, Yamazaki G. Evolutionary design of N-version fault tolerant software system. In:...
  • Tsujimura Y, Yamamoto H, Takeno T, Yamazaki G. A genetic algorithm for designing N-version program. In: Proceedings of...
  • J. Holland

    Adaptation in natural and artificial systems

    (1975)
There are more references available in the full text version of this article.

Cited by (23)

  • A multi-objective reliability optimization for reconfigurable systems considering components degradation

    2019, Reliability Engineering and System Safety
    Citation Excerpt :

    Multi-objective reliability optimization is a popular topic, whose objectives are to maximize system reliability and minimize total cost or performance loss. Yamachi et al [18] proposed a multi-objective genetic algorithm, which is a powerful but time-consuming method, to solve bi-objective optimization problems. Li et al [19] proposed a two-stage approach to get the Pareto solution for solving multi-objective redundancy allocation problem.

  • Baud-spaced constant modulus blind equalization via hybrid genetic algorithm and generalized pattern search optimization

    2008, AEU - International Journal of Electronics and Communications
    Citation Excerpt :

    They were first introduced and investigated by John Holland [11]. Extensive research have been performed exploiting the robust properties of the genetic algorithms and demonstrating their capabilities across a broad range of problems including multi-objective optimization [12,13], image and video processing [14], classification and machine learning [15], complex scheduling problems [16], training of neural networks [17] and system control [18]. Genetic algorithm are very different from classical optimization techniques such as gradient-based algorithm in the following points:

  • Genetic algorithms in reliability engineering

    2006, Reliability Engineering and System Safety
View all citing articles on Scopus
View full text