sistemas de tiempo real -...

1

Sistemas de Tiempo Real

Fiabilidad y Tolerancia a Fallos

Javier García Martín

3

Capítulo 4

Fiabilidad y Tolerancia a Fallos

1. Conceptos básicos 2. Tolerancia a Fallos 3. Bloques de Recuperación 4. Exepciones y Redundancia Dinámica 5. Exepciones en Ada 6. Ejemplo de utilización de las exepciones 7. Implementación de Bloques de Recuperación 8. Tolerancia a Fallos en restricciones temporales

Planificacion de tareas

4

1.- Conceptos básicos

Fuentes de Fallos

Especificaciones inadecuadas

Introducidos por errores en el diseño

Introducidos por fallo en el funcionamiento de algún componente

Fallo en subsistema de comunicaciones


5

Definiciones

• Fiabilidad (reliability) • Seguridad

• Avería o Fallo del Sistema (failure)

• Estado

• Error

• Defecto (fault)


6

Prevención de fallos

1.- Evitar fallos (avoidance) 2.- Corregir fallos (removal)

Tolerancia a de fallos

Sistema en funcionamiento …

¿cómo responde ante la aparición de un fallo?


7

Formalidad (Dependability)

Disponibilidad de instrucciones de uso

Seguridad (no ocurren catástrofes)

Confidencialidad en la información interna

Integridad en la información del sistema

Mantenibilidad, evolución y reparaciones


8

2.- Tolerancia a fallos Niveles de tolerancia

1. Tolerancia a Caídas (Fall fault tolerance)

2. Degradación Parcial (Graceful degradation)

3. Parada Segura (Fail safe)


9

Programación de N-versiones

Principales aspectos: Las especificaciones iniciales tienen especial importancia Asegurar la independencia de los n diseños El coste de desarrollo se multiplica por n En ocasiones la comparación de resultados no es fácil Los n procesos redundantes siempre se ejecutan. Sube la carga de la CPU.

Versión 1

Versión 2

Versión n

Driver

. . .

Resultado


10

Recuperación de errores. Redundancia dinámica.

1.- Detección del error 2.- Valoración y aislamiento 3.- Recuperación del error

• Hacia-Delante (fordware) • Hacia-Atrás (backward)

4.- Tratamiento del fallo y recuperación del servicio


11

3.- Bloques de recuperación

Ejecuta sig. alternativa A1 A2 An

Salva el estado del Sistema

Selecciona siguiente alternativa

Ejecuta Test de Aceptación

Restaura el estado del Sistema

Punto de Recuperación

Pasa

No Pasa

FalloFin alternativas

Fallo Interno...


12

ensure test_aceptación by Algoritmo 1 else by Algoritmo 2 else by Algoritmo 3 else Error


13

Consideraciones

• El fallo real se está “ocultando” (dejar traza para su corrección) • Alternativas lo más independientes posible

• Posibilidad de degradación de servicio

• Sobrecarga de almacenamiento y de tiempo de ejecución

• Programación de alternativas distintas equivale a hacer

distintos exámenes a las especificaciones • Puesta en marcha de nuevas versiones


14

Bloques de recuperación en sistemas concurrentes

Tarea 1

Alternativas

t

Test Checkpoint

Tarea 2

Comunicación


15

Bloques de recuperación en sistemas concurrentes (efecto dominó)

Tarea 1

1.1

Tarea 2

Tarea 3

1.2 1.3 1.4

2.1 2.2 2.3 2.4

3.1 3.2 3.3 3.4

t

Instante actual


16

Tarea 1

1.1

Tarea 2

Tarea 3

1.2 1.3 1.4

2.1 2.2 2.3 2.4

3.1 3.2 3.3 3.4

t

Instante actual

Test


17

Tarea 1

1.1

Tarea 2

Tarea 3

1.2 1.3 1.4

2.1 2.2 2.3 2.4

3.1 3.2 3.3 3.4

t

Instante actual

Test


18

Tarea 1

1.1

Tarea 2

Tarea 3

1.2 1.3 1.4

2.1 2.2 2.3 2.4

3.1 3.2 3.3 3.4

t

Instante actual

Test


19

Conversaciones

Tarea 1

Tarea 2

Tarea 3

1

1

t

2

2


20

Conversaciones anidadas

Tarea 1

1

Tarea 2

Tarea 3

2

1 2

1

t


21

Ejemplo de conversaciones incorrectas

Tarea 1

Tarea 2

Tarea 3

1

1

t

2

2


22

Ejemplo de implementación de conversaciones

-- suponemos que P es el proceo que ejecuta la primitiva enter_conversation (conversation_name);

• Comprueba que P puede participar en la conversación • Realiza un chekpoint de P • Añade P al grupo de participantes en la conversación • Activa la primera alternativa de P en la conversación

close_conversation;

• Deja anotado que P quiere dejar la conversación actual C • Bloquea a P hasta que se cumple una de las condiciones

- quieren abandonar C todos los participantes - algún proceso ejecuta un abort_conversation para C entonces - Si satisfacen su test todos los procesos en C

entonces descarta sus checkpoints sino procede a abortar C (abort_conversation)


23

abort_conversation; • Deja constancia de que cada participante ha fallado su alternativa actual

• Restaura checkpoints de los procesos • Si tienen aún alguna alternativa todos los participantes, activa dichas alternativas

• Si algún participante ha agotado sus alternativas provoca una excepción para todos los participantes en C


24

Bloques de recuperación en sistemas de tiempo real

A1 A2 An

Salva el estado del Sistema

Selecciona siguiente alternativa

Ejecuta sig. alternativa

Ejecuta Test de Aceptación

Restaura el estado del Sistema

Punto de Recuperación

Pasa

No Pasa

FalloFin alternativas

Fallo Interno...

¿Se ha cumplido el plazo? No

Sí

Fallo


25

Bloques de recuperación distribuidos

Versión A

Salida

Pasa

Entrada

TestLogico

Versión B

No

Fallo

Nodo Primario Nodo Respaldo

TestTiempo

No

Hayalternativas

No


26

Versión A

Entrada

Versión B

Fallo


Salida

Pasa

TestLogico

TestTiempo

TestLogico

TestTiempo

Pasa

No

No Pasa


27

A

Test Log. yTmp

Salida

falloPasa

Entrada

B


fallo

Plazo

AB

Test Log. yTmp

fallo

Plazo

Salida

Pasa


28

4.- Excepciones y Redundancia Dinámica

Comportamiento de un sistema ideal

RetornoServ. Normal

Actividad Normal Manejo de Excepción

PeticiónServicio

PeticiónServicio

RespuestaNormal

RespuestaNormal

Excepciónde interfaz

Excepciónde interfaz

Excepciónpor fallo

Excepciónpor fallo

ExcepciónInterna


29

Características deseables de un sistema de excepciones

Fácil de entender No debe oscurecer el funcionamiento normal del sistema Sobrecarga de tiempo de ejecución sólo cuando hay errores Tratamiento uniforme de distintos tipos de excepciones Permitir programar recuperación de errores

Manejo de excepciones en lenguajes antiguos

• Valor de retorno especial • Salto forzado • Salto incondicional no local • Variable de error


30

Modelo de restauración y de terminación

a) RESTAURACIÓN

Nivel Superior Programa

Trat. Excepción

X (Fallo)


31

b) TERMINACIÓN b.1) El manejador se encuentra en el mismo nivel

Nivel Superior Programa

Trat. Excepción

X (Fallo)


32

b.2) El manejador se encuentra en un nivel superior

Nivel 1 Nivel 2

Trat. Excepción

Nivel 3 Nivel 4

X (Fallo)


33

5.- Excepciones en Ada

DECLARACIÓN

a) Como constantes de tipo “exception” Fallo_General, Desbordado : exception ;

b) Utilizando el paquete predefinido “Ada.Exception” with Ada.Exception ; package Mi_Modulo is ... Desbordado : exception ; ... Id: Ada.Exception.Exception_Id :=Desbordado’Identity; ... end Mi_Modulo ;


34

Excepciones predefinidas • Constraint_Error :

Problema de rango en las variables.

• Storage_Error : Problema por falta de espacio en memoria (p.e. desbordamiento de pila)

• Program_Error : Si se intenta violar la estructura de control en tiempo de ejecución (p.e. se encuentra el final de una función, instrucción end, sin haber ejecutado return).

• Tasking_Error : Problemas en la activación de las tareas.


35

ELEVACIÓN DE UNA EXCEPCIÓN

a) El Run_Time Support las eleva automáticamete b) El propio programador if Cond_de_Error then raise Desbordamiento end if ; c) Si declarada con paquete Ada.Exception → procedimiento Raise_Exception

(…)


36

------------------------------------------------------------------------------ -- GNAT COMPILER COMPONENTS -- -- A D A . E X C E P T I O N S Spec -- ------------------------------------------------------------------------------ with Ada.Streams; with System.Standard_Library; package Ada.Exceptions is type Exception_Id is private; Null_Id : constant Exception_Id; type Exception_Occurrence is limited private; type Exception_Occurrence_Access is access all Exception_Occurrence; Null_Occurrence : constant Exception_Occurrence; -- Note: we altered the order to simplify the processing for the intrinsic -- routine Exception_Name, which needs to call the Exception_Occurrence -- version of the routine here, and Rtsfind will find the first matching -- occurrence when we have overloaded routines. function Exception_Identity (X : Exception_Occurrence) return Exception_Id; function Exception_Name (X : Exception_Occurrence) return String; -- Same as Exception_Name (Exception_Identity (X))


37

function Exception_Name (X : Exception_Id) return String; procedure Raise_Exception (E : in Exception_Id; Message : in String := ""); function Exception_Message (X : Exception_Occurrence) return String; procedure Reraise_Occurrence (X : Exception_Occurrence); function Exception_Information (X : Exception_Occurrence) return String; procedure Save_Occurrence (Target : out Exception_Occurrence; Source : in Exception_Occurrence); function Save_Occurrence (Source : in Exception_Occurrence) return Exception_Occurrence_Access;


38

private package SSL renames System.Standard_Library; type Exception_Id is access all SSL.Exception_Data; Null_Id : constant Exception_Id := null; subtype Nat is Natural range 0 .. SSL.Exception_Message_Buffer'Last; -- ??? replace Nat by Natural when limited types with discriminants -- are implemented properly -- Exception_Occurrence is defined as a limited record so that when a -- default instance is allocated, the default discriminant value is used -- to determine the length (given that even the full view is limited, we -- do not need to allocate the maximum length). type Exception_Occurrence (Max_Length : Nat := SSL.Exception_Msg_Max) is limited record Id : Exception_Id; Msg_Length : Natural; Msg : String (1 .. Max_Length); end record;


39

procedure Set_Exception_Occurrence (Occ : Exception_Occurrence_Access); pragma Export (C, Set_Exception_Occurrence, "__set_except_occ"); -- Procedure called directly by gigi to copy in the exception occurrence -- the exception message kept in the task-Specific data. -- Note: the whole issue of stream attributes and exception occurrences -- is rather mixed up. We implement 'Read and 'Write as required in the -- RM, with the addition that Read is allowed to truncate a long message -- to the allowed 200 characters (just like Save_Occurrence). procedure Exception_Occurrence_Read (Stream : access Ada.Streams.Root_Stream_Type'Class; Item : out Exception_Occurrence); procedure Exception_Occurrence_Write (Stream : access Ada.Streams.Root_Stream_Type'Class; Item : in Exception_Occurrence); for Exception_Occurrence'Read use Exception_Occurrence_Read; for Exception_Occurrence'Write use Exception_Occurrence_Write; -- We do not implement 'Input and 'Output for Exception_Occurrence, -- since they are not required, and 'Input in particular is not easy -- to implement (more properly is impossible), since there is no way -- to write a 'Input function for a limited record that does not have -- a serious storage leak problem.


40

-- Instead, analogous to how Save_Occurrence works, we implement a -- special 'Input routine for Exception_Occurrence_Access that returns -- a pointer to an Exception_Occurrence that can hold a message of any -- length as originally written by Exception_Occurrence'Write. function Exception_Occurrence_Access_Input (Stream : access Ada.Streams.Root_Stream_Type'Class) return Exception_Occurrence_Access; for Exception_Occurrence_Access'Input use Exception_Occurrence_Access_Input; -- Note: the following definition of Null_Occurrence is not legal Ada. In -- fact, given the clear requirement to make Exception_Occurrence a limited -- record (see above note), there is no way to complete Null_Occurrence in -- a legal way. There is a special kludge in the compiler to permit this -- particular bit of illegal Ada! Null_Occurrence : constant Exception_Occurrence := ( Max_Length => 0, Id => Null_Id, Msg_Length => 0, Msg => ""); end Ada.Exceptions;


41

MANEJO DE LA EXCEPCIÓN begin ... exception when E : Desbordado => ... -- E contiene la ocurrencia de la excepcion

end


42

RESUMEN

declare Sensor_alto, Sensor_bajo, Sensor_nulo : exception ; Desbordado : exception ;

-- predefinidas : Constraint_Error, Storage_Error, -- Program_Error y Tasking_Error

begin ...

-- el Run_Time Support realiza chequeos en tiempo de ejecución -- y eleva una excepción predefinida cuando la detecta if Condicion then raise Sensor_alto – elevada por programador ... exception when Sensor_alto | Sensor_bajo => .... manejador de excepción when Constraint_Error => .... manejador de excepción

when others => .... manejador de excepción end ;


43

PROPAGACIÓN DE EXCEPCIONES Ada sigue un modelo de terminación con propagación.

Criterios de propagación: • Dominio: región de computación durante la cual, si ocurre la excepción se activa su manejador. → En el caso de Ada, el dominio es el bloque.

• Si no hay un manejador en bloque/subprograma donde se ha elevado una excepción → se propaga al bloque que envuelve al bloque actual o al punto de llamada


44

• Posibilidad de tratar y repropagar una exepción al nivel superior begin ... exception when Sensor_alto => ... ultimos deseos raise ; end ; -- útil para atomicidad en la acción del procedimiento. • Si se produce una excepción durante las declaraciones de un bloque → se abandona la declaración y se eleva la excepción al nivel superior.

• Si paquete exporta un procedimiento que eleva una excepción pero … el manejador está en cuerpo del paquete

→ no se podrá saltar al manejador de excepción desde otro paquete


45

SUPRESIÓN DE EXCEPCIONES pragma “Suppress”


46

6.- Ejemplo de utilización de las excepciones : Pila Package Pila is Capacidad: Natural := 100 ; Pila_Llena, Pila _Vacia : exception ; procedure Apilar (X : in Integer) ; procedure Desapilar (X : out Integer) ; end Pila ; Package body Pila is type Indice_Pila is new Integer range 0..Capacidad-1 ; type Tabla_Pila is array (Indice_Pila) of Integer ; type Pila is record T : Tabla_Pila ; I : Indice_Pila ; end record ; Mi_Pila : Pila ;


47

procedure Apilar (X : in Integer) is begin if Mi_Pila.I = Capacidad - 1 then raise Pila_Llena ; -- finaliza la ejec. de “apilar” -- y retorna al programa le ha llamado end if ; Mi_Pila.I := M_Pila.I + 1 ; Mi.Pila.T (Mi_Pila.I) := X ; -- aquí no hemos puesto menejador de la excepción end Apilar ; procedure Desapilar (x : out Integer) is begin if Mi_Pila.I = 0 then raise Pila_Vacia ; end if ; X := Mi_Pila.T (Mi_Pila.I) ; Mi_Pila.I := Mi_Pila.I - 1 ; end Desapilar ; end Pila ;


48

with Pila ; with Text_IO ; procedure Usa_la_Pila is Dato : Integer ; begin .... Apila (Dato) ; .... Desapila (Dato) ; ... exception when Pila_Llena => Text_IO.Put_Line (“La pila se ha desbordado”) ; when Pila_Vacia => Text_IO.Put_Line (“La pila se ha agotado”) ; end Usa_la_Pila ;


49

7.- Implementación de bloques de recuperación mediante excepciones

package Cache is procedure Salva_Estado; -- salva estado de variables etc. procedure Restaura_Estado ; -- restaura el estado end Cache ; Procedure Bloque_Recuperacion is Primer_Fallo, Segundo_Fallo, Tercer_Fallo : exception ; Fallo_del_bloque : exception ; type Modulo is (Primer_Intento, Segundo_Intento, Tercer_Intento); .... ----------------------------------------------- function Test_Aceptacion return Boolean is begin

-- codigo para el test de aceptacion end Test_Aceptacion ;


50

----------------------------------------------- procedure Algoritmo_1 is begin

-- codigo del primer algoritmo if not Test_Aceptacion then raise Primer_Fallo end if ; exception when Primer_Fallo =>

-- ultimos deseos raise;

when others => -- el primer intento ha fallado

raise Primer_Fallo; end Algoritmo_1 ; ----------------------------------------------- procedure Algoritmo_2 is ..... ----------------------------------------------- procedure Algoritmo_3 is ..... -----------------------------------------------


51

begin -- Bloque_Recuperacion Cache.Salva_Estado ; for Intento in Modulo loop begin case Intento is when Primer_Intento => Algoritmo_1; exit ; when Segundo_Intento => Algoritmo_2; exit ; when Tercer_Intento => Algoritmo_3; exit ; end case ; exception when Primer_Fallo => Cache.Restaura_Estado ; when Segundo_Fallo => Cache.Restaura_Estado ; when Tercer_Fallo => Cache.Restaura_Estado ; raise Fallo_del_bloque ; end ; end loop ; -- Si llega aquí, es que ha terminado con éxito -- alguna de las alternativas

end Bloque_Recuperacion ;


52

8.- Tolerancia a fallos en restricciones temporales Algunos motivos por los que un plazo puede no cumplirse:

Estimaciones del caso peor no adecuadas

Suposiciones hechas en el estudio de planificabilidad no acertadas

Falla el propio algoritmo de planificabilidad

El sistema está trabajando fuera de los parámetros para los cuales ha sido diseñado


53

Recuperación Hacia-Delante

Prog. Principal

Lanza procesos

exception when DeadLine_Error ... when Period_Error ...

Proceso 1 (T=20 ;D=12)




54

Recuperación Hacia-Atrás

a) Requisito temporal dentro del test de aceptación de bloques de recuperación

b) Asociar un time-out que detecta el final del plazo task body A is begin loop ... calcula el tiempo del time-out (plazo) select opcion-1 time-out (plazo) instrucciones para restaurar el sistema else fail end select ; end loop ; ... end A;


55

Facilidades del lenguaje Ada

• Suspensión de tareas creadas dinámicamente abort

• Transferencia Asíncrona de Control (ATC) select A then abort B end select ;

• Tratamiento de excepciones dentro de las tareas


56

Detección de plazo excedido y recuperación hacia delante

task body A is Siguiente_Activacion, Siguiente_Plazo : Time; Periodo: constant Time_Span := ... Plazo: constant Time_Span := ... begin …


57

begin Inicio_A := Clock; -- o bien, inicializada en otro sitio Siguiente_Activacion := Inicio_A + Periodo; Siguiente_Plazo := Inicio_A + Plazo; Loop select delay until Siguiente_Plazo; raise plazo_excedido; then abort Accion_de_la_tarea; end select; delay until Siguiente_Activación; Siguiente_Activacion := Siguiente_Activacion + Periodo; Siguiente_Plazo := Siguiente_Activacion + Plazo; end loop; exception when plazo_excedido => tratamiento_del_fallo; raise; end

sistemas de tiempo real -...

Documents