Técnicas básicas de software tolerante a fallas

El estudio de la tolerancia a fallos del software es relativamente nuevo en comparación con el estudio del hardware tolerante a fallos. En general, los enfoques tolerantes a fallos se pueden clasificar en enfoques de eliminación de fallos y de enmascaramiento de fallos. Las técnicas de eliminación de fallas pueden ser recuperación de errores hacia adelante o recuperación de errores hacia atrás.

La recuperación de errores de reenvío tiene como objetivo identificar el error y, en función de este conocimiento, corregir el estado del sistema que contiene el error. El manejo de excepciones en lenguajes de alto nivel, como Ada y PL/1, proporciona una estructura de sistema que admite la recuperación hacia adelante. La recuperación de errores hacia atrás corrige el estado del sistema restaurando el sistema a un estado que ocurrió antes de la manifestación de la falla. El esquema de bloque de recuperación proporciona una estructura de sistema de este tipo. Otra técnica de software tolerante a fallas comúnmente utilizada es el enmascaramiento de errores. El esquema NVP utiliza varias versiones desarrolladas de forma independiente de un algoritmo. Se aplica un sistema de votación final a los resultados de estas N-versiones y se genera un resultado correcto.

Una forma fundamental de mejorar la confiabilidad de los sistemas de software depende del principio de diversidad de diseño donde se implementan diferentes versiones de las funciones. Para evitar fallas de software causadas por condiciones imprevistas, se desarrollan diferentes programas (programas alternativos) por separado, preferiblemente basados en diferentes lógicas de programación, algoritmos, lenguajes de programación, etc. Esta diversidad normalmente se aplica en forma de bloques de recuperación o versión N. programación.

El software tolerante a fallas asegura la confiabilidad del sistema mediante el uso de redundancia de protección a nivel de software. Existen dos técnicas básicas para obtener software tolerante a fallos: esquema RB y NVP. Ambos esquemas se basan en la redundancia de software, asumiendo que los eventos de fallas de software coincidentes son raros.

Esquema de
bloques de recuperación: el esquema de bloques de recuperación consta de tres elementos: módulo principal, pruebas de aceptación y módulos alternativos para una tarea determinada. El esquema más simple del bloque de recuperación es el siguiente:
```
Ensure T
   By P
    Else by Q1
      Else by Q2
         .
         .
         .
      Else by Qn-1
    Else Error 
```
Donde T es una condición de prueba de aceptación que se espera cumplir con la ejecución exitosa del módulo principal P o de los módulos alternativos Q1, Q2, . . ., Qn-1.
El proceso comienza cuando se prueba la aceptabilidad de la salida del módulo principal. Si la prueba de aceptación determina que la salida del módulo principal no es aceptable, recupera o revierte el estado del sistema antes de que se ejecute el módulo principal. Permite que se ejecute el segundo módulo Q1. La prueba de aceptación se repite para comprobar la ejecución exitosa del módulo Q1. Si falla, se ejecuta el módulo Q2, etc.

Los módulos alternativos se identifican con las palabras clave «else by». Cuando se agotan todos los módulos alternativos, se considera que el bloque de recuperación ha fallado y las palabras clave finales «else error» declaran el hecho. En otras palabras, cuando todos los módulos se ejecutan y ninguno produce resultados aceptables, el sistema falla. Pham (1989b) ha estudiado un modelo de optimización de la confiabilidad para determinar el número óptimo de módulos en un esquema de bloque de recuperación que minimiza el costo total del sistema dada la confiabilidad de los módulos individuales.

En un bloque de recuperación, una función de programación se realiza mediante n programas alternativos, P1, P2, . . . ., pág. El resultado computacional generado por cada programa alternativo se verifica mediante una prueba de aceptación, T. Si se rechaza el resultado, se ejecuta otro programa alternativo. El programa se repetirá hasta que una de las n alternativas genere un resultado aceptable o hasta que todos los programas alternativos fallen.

La probabilidad de falla del esquema RB, $P_{rb}$ , es la siguiente:

$P_{rb}= \prod_{i=1}^n (e_i+t_{2i})+\sum_{i=1}^n t_{1i}e_i\left ( \prod_{j=1}^{i-1} (e_j+t_{2j}) \right)$

donde
$e_i$ = probabilidad de falla para la versión Pi
$t_{1i}$ = probabilidad de que la prueba de aceptación i juzgue un resultado incorrecto como correcto
t $t_{2i}$ = probabilidad de que la prueba de aceptación i juzgue un resultado correcto como incorrecto.

La ecuación anterior corresponde al caso en que todas las versiones pasan la prueba de aceptación. El segundo término corresponde a la probabilidad de que la prueba de aceptación i juzgue un resultado incorrecto como correcto en la i-ésima prueba de las n versiones.
Programación de versión N:
NVP se utiliza para proporcionar tolerancia a fallas en el software. En concepto, el esquema NVP es similar al esquema de redundancia modular N que se usa para brindar tolerancia contra fallas de hardware.
La NVP se define como la generación independiente de $N \geq 2$ programas funcionalmente equivalentes, llamados versiones, a partir de una misma especificación inicial. La generación independiente de programas significa que los esfuerzos de programación son realizados por N individuos o grupos que no interactúan con respecto al proceso de programación. Siempre que sea posible, se utilizan diferentes algoritmos, técnicas, lenguajes de programación, entornos y herramientas en cada esfuerzo. En esta técnica, N versiones del programa se ejecutan en paralelo con entradas idénticas y los resultados se obtienen votando las salidas de los programas individuales. La ventaja de NVP es que cuando ocurre una falla en la versión, no se requiere tiempo adicional para reconfigurar el sistema y rehacer el cálculo.

Considere que un esquema NVP consta de n programas y un mecanismo de votación, V. A diferencia del enfoque RB, los n programas alternativos generalmente se ejecutan simultáneamente y sus resultados se envían a un mecanismo de decisión que selecciona el resultado final. El mecanismo de decisión normalmente es un votante cuando hay más de dos versiones (o, más de k versiones, en general), y es un comparador cuando hay solo dos versiones (k versiones). La estructura sintáctica de NVP es la siguiente:
```
seq
 par
  P1(version 1)
  P2(version 2)
  .
  .
  .
  Pn(version n)
  decision V 
```
Suponga que se espera un resultado correcto cuando hay al menos dos resultados correctos.

La probabilidad de falla del esquema NVP, Pn, se puede expresar como

$p_{nv}=\prod_{i=1}^n e_i+ \prod_{i=1}^n (1-e_i)e_i^{-1}\prod_{j=1}^n e_j + d$

El primer término de esta ecuación es la probabilidad de que todas las versiones fallen. El segundo término es la probabilidad de que solo una versión sea correcta. El tercer término, d, es la probabilidad de que haya al menos dos resultados correctos pero el algoritmo de decisión no entregue el resultado correcto.

Vale la pena señalar que el objetivo del enfoque NVP es garantizar que es poco probable que varias versiones fallen en las mismas entradas. Con cada versión desarrollada de forma independiente por un equipo de programación diferente, enfoque de diseño, etc., el objetivo es que las versiones sean lo suficientemente diferentes para que no fallen con demasiada frecuencia en las mismas entradas. Sin embargo, la programación multiversión sigue siendo un tema controvertido.

La principal diferencia entre el esquema de bloques de recuperación y la programación de la versión N es que los módulos se ejecutan secuencialmente en el primero. El bloque de recuperación generalmente no es aplicable a sistemas críticos donde la respuesta en tiempo real es de gran preocupación.

Publicación traducida automáticamente

Artículo escrito por ash264 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta