Sistemas de Tiempo Real

SISTEMAS DE TIEMPO REAL Optativa de 2º ciclo Ingeniería Informática Ingeniería de Telecomunicación Ingeniería Industrial

José Luis Villarroel Salcedo Departamento de Informática e Ingeniería de Sistemas Centro Politécnico Superior Universidad de Zaragoza

ÍNDICE • • • • • • • • • • • • • •

Introducción Nociones sobre concurrencia Medida y control del tiempo Planificación cíclica Planificación basada en prioridades: RMS Planificación basada en prioridades: DMS Planificación basada en prioridades: EDF Manejadores de dispositivos Tolerancia a fallos. Excepciones Programación secuencial. Ada95 Programación concurrente. Ada95 Medida y control del tiempo en Ada95 Programación de bajo nivel. Ada95 Excepciones en Ada95

1 13 48 86 131 199 225 253 267 287 330 362 382 399

SISTEMAS DE TIEMPO REAL


INTRODUCCIÓN

1


2

DEFINICIÓN Un sistema de Tiempo Real es un sistema informático que: • Interacciona con su entorno físico • Responde a los estímulos del entorno dentro de un plazo de tiempo determinado No basta con que las acciones del sistema sean correctas, sino que, además, tienen que ejecutarse dentro de un intervalo de tiempo determinado.

Los sistemas tiempo real suelen estar integrados en un sistema de ingeniería más general, en el que realizan funciones de control y/o monitorización: SISTEMAS EMPOTRADOS (embedded systems)


3

CLASES Sistemas de Tiempo Real: Críticos (hard real-time systems): » los plazos de respuesta deben respetarse siempre estrictamente. » una sola respuesta tardía a un suceso externo puede tener consecuencias fatales.

Acríticos (soft real-time systems): » se pueden tolerar retrasos ocasionales en la respuesta a un suceso.

Sistemas Interactivos (no de tiempo real): No tienen plazos de respuesta explícitos


4

EJEMPLO Robot móvil de inspección


5

EJEMPLO Varias tareas: Control automático de velocidad y posición (50 ms) Lectura del láser y evitación de obstáculos (100 ms) Toma de imágenes y procesamiento (1 s) » Reconocimiento de objetos » Lectura de matrículas

Comunicación con la consola » Recepción de órdenes » Envío de imágenes y otros datos » ...


6

CARACTERISTÍCAS Determinismo Temporal Acciones en intervalos de tiempo determinados Es fundamental que el comportamiento temporal de los STR sea determinista » no hay que confundirlo con la necesidad de que sea eficiente » el sistema debe responder correctamente en todas las situaciones » hay que prever el comportamiento en el peor caso posible

Fiabilidad y seguridad Un fallo en un sistema de control puede hacer que el sistema controlado se comporte de forma peligrosa o antieconómica Es importante asegurar que si el sistema de control falla lo haga de forma que el sistema controlado quede en un estado seguro => hay que tener en cuenta los posibles fallos o excepciones en el diseño


7

CARACTERISTÍCAS Concurrencia Los componentes del sistema controlado funcionan simultáneamente El sistema de control debe atenderlo y generar las acciones de control simultáneamente Dos opciones » Sistema monoprocesador » Computadores multiprocesador o sistemas con varios computadores

Un computador ejecuta sus acciones de forma secuencial RAPIDEZ se puede hacer que el computador ejecute sus acciones de forma aparentemente simultánea La programación de sistemas concurrentes es compleja


8

CARACTERÍSTICAS Interacción con dispositivos físicos Los sistemas empotrados interaccionan con su entorno mediante diversos tipos de dispositivos que normalmente no son convencionales (teclados, impresoras, ...): convertidores A/D y D/A, entradas y salidas digitales, ... (interfases con sensores, actuadores, periféricos especiales, ...) Los componentes del software que controlan el funcionamiento de estos dispositivos (manejadores, "drivers") son, en general, dependientes del sistema concreto


9

PROGRAMACIÓN Actualmente existen dos alternativas: Lenguajes secuenciales (C, C++, ...) + sistema operativo de tiempo real » Los lenguajes secuenciales dependen de un sistema operativo para las funciones de concurrencia y temporización

Lenguajes concurrentes (Ada95, ...) » Las funciones de concurrencia y tiempo real forman parte del lenguaje


10

SISTEMAS OPERATIVOS Los sistemas operativos convencionales no son adecuados para tiempo real: No tienen comportamiento determinista No permiten garantizar los tiempos de respuesta

Un sistema operativo de tiempo real debe soportar: concurrencia: procesos ligeros con memoria común temporización: medida de tiempos y ejecución periódica planificación: expulsiva con prioridades, y acceso a recursos con herencia de prioridad manejo de dispositivos E/S: acceso a recursos de hardware e interrupciones Ejemplos: VxWorks, LynxOS, QNX, RTEMS, RT-Linux, ....


11

POSIX Portable Operating System Interface + X Conjunto de normas IEEE/ISO que definen servicios que pueden ofrecer los sistemas operativos Normas básicas, con interfaces para C Interfaces para Ada y otros lenguajes Perfiles de aplicación


12

PROGRAMACIÓN Ada95 » Se desarrolló específicamente para sistemas empotrados por encargo del DoD (Ministerio de Defensa de EEUU) --> Ada 83 » Revisión 1995 --> Ada95 » Soporta tecnologías de software avanzadas –

descomposición, abstracción, reutilización

–

programación orientada a objetos

» Incluye concurrencia, tiempo real, acceso a recursos de bajo nivel y potente tratamiento de excepciones » Se utiliza ampliamente en todo tipo de sistemas de tiempo real (no sólo militares), especialmente en Europa » Transportabilidad, Legibilidad, Eficiencia, Seguridad (chequeos compilador) » Anexos especializados (aplicaciones distribuidas, sistemas de información, ...)



NOCIONES SOBRE CONCURRENCIA

13


14

PROCESOS CONCURRENTES Procesos concurrentes: Se dice que dos o más procesos son concurrentes si pueden ejecutarse en paralelo, de forma que alguno de ellos comience a ejecutarse antes que termine algún otro. Programa concurrente: Es un programa que especifica dos o más procesos concurrentes o, de forma equivalente, un programa cuya ejecución se realiza según varios flujos de control que avanzan en paralelo. Paralelismo virtual Monoprocesador: Un único procesador va alternando la ejecución de los diversos procesos (entrelazado) Paralelismo real Multiprocesador: Cada proceso se ejecuta en un procesador diferente. Zona de memoria común (datos comunes). Sistema distribuido: Multiprocesador sin memoria compartida.


15

PROCESOS PESADOS Y LIGEROS Los sistemas operativos suelen soportar procesos "pesados" » Espacios de memoria totalmente independientes

Algunos sistemas operativos tienen procesos "ligeros" (threads) » Tienen acceso al mismo espacio de memoria » El entrelazado, comunicación y sincronización entre threads es más eficiente » Se necesitan mecanismos para evitar las interferencias entre los threads.

Nos centraremos en procesos ligeros: threads o tareas


16

ESTADOS DE UN PROCESO

kernel preparado

nuevo

espera

activo

ejecución

terminado

En un sistema con N procesadores, sólo puede haber N procesos en ejecución


17

NÚCLEO DE TIEMPO REAL Los procesos concurrentes se ejecutan con ayuda de un núcleo de ejecución (run-time kernel) El núcleo se encarga de la creación, terminación y entrelazado de los procesos

El núcleo puede tomar varias formas: Núcleo desarrollado como parte de la aplicación » ejemplo: ejecutivo cíclico

Núcleo del entorno de ejecución del lenguaje » ejemplo: lenguaje Ada95

Núcleo de un sistema operativo de tiempo real » ejemplo: VxWorks, LynxOS, RTEMS, RT-Linux, QNX, ...


18

Ejemplo: control de temperatura y nivel

» T: temperatura » H: nivel de líquido

V

» C: ajuste del calefactor » V: ajuste de la válvula

Periodo de muestreo deseado: » Temperatura: 5 s » Nivel: 1 s

H

T C


19

Ejemplo: Ejecutivo cíclico (C)

void CONTROL_DE_TEMPERATURA(void) { TEMPERATURA T ; AJUSTE_DE_CALEFACTOR C ; MEDIR(&T) ; CALCULAR_ACCION(T,&C) ; GENERAR(C) ; MOSTRAR(T) ;

void EJECUTIVO_CICLICO(void) { int i ; for (i = 0; 1; i=(i+1)%5 ) { CONTROL_DE_NIVEL() ; if (i==0) CONTROL_DE_TEMPERATURA() ; -- esperar hasta 1 s }

} void CONTROL_DE_NIVEL(void) { ALTURA H ; AJUSTE_DE_VALVULA V ; MEDIR(&H) ; CALCULAR_ACCION(H,&V) ; GENERAR(V) ; MOSTRAR(H) ; }

}


20

Ejemplo: Tareas en Ada95

procedure SISTEMA_DE_CONTROL is task CONTROL_DE_TEMPERATURA ; task CONTROL_DE_NIVEL ; task body CONTROL_DE_TEMPERATURA is T: TEMPERATURA ; C: AJUSTE_DE_CALEFACTOR ; begin loop MEDIR(T) ; CALCULAR_ACCION(T,C) ; GENERAR(C) ; MOSTRAR(T) ; -- esperar hasta 5 seg end loop ; end CONTROL_DE_TEMPERATURA ;

task body CONTROL_DE_NIVEL is H: ALTURA ; V: AJUSTE_DE_VALVULA ; begin loop MEDIR(H) ; CALCULAR_ACCION(H,V) ; GENERAR(V) ; MOSTRAR(H) ; -- esperar hasta 1 seg end loop ; end CONTROL_DE_NIVEL ; begin -- SISTEMA_DE_CONTROL null ; end SISTEMA_DE_CONTROL ;


21

Ejemplo: Threads en POSIX

#include pthread_attr_t atributos ; pthread_t thread_T, thread_H ; void CONTROL_TEMP(void) { TEMPERATURA T ; AJUSTE_DE_CALEFACTOR C ; while(1) { MEDIR(&T) ; CALCULAR_ACCION(T,&C) ; GENERAR(C) ; MOSTRAR(T) ; -- esperar hasta 5 s } }

void CONTROL_NIVEL(void) { ALTURA H ; AJUSTE_DE_VALVULA V ; while(1) { MEDIR(&H) ; CALCULAR_ACCION(H,&V) ; GENERAR(V) ; MOSTRAR(H) ; -- esperar hasta 1 s } } ......


22

Ejemplo: Threads en POSIX ..... void main() { void *result ; /* preparar atributos por defecto */ pthread_attr_init(&atributos); /* crear los threads */ pthread_create(&thread_T, &atributos, (void *)CONTROL_TEMP, void); pthread_create(&thread_H, &atributos, (void *)CONTROL_NIVEL, void); /* bloquea el progama principal */ /* hasta que terminen los threads */ pthread_join(thread_T, &result ) ; pthread_join(thread_H, &result ) ; exit(-1) ; /* nunca se ejecutará */ }


23

ENTRELAZADO Entrelazado y operaciones atómicas Proceso P ; x,y: entero ;

Proceso Q ; z,u: entero ;

P1: x:=1 ; P2: y:=x+2 ;

Q1: z:=3 ; Q2: u:=z+1 ;

fin P ;

fin Q ;

Posibles ejecuciones: (P1; P2; Q1; Q2) (P1; Q1; P2; Q2) (Q1; P1; P2; Q2) ...


24

ENTRELAZADO Cada instrucción de alto nivel: varias instrucciones código máquina.

Por ejemplo: x := y + z ; copiar

y, r1

copiar

z, r2

sumar

r1, r2

copiar

r2, x

Operaciones atómicas.


COMPETENCIA / EXCLUSIÓN MUTUA Dos procesos compiten cuando comparten: un recurso una variable El acceso al recurso o a la variable debe ser en exclusión mutua. Región crítica: secuencia de instrucciones que deben ejecutarse en exclusión mutua

25


26

COMPARTICIÓN DE UN RECURSO Ejemplo: dos procesos (P y Q) comparten una cinta magnética. libre:= true; proceso

P;

principio repetir repetir nada; hasta libre; libre:= false; usar cinta; libre:= true; otras cosas; fin repetir; fin ;

proceso Q; principio repetir repetir nada; hasta libre; libre:= false; usar cinta; libre:= true; otras cosas; fin repetir; fin ;


27

COMPARTICIÓN DE UNA VARIABLE Ejemplo: dos procesos (acumulador y escritor) comparten una variable n. n : entero := 0; proceso acumulador; principio repetir esperar impulso; n:=n+1; fin repetir; fin;

proceso escritor; principio repetir esperar 1 hora; escribir n; n:=0; fin repetir; fin;


28

COMPARTICIÓN DE UNA VARIABLE Posibles trazas: (escribir n; n:=0; n:=n+1) (escribir n; n:=n+1; n:=0) --> Pérdida de pulso (n:=n+1; escribir n; n:=0) n := n + 1 ; copiar

n, r1

sumar

r1, 1

copiar

r1, n

/ (escritor) n:=0; => Pérdida de la puesta a cero de n

Pb: entrelazado de las instrucciones en el acceso a la variable común. Solución en ambos casos: garantizar el acceso en exclusión mutua al elemento compartido.


29

REGIÓN CRÍTICA Se garantiza que dos procesos no estarán ejecutando a la vez una misma región crítica Ejemplo: dos procesos (P y Q) comparten una cinta magnética. n : compartida entero := 0; proceso acumulador; principio repetir esperar impulso; region n hacer n:=n+1; fin; fin repetir; fin;

proceso escritor; principio repetir esperar 1 hora; region n hacer escribir n; n:=0; fin; fin repetir; fin;


30

REGIÓN CRÍTICA Ejemplo: dos procesos (P y Q) comparten una cinta magnética. v : compartida boolean; proceso P; principio repetir region v hacer usar cinta; fin; otras cosas; fin repetir; fin ;

proceso Q; principio repetir region v hacer usar cinta; fin; otras cosas; fin repetir; fin ;


REGIÓN CRÍTICA: REALIZACIÓN Varias posibles realizaciones: Mutex (semáforo binario) » POSIX, VxWorks, RTEMS, ...

Monitor » Protected (Ada95)

Aplicación tiempo real: tareas + núcleo El núcleo es el que ejecuta las primitivas de exclusión mutua El núcleo no puede ser expulsado » El núcleo es el que decide qué tarea está en el procesador en cada momento

31


32

MUTEX Es una variable booleana S : mutex := valor_inicial ; wait(S): si S = true,

S := false

si no, suspender el proceso signal(S): si hay procesos esperando, pasar uno de ellos a preparado si no,

S := true

Las operaciones signal y wait son atómicas. Los semáforos tienen asociada una cola de procesos suspendidos en espera. Los semáforos son gestionados por el núcleo de ejecución


33

MUTEX La exclusión mutua puede asegurarse con un semáforo binario, inicializado a uno (true)

mutex: mutex_semaphore := 1 ; proceso P1; principio repetir Wait(mutex) ; Signal(mutex) fin repetir; fin P1 ;

proceso P2; principio repetir Wait(mutex) ; Signal(mutex) fin repetir; fin P2 ;

CUIDADO: si un proceso olvida liberar el mutex, el recurso queda bloqueado


34

MONITOR (protected Ada95) No se puede acceder a las variables definidas en un monitor salvo a través de los procedimientos definidos en él. El número de procesos que pueden ejecutar a la vez procedimientos de un monitor está limitado a uno => exclusión mutua en el acceso a las variables protected body contador is

protected contador is procedure incremento ; procedure escribe_borra ; private n: integer := 0 ; end ;

procedure incremento is begin n := n+1 ; end ; procedure escribe_borra is begin escribir (n) ; n := 0 ; end ; end ;


35

MONITOR Pueden programarse mediante mutex

/* fichero contador.c */ #include “contador.h” #include

/* fichero contador.h */ void incrementa(void) ; void escribe_borra(void) ;

/* variables privadas del monitor */ static semaphore mutex_contador ; static int n = 0 ; void incrementa(void) { wait(mutex_contador) ; n:=n+1; signal(mutex_contador) ; } void escribe_borra(void) { wait(mutex_contador) ; escribir(n); n:=0; signal(mutex_contador) ; }


36

EXCLUSIÓN MUTUA E INTERRUPCIONES Las rutinas de servicio de interrupciones (ISR) se ejecutan en concurrencia con el resto de procesos. Exclusión mutua => inhibir interrupciones static int n = 0 ; void rutina_interrupcion(void) { n:=n+1; } void escribe_borra(void) { inhibir_interrupcion() ; escribir(n); n:=0; activar_interrupcion() ; }


37

COOPERACION / COMUNICACION Interacciones más directas entre procesos que cooperan en la realización de alguna tarea. Cooperación => intercambio de datos

Comunicación asíncrona: » buzones » semáforos.

Comunicación síncrona: » cita » cita extendida.


38

BUZON Comunicación asíncrona Un proceso P produce y envía una secuencia de datos a otro proceso C que los recibe y consume. Los datos son transmitidos en porciones discretas denominadas mensajes. Es posible que P produzca un mensaje cuando C no esté en disposición de recibirlo. Para evitar que P espere se introduce un área de almacenamiento de mensajes donde P puede colocar sus mensajes hasta que C los lea: BUZON.

P

B

C


39

BUZON Restricciones: El proceso emisor no puede exceder la capacidad finita del buzón. Si el buzón está lleno el emisor espera para depositar su mensaje. El proceso receptor no puede consumir mensajes más deprisa de lo que se producen. Si el buzón está vacío el proceso receptor espera a que un mensaje sea depositado. Manejo de buzones: var B : buffer send(M,B)

max

of

T

receive(M,B)

B es memoria compartida por varios procesos (emisor y receptor) => exclusión mutua en el acceso => un buzón es una región crítica. Es posible que un buzón tenga varios procesos emisores y varios receptores.


40

BUZÓN La política de manejo de un buzón puede ser: Si al enviar un mensaje el buzón está lleno: » el emisor espera hasta que haya espacio » el emisor espera, con un tiempo máximo » el mensaje se descarta » se descarta otro mensaje (p.ej. el más antiguo)

Si al solicitar un mensaje el buzón está vacío: » el receptor espera hasta que haya mensaje » el receptor espera, con un tiempo máximo » se le indica que no hay mensaje y puede continuar


41

BUZONES EN POSIX Y VXWORKS Algunos sistemas ofrecen paquetes de manejos de buzones con posibilidades adicionales: Colas de mensajes en POSIX » Consulta del número de mensajes pendientes » Opción de no bloqueo al enviar o al recibir » Si hay varios receptores esperando se les atiende por prioridad » Mensajes con 32 prioridades

Colas de mensajes en VxWorks » Consulta del número de mensajes pendientes » Opción de no bloqueo y de tiempo máximo de espera al enviar o al recibir » Si hay varios receptores esperando se les atiende por prioridad o por orden FIFO » Mensajes con 2 prioridades: normal o urgente


42

SEMÁFORO Si los mensajes no encierran ninguna información el buzón se denomina SEMAFORO. No interesa el contenido de los mensajes sino solamente su número => el semáforo es un contador de mensajes. Sintaxis:

S : semaphore := valor_inicial ; wait(S): si S > 0, S := S - 1 si no, suspender el proceso signal(S): si hay procesos esperando, pasar uno de ellos a preparado si no, S := S + 1

Las operaciones signal y wait son atómicas. Cola de procesos suspendidos en espera. Los semáforos son gestionados por el núcleo de ejecución


43

SEMÁFORO El problema de hacer cuadernillos:

programa GRAPAR_HOJAS ; var S: semaphore; proceso AMONTONAR; principio repetir coger una hoja de cada montón ; dejar el grupo de hojas en la mesa ; signal(S) ; hasta que se acaben las hojas; fin ; proceso GRAPAR ; principio repetir wait(S) ; tomar un grupo de la mesa ; graparlo ; hasta que se acaben los grupos; fin ; principio init (S,0) ; fin ;


44

CITA Una cita supone: Una sincronización de dos procesos Un intercambio de información La cita es un mecanismo no simétrico: un proceso ejerce de llamador y otro de aceptador de la llamada. Proceso Aceptador Proceso Llamador El intercambio de información puede ser bidireccional (Ada) o unidireccional (OCCAM).

envío datos

aceptación de la llamada

respuesta


45

CITA EXTENDIDA Cita extendida (rendez-vous de Ada): es una cita en la que el proceso aceptador ejecuta un código en la aceptación: Procesamiento datos recibidos Preparación datos a enviar Sintaxis (proceso aceptador): entry NOMBRE_ENT (DEC_PARAMETROS) ; accept NOMBRE_ENT(DEC_PARAMETROS) do código de la cita extendida; end NOMBRE_ENT;

Proceso llamador (≈ llamada procedimiento): P_ACEPTADOR.NOMBRE_ENT(PARAMETROS) ;


46

CITA EXTENDIDA procedure BAR is

BAR: El camarero y los clientes

task CLIENTE ; task CAMARERO is entry COBRAR (DINERO: in out integer) ; end CAMARERO ; task body CLIENTE is MONEDERO: integer := 100 ; begin -- tomar una consumición ; CAMARERO.COBRAR (MONEDERO) ; -- hacer otras cosas ; end CLIENTE ; task body CAMARERO is PRECIO: integer := 50 ; begin -- atender clientes ; accept COBRAR(DINERO: in out integer) do begin DINERO := DINERO - PRECIO ; end COBRAR ; -- hacer otras cosas ; end CAMARERO ; begin null; end BAR ;


47

SELECCIÓN NO DETERMINISTA BAR: El camarero mejorado

task C1 ; task body C1 is begin ... CAMARERO.SERVIR (_) ; ... CAMARERO.COBRAR (_) ; ... end C1 ;

task CAMARERO is entry SERVIR (_) ; entry COBRAR (_) ; end CAMARERO ; task body CAMARERO is begin loop select accept SERVIR (_) do ... end SERVIR ; or accept COBRAR (_) do ... end COBRAR ; end select ; end loop ; end CAMARERO ;



MEDIDA Y CONTROL DEL TIEMPO

48


49

INTRODUCCION Característica más importante de un sistema tiempo real: capacidad para ejecutar sus acciones en intervalos de tiempo bien definidos. Por este motivo es fundamental disponer de mecanismos adecuados para: medir el tiempo controlar la duración de las acciones del sistema

Más concretamente hace falta: Mecanismos para medir el tiempo: relojes y temporizadores Mecanismos para activar tareas en instantes determinados Mecanismos para reconocer fallos en los plazos de ocurrencia de ciertos eventos: timeouts Mecanismos para especificar y asegurar los plazos de ejecución de las acciones: planificadores de tiempo real


50

INTRODUCCIÓN Además un sistema tiempo real es un sistema concurrente, compuesto por procesos. Desde el punto de vista del tiempo, principalmente dos tipos de procesos:

Procesos periódicos: son aquellos que se activan regularmente en instantes de tiempo separados por un período de tiempo determinado.

Procesos esporádicos: son aquellos que se activan de forma irregular, cada vez que se producen ciertos eventos externos.

proceso P; cada T repetir actividad; fin repetir; fin P;

proceso P; repetir esperar E ; actividad; fin repetir; fin P;


51

TIEMPO El tiempo es una magnitud física fundamental, cuya unidad en el SI es el segundo. Se necesitan dos tipos de medidas: » Tiempo absoluto » Tiempo relativo o intervalos de tiempo

El tiempo absoluto necesita un sistema de referencia » escala de tiempo » con un origen que se denomina época

Un sistema de tiempo real para medir el paso del tiempo puede: » Acceder a un sistema de referencia externo (p.e. Señal UTC del GPS) » Utilizar un reloj de hardware interno que proporciona una aproximación del paso del tiempo en el entorno » Utilizar un reloj interno + sincronizaciones con sistema de referencia externo


52

TIEMPO Sistemas de referencia estándar Astronómicos » Tiempo universal (UT0):Tiempo solar en el meridiano Greenwich » UT1, UT2: correcciones por el desplazamiento polar y por variaciones de la velocidad de rotación de la Tierra

Atómicos » Tiempo Atómico Internacional (IAT): Basado en un reloj atómico de cesio » Tiempo Universal Coordinado (UTC): Reloj IAT sincronizado con UT2 mediante la adición de ticks ocasionales


53

MEDIDA DEL TIEMPO El tiempo en un computador se mide con: Relojes » Pueden llegar a medir tiempo absoluto » Funcionan de forma continua

Temporizadores » Medida de intervalos temporales » Arranque y paro

Arranque

[ t1

∆t

Paro

Temporizador

] t2

t

Reloj ∆t = t2-t1


54

RELOJES Reloj: es un módulo (de hardware y software) que proporciona el valor del tiempo real cuando se lee. Un reloj está compuesto por: Un circuito que genera impulsos periódicos Un contador que acumula los impulsos Un software de gestión » Lectura del tiempo » Puesta en hora » Conversión del contador en unidades de tiempo (segundos, minutos, ...) » ...

Las características más importantes de un reloj son: Precisión (granularidad). Depende de la frecuencia de los impulsos. Intervalo de valores. Depende de la precisión y de la capacidad del contador.


55

MEDIDA DEL TIEMPO Unidad de tiempo: tick El contador es de capacidad limitada » desbordamiento -> reinicio cuenta Tiempo computador tick vida aplicación (t. no monótono)

tiempo

tiempo monótono, la aplicación tiene una vida menor que el tiempo de desbordamiento. tiempo no monótono, la aplicación vive más que el tiempo de desbordamiento


56

MEDIDA DEL TIEMPO La monotonía del tiempo depende de: el tiempo de vida de la aplicación el tamaño del contador en relación con el tamaño del tick.

Problemas del tiempo no monótono No se dispone del tiempo absoluto » No se puede mantener fecha, hora, ...

No se pueden utilizar intervalos temporales por encima del tiempo de desbordamiento del contador del reloj


57

TIPOS DE RELOJES Reloj calendario Mantenimiento de la fecha y hora de una aplicación No monótono » Generalmente sincronizado con un sistema de referencia exterior (p.e. UTC) puesta en hora » Horario de invierno y de verano

Reloj de tiempo real Medida y control del tiempo Monótono o no monótono » No monotonía sólo por desbordamiento » No puesta en hora

Generalmente de más precisión


58

EJEMPLOS DE RELOJES POSIX.1b: CLOCK_REALTIME (p.e. VxWorks) número entero de segundos (32 bits)

Ada95: Ada.Real_Time Tipo abstracto de dato con funciones de manejo y conversión época: arranque de la aplicación

número entero de nanosegundos (32 bits)

intervalo: igual o mayor a 50 años

Resolución en la representación: 1ns

Resolución en la representación: mínimo 20 µs

Granularidad

Granularidad

» Depende de la implementación » Como mínimo 20 ms

intervalo: 232 s = 136 años

» Depende de la implementación » Como mínimo 1 ms


59

CLOCK_REALTIME struct timespec { time_t tv_sec ; /* segundos */ long tv_nsec; /* nanosegundos */ };

#include struct timespec ts ; /* leer la hora */ clock_gettime(CLOCK_REALTIME, &ts); /* poner en hora */ clock_settime(CLOCK_REALTIME, &ts); /* obtener la resolucion del reloj */ clock_getres(CLOCK_REALTIME, &ts);


60

Ada.Real_Time

package Ada.Real_Time is type Time is private; Time_First : constant Time; Time_Last : constant Time; Time_Unit : constant := implementation-defined-real-number; type Time_Span is private; Time_Span_First : constant Time_Span; Time_Span_Last : constant Time_Span; Time_Span_Zero : constant Time_Span; Time_Span_Unit : constant Time_Span; Tick : constant Time_Span; function Clock return Time;


EJEMPLO DE MEDIDA DEL TIEMPO Medida del tiempo de ejecución de una actividad

use Ada.Real_Time; declare Old_Time, New_Time : Time; Interval : Time_Span; begin Old_Time := Clock; -- actividad cuya duración se mide New_Time := Clock; Interval := New_Time - Old_Time; end;

61


62

EJEMPLO DE MEDIDA DEL TIEMPO Técnica de doble bucle Sólo es válido si la secuencia de instrucciones se ejecuta de una vez (sin ceder el procesador a otras tareas o al núcleo) declare T0, T1, T2 : Ada.Real_Time.Time; Execution_Time : Ada.Real_Time.Time_Span; N : constant Positive := ...; begin T0 := Ada.Real_Time.Clock; for i in 1 .. N loop -- secuencia de instrucciones end loop; T1 := Ada.Real_Time.Clock; for i in 1 .. N loop null; end loop; T2 := Ada.Real_Time.Clock; Execution_Time = ((T1 - T0) - (T2 - T1))/N; end;


63

RELOJES CALENDARIO Reloj calendario Fecha Hora oficiales Un reloj calendario no es monótono Horario de invierno Horario de verano En el cambio a horario de verano el reloj se atrasa

Un reloj de estas características no se puede utilizar en tiempo real


64

ACTIVACIÓN DE TAREAS Mecanismos básicos de activación de tareas: Por interrupción » Tareas periódicas » Tareas esporádicas

Con retardos » Tareas periódicas

Primitivas de comunicación/sincronización (tareas que activan a otras tareas) » Semáforos, buzones » Cita » Tareas periódicas o esporádicas


ACTIVACIÓN POR INTERRUPCIÓN La estructura de la aplicación depende del hardware disponible: » La activación es realizada directamente por el hardware » Se asocia una interrupción a cada tarea » Tareas periódicas -> un timer (hardware) por cada tarea

Con esta aproximación la aplicación es dependiente del hardware: » Hardware específico, no de propósito general » Falta de transportabilidad » Mucha eficiencia

65


66

EJEMPLO INTERRUPCIONES Ada95

task body Task_i is

begin loop Int_i.Wait_for_Event ; Event_Processing ; end loop ; end Task_i ; protected Int_i is entry Wait_for_Event ; private protected body Int_i is procedure Handler ; Interrupt_Ocurred: boolean := false ; procedure Handler is end ; begin Interrupt_Ocurred:= true ; end ; entry Wait_for_Event when Interrupt_Ocurred is begin Interrupt_Ocurred := false ; end ; end ;


67

EJEMPLO INTERRUPCIONES VxWorks

void task (void) {

void Int_Handler (void) { ... ; semGive (syncSem) ; }

while (TRUE){ semTake (syncSe, WAIT_FOREVER) ; Event_Processing () ; } }


68

RETARDOS Los retardos permiten controlar el tiempo de activación de las tareas. Esta técnica de activación no depende del hardware Hardware propósito general Transportabilidad En Ada95 y otros lenguajes y sistemas operativos se realizan mediante la instrucción: delay ; / nanosleep () ; Efecto: suspende la ejecución de la tarea durante, al menos, la duración especificada, a partir del momento en que se invoca. La ejecución puede verse retrasada durante una duración mayor a la especificada debido a: Precisión del reloj menor que la precisión de la duración especificada. Un método de planificación que selecciona otra tarea para la ejecución antes que la retrasada.


TAREAS PERIÓDICAS Y RETARDOS Los retardos se pueden utilizar para realizar tareas periódicas: task PERIODICA; task body PERIODICA is PERIODO: constant DURATION := … ; begin loop -- acción periodica delay PERIODO ; end loop ; end PERIODICA ;

Problema: deriva acumulativa. Los retrasos que se producen en cada periodo (deriva local) se van acumulando.

69


TAREAS PERIÓDICAS Y RETARDOS Esquema que elimina la deriva acumulativa (no la local):

task body PERIODICA is PERIODO: constant DURATION := … ; SIGUIENTE: TIME ; begin SIGUIENTE:= CLOCK ; loop -- acción periodica SIGUIENTE:= SIGUIENTE + PERIODO ; delay SIGUIENTE - CLOCK ; end loop ; end PERIODICA ;

70


71

TAREAS PERIÓDICAS Y RETARDOS P=50 ms a3

a2

a1

A1

a4

A2

delay 0.05

delay 0.05

50 ms

DL

DA

A3 50 ms

DA

DL

Primera aproximación

A1

delay A2 0.01

DL

DL

delay 0.02

A3

DL=0

Aproximación buena

delay 0.03

A4

DL


TAREAS PERIÓDICAS Y RETARDOS En C + VxWorks #include "delays.h" .... void tarea_periodica(void) { struct timespec siguiente, inicio, ahora, ts ; struct timespec periodo = to_timespec(0.05) ; clock_gettime(CLOCK_REALTIME, &inicio) ; siguiente = inicio ; while(1) { siguiente=add_timespec(siguiente, periodo); clock_gettime(CLOCK_REALTIME, &ahora) ; ts = sub_timespec (siguiente, ahora) ; nanosleep(&ts, 0) ; } }

72


73

DELAY UNTIL Resuelve el problema de la no atomicidad de la instrucción: delay SIGUIENTE - CLOCK ; utilizando tiempo absoluto

Ada 95

task body PERIODICA is PERIODO: constant DURATION := … ; SIGUIENTE: TIME ; begin SIGUIENTE:= CLOCK ; loop -- acción periodica SIGUIENTE:= SIGUIENTE + PERIODO ; delay until SIGUIENTE ; end loop ; end PERIODICA ;


74

COMUNICACIÓN / SINCRONIZACIÓN Tarea periódica con supervisor Es posible tratar posibles pérdidas de activación con un supervisor procedure main is ... task body supervisor_T1 is begin SIGUIENTE:= CLOCK ; loop select T1.activacion ; else manejo_perdida_activacion ; end select ; SIGUIENTE:= SIGUIENTE + PERIODO ; delay until SIGUIENTE ; end loop ; end supervisor_T1 ;

task body T1 is begin loop accept activacion ; task1 ; end loop ; end T1 ; ... begin null; end main ;


75

TIME-OUT A veces es necesario limitar el tiempo durante el cual una tarea espera que ocurra algún evento. Una tarea queda suspendida cuando requiere: una operación de entrada/salida u otro servicio del sistema operativo una comunicación con otra tarea Pb: si el dispositivo o la tarea cooperante falla la tarea suspendida nunca volverá a estar activa Solución: Time-out, tiempo máximo en el cual la tarea quedará suspendida


76

TIME OUT Limitación del tiempo de espera Sincronización condicional: semáforo con time-out » Ejemplo: en VxWorks semTake(semaforo, NO_WAIT) ; semTake(semaforo, WAIT_FOREVER) ; semTake(semaforo, num_ticks) ;

Paso de mensajes: buzón con time-out » Ejemplo: en VxWorks msgQReceive(Qid, &buf, max, NO_WAIT) ; msgQReceive(Qid, &buf, max, WAIT_FOREVER) ; msgQReceive(Qid, &buf, max, num_ticks) ; msgQSend(Qid, &buf, lon, NO_WAIT, prio) ; msgQSend(Qid, &buf, lon, WAIT_FOREVER, prio) ; msgQSend(Qid, &buf, lon, num_ticks, prio) ;


77

TIME OUT Limitar el tiempo de ejecución de una acción si se supera el tiempo máximo, puede ser necesaria una acción de recuperación » Ejemplo: Watchdogs en VxWorks void recupera(int parametro) { printf(“Watchdog expirado\n”) ; } void tarea1(void) { WDOG_ID miwdog ; ... miwdog = wdCreate() ; ... wdStart(miwdog, ticks, recupera, param) ; wdCancel(miwdog) ; ... }


78

PLANIFICACION Además de la limitación del tiempo de espera aparecen otras restricciones que afectan al tiempo de ejecución de sus actividades:

Periodicidad Tiempo de respuesta ante un evento Completar el trabajo antes de un plazo …

¿Cómo planificar la ejecución de las actividades de forma que se satisfagan las restricciones temporales?


79

PLANIFICACIÓN Marco temporal de una tarea: es el conjunto de atributos temporales asociados. » Tiempo de activación: ta » Periodo de ejecución: P ó T; o separación mínima: S » Retardo: r ; retardo máximo: R –

Jitter: variación en r

» Tiempo de cómputo: c ; id. máximo: C » Tiempo de ejecución transcurrido: e » Tiempo de finalización: tf

activación comienzo k

» Tiempo de respuesta: d

c1

fin

c = c1 + c2 + c3 c2 c3

r

» Plazo de respuesta: D (deadline)

e d

» Tiempo límite: tl

activación k+1

t f (k) D

t l (k) P

t a (k)

t a (k+1)


80

PLANIFICACIÓN Las restricciones temporales más comunes se refieren al plazo de respuesta de las tareas. Desde este punto de vista, podemos distinguir tres clases de tareas: Tareas de tiempo real críticas. No admiten que se sobrepase el tiempo límite en ningún caso. Tareas de tiempo real acríticas. Admiten que se sobrepase el tiempo límite ocasionalmente. Tareas interactivas. No tienen plazo de respuesta estricto, aunque el tiempo de respuesta debe ser lo más corto posible.


81

PLANIFICACIÓN Objetivo: Planificar el uso de los recursos del sistema (en particular, el procesador), para poder garantizar los requisitos temporales de las tareas

Un método de planificación consta de: Un algoritmo de planificación, que determina el orden de acceso de las tareas a los recursos del sistema Un método de análisis que permite calcular el comportamiento temporal del sistema » Para comprobar que los requisitos están garantizados en todos los casos » Se estudia siempre el peor caso » Es necesario conocer la duración de las tareas en el peor caso


82

PLANIFICACION Métodos: Planificación estática “off-line” » Planificación cíclica

Planificación basada en prioridades » Prioridades estáticas –

Prioridad al más frecuente (Rate monotonic)

–

Prioridad al más urgente (Deadline monotonic)

» Prioridades dinámicas –

Proximidad del plazo de respuesta (Earliest deadline first)

–

Prioridad al de menor holgura (Least Laxity First)


83

PLANIFICACION CICLICA Ejecutivo cíclico: estructura de control o programa cíclico que entrelaza de forma explícita la ejecución de diversos procesos periódicos en un único procesador. El entrelazado es fijo. Planificación cíclica: especificación del entrelazado de varios procesos periódicos durante un periodo de tiempo (ciclo principal) de tal forma que su ejecución cíclica garantiza el cumplimiento de los plazos de los procesos

Ejemplo: cuatro procesos (plazo = periodo) (C,P,D) A=(1,10,10), B=(3,10,10), C=(2,20,20), D=(8,20,20) 0 A B

6 C

D1

10 A B

14 D2

20


84

PRIORIDADES Son un mecanismo elemental para planificar la ejecución de un conjunto de tareas. La prioridad es un atributo de las tareas normalmente ligado a su importancia relativa en el conjunto de tareas. Planificación por prioridades: en cada momento se ejecuta la tarea más prioritaria de entre todas las ejecutables (preparadas). Planificación expulsiva: se abandona inmediatamente la ejecución de la tarea en ejecución cuando otra más prioritaria pasa al estado preparada para ejecución. La prioridad de una tarea puede ser: Estática: la prioridad permanece constante a lo largo de la existencia de la tarea. Dinámica: la prioridad puede variar en función del estado o modo de funcionamiento del sistema.


85

PRIORIDADES Ejemplo: T1 = (5,20,20) T2 = (10,40,40) T3 = (40,80,80)

Prio(T1) > Prio(T2) > Prio(T3)

T1 T2 fin T3 T3 0

10

20

30

40

50

60

70

80



PLANIFICACION CÍCLICA

86


87

MODELO DE TAREAS Consideraremos inicialmente un modelo de tareas simple: Conjunto de tareas estático Todas las tareas son periódicas Las tareas son independientes entre sí Se conoce el tiempo de ejecución máximo de cada tarea C i Cada tarea tiene un plazo de respuesta D i ≤ T i

Después veremos como incorporar tareas esporádicas


88

PLAN PRINCIPAL Ejecutivo cíclico: estructura de control o programa cíclico que entrelaza de forma explícita la ejecución de diversos procesos periódicos en un único procesador. El entrelazado es fijo y está definido en el denominado plan principal que es construido antes de poner en marcha el sistema Plan principal: especificación del entrelazado de varios procesos periódicos durante un período de tiempo (ciclo principal) de tal forma que su ejecución cíclica garantiza el cumplimiento de los plazos de los procesos La duración del ciclo principal es igual al mínimo común múltiplo de los períodos de los procesos » M = mcm (Ti) » se supone tiempo entero (p.e. Número de ticks) » el comportamiento temporal del sistema se repite cada ciclo principal


89

PLANES SECUNDARIOS Cada plan principal es dividido en uno o más planes secundarios o marcos (“frames”) que se ejecutarán de forma secuencial. Cada comienzo/fin de un marco en el ejecutivo cíclico se sincroniza con el reloj. Son puntos donde se fuerza la corrección del tiempo real. Por simplicidad, en la práctica, la duración de todos los marcos es la misma. A esta duración se le denomina ciclo secundario. Si las acciones definidas en un marco acaban antes de que concluya el ciclo secundario el ejecutivo cíclico espera (p.e. en un delay) Si las acciones definidas en un marco no han acabado al terminar el ciclo secundario, se produce un error: desbordamiento de marco. Si la duración de una acción es superior al ciclo secundario debe ser descompuesta en subacciones


90

EJEMPLO Cuatro procesos (plazo = periodo) (C,T,R) A=(1,10,10), B=(3,10,10), C=(2,20,20), D=(8,20,20)

Plan principal: 0 A B

6 C

D1

Ciclo principal: 20 ms Ciclo secundario: 10 ms

10 A B

14 D2

20


91

EJEMPLO Ejecutivo cíclico: procedure cyclic_executive_1 is type frame_index is mod 2 ; interval: constant := 0.01 ; next_time: time := clock ; frame_number: frame_index := 1 ; begin loop frame_number:= frame_number + 1 ; case frame_number is when 0 => A; B; C; D1; when 1 => A; B; D2; end case next_time := next_time + interval ; if clock > next_time them frame_overrun ; end if ; delay until next_time ; end loop ; end cyclic_executive_1 ;


92

EJEMPLO (C+VxWorks) Ejecutivo cíclico: #include "delays.h“

void delay_until(TS ts) { TS ahora, resto ; clock_gettime(CLOCK_REALTIME, &ahora) ; resto = sub_timespec(ts, ahora) ; nanosleep(&resto, 0) ;

void main (void) { } struct timespec next ; struct timespec interval = to_timespec(0.01) ; int frame_number = 1 ; clock_gettime(CLOCK_REALTIME, &next) ; while(1) { frame_number = (frame_number + 1)%2 ; switch (marco) { case 0: A; B; C; D1; break ; case 1: A; B; D2; break ; } next = add_timespec(next, interval); delay_until (next) ; } }


93

PROPIEDADES No hay concurrencia en la ejecución » Cada ciclo secundario es una secuencia de llamadas a procedimientos » No se necesita un núcleo de ejecución multitarea

Los procedimientos pueden compartir datos » No se necesitan mecanismos de exclusión mutua como los semáforos o monitores


94

DETERMINACION DE LOS CICLOS Sea un conjunto de procesos periódicos {Pi / i = 1..n}, con requisitos temporales representados por ternas (Ci, Ti, Di). Ciclo principal: » M = mcm (Ti)

Ciclo secundario » m ≤ min(Di) » m ≥ max(Ci) » ∃k: M = km » ∀i: m+ (m - mcd(m,Ti)) ≤ Di –

garantiza que entre el instante de activación de cada proceso y su plazo límite exista un marco o ciclo secundario completo

–

m - mcd(m,Ti) es el retraso máximo entre la activación de un proceso y el comienzo del siguiente marco

–

esta condición incluye a la primera


95

EJEMPLO Considérese tres procesos » P

C

T

D

» E

1

14

14

» F

2

20

20

» G

3

22

22

Ciclo principal » M = mcm(14,20,22) = 1540

Ciclo secundario » m ≤ min(14,20,22) => m = 1..14 » m ≥ max(1,2,3) => m = 3..14 » ∃k: 1540 = km => m = 4,5,7,10,11,14 » m+ (m - mcd(m,Ti)) ≤ Di => m = 4,5,7


96

EJEMPLO para m = 4 i

Ti

mcd(m,Ti) retraso

1

14

2

2

6

<

14

2

20

4

0

4

<

20

3

22

2

2

6

<

22

m=4

E F G

14 6

m+retraso

20 4

22 6

Di


97

EJEMPLO para m = 10 i

Ti

1

14

mcd(m,Ti) retraso 2

m+retraso

8

18

18 14 m = 10

E F G

0

14

28

42

56

Di >

14 NO


98

INCLUSIÓN DE PROCESOS PERIODICOS En cada ciclo principal se tienen ncs = M/m ciclos secundarios En cada plan principal se tienen nei = M/Ti ejecuciones de cada proceso Pi Hay que definir la secuencia de procesos de cada marco: σx:{Pik,Pjl,..,Prs} La ejecución k-ésima de un proceso Pi caracterizado por ternas (Ci, Ti, Di) podrá ser incluida en los marcos j-ésimos que comienzan después de la activación de Pik y terminan antes del deadline de Pik: (k − 1)Ti ≤ ( j − 1)m jm ≤ (k −1)Ti + Di

Para que la ejecución k-ésima de Pi pueda ser incluida en la secuencia de procesos σx del marco x, debe quedar suficiente tiempo libre en el marco: Ci ≤ m −

∑ Cl

∀l,Pl ∈σ x


99

PLANIFICACIÓN Objetivo: asignación de procesos (o subprocesos) a los marcos de forma que se cumplan los requisitos temporales Planteamiento: búsqueda en el espacio de estados Estado: asignación parcial Algoritmo: búsqueda en profundidad con retroceso » se pretende encontrar una única solución

Guiado de la búsqueda: heurísticas » sobre el siguiente proceso a asignar –

primero el más urgente o el más frecuente

–

primero el de tiempo de proceso más grande

» si varios marcos cumplen las condiciones: –

el primer marco que cumpla las condiciones

–

el marco con menor tiempo de cómputo libre


100

EJEMPLO: PLANIFICACIÓN Conjunto de procesos a planificar: Proceso

C

T

D

P1

2

8

8

P2

3

8

8

P3

1

6

6

P4

2

12

12

Ciclo principal: M = mcm(6,8,12) = 24 Número de ejecuciones a planificar » ne1 = M/8 = 3 » ne2 = M/8 = 3 » ne3 = M/6 = 4 » ne4 = M/12 = 2


101

EJEMPLO: PLANIFICACIÓN Ciclo secundario » m ≤ min(6,8,12) => m = 1..6 » m ≥ max(1,2,3) => m = 3..6 » ∃k: 24 = km => m = 3,4,6 » m+ (m - mcd(m,Ti)) ≤ Di => m = 3,4

posibles_m = {4,3}


102

EJEMPLO: PLANIFICACIÓN Ordenación procesos: primero el más urgente Proceso

C

T

D

n

P1

1

6

6

4

P2

3

8

8

3

P3

2

8

8

3

P4

2

12

12

2

Se intenta planificar primero para m=4 (la complejidad del problema disminuye con el número de marcos) Un planificación consta de 6 marcos consecutivos


103

EJEMPLO: PLANIFICACION Pik puede ir en el marco j si:

(k − 1)Ti ≤ ( j − 1)m jm ≤ (k −1)Ti + Di

P11

P1

0

P12 4

8

P21

P2

0

0

12

16

0

4

8

12

16

20

P32

4

4

20

8

12

24

P23 24

P33 16

20

24

20

24

P42

P41

P4

P14

P22

P31

P3

P13

8

12

16


104

EJEMPLO: PLANIFICACIÓN

1 1 1 1

1 2

1 2

1 2 1 2 1

1 2 1 2 1 2 1

1 3 1 1 2 1

1 2 1 1 2 1

2 2 3 3

3 2 3 3

1 2

1 1 2 2 1

1 2 1 1 2 2 1

1 3 1 1 2 1

1 2 1 1 2 1

1 3 1 1 3 1

2

1 3 1 1 3 1

2

2 3 2 3

3 3 2 3

1 2 1 1 2

2 3 2

4 2 3 4 2


105

PARTICIÓN DE PROCESOS Hay casos en que un conjunto de procesos que no es planificable: Si el tiempo de cómputo de uno es mayor que el plazo de algún otro: Ci > Dk => No existe valor de m que cumpla a la vez: » m ≤ min(Di) » m ≥ max(Ci)

Si para una ejecución de un proceso no queda ningún marco con suficiente tiempo libre Solución: descomponer el proceso demasiado largo Pi=(Ci,Ti,Di) en varios subprocesos Pij=(Cij,Tij,Dij): Tij=Ti ; Dij=Di Ci1+Ci2+Ci3+... = Ci no partir secciones críticas relación de precedencia en cada una de las ejecuciones a mantener en la planificación: Pi1→Pi2→Pi3→...


106

RELACIONES DE PRECEDENCIA Sean Pi1 y Pi2 dos procesos entre los que existe una relación de precedencia Pi1→Pi2, En la ordenación de los procesos para su inclusión en la planificación se mantiene el orden de precedencia (los dos subprocesos tienen las mismas restricciones temporales) Para incluir la ejecución k-ésima de Pi2, Pi2k, en la planificación: » obtener los valores {j,...,j+h} de los marcos donde puede ser incluida a partir de: (k − 1)T ≤ ( j − 1)m i

jm ≤ (k −1)Ti + Di

» Debido al orden de inclusión Pi1k ya ha sido incluida en el marco j+l ∈ {j,...,j+h}. El conjunto de marcos donde puede ser incluida se reduce a {j+l,...,j+h} » A los elementos de {j+l,...,j+h} se aplica la condición Ci2 ≤ m −

∑ Cl

∀l,Pl ∈σ x


107

EJEMPLO: PARTICIÓN DE PROCESOS Conjunto de procesos a planificar: Proceso

C

T

D

P1

2

6

6

P2

2

8

8

P3

8

24

20


Ciclo secundario » m ≤ min(6,8,20) => m = 1..6 » m ≥ max(2,2,8) => no hay ningún m que lo cumpla

Es preciso partir el proceso P3 en varios subprocesos con tiempo de cómputo menor que 6 unidades de tiempo Partición en P31 → P32 con igual tiempo de cómputo, 4 unidades


108

EJEMPLO: PARTICIÓN DE PROCESOS Conjunto de procesos a planificar: Proceso

C

T

D

P1

2

6

6

P2

2

8

8

P31

4

24

20

P32

4

24

20


Número de ejecuciones a planificar » ne1 = M/6 = 4 » ne2 = M/8 = 3 » ne31 = M/24 = 1 » ne32 = M/24 = 1


EJEMPLO: PARTICIÓN DE PROCESOS Ciclo secundario » m ≤ min(6,8,20) => m = 1..6 » m ≥ max(2,2,4) => m = 4..6 » ∃k: 24 = km => m = 4,6 » m+ (m - mcd(m,Ti)) ≤ Di => m = 4

Unica posibilidad de planificación m=4 Ordenación de procesos: primero el más urgente manteniendo relaciones de precedencia » Misma tabla anterior P1 → P2 → P31→ P32

Un planificación consta de 6 marcos consecutivos: M = 6m

109


110

EJEMPLO: PARTICIÓN DE PROCESOS

1

1 1

1

1

2

1

2

1 1 2 1

2

1 1

2

1

2

1 31 1 1 2 1

2

1 31 1 1

2

1

2

1 31 1 1 32 1

2

2

2

2

2


111

PARTICIÓN CON SECCIONES CRÍTICAS Si es preciso partir algún proceso en subprocesos, no deben partirse las secciones críticas con objeto de preservar la exclusión mutua Ejemplo: Planificar la ejecución de los siguientes procesos: P

C

T

D

P1

20

100

100

P2

25

150

150

P3

90

300

300

Dichos procesos acceden a una sección crítica común tal y como muestra el siguiente esquema: P1

15

P2

15

P3

15

5 10 20

15

40


PARTICIÓN CON SECCIONES CRÍTICAS Ciclo principal » M = mcm(100,150,300) = 300

Número de ejecuciones a planificar » ne1 = M/100 = 3 ; ne2 = M/150 = 2 ; ne3 = M/300 = 1

Ciclo secundario » m ≤ min(100,150,300) => m = 1..100 » m ≥ max(20,25,90) => m = 90..100 » ∃k: 300 = km => m = 100 » m+ (m - mcd(m,Ti)) ≤ Di => m = 100

Posibles valores de m = {100} Ordenación procesos: primero el más urgente » Misma ordenación que en el enunciado

Un planificación consta de 3 marcos consecutivos

112


113

PARTICIÓN CON SECCIONES CRÍTICAS No existe planificación porque no queda ningún marco donde quepa el proceso P3 Partición de P3 » Tiempo sobrante en los marcos: 55, 80, 55 ms » P31: primera sección crítica + segundo segmento código » P32: segunda sección crítica + cuarto segmento código

1 1 1

1 1 1

2 2


114

PARTICION CON SECCIONES CRITICAS Nueva especificación de procesos: P

C

T

D

P1

20

100

100

P2

25

150

150

P31

35

300

300

P32

55

300

300


Número de ejecuciones a planificar » ne1 = M/100 = 3 » ne2 = M/150 = 2 » ne31 = M/300 = 1 » ne32 = M/300 = 1


115

PARTICIÓN CON SECCIONES CRÍTICAS Ciclo secundario » m ≤ min(100,150,300) => m = 1..100 » m ≥ max(20,25,35,55) => m = 55..100 » ∃k: 300 = km => m = 60,75,100 » m+ (m - mcd(m,Ti)) ≤ Di => m = 60,100

Posibles valores de m = {60,100} Para m=100:

1 1 1

1 1 1

2

1 1 1

2 32 2

2

31


116

PROCESOS ESPORÁDICOS Proceso esporádico E: atención a eventos externos aperiódicos SE : separación mínima entre eventos DE : plazo límite ( normalmente DE ≤ SE ) CE : tiempo de cómputo máximo En un ejecutivo cíclico los procesos esporádicos pueden programarse de dos formas: Por muestreo periódico del evento

Por interrupción


117

ESPORADICOS POR MUESTREO Se programa el proceso esporádico como un proceso periódico que consulta si ha llegado un evento, y en tal caso, lo procesa. Transformamos el proceso esporádico en periódico con D’ = T’ ≤ DE / 2, y lo planificamos de la forma convencional » Si el proceso periódico cumple sus plazos, cualquier evento se atiende en su plazo DE T’

Proceso periódico

DE evento Se consulta, y no hay evento Hay evento, y se procesa CE


118

EJEMPLO 1 Conjunto de procesos a planificar: Proceso

C

T

D

S

E

1

8

20

P1

3

6

6

P2

2

12

12

Proceso periódico equivalente: D’ = T’= 4 ≤ DE / 2 Proceso

C

T

D

PE

1

4

4

P1

3

6

6

P2

2

12

12


Ejecuciones a planificar: nE = M/4 = 3 ; n1 = M/6 = 2 ; n2 = M/24 = 1


119

EJEMPLO 1 Ciclo secundario » m ≤ min(4,6,12) => m = 1..4 » m ≥ max(1,2,3) => m = 3..4 » ∃k: 12 = km => m = 3,4 » m+ (m - mcd(m,Ti)) ≤ Di => m = 4

Plan de 3 marcos de duración m=4

E E E E E E

1

E E E

1

1

2 1


120

ESPORÁDICOS POR INTERRUPCIÓN La llegada del evento produce una interrupción, y el evento se trata inmediatamente

Basta con reservar tiempo en cada marco para atender el máximo número de eventos que pueden llegar en un marco:

Cres

⎡m⎤ = ⎢ ⎥C E ⎢ SE ⎥


121

EJEMPLO 2 Conjunto de procesos a planificar (primero el más urgente): Proceso

C

T

D

S

E

1

7

10

P2

3

8

8

P3

2

8

8

P4

2

12

12

Calculamos los ciclos con los periódicos Ciclo principal » M = mcm(8,12) = 24

Número de ejecuciones a planificar » ne2 = M/8 = 3 » ne3 = M/8 = 3 » ne4 = M/12 = 2


122

EJEMPLO 2 Ciclo secundario » m ≤ min(8,12) => m = 1..8 » m ≥ max(2,3) => m = 3..8 » ∃k: 24 = km => m = 3,4,6,8 » m+ (m - mcd(m,Ti)) ≤ Di => m = 3,4,8

Probamos con 3 marcos de duración m=8 En cada uno reservamos tiempo para atender un evento

Cres

⎡m⎤ = ⎢ ⎥ CE ⎢ SE ⎥


123

EJEMPLO 2

E E E E E E

P2 P2 P2

E E E

P2 P2 P2

P3 P3 P3

E E E

P2 P2 P2

P3 P3 P3

P4 P4


124

PROGRAMACIÓN DEL EJECUTIVO Mediante un ejemplo: Cuatro procesos (plazo = periodo) (C,T,D): A=(1,10,10), B=(3,10,10), C=(2,20,20), D=(8,20,20) Proceso

C

T

D

A

1

10

10

B

3

10

10

C

2

20

20

D1

2

20

20

D2

6

20

20

Planificación: » M = 20, m=10

0 A B

6 C

D1

10 A B

14 D2

20


125

EJECUTIVO - 1 task cyclic_executive_1 ; task body cyclic_executive_1 is interval: constant := 0.01 ; next_time: time := clock ; frame_number: integer := 0 ; begin loop frame_number:= (frame_number mod 2) +1 ; case frame_number is when 1 => A; B; C; D1; when 2 => A; B; D2; end case next_time := next_time + interval ; if clock > next_time them frame_overrun ; end if ; delay until next_time; end loop ; end cyclic_executive_1 ;


126

EJECUTIVO - 1 Ventajas: Independiente del hardware: transportable, no hardware específico, ... Inconvenientes: El desbordamiento de marco sólo es detectado después de acabar el marco Sobrecarga por la ejecución del delay » aritmetica del tipo TIME costosa (normalmente 64 bits) » acceso al reloj costoso (p.e. en exclusión mutua con la actualización) » manejo de la tarea por el RTS costoso


127

EJECUTIVO - 2 task cyclic_executive_2 ; task body cyclic_executive_2 is frame_number: integer := 0 ; begin loop Timer_Handler.Wait_for_Interrupt ; frame_number:= (frame_number mod 2) +1 ; case frame_number is when 1 => A; B; C; D1; when 2 => A; B; D2; end case end loop ; end cyclic_executive_2 ;


128

EJECUTIVO - 2 Ventajas: Mayor control sobre el tiempo » No sobrecarga por manejo tiempo, lo hace el hardware

Inconvenientes: Dependencia del hardware » No transportable » Necesidad de un timer esclavo

¿Qué pasa con el desbordamiento de marco? » No se detecta el desbordamiento pero el sistema puede recuperarse


129

EJECUTIVO - 3 task cyclic_executive_3 is pragma priority (system.priority’last) ; end cyclic_executive_3 ; task action is entry next_frame ; end action ; task body cyclic_executive_3 is begin loop Timer_Handler.Wait_for_Interrupt ; select action.next_frame ; else frame_overrun ; end select ; task body action is end loop ; frame_number: integer := 0 ; end cyclic_executive_3 ; begin loop accept next_frame ; frame_number:= (frame_number mod 2) +1 ; case frame_number is when 1 => A; B; C; D1; when 2 => A; B; D2; end case end loop ; end action ;


130

VENTAJAS/INCONVENIENTES Ventajas Predictibilidad del sistema: la ejecución está predeterminada Al no requerirse cambios de contexto la sobrecarga introducida por el núcleo es muy pequeña Inconvenientes La introducción de cualquier cambio es muy costosa (replanificación, reprogramación) Ante un conjunto de procesos no planificable, la partición de procesos no es evidente


PLANIFICACIÓN BASADA EN PRIORIDADES: PRIORIDAD AL MÁS FRECUENTE (RMS)

131


132

INTRODUCCION Planificación con asignación de prioridades a la tarea más frecuente RMS/RMA: Rate Monotonic Scheduling / Analysis Prioridades estáticas Plazo de respuesta = período en tarea periódicas

Es un marco teórico que proporciona una base para el diseño de sistemas de tiempo real. Proporciona directrices para asignar prioridades óptimas Proporciona un marco analítico para verificar los requisitos temporales Ayuda a identificar cuellos de botella Permite la separación de los aspectos temporales y funcionales


133

TAREAS PERIODICAS CRITICAS Factor de utilización Es una medida de la carga del procesador. El factor de utilización de una tarea Ti es:

El factor de utilización total del sistema es

Ui =

Ci Pi n

n

Ci i =1 Pi

U = ∑U i = ∑ i =1

Se trata de encontrar métodos que proporcionen planificaciones admisibles con factores de utilización lo más altos posible. Con un solo procesador, el factor de utilización está limitado a » U≤1

En general para M procesadores » U≤M


134

TAREAS PERIODICAS CRITICAS Planificación basada en prioridades Consideraremos prioridades estáticas y planificación expulsiva. Frecuentemente se asignan prioridades a las tareas según su "importancia". De esta forma no se puede calcular si se pueden garantizar los plazos o no. Puede fallar incluso con factores de utilización muy bajos. Ejemplo:

T

C

P

U

T1

10

50

0.20

T2

2

10

0.20 0.40

Si hacemos p1 > p2, T2 falla.

a

fin

T1 a T2

a

a

a

20

30

fallo 0

10


135

TAREAS PERIODICAS CRITICAS Prioridad al más frecuente (RMS) La asignación de prioridades más altas a las tareas más frecuentes (período más corto) es óptima (Liu & Layland, 1973). Por óptima se entiende que no hay ninguna otra planificación mejor. Si de esta forma no se obtiene un plan admisible, no se puede obtener con ningún otro método basado en prioridades estáticas. Ejemplo:

T

C

P

U

T1

10

50

0.20

T2

2

10

0.20 0.40 a

Hacemos ahora p2 > p1 ( P2 < P1) --> las dos tareas terminan a tiempo

…

T1 a

a

a

a

0

10

20

30

T2


136

CONDICIONES DE GARANTIA DE PLAZOS Teorema 1 (Liu & Layland): En un sistema de n tareas periódicas independientes con prioridades asignadas en orden de frecuencia, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si n C U = ∑ i ≤ n( 21/ n − 1) = U 0 (n) i =1 Pi U0(n) es la utilización mínima garantizada para n tareas.

U 0 (1) = 1.000 U 0 (2) = 0.828 U 0 (3) = 0.779 U 0 (4) = 0.757 U 0 (5) = 0.743 ...

limU 0 (n) = 0.693 = ln 2 n →∞


137

CONDICIONES DE GARANTIA DE PLAZOS Ejemplo: T

C

P

U

T1

5

20

0.25

T2

10

40

0.25

T3

20

80

0.25 0.75

La utilización total es 0.75 < U(3) = 0.779 => los plazos de las tres tareas están garantizados si: pr1 > pr2 > pr3 El 25% del tiempo de CPU utilizable en cálculos sin requerimientos temporales


138

CONDICIONES DE GARANTIA DE PLAZOS En muchos caso se pueden garantizar plazos con factores de utilización mayores que U0(n). Teorema 1: condición suficiente, no necesaria Ejemplo:

T

C

P

U

T1

5

20

0.25

T2

10

40

0.25

T3

40

80

0.50 1.00

U = 1.00 > U0(3) = 0.779 Los plazos de respuesta de las tareas no están garantizados, según el Teorema 1 Sin embargo asignando prioridades RMA se cumplen los plazos de respuesta


139

CONDICIONES DE GARANTIA DE PLAZOS Teorema 2 (Liu & Layland): En un sistema de n tareas periódicas independientes con prioridades estáticas, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si cuando se activan todas ellas simultáneamente, cada tarea acaba dentro del plazo en su primera ejecución. En el ejemplo anterior: U1.2 = 0.50 < U0(2) = 0.828 Por tanto, se pueden garantizar los plazos de T1 y T2. Para comprobar si se puede garantizar los plazos de T3 hay que aplicar el teorema 2

T1 T2 fin T3 T3 0

10

20

30

40

50

60

70

80


140

CONDICIONES DE GARANTIA DE PLAZOS Test de Tiempo de Finalización El tiempo de finalización de una tarea Ti (tfi) es:

⎞ ⎛⎡ t ⎤ ⎡ t ⎤ ⎟⎟ C C t + = t fi = min⎜⎜ ⎢ ⎥C1 + ... + ⎢ i −1 i ⎥ t >0 ⎝ ⎢ P1 ⎥ ⎢ Pi −1 ⎥ ⎠ Por lo tanto la tarea Ti cumplirá su primer plazo si:

t fi ≤ Pi Justificación: » Ti finaliza cuando no hay más trabajo de prioridad ≥ pri pendiente. El trabajo solicitado en el instante t, suponiendo que todas las tareas han empezado en t=0, es: i ⎡t ⎤ ⎡ t ⎤ ⎡t⎤ Wi (t ) = ⎢ ⎥C1 + ... + ⎢ Ci −1 + Ci = ∑ C j ⎢ ⎥ ⎥ ⎢ P1 ⎥ ⎢ Pi −1 ⎥ j =1 ⎢ Pj ⎥

» Wi : carga parcial de grado i en el instante t


141

CONDICIONES DE GARANTIA DE PLAZOS Cálculo del tiempo de finalización Se puede usar el siguiente método iterativo:

Wi

k +1

⎡Wi k ⎤ ⎡Wi k ⎤ =⎢ ⎥C1 + ... + ⎢ ⎥Ci −1 + Ci ⎢ P1 ⎥ ⎢ Pi −1 ⎥

El cálculo se realiza iterativamente hasta que se repite el resultado anterior:

Wi k +1 = Wi k = t fi


142


C

P

U

T1

7

20

0.35

T2

10

40

0.25

T3

20

80

0.25 0.85

U = 0.85 > U0(3) = 0.779 Sin embargo, U1,2= 0.60 < 0.828 Las tareas T1 y T2 cumplen sus plazos.

¿T3 cumple su plazo? => Tiempo de finalización


143

CONDICIONES DE GARANTIA DE PLAZOS Cálculo del tiempo de finalización:

W30 = 0 W31 = C3 = 20 ⎡ 20 ⎤ ⎡ 20 ⎤ W32 = ⎢ ⎥ 7 + ⎢ ⎥10 + 20 = 37 ⎢ 20 ⎥ ⎢ 40 ⎥ ⎡ 37 ⎤ ⎡ 37 ⎤ W33 = ⎢ ⎥ 7 + ⎢ ⎥10 + 20 = 44 ⎢ 20 ⎥ ⎢ 40 ⎥ ⎡ 44 ⎤ ⎡ 44 ⎤ W34 = ⎢ ⎥ 7 + ⎢ ⎥10 + 20 = 61 ⎢ 20 ⎥ ⎢ 40 ⎥ ⎡ 61 ⎤ ⎡ 61 ⎤ W35 = ⎢ ⎥ 7 + ⎢ ⎥10 + 20 = 68 ⎢ 20 ⎥ ⎢ 40 ⎥ ⎡ 68 ⎤ ⎡ 68 ⎤ W36 = ⎢ ⎥ 7 + ⎢ ⎥10 + 20 = 68 ⎢ 20 ⎥ ⎢ 40 ⎥ t fi = W35 = W36 = 68 < 80


144

CONDICIONES DE GARANTIA DE PLAZOS Reformulación / Generalización Punto de planificación: Los puntos de planificación de una tarea Ti son todos los instantes límite (es decir los finales de los períodos) de las tareas de prioridad mayor o igual que Ti que se dan antes del final de su período, suponiendo que todas las tareas han comenzado simultáneamente. Si es el conjunto de puntos de planificación de la tarea Ti: ⎧⎪ ⎢ Pi ⎥ ⎫⎪ Si = ⎨k × p j j = 1..i; k = 1..⎢ ⎥ ⎬ ⎪⎩ ⎣ Pj ⎦ ⎪⎭

Teorema 3 (Lehoczky, Sha & Ding): En un sistema de n tareas periódicas independientes con prioridades asignadas en orden de frecuencia, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si y sólo si

⎛ i Cj ∀i,1 ≤ i ≤ n, min⎜ ∑ t∈Si ⎜ j =1 t ⎝

⎡ t ⎤⎞ ⎢ ⎥ ⎟⎟ ≤ 1 ⎢ Pj ⎥ ⎠


145


C

P

U

T1

7

20

0.35

T2

10

40

0.25

T3

20

80

0.25 0.85

S1 = {20} S2 = {20, 40} S3 = {20, 40, 60, 80}


CONDICIONES DE GARANTIA DE PLAZOS t

W1(t)

20

(7*1)=7

t

W2(t)

20

(7*1 + 10*1)=17

t

W3(t)

20

(7*1 + 10*1 + 20*1)=37

40

(7*2 + 10*1 + 20*1)=44

60

(7*3 + 10*2 + 20*1)=61

80

(7*4 + 10*2 + 20*1)=68

146


147

TIEMPO DE CAMBIO DE CONTEXTO Tiempo de cambio de contexto de peor caso:

Cs = Csa + Csb

» Csa: Salvar el contexto de la tarea en ejecución » Csb: Planificar y recuperar el contexto de la nueva tarea

C sb

Csa

T1

C sb T2

Csa


TIEMPO DE CAMBIO DE CONTEXTO Así pues:

Cada vez que una tarea expulsa a una de prioridad inferior que está activa, hay dos cambios de contexto En el peor caso es preciso considerar dos cambios de contexto por cada expulsión Esto implica añadir 2Cs al tiempo de ejecución de cada tarea para el análisis

148


149

TIEMPO DE CAMBIO DE CONTEXTO Ejemplo: Se supone un tiempo de cambio de contexto Cs = 2ms T

C

P

U

T1

20+4

100

0.240

T2

40+4

150

0.293

T3

100+4

350

0.271 0.831

U = 0.831 > U0(3) = 0.779 => Test de tiempos de finalización:

t f 1 = C1 + 2CS = 24ms ⎡ 68 ⎤ t f 2 = ⎢ ⎥ (C1 + 2CS ) + C2 + 2CS = 68ms ⎢ P1 ⎥ ⎡ 264 ⎤ ⎡ 264 ⎤ ( ) (C2 + 2CS ) + C3 + 2CS = 264ms tf3 = ⎢ C + 2 C + 1 S ⎥ ⎢ ⎥ ⎢ P1 ⎥ ⎢ P2 ⎥


150

TAREAS PERIODICAS CRITICAS/ACRITICAS Cuando hay tareas acríticas podemos admitir fallos ocasionales en sus tiempos de respuesta. Se trata de garantizar: Los plazos de todas las tareas (críticas y acríticas) con los tiempos de cómputo medios. Los plazos de las tareas críticas con los tiempos de cómputo máximos.

La planificación con prioridades es estable: fallan primero las tareas menos prioritarias. Si las tareas críticas no son las más frecuentes, se puede hacer una transformación de períodos. Se puede acortar el período de las tareas críticas o alargar el de las acríticas.


151

TAREAS PERIODICAS CRITICAS/ACRITICAS Ejemplo: T

cm

C

P

um

U

T1

6

10

30

0.200

0.333

T2

8

10

40

0.200

0.250

T3

10

12

50

0.200

0.240

0.600

0.823

um = 0.600 < U0(3) = 0.779 Se pueden garantizar los plazos de todas las tareas con los tiempos de cómputo medios. U = 0.823 > U0(3) = 0.779 U1.2 = 0.583 < U0(2) = 0.828 Con los tiempos de cómputo máximos, sólo se pueden garantizar T1 y T2. Si T3 es crítica y T2 no: acortar el período de T3 => subir su prioridad.


152

TAREAS PERIODICAS CRITICAS/ACRITICAS

T1 T2 T3 0

20 30 40 50 10 Tiempos de ejecución medios

T1 T2 fallo T3 T3 0

20 30 40 50 10 Tiempos de ejecución máximos


153

TAREAS PERIODICAS CRITICAS/ACRITICAS Transformación de T3: Descomponemos T3 en dos segmentos, T31 y T32, cuyos tiempos de cómputo son la mitad del de T3. Construimos una nueva tarea, T3', que cada vez que se activa ejecuta uno de estos segmentos, alternativamente. El período de la nueva tarea es P3' = P3/2 = 25 T

cm

C

P

um

U

T3'

5

6

25

0.200

0.240

T1

6

10

30

0.200

0.333

T2

8

10

40

0.200

0.250

0.600

0.823

El factor de utilización sigue siendo el mismo, pero ahora T3 tiene la prioridad más alta


154

TAREAS PERIODICAS CRITICAS/ACRITICAS

T1 fallo T2 (9 u.)

T2 T31

T32

T3' 20 30 40 50 10 0 Tiempos de ejecución máximos, con T3 transformada


TAREAS PERIODICAS CRITICAS/ACRITICAS El código de T3' es: with Ada.Real_Time; use Ada.Real_Time; task body T3_MODIFICADA is PERIODO: constant Time_Span := To_Time_Span(0.025); SIGUIENTE: TIME := CLOCK ; begin loop -- accion T31 ; SIGUIENTE:= SIGUIENTE + PERIODO ; delay until SIGUIENTE ; -- accion T32 ; SIGUIENTE:= SIGUIENTE + PERIODO ; delay until SIGUIENTE ; end loop ; end T3_MODIFICADA ;

155


156

COMUNICACION ENTRE TAREAS El análisis de tareas con comunicaciones es un problema de gran complejidad => simplificaciones: las comunicaciones se restringen al modelo de clientes-servidores. las alternativas de los servidores no pueden estar guardadas La segunda simplificación evita que una tarea se quede bloqueada durante un tiempo no acotado.

Pb. clientes-servidores: INVERSION DE PRIORIDADES.


157

COMUNICACION ENTRE TAREAS Ejemplo de servidor: T1 VARIABLE_COMUN

/* Variable_Comun.h */

MODIFICAR T2

EXAMINAR

void Inicializa_Servidor (void) ; void Modificar (tipoV Valor) ; tipoV Examinar (void) ;

protected Variable_Comun is procedure Modificar (Valor: in tipoV) ; procedure Examinar (Valor: out tipoV) ; private Variable: tipoV ; end Variable_Comun ; task Variable_Comun is entry Modificar (Valor: in tipoV) ; entry Examinar (Valor: out tipoV) ; end Variable_Comun ;


158

COMUNICACION ENTRE TAREAS Con un MUTEX de VxWorks:

static SEM_ID Mutex ; static tipoV Variable_Protegida ; void Inicializa_Servidor (void) {... Mutex = semMCreate (...) ; ... } void Modificar (tipoV Valor) { semTake (Mutex, WAIT_FOREVER) ; Variable_Protegida = Valor ; semGive (Mutex) ; return ; } tipoV Examinar (void) { tipoV Local ; semTake (Mutex, WAIT_FOREVER) ; Local = Variable_Protegida ; semGive (Mutex) ; return Local ; }


COMUNICACION ENTRE TAREAS Ada83 task body Variable_Comun is VARIABLE: tipoV; begin … loop select accept Modificar (Valor: in tipoV) do VARIABLE:= Valor; end MODIFICAR ; or accept Examinar (Valor: out tipoV) do Valor := VARIABLE ; end EXAMINAR ; or terminate ; end select ; end loop ; end Variable_Comun ;

159


160

COMUNICACION ENTRE TAREAS Ada95

protected Variable_Comun is procedure Modificar (Valor: in tipoV) is begin Variable := Valor; end Modificar ; procedure Examinar (Valor: out tipoV) is begin Valor := Variable; end Examinar ; end Variable_Comun ;


161

COMUNICACION ENTRE TAREAS Ejemplo comunicación entre tareas:

T1 T=100 ms C=20 ms

S1 10 ms

T2 T=150 ms C=40 ms

10 ms

S2 2 ms

T3 T=350 ms C=100 ms

20 ms


162

INVERSION DE PRIORIDADES A veces una tarea puede verse retrasada por la ejecución de otra menos prioritaria. Este fenómeno se denomina inversión de prioridades, y puede ocurrir cuando hay interacción entre tareas. Ejemplo: INVERSION DE PRIORIDAD

T1 T2 T3

Ejecución de servicios S2

Pb.: el retraso de una tarea por inversión de prioridad puede no estar acotado


PROTOCOLOS DE COMUNICACION Los siguientes protocolos evitan la inversión de prioridad sin límite: Sección crítica no expulsable Herencia de prioridad Techo de prioridad Techo de prioridad inmediato

163


164

SECCION CRITICA NO EXPULSABLE Un servidor ejecutando un servicio no puede perder el procesador. Pb.: Introduce inversión de prioridad aunque la tarea más prioritaria sea independiente y no solicite ningún servicio.

INVERSION DE PRIORIDAD

T1 T2 T3



165

SECCION CRITICA NO EXPULSABLE Implementación Kernel Enmascaramiento interrupciones » Sin MUTEX

Elevación de prioridad » Sin MUTEX

void Servicio (...) { Mask_all_Interrupts () ; Service_Code() ; Unmask_all_Interrupts () ; return ; }

void Servicio (...) { Nominal = Get_Priority () ; Set_Priority (HIGH) ; Service_Code() ; Set_Priority (Nominal) ; return ; }


166

HERENCIA DE PRIORIDAD Los clientes tienen prioridades estáticas y los servidores dinámicas. Está basado en las siguientes reglas: Cuando un servidor está realizando un servicio o bloqueando a algún cliente hereda la prioridad más alta entre la del cliente al que esta sirviendo y los clientes bloqueados. Las llamadas pendientes se aceptan por orden de prioridad de clientes. Protocolo implementado en el kernel sobre el semáforo que protege el servidor Se produce inversión de prioridad únicamente cuando una tarea solicita un servicio a un servidor que está ejecutando un servicio para otra tarea de menor prioridad desde antes de la activación.


167

HERENCIA DE PRIORIDAD Puede haber mas de un bloqueo por inversión de prioridad durante una ejecución.



T1

T1

T2

T2

T3

T3 Bloqueo indirecto (Push-trough blocking)


Ejecución de servicios S1 Ejecución de servicios S2


168

TECHO DE PRIORIDAD Es un protocolo de herencia de prioridades con las siguientes reglas adicionales: El techo de prioridad de un servidor es igual a la prioridad del más prioritario de sus clientes potenciales. Un cliente que intenta llamar a un servidor se bloquea si cualquier otro servidor con techo de prioridad mayor o igual que la prioridad dinámica del cliente está ya ejecutando un servicio para otro cliente. Características básicas: Bloqueo único: En una ejecución de una tarea, ésta sólo se puede ver bloqueada, por inversión de prioridad, durante la ejecución de un servicio. Es un protocolo para sistemas monoprocesador.


169

TECHO DE PRIORIDAD BLOQUEO UNICO: Protocolo de techo de prioridad


T1 T2 T3

Ejecución de servicios S1 Ejecución de servicios S2


170

TECHO DE PRIORIDAD INMEDIATO Con este protocolo, una tarea que accede a un recurso hereda inmediatamente el techo de prioridad del servidor la prioridad dinámica de una tarea es el máximo de su prioridad básica y los techos de prioridad de los servidores que usa Las propiedades son las mismas que las del protocolo del techo de prioridad » Bloqueo único

Es más fácil de implementar que el protocolo básico Es más eficiente (menos cambios de contexto) Se producen más bloqueos que en el caso del protocolo de techo de prioridad » Comportamiento idéntico de peor caso » Peor comportamiento medio


171

TECHO DE PRIORIDAD INMEDIATO Si el protocolo no está implementado en el kernel, se puede realizar asignando a cada servidor una prioridad » ps = tps + 1

donde tps es el techo de prioridad del servidor. Implementación Elevación prioridad

Ada83

void Servicio (...) { Nominal = Get_Priority () ; Set_Priority (Server_Ceiling+1) Service_Code() ; Set_Priority (Nominal) ; return ; }

task servidor is pragma priority (Server_Ceiling+1) ; entry … end servidor ;

;


172

HERENCIA/TECHO DE PRIORIDAD Ejemplo T1

P=100 C=10

S1

T2

Tarea T1 T2 T3 T4 T5 S1 S2

P 100 150 250 300 500

C 15 30 50 50 30

Pr 5 4 3 2 1

Tpr

4 P=150 C=30

20

T3

P=250 C=50

4 5

T4

S2 2

P=300 C=30

T1

P=500 C=50

8


173

HERENCIA/TECHO DE PRIORIDAD Techo de prioridad

S2

T1

5

T2

…

directo

S1

4

T3

…

forzado

T4

…

techo

S2

2

T5

… S1

1

S1

2

S1

4

S1

4


174

HERENCIA/TECHO DE PRIORIDAD Herencia de prioridad

S2

T1

5 directo forzado

T2

directo

… S1

4

T3

…

forzado

T4 T5

…

forzado

S2

S2

2

5

… S1

1

S1

4

S1

4


175

CONDICIONES DE GARANTIA DE PLAZOS La inversión de prioridad puede ser tenida en cuenta en el análisis mediante la incorporación de un término denominado tiempo de bloqueo: bi » Tiempo de bloqueo de peor caso » Cada protocolo proporciona tiempos de bloqueo diferentes » Análisis => cálculo de los tiempos de bloqueo

tiempo de cómputo modificado

Ci* = (Ci + Bi )


176

CONDICIONES DE GARANTIA DE PLAZOS Sección crítica no expulsable Una tarea puede ser bloqueada como máximo por un servicio Cálculo » sjk servicio k usado por la tarea j » D(sjk) duración del servicio

⎞ ⎛ Bi = MAX ⎜ MAX (D (s jk ))⎟ j ⎠ ⎝ k j >i


177

CONDICIONES DE GARANTIA DE PLAZOS Protocolo de Herencia de Prioridad Una tarea T pude ser bloqueada como máximo por MIN(n,m) servicios » n: número de tareas de menor prioridad que T que la pueden bloquear » m: número de servidores distintos que pueden bloquear a T

Bi: suma de todos los bloqueos (de peor caso) posibles Para calcular Bi hay que establecer qué servicios pueden estar en ejecución cuando se active T y que puedan bloquearle (bloqueo directo o indirecto por aumento de prioridad) Difícil de sistematizar: Algoritmo que calcula una cota superior del tiempo de bloqueo » Condición suficiente


178

CONDICIONES DE GARANTIA DE PLAZOS Algoritmo para calcular Bi Ceiling(): prioridad del más prioritario de los clientes Dj,k: duración de un servicio

Bil

=

Bis

∑ MAX [D j ,k : Ceiling (S k ) ≥ Pi ] k n

j =i +1 m

[

= ∑ MAX D j ,k : Ceiling (S k ) ≥ Pi k =1

j >i

(

Bi = MIN Bil , Bis

)

]


179

CONDICIONES DE GARANTIA DE PLAZOS Protocolo de techo de prioridad El valor máximo del tiempo de bloqueo de una tarea Ti, bi, es igual a la duración del servicio más largo de los requeridos, a cualquiera de los servidores, por tareas de prioridad inferior (pri≤techo prioridad servidor) Un cliente puede verse bloqueado por otro menos prioritario aunque no llamen a servidores comunes. El cliente de menos prioridad no se puede bloquear por otros menos prioritarios: bn=0.

{

Bi = MAX D j ,k Pj < Pi , Ceiling (S k ) ≥ Pi j ,k

Protocolo de techo de prioridad inmediato IDEM que el de techo

}


180

CONDICIONES DE GARANTIA DE PLAZOS Teorema 4 (Sha, Rajkumar & Lehoczky): En un sistema de n tareas periódicas con prioridades asignadas en orden de frecuencia, que se comunican mediante servidores, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si

∀i,1 ≤ i ≤ n,

(

)

C b C1 + ... + i + i ≤ i 21/ i − 1 P1 Pi Pi

Corolario (Sha, Rajkumar & Lehoczky): Se cumple lo mismo si

(

)

⎛ bi ⎞ Ci + max ∑ P i=1..n−1⎜⎜ P ⎟⎟ ≤ n 21/ n − 1 = U 0 (n ) ⎝ i⎠ i =1 i n

Condición suficiente más restrictiva.


181

CONDICIONES DE GARANTIA DE PLAZOS Teorema 5 (Sha, Rajkumar & Lehoczky): En un sistema de n tareas periódicas con prioridades asignadas en orden de frecuencia, que se comunican mediante servidores, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si

⎛ i Cj ∀i,1 ≤ i ≤ n, min⎜ ∑ t∈Si ⎜ j =1 t ⎝

⎡ t ⎤ ⎞ bi ⎢ ⎥ ⎟⎟ + ≤ 1 ⎢ Pj ⎥ ⎠ t

Test de tiempo de finalización: El tiempo de finalización de una tarea Ti (tfi) es:

⎛⎡ t ⎤ ⎞ ⎡ t ⎤ ⎟⎟ + + = t fi = min⎜⎜ ⎢ ⎥C1 + ... + ⎢ C C b t i −1 i i ⎥ t >0 ⎝ ⎢ P1 ⎥ ⎢ Pi −1 ⎥ ⎠ En el tiempo de finalización de Ti sólo influye bi


182

CONDICIONES DE GARANTIA DE PLAZOS Análisis del ejemplo Sección crítica no expulsable: Tarea P

C

b

p

T1

100

20

20

3

T2

150

40

20

2

T3

350

100

0

1

C1 b1 20 20 + = + = 0.400 ≤ 1.0 = U 0 (1) P1 P1 100 100 C1 C 2 b2 20 40 20 + + = + + = 0.600 ≤ 0.828 = U 0 (2 ) P1 P2 P2 100 150 150 C1 C 2 C3 b3 20 40 100 0 + + + = + + + = 0.753 ≤ 0.779 = U 0 (3) P1 P2 P3 P3 100 150 350 350


183

CONDICIONES DE GARANTIA DE PLAZOS Análisis del ejemplo Herencia de prioridad: Tarea P

C

b

tp

T1

100

20

30

3

T2

150

40

20

2

T3

350

100

0

1

S1

3

S2

3

p

S1 S2 T1 10 2 T2 10 T3 - 20



184

CONDICIONES DE GARANTIA DE PLAZOS Análisis del ejemplo: Techo de prioridad: Tarea P

C

b

tp

T1

100

20

20

3

T2

150

40

20

2

T3

350

100

0

1

S1

3

S2

3

p



CONDICIONES DE GARANTIA DE PLAZOS Cálculo de los tiempos de finalización

t f 1 = C1 + b1 = 40ms ⎡80 ⎤ t f 2 = ⎢ ⎥C1 + C 2 + b2 = 80ms ⎢ P1 ⎥ ⎡ 240 ⎤ ⎡ 240 ⎤ tf3 = ⎢ ⎥C1 + ⎢ P ⎥C 2 + C3 + b3 = 240ms P ⎢ 1 ⎥ ⎢ 2 ⎥ b3 = 0

185


186

TAREAS ESPORADICAS Y APERIODICAS Tareas que se ejecutan como respuesta a un evento => NO PERIODICAS. Se consideran dos tipos: Tareas aperiódicas: no tienen requisitos de tiempo real críticos. Generalmente se desea que tengan un comportamiento estadístico adecuado, p.e. el valor del tiempo medio de respuesta esté limitado. Tareas esporádicas: tienen plazo de respuesta crítico.


187

TAREAS APERIODICAS Se pueden ejecutar de varias formas: Como tareas de segundo plano (sin requisitos de tiempo real). Solución más sencilla, tiempo de respuesta medio excesivo. Procesado directo de eventos (a alta prioridad). Tiempo de respuesta muy bueno pero puede haber una expulsión excesiva sobre tareas de menos prioridad que sean críticas. Mediante servidores aperiódicos. Son tareas que ejecutan las actividades aperiódicas en momentos oportunos para no perturbar a las tareas críticas. Se van a considerar dos: » Servidor de muestreo (polling server). Tarea periódica que en cada activación ejecuta las actividades correspondientes a eventos aperiódicos pendientes de atender. Se debe limitar su tiempo de cómputo, tiempos de respuesta elevados. » Servidor esporádico (sporadic server). Se basa en la idea de reservar tiempo para atender eventos aperiódicos. Si queda tiempo reservado, un evento se atiende inmediatamente (a la prioridad que le corresponda).


188

TAREAS APERIODICAS Procesado en segundo plano tr

Procesado directo Exceso expulsión

Muestreo Periodo

Servidor esporádico

Procesado del evento Relleno Llegada del evento


189

SERVIDOR ESPORADICO Varias posibles implementaciones dependiendo de la política de relleno. Una de las más sencillas está basada en: Período de relleno. Igual al ritmo medio de llegada de los eventos. Capacidad de ejecución. Tiempo de peor caso en el procesado de un evento. Asignación de prioridades. En el peor caso el servidor esporádico se comporta como una tarea periódica de período el tiempo de renovación. relleno tiempo renovación

relleno


190

SERVIDOR ESPORADICO En Ada95 task body Sporadic_Server is Replenishment_Period: time_span := milliseconds (...) ; Next_Star : time := clock ; Time_Stamp : time ; begin loop Interrupt_Handler.Wait_for_Event(Time_Stamp) ; Activation_Time := max (Time_Stamp, Next_Start) ; Event_Processing ; Next_Star := Activation_Time + Replenishment_Period ; delay until Next_Start ; end loop ; end Sporadic_Server ;


191

SERVIDOR ESPORADICO protected body Interrupt_Handler is procedure Handler is begin Interrupt_Ocurred := true ; Add (Event_Queue, clock) ; end ; entry Wait_for_Event (TS: out time) when Interrupt_Ocurred is begin Extract (Event_Queue, TS) ; if Empty(Event_Queue) then Interrupt_Ocurred := false ; end if ; protected Interrupt_Handler is end ; entry Wait_for_Event (TS: out time) ; private end ; procedure Handler ; Event_Queue : … ; Interrupt_Ocurred : boolean := false ; end ;


192

SERVIDOR ESPORADICO En VxWorks void Sporadic_Server (void) { struct timespec Replenishment_Period = to_timespec (...) ; struct timespec Next_Star, Time_Stamp, Activation_Time ; clock_gettime (CLOCK_REALTIME, &Next_Start) ; while (TRUE){ msgQReceive (Event_Queue, &Time_Stamp, ...) ; Event_Processing () ; Activation_Time = max (Time_Stamp, Next_Start) ; Next_Star = add_timespec (Activation_Time, Replenishment_Period) ; delay_until (Next_Start) ; } }

void Handler (void) { ... ; clock_gettime (CLOCK_REALTIME, &Time_Stamp) ; msgQSend (Event_Queue, Time_Stamp, ...) ; }


193

TAREAS ESPORADICAS Para poder garantizar plazos es preciso suponer una separación mínima entre eventos, si. Puede utilizarse un servidor esporádico con una reserva ci (tiempo de cómputo de la acción asociada al evento) y un intervalo de renovación si.

Pb.: asignación de prioridades: Si si = di => tarea periódica de período si y con una prioridad RMA. Si si > di (caso más frecuente) => no caso RMA. Una aproximación: prioridad al más urgente para tareas esporádicas y prioridad RMA para el resto. Posibilita análisis RMA considerando tiempos adicionales de bloqueo.


194

TAREAS ESPORADICAS Si la separación está garantizada:

task body Sporadic_Server is begin loop Interrupt_Handler.Wait_for_Event ; Event_Processing ; end loop ; end Sporadic_Server ;


195

TAREAS ESPORADICAS Rechazo de eventos que no cumplen el requisito de separación mínima protected body Interrupt_Handler is procedure Handler is begin Event_Time := clock ; if Event_Time >= Rejection_Time then Interrupt_Ocurred := true ; Rejection_Time := Event_Time + Minimum_Separation ; end if ; end ; entry Wait_for_Event when Interrupt_Ocurred is begin Interrupt_Ocurred := false ; end ; end ;


196

TAREAS ESPORADICAS Ejemplo: T1 T=100 ms C=20 ms

Emergencia

S1 10 ms

T2 T=150 ms C=40 ms

10 ms

S2 2 ms

T3

s = 120 ms d = 6 ms Ce = 5 ms

20 ms

ev. Acríticos s = 40 ms Ce = 2 ms

T=350 ms C=100 ms

Tareas no periódicas: E : servidor esporádico (separación mínima = 120 ms ; plazo = 6 ms ; c = 5 ms) A : servidor esporádico (renovación = 40 ms ; c = 2 ms)


197

TAREAS ESPORADICAS Tarea

P

C

b

tp

A

40

2

0+5

4

T1

100

20

20+5

3

E

120

5

0

5

T2

150

40

20

2

T3

350

100

0

1

S1

3

S2

3

p


198

TAREAS ESPORADICAS C A CE 2 5 + = + = 0.175 ≤ 1.0 = U 0 (1) PA PA 40 40 C A C1 b1 C E 2 20 20 5 + + + = + + + = 0.509 ≤ 0.828 = U 0 (2 ) PA P1 P1 P1 40 100 100 100 C E ≤ DE C A C1 C E C 2 b2 2 20 5 40 20 + + + + = + + + + = 0.692 ≤ 0.756 = U 0 (4 ) PA P1 PE P2 P2 40 100 120 150 150 C A C1 C E C 2 C3 2 20 5 40 100 + + + + = + + + + = 0.844 > 0.743 = U 0 (5) PA P1 PE P2 P3 40 100 120 150 350

Tiempo de finalización de T3:

⎡ 275 ⎤ ⎡ 275 ⎤ ⎡ 275 ⎤ ⎡ 275 ⎤ + + + tf3 = ⎢ C C C C A + C3 = 269ms 1 ⎢ E 2 ⎢ ⎥ ⎥ ⎥ ⎢ ⎥ ⎢ P1 ⎥ ⎢ PE ⎥ ⎢ P2 ⎥ ⎢ PA ⎥ SE CUMPLEN LOS PLAZOS DE LAS TAREAS



PLANIFICACIÓN BASADA EN PRIORIDADES: PRIORIDAD AL MÁS URGENTE (DMS)

199


200

INTRODUCCIÓN Planificación con asignación de prioridades a la tarea más urgente DMS/DMA: Deadline Monotonic Scheduling / Analysis Prioridades estáticas Plazo de respuesta ≤ período en tarea periódicas Nace del RMS basándose en alguno de sus conceptos

Estructura: Tareas periódicas. Tareas esporádicas. Comunicación entre tareas Plazos de respuesta arbitrarios Jitter


201

TAREAS PERIÓDICAS Prioridad al más urgente (DMS) La asignación de prioridades más altas a las tareas más urgentes (plazo de respuesta más corto) es óptima (Leung & Whitehead, 1982). Por óptima se entiende que no hay ninguna otra planificación mejor. Si de esta forma no se obtiene un plan admisible, no se puede obtener con ningún otro método basado en prioridades estáticas. Ejemplo: T

C

D

P

T1

6

15

15

T2

6

10

20

DMS => Pr1 < Pr2

T1 T2 0

5

10

15

20

25

30

35

40


202

CONDICIONES DE GARANTÍA DE PLAZOS Los test de utilización del procesador no sirven con el DMS. Los test de garantía de de plazos se basan en: En un sistema de n tareas periódicas independientes con prioridades estáticas, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si cuando se activan todas ellas simultáneamente, cada tarea acaba dentro del plazo en su primera ejecución. (Liu & Layland) El tiempo de finalización y en el trabajo requerido al procesador


203

CONDICIONES DE GARANTÍA DE PLAZOS Test 1: En un sistema de n tareas periódicas independientes con prioridades asignadas en orden de urgencia, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si: ∀i,1 ≤ i ≤ n,

Ci I i + ≤1 Di Di

donde i −1 ⎡

D⎤ I i = ∑ ⎢ i ⎥C j P j =1 ⎢ j ⎥

Ii se denomina tiempo de interferencia de la tarea Ti


204

CONDICIONES DE GARANÍA DE PLAZOS Se trata de una condición suficiente pero no necesaria T

C

D

P

C1 + I1 = 2 + 0 ≤ D1 = 3

T1

2

3

5

T2

2

6

15

⎡D ⎤ ⎡6⎤ C2 + ⎢ 2 ⎥C1 = 2 + ⎢ ⎥ 2 = 6 ≤ D2 = 6 ⎢5⎥ ⎢ P1 ⎥

T3

4

11

20

⎡D ⎤ ⎡D ⎤ C3 + ⎢ 3 ⎥C1 + ⎢ 3 ⎥C2 = ⎢ P1 ⎥ ⎢ P2 ⎥ ⎡11⎤ ⎡11⎤ 4 + ⎢ ⎥ 2 + ⎢ ⎥ 2 = 12 > D3 = 11 ⎢5⎥ ⎢15 ⎥

y sin embargo T3 cumple sus plazos de respuesta: T1 T2 T3 0

5

10

15

20

25

30

35

40


205

CONDICIONES DE GARANTÍA DE PLAZOS La condición necesaria y suficiente la da el test del tiempo de finalización Test de Tiempo de Finalización El tiempo de finalización de una tarea Ti (tfi) es: ⎛⎡ t ⎤ ⎞ ⎡ t ⎤ ⎟ t fi = min⎜⎜ ⎢ ⎥C1 + ... + ⎢ C C t + = i −1 i ⎥ ⎟ t > 0 ⎝ ⎢ P1 ⎥ ⎢ Pi −1 ⎥ ⎠

Por lo tanto la tarea Ti cumplirá su primer plazo si: t fi ≤ Di

Tiempo de interferencia: » Sólo se tienen en cuenta las activaciones de tareas más prioritarias que afectan efectivamente a la ejecución de una tarea dada: ⎡ t fi ⎤ ⎡ t fi ⎤ I i = ⎢ ⎥C1 + ... + ⎢ Ci −1 ⎥ ⎢ P1 ⎥ ⎢ Pi −1 ⎥


206

CONDICIONES DE GARANTÍA DE PLAZOS Ejemplo: T

C

D

P

T1

2

3

5

T2

2

6

15

T3

4

11

20

Mismo ejemplo anterior. Análisis: C1 + I1 = 2 + 0 ≤ D1 = 3 ⎡D ⎤ ⎡6⎤ C2 + ⎢ 2 ⎥C1 = 2 + ⎢ ⎥ 2 = 6 ≤ D2 = 6 ⎢5⎥ ⎢ P1 ⎥ ⎡D ⎤ ⎡D ⎤ ⎡11⎤ ⎡11⎤ C3 + ⎢ 3 ⎥C1 + ⎢ 3 ⎥C2 = 4 + ⎢ ⎥ 2 + ⎢ ⎥ 2 = 12 > D3 = 11 ⎢5⎥ ⎢15 ⎥ ⎢ P1 ⎥ ⎢ P2 ⎥

Cálculo del tiempo de finalización para T3


207

CONDICIONES DE GARANTÍA DE PLAZOS Tiempo de finalización: tf3 W30 = 0 W31 = C3 = 4 ⎡4⎤ ⎡4⎤ W32 = ⎢ ⎥ 2 + ⎢ ⎥ 2 + 4 = 8 ⎢5⎥ ⎢15 ⎥ ⎡8 ⎤ ⎡8⎤ W33 = ⎢ ⎥ 2 + ⎢ ⎥ 2 + 4 = 10 ⎢5⎥ ⎢15 ⎥ ⎡10 ⎤ ⎡10 ⎤ W34 = ⎢ ⎥ 2 + ⎢ ⎥ 2 + 4 = 10 ⎢5⎥ ⎢15 ⎥ t f 3 = 10 < 11


208

CONDICIONES DE GARANTÍA DE PLAZOS Reformulación Punto de planificación: Los puntos de planificación de una tarea Ti son todos los instantes límite (es decir los finales de los períodos) de las tareas de prioridad mayor o igual que Ti que se dan antes del final de su plazo de respuesta, suponiendo que todas las tareas han comenzado simultáneamente. Si es el conjunto de puntos de planificación de la tarea Ti: ⎧⎪ ⎢ Di ⎥ ⎫⎪ Si = ⎨ Di , k × p j j = 1..i − 1; k = 1..⎢ ⎥ ⎬ ⎪⎩ ⎢⎣ Pj ⎥⎦ ⎪⎭

Teorema 3 (Lehoczky, Sha & Ding): En un sistema de n tareas periódicas independientes con prioridades asignadas en orden de urgencia, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si y sólo si ⎛ i Cj ∀i,1 ≤ i ≤ n, min⎜ ∑ t∈Si ⎜ j =1 t ⎝

⎡ t ⎤ ⎞⎟ ⎢ ⎥⎟ ≤ 1 ⎢ Pj ⎥ ⎠


209

TAREAS ESPORÁDICAS Caracterizadas por: Separación mínima entre eventos: si Tiempo de cómputo: Ci Plazo de respuesta: Di Tratamiento mucho más sencillo que en el caso de RMS En el peor caso tarea periódica de período si y plazo de respuesta Di Ejemplo: T

C

D

P/S

T1

1

5

6

T2

2

6

8

T3

2

7

9

T4

2

8

10

Esporádica

Esporádica


210

TAREAS ESPORADICAS Análisis: C1 + I1 = 1 + 0 ≤ D1 = 5 ⎡D ⎤ ⎡6⎤ C2 + ⎢ 2 ⎥C1 = 2 + ⎢ ⎥1 = 3 ≤ D2 = 6 ⎢6⎥ ⎢ P1 ⎥ ⎡D ⎤ ⎡D ⎤ ⎡7 ⎤ ⎡7 ⎤ C3 + ⎢ 3 ⎥C1 + ⎢ 3 ⎥C2 = 2 + ⎢ ⎥1 + ⎢ ⎥ 2 = 6 ≤ D3 = 7 ⎢6⎥ ⎢8 ⎥ ⎢ P1 ⎥ ⎢ P2 ⎥ ⎡D ⎤ ⎡D ⎤ ⎡D ⎤ ⎡8 ⎤ ⎡ 8 ⎤ ⎡8 ⎤ C4 + ⎢ 4 ⎥C1 + ⎢ 4 ⎥C2 + ⎢ 4 ⎥C3 = 2 + ⎢ ⎥1 + ⎢ ⎥ 2 + ⎢ ⎥ 2 = 8 ≤ D4 = 8 ⎢9 ⎥ ⎢ 6 ⎥ ⎢8 ⎥ ⎢ P1 ⎥ ⎢ P2 ⎥ ⎢ P3 ⎥

por lo tanto todas las tareas cumplen sus plazos de respuesta


211

COMUNICACIÓN ENTRE TAREAS Protocolo de techo de prioridad Introducción en los test de garantía de plazos del término de bloqueo El valor máximo del tiempo de bloqueo de una tarea Ti, bi, es igual a la duración del servicio más largo de los requeridos, a cualquiera de los servidores, por tareas de prioridad inferior (pri ≤ techo prioridad servidor) Condición suficiente C I b ∀i,1 ≤ i ≤ n, i + i + i ≤ 1 Di Di Di

i −1 ⎡

D⎤ I i = ∑ ⎢ i ⎥C j P j =1 ⎢ j ⎥

Condición necesaria y suficiente (tiempo finalización) ⎛⎡ t ⎤ ⎞ ⎡ t ⎤ ⎟ t fi = min⎜⎜ ⎢ ⎥C1 + ... + ⎢ C C b t + + = i i ⎥ i −1 ⎟ P t > 0 ⎝ ⎢ P1 ⎥ ⎢ i −1 ⎥ ⎠

t fi ≤ Di


212

COMUNICACIÓN ENTRE TAREAS Ejemplo: Tarea P

D

C

b

T1

100

100

20

20

2

T2

150

90

40

10

3

T3

350

310

120

0

1

S1 S2

tp

3 2

T1 P=100 ms D=100 ms C=20 ms

S1 10 ms

T2

10 ms

P=150 ms D=90 ms C=40 ms

S2 2 ms

T3 P=350 ms D=300 ms C=100 ms

20 ms

p


COMUNICACIÓN ENTRE TAREAS Condición suficiente: Ci + I i + bi ≤ Di C2 + I 2 + b2 = 40 + 0 + 10 = 50 ≤ D2 = 90 ⎡D ⎤ ⎡100 ⎤ C1 + ⎢ 1 ⎥C2 + b1 = 20 + ⎢ 40 + 20 = 80 ≤ D1 = 100 ⎥ ⎢150 ⎥ ⎢ P2 ⎥ ⎡D ⎤ ⎡D ⎤ ⎡ 310 ⎤ ⎡ 310 ⎤ C3 + ⎢ 3 ⎥C2 + ⎢ 3 ⎥C1 + b3 = 120 + ⎢ 40 20 + 0 = 320 > D3 = 310 + ⎥ ⎥ ⎢ ⎢100 ⎥ ⎢150 ⎥ ⎢ P1 ⎥ ⎢ P2 ⎥

Tiempo de finalización para T3: ⎞ ⎛⎡ t ⎤ ⎡t ⎤ t f 3 = min⎜⎜ ⎢ ⎥C1 + ⎢ ⎥C2 + C3 + b3 = t ⎟⎟ t > 0 ⎝ ⎢ P1 ⎥ ⎢ P2 ⎥ ⎠ ⎡ 260 ⎤ ⎡ 260 ⎤ + 260 = ⎢ 20 40 + 120 + 0 < 310 ⎥ ⎢ ⎥ ⎢100 ⎥ ⎢150 ⎥

213


214

PLAZOS DE RESPUESTA ARBITRARIOS Algunas aplicaciones de tiempo real pueden aceptar que los plazos de respuesta de las tareas sean superiores a los periodos: Una tarea puede ser reactivada antes de que la invocación previa haya concluido su ejecución Ni la asignación de prioridades en orden de frecuencia ni la asignación en orden de urgencia son óptimas Otro algoritmo de asignación de prioridades


PLAZOS DE RESPUESTA ARBITRARIOS Ecuación del tiempo de respuesta para sistemas con prioridades: ⎛⎡ t ⎤ ⎞ ⎡ t ⎤ ⎟ t fi = min⎜⎜ ⎢ ⎥C1 + ... + ⎢ C C t + = i ⎥ i −1 ⎟ P t > 0 ⎝ ⎢ P1 ⎥ ⎢ i −1 ⎥ ⎠

¿Qué ocurre si tfi > Pi? Nueva activación de Ti » Si Di ≤ Pi → no importa porque la tarea no es planificable » Si Di > Pi → la primera ejecución interfiere en la segunda y por lo tanto puede tener un tfi mayor –

NO SIRVE LA ECUACIÓN

215


216

PLAZOS DE RESPUESTA ARBITRARIOS Ejemplo

T

C

D

P

T1

15

20

41

T2

9

40

16

T1 T2

0

10

20

30

40

50

60

Periodo de ocupación nivel 2

70

80

90


217

PLAZOS DE RESPUESTA ARBITRARIOS Teorema (Tindell, Burns & Wellings 1994): En un conjunto de tareas ordenadas por prioridad, el tiempo de respuesta de peor caso es: t fi =

max

q = 0,1, 2,...Q

( wi (q ) − qPi )

donde: wi(q) se calcula con: wi ( q ) = (q + 1)Ci + Bi +

⎡ wi (q ) ⎤ ∑ ⎢⎢ Pj ⎥⎥C j ∀j∈hp (i )

hp(i) es el conjuto de tareas de mayor prioridad que la de la tarea i Q se calcula con: Q = min{q wi ( q ) ≤ (q + 1)Pi }


218

PLAZOS DE RESPUESTA ARBITRARIOS Aplicación al ejemplo:

⎡ w (q) ⎤ ⎡ w (q) ⎤ w2 ( q ) = C2 (1 + q ) + ⎢ 2 ⎥C1 = 9(1 + q ) + ⎢ 2 ⎥15 ⎢ 41 ⎥ ⎢ P1 ⎥

q=0

⎡ w (0) ⎤ w2 (0) = 9 + ⎢ 2 ⎥15 = 24 ⎢ 41 ⎥ w2 (0) = 24 > 16 = (1 + q) P2

q=1

⎡ w (1) ⎤ w2 (1) = 9(1 + 1) + ⎢ 2 ⎥15 = 33 ⎢ 41 ⎥ w2 (1) = 33 > 32 = (1 + q ) P2

q=2

⎡ w ( 2) ⎤ w2 (2) = 9(1 + 2) + ⎢ 2 ⎥15 = 57 ⎢ 41 ⎥ w2 (2) = 57 > 48 = (1 + q ) P2


219

PLAZOS DE RESPUESTA ARBITRARIOS q=3

⎡ w (3) ⎤ w2 (3) = 9(1 + 3) + ⎢ 2 ⎥15 = 66 ⎢ 41 ⎥ w2 (3) = 66 > 64 = (1 + q ) P2

q=4

⎡ w ( 4) ⎤ w2 (4) = 9(1 + 4) + ⎢ 2 ⎥15 = 75 ⎢ 41 ⎥ w2 (4) = 75 ≤ 80 = (1 + q ) P2

» CONDICION DE PARADA CUMPLIDA tf 2 =

max

q = 0,1, 2,3, 4

( w2 ( q ) − qP2 ) =

max{24,33 − 16,57 − 32,66 − 48,75 − 64} = max{24,17,25,18,11} = 25


ASIGNACIÓN DE PRIORIDADES La asignación de prioridades DMS deja de ser óptima con plazos de respuesta arbitrarios Audsley (1991) desarrolló un algoritmo de asignación de prioridades estáticas que es óptimo en cualquier caso: ordered := number_of_tasks repeat finished := false failed := true task := first_task repeat insert task at priority ordered if task is schedulable then ordered := ordered - 1 failed := false finished := true extract task end if task := next_task until finished or no_more_tasks until ordered = 1 or failed

220


221

ASIGNACIÓN DE PRIORIDADES Ejemplo: T

C

D

P

T1

2

50

50

T2

9

40

16

T3

15

20

41

ordered = 3, task = T1 => T1 mínima prioridad ⎡t f 1 ⎤ ⎡t f 1 ⎤ ⎡t f 1 ⎤ ⎡t f 1 ⎤ t f 1 = C1 + ⎢ ⎥C2 + ⎢ ⎥C3 = 2 + ⎢ ⎥9 + ⎢ ⎥15 = 68 ⎢ P2 ⎥ ⎢ P3 ⎥ ⎢ 16 ⎥ ⎢ 41 ⎥ t f 1 = 68 > 50 = D1

» not schedulable, next_task

ordered = 3, task = T2 => T2 mínima prioridad ⎡ w (q) ⎤ ⎡ w (q) ⎤ ⎡ w (q) ⎤ ⎡ w (q) ⎤ w2 (q ) = C2 (1 + q ) + ⎢ 2 ⎥C1 + ⎢ 2 ⎥C3 = 9(1 + q ) + ⎢ 2 ⎥ 2 + ⎢ 2 ⎥15 ⎢ 50 ⎥ ⎢ 41 ⎥ ⎢ P1 ⎥ ⎢ P3 ⎥


222

ASIGNACIÓN DE PRIORIDADES

» q=0

⎡ w ( 0) ⎤ ⎡ w (0) ⎤ w2 (0) = 9 + ⎢ 2 ⎥ 2 + ⎢ 2 ⎥15 = 26 ⎢ 50 ⎥ ⎢ 41 ⎥ w2 (0) = 26 > 16 = (1 + q ) P2

» q=1

⎡ w (1) ⎤ ⎡ w (1) ⎤ w2 (1) = 9(1 + 1) + ⎢ 2 ⎥ 2 + ⎢ 2 ⎥15 = 35 ⎢ 50 ⎥ ⎢ 41 ⎥ w2 (1) = 35 > 32 = (1 + q ) P2

» q=2

⎡ w (1) ⎤ ⎡ w (1) ⎤ w2 (2) = 9(1 + 2) + ⎢ 2 ⎥ 2 + ⎢ 2 ⎥15 = 61 ⎢ 50 ⎥ ⎢ 41 ⎥ w2 (2) = 61 > 48 = (1 + q ) P2


223

ASIGNACIÓN DE PRIORIDADES » q=3

⎡ w (3) ⎤ ⎡ w (3) ⎤ w2 (3) = 9(1 + 3) + ⎢ 2 ⎥ 2 + ⎢ 2 ⎥15 = 70 ⎢ 50 ⎥ ⎢ 41 ⎥ w2 (3) = 70 > 64 = (1 + q) P2

» q=4

⎡ w (4) ⎤ ⎡ w ( 4) ⎤ w2 (4) = 9(1 + 4) + ⎢ 2 ⎥ 2 + ⎢ 2 ⎥15 = 79 ⎢ 50 ⎥ ⎢ 41 ⎥ w2 (4) = 79 ≤ 80 = (1 + q ) P2

tf 2 =

max

q = 0,1, 2,3, 4

( w2 (q ) − qP2 ) =

max{26,35 − 16,61 − 32,70 − 48,79 − 64} = max{26,19,29,22,15} = 29 < 40 = D2

» schedulable, ordered:= ordered - 1, finished, extract (T2)


224

ASIGNACIÓN DE PRIORIDADES ordered = 2, task = T1 => T1 prioridad media ⎡t f 1 ⎤ ⎡t f 1 ⎤ t f 1 = C1 + ⎢ ⎥C3 = 2 + ⎢ ⎥15 = 17 ⎢ 41 ⎥ ⎢ P3 ⎥ t f 1 = 17 < 50 = D1

» schedulable, ordered:= ordered - 1, finished

ordered = 1, task = T3 => T3 prioridad máxima t f 3 = C3 = 15 < 20 = D3

» schedulable, ordered:= ordered - 1, finished

ordered = 0 => FIN



PLANIFICACIÓN BASADA EN PRIORIDADES: PRIORIDADES DINÁMICAS - EDF -

225


226

PRIORIDADES DINÁMICAS - EDF Asignar en cada instante la prioridad más alta al proceso cuyo plazo de respuesta está más próximo (Earliest Deadline First, EDF) La prioridad de una tarea se calcula en tiempo de ejecución La prioridad de una tarea puede cambiar a lo largo de su ejecución y en diferentes activaciones » Prioridades dinámicas

T

C

D

Activación

T1

T1

8

20

0

T2

T2

4

6

6

T3

7

15

9

T3 0

5

10

15

20

25


227

EDF Earliest Deadline First es un método de planificación óptimo bajo las siguientes restricciones: Tareas independientes Planificación expulsiva Sistemas monoprocesador


228

BASES DEL ANÁLISIS Conjunto síncrono: todas las tareas se activan por primera vez en el mismo instante temporal Peor caso de una tarea esporádica: activación cada separación mínima entre eventos = tarea periódica Un sistema de tareas esporádicas cumple sus plazos de respuesta si y sólo si su correspondiente conjunto de tareas periódicas síncronas cumple sus plazos de respuesta Peor caso de un conjunto de tareas periódicas: conjunto síncrono Un sistema híbrido de tareas (esporádicas y periódicas) cumplirá sus plazos de respuesta si y sólo si su correspondiente conjunto de tareas periódicas síncronas cumple sus plazos de respuesta


229

FACTOR DE CARGA Demanda de procesador

h[t ,t ) = 1

2

∑ Ck

t1 ≤ rk , d k < t 2

h[t1,t2 ) ≠ W[t1,t2 ) =

T1

3

T2 T3 0

5

h[0,13) = 4

12 6

14

10

t1≤ rk ≤t2

h[3,18 ) = 4 + 4 + 6 = 14

18 5

∑ Ck

15

20

25

La demanda sólo cambia en rk y en dk


230

FACTOR DE CARGA Factor de carga

u[t1 ,t2 ) =

h[t1 ,t2 )

t2 − t1

u = max u[t1 ,t2 ) 0≤t
Factor de carga absoluto

1

2

4 + 4 + 6 14 = 15 15 4 u[5,12 ) = 7 4 + 6 10 = u[5,14 ) = 9 9 6 u[6,14 ) = 8 10 u= 9 u[3,18 ) =

T1

3

T2

18 12

5

T3

6

0

5

14

10

15

20

25


231

FACTOR DE CARGA Teorema (Spuri, 1995): Un conjunto de tareas planificadas mediante el algoritmo EDF cumple sus plazos de respuesta si y sólo si

u ≤1

T1

3

T2

18 12

5

T3

6

0

5

fallo 14

10

15

20

25


232

UTILIZACIÓN DEL PROCESADOR Tareas periódicas, independientes, plazo de respuesta igual al período Teorema (Liu&Layland 1973): En un sistema de n tareas periódicas, síncronas, independientes, con su plazo de respuesta igual al periodo y con prioridades asignadas mediante el algoritmo EDF, se cumplen todos los plazos de respuesta si y sólo si n

Ci U = ∑ ≤1 i =1 Ti En 1976 Coffman extiende el resultado para un conjunto de tareas periódicas asíncronas


233

UTILIZACIÓN DEL PROCESADOR Demostración

n

T n Ci U= ∑ = T i =1 Ti

T

∑ T Ci i =1

i

T

= u[0,T )

(T = hiperperiodo )

n Ci t 2 − t1 C t t C ≤ = − ( ) ∑ k ∑ T i 2 1 ∑ T ⇒ u[t1 ,t2 ) ≤ U i =1 t1 ≤ rk , d k ≤t 2 i =1 i i n

⇓ u =U


234

DEMANDA DE PROCESADOR Teorema: Cualquier conjunto híbrido de tareas con prioridades asignadas mediante el algoritmo EDF cumple sus plazos de respuesta si y sólo si

∀t , h(t ) ≤ t

h(t) = h[0,t) en un sistema síncrono el factor absoluto de carga se da en un intervalo de la forma [0,t) u ≤ 1 ⇒ h(t) ≤ t


DEMANDA DE PROCESADOR Cálculo de la demanda Sistema síncrono ⇒ hiperperiodo = T = mcm(Ti)

⎛ ⎢ t − Di ⎥ ⎞ ⎟⎟Ci h(t ) = ∑ ⎜⎜1 + ⎢ ⎥ Di ≤t⎝ ⎣ Ti ⎦ ⎠ La demanda sólo cambia en los plazos de respuesta

S = {e j e j = mTi + Di ; m = 0,1,...; i ∈ [1, n]; e j ≤ T }

235


236

DEMANDA DE PROCESADOR Ejemplo T1: C=3, D=4, P=4 T2: C=2, D=18, P=20 T1: C=1, D=3, P=10

T1

4

8

12

16

T2

20 18 20

T3

3

0

13

5

10

23

15

20

25

si 3 4 8 12 13 16 18 20

h(t) 1 4 7 10 11 14 16 19

c3 c1 + c3 c1 + c3 3c1 + c3 3c1 + 2c3 4c1 + 2c3 4c1 + c2 + 2c3 5c1 + c2 + 2c3


237

DEMANDA DE PROCESADOR Teorema (Liu&Layland 1973, Spuri 1995, Ripoll&Crespo&Mok 1996): Si en un sistema síncrono de tareas con Di≤Ti ∀i y prioridades asignadas mediante el algoritmo EDF no cumple sus plazos de respuesta, entonces existe un fallo de plazo sin tiempo libre antes.

Cálculo de la demanda durante el primer intervalo de ocupación completa del procesador Longitud del intervalo (L): solución más pequeña de la ecuación

x = W (x) ⎡t ⎤ W (t ) = ∑ ⎢ ⎥Ci i =1 ⎢Ti ⎥ n

Cálculo de la demanda en los puntos

S = {e j e j = mTi + Di ; m = 0,1,...; i ∈ [1, n]; e j ≤ L}


238

DEMANDA DE PROCESADOR Ejemplo

L(0) = 3 + 2 + 1 = 6 L(1) = W(6) = 2x3 + 1x2 + 1x1 = 9 L(2) = W(9) = 3x3 + 1x2 + 1x1 = 12 L(3) = W(12) = 3x3 + 1x2 + 2x1 = 13 L(4) = W(13) = 4x3 + 1x2 + 2x1 = 16 L(5) = W(16) = 4x3 + 1x2 + 2x1 = 16 L = 16

si 3 4 8 12 13 16

h(t) 1 4 7 10 11 14

c3 c1 + c 3 c1 + c 3 3c1 + c3 3c1 + 2c3 4c1 + 2c3

T1

4

8

12

16

T2

20 18 20

T3

3

0

13

5

10

23

15

20

25


239

NIVEL DE EXPULSIÓN Una tarea Tj expulsará a otra Ti si:

t ai ≤ t aj ∧ t di ≥ t dj

Esta situación sólo se puede dar si Dj ≤ Di

Ti Tj

tdi

tai taj

tdj


240

NIVEL DE EXPULSIÓN El nivel de expulsión de una tarea Ti se denota πi Una tarea Ti que puede expulsar a otra Tj tiene un nivel de expulsión πi ≥ π j Si suponemos EDF:

π i > π j ⇔ Di < D j

En EDF la prioridad no es una propiedad inherente a la tarea, su nivel de expulsión si


241

BLOQUEOS ¿Cuándo una tarea puede sufrir un bloqueo con inversión de prioridades? La tarea Ti está activa y dentro de una sección crítica La tarea Tj expulsa a la Ti (tdj < tdi) Para que esto suceda: πi > πj Ti Tj

tdi

tai taj

tdj

En EDF, una tarea Tj puede ser bloqueada por otra Ti de menor prioridad sólo si Ti tiene mayor nivel de expulsión que Tj (πi > πj)


242

PROTOCOLOS En EDF son válidos los protocolos: Herencia de prioridades Techo de prioridad Aspectos a tener en cuenta: La definición de los protocolos es la misma que con prioridades estáticas El cálculo de los tiempos de bloqueo es el mismo que con prioridades estáticas pero atendiendo a los niveles de expulsión de las tareas, no a su prioridad (que cambia según la situación)


243

HERENCIA DE PRIORIDAD Tareas periódicas que comunican mediante servidores con el protocolo de techo de prioridad, plazo de respuesta menor o igual al periodo

Teorema (Stankovic&col 1998): En un sistema de n tareas con prioridades asignadas mediante el algoritmo EDF, se cumplen todos los plazos de respuesta si

∀i = 1,..., n

i −1

Cj

j =1

j

∑D

+

Ci + bi ≤1 Di

» Condición suficiente, no necesaria » Tareas ordenadas por nivel de expulsión


244

TECHO DE PRIORIDAD Tareas periódicas que comunican mediante servidores con el protocolo de techo de prioridad, plazo de respuesta igual al periodo

Teorema (Chen&Lin 1989): En un sistema de n tareas con prioridades asignadas mediante el algoritmo EDF, se cumplen todos los plazos de respuesta si Ci + bi ∑ Pi ≤ 1 i =1 n

» Condición suficiente, no necesaria


245

TECHO DE PRIORIDAD Ejemplo:

Tarea P

C

b

T1

100

20

0

T2

150

40

10

T3

350

100

0

T1 P=100 ms C=20 ms

T2 P=150 ms C=40 ms

5 ms T3 P=350 ms C=100 ms

Ci + bi 20 40 + 10 100 ∑ P = 100 + 150 + 350 = 0.819 ≤ 1 i =1 i n

S2

10 ms


246

PLANIFICACIÓN DINÁMICA Tipos de planificaciones: Planificación Estática » Se realiza la planificación antes del tiempo de ejecución » Se requiere un conocimiento previo de todas las características de las tareas el sistema » Poco coste en ejecución » Planificación cíclica, RMS, DMS, ...

Planificación Dinámica » Se construye el plan en tiempo de ejecución » Se adapta a cambios –

Llegada de nuevas tareas al sistema

–

Desaparición de tareas

–

Cambios en el entorno

» Gran coste de ejecución » EDF permite la planificación dinámica


247

PLANIFICACIÓN DINÁMICA Se conocen a priori todas las tareas y sus características Análisis previo de planificabilidad Todas las tareas cumplirán plazos No se conocen las tareas y sus características. Dos aproximaciones cuando llega el evento de activación de una tarea: Control de admisión. La ejecución de la tarea se iniciará sólo si pasa un test de planificabilidad, esto es, todas las tareas del sistema incluyendo la nueva cumpliran sus plazos. Si no pasa el test: » la activación es rechazada » una acción correctora puede ser ejecutada

No se realiza un test de aceptación. No se sabe a priori si una tarea que ha comenzado su ejecución cumplirá su plazo de respuesta: » una tarea puede ser abortada » una acción correctora puede ser ejecutada


PROGRAMACIÓN DE UN PLANIFICADOR Características Prioridades dinámicas Ada95 Las tareas se planifican ellas mismas mediante un “protected” with Ada.Task_Identification, Ada.Task_Attributes, Ada.Real_Time ; with Ada.Dynamic_Priorities, System ; use Ada, Ada.Real_Time ; procedure EDF is pragma Locking_Policy (Ceiling_Locking) ; pragma Task_Dispatching_Policy (Fifo_Within_Priority) ; N: constant Positive := ... ; subtype Active_Range is Natural range 0..N ; subtype Task_Range is Active_Range range 1..N ; High: constant System.Priority := System.Priority’Last ; Medium: constant System.Priority := High - 1 ; Low: constant System.Priority := High - 2 ; package Deadline_Attributes is new Task_Attributes(Time, Time_Last) ; -- Time_Last is the furtest time into the future the -- implementation can give, it is defined in Real_Time type Labels is array (Task_Range) of Task_Identification.Task_Id ;

248


PROGRAMACIÓN DE UN PLANIFICADOR protected Scheduler is pragma Priority (High) ; procedure Register ; procedure Reschedule ; -- called by tasks coming off delay queue procedure Remove ; -- called by tasks completing their execution private Task_Labels: Labels ; Number_Of_Tasks: Active_Range := 0 ; Shortest_Deadline: Time := Time_Last ; Running_Task: Task_Identification.Task_Id := Task_Identification.Null_Task_Id ; end Scheduler ; task type Worker is pragma priority (High) ; end Worker ; protected body Scheduler is ... task body Worker is ... -- declaration of N Workers end EDF ;

249


PROGRAMACIÓN DE UN PLANIFICADOR

task body Worker is -- internal declarations Period: Time_Span := -- some value Deadline: Time_Span := -- some value Next_Release: Time : begin Scheduler.Register ; Next_Release:= Clock + Period ; Dynamic_Priorities.Set_Priority (High) ; loop delay until Next_Release ; Deadline_Attributes.Set_Value (Next_Release+Deadline) ; Secheduler.Reschedule ; -- lowers priority from high -- code of application Dynamic_Priorities.Set_Priority (High) ; Deadline_Attributes.Set_Value (Time_Last) ; Scheduler.Remove ; -- retains priority at high Next_Release := Next_Release + Period ; end loop ; end Worker ;

250



protected body Scheduler is procedure Register is begin Number_Of_Tasks := Number_Of_Tasks + 1 ; Tasks_Labels(Number_Of_Tasks) := Task_Identification.Current_task ; end Register ; procedure Reschedule is begin if Deadline_Attributes.Value < Shortest_Deadline then Dynamic_Priorities.Set_Priority(Medium) ; Dynamic_Priorities.Set_Priority(Low,Running_Task) ; Shortest_Deadline := Deadline_Attributes.Value ; Running_Task := Task_Identification.Current_Task ; else Dynamic_Priorities.Set_Priority(Low) ; end if ; end Reschedule ;

251


252


procedure Remove is begin Shortest_Deadline := Time_Last ; Running_Task := Task_Identification.Null_Task_Id ; for T in 1..Number_Of_Tasks loop if Deadline_Attributes.Value(Task_Labels(T)) < Shortest_Deadline then Shortest_Deadline := Deadline_Attributes.Value(Task_Labels(T)) ; Running_Task := Task_Labels(T) ; end if ; end loop ; if Shortest_Deadline < Time_Last then Dynamic_Priorities.Set_Priority(Medium,Running_Task) ; end if ; end Remove ; end Scheduler ;



MANEJADORES DE DISPOSITIVOS

253


254

MECANISMOS DE ENTRADA-SALIDA Los sistemas tiempo real se conectan a los sistemas físicos que controlan por medio de dispositivos de entrada y salida específicos (sensores, actuadores, etc.), que suelen requerir un tratamiento especial en cada caso. Esquema genérico:

SISTEMA CONTROL MANEJADOR DE DISPOSITIVO CONTROLADOR DE DISPOSITIVO

DISPOSITIVO


255

MECANISMOS DE ENTRADA-SALIDA Los controladores presentan como interfase al procesador un conjunto de registros (estado, control, datos). Existen dos formas básicas de conectar un controlador a una cierta arquitectura: Mediante un bus específico de entradas-salidas: » El espacio de direccionamiento de los controladores es diferente que el de la memoria. » El procesador accede a los registros mediante instrucciones de máquina especiales:

in Rn, puerto out Rn, puerto

Mediante el bus de memoria: » El espacio de direccionamiento de los controladores es el mismo que el de la memoria. » Los registros se comportan, a todos los efectos, como celdas de memoria:

mov Rn, registro mov registro, Rn


256

MECANISMOS DE ENTRADA-SALIDA El manejo de un controlador de dispositivos: Activación de la operación » Por programa » Autónoma » Exterior

Paso de los datos » Interrupción: el controlador interrumpe al procesador cuando termina una operación y fuerza la ejecución de un manejador. » DMA: acceso directo a memoria » Muestreo: el procesador interroga cada cierto tiempo al controlador sobre el estado de la operación.


257

EJEMPLO Supondremos un sistema de entradasalida con direccionamiento en espacio de memoria. Cada controlador tiene dos tipos de registros:

Por ejemplo, el registro de control y estado de un convertidor analógicodigital con 64 canales de entrada podría tener esta estructura: Bits Función

Registros de control y estado (CSR). Se dividen en campos correspondientes a operaciones o componentes de estado.

0 Arranca

Registros de datos (DBR). Contienen datos que se transmiten hacia o desde el dispositivo.

7 Terminado

1-5 No utilizados 6 Interrupción permitida

8-13 Canal 14 No utilizado 15 Error

Extraído de las transparencias de Tiempo Real de Juan Antonio de la Puente (DIT/UPM)


258

EJEMPLO

0 1

…

12 bits

A/D

MUX

63

LCI 6 bits

14 13

E

8

C

RC 8#176562#

5

TI 16 bits

BUS DEL SISTEMA

1

15

12 11

0

M

A RD 8#176560#

INTERRUPCION Vector: 8#100#

16 bits


259

EJEMPLO

package ADC_Device_Driver is Bits : constant := 16; Max_Measure : constant := 2**Bits - 1; type Channel is range 0 .. 63; subtype Measurement is Integer range 0 .. Max_Measure; procedure Read (C : Channel; M : out Measurement); Conversion_Error : exception; private for Channel'Size use 6; end ADC_Device_Driver ;


260

EJEMPLO with with with with

Ada.Interrupts; use Ada.Interrupts; Ada.Interrupts.Names; use Ada.Interrupts.Names; System; use System; System.Storage_Elements; use System.Storage_Elements;

package body ADC_Device_Driver is Bits_In_Word : constant := 16; Word : constant := 2; type Flag is (Down, Set); for Flag use (Down => 0, Set => 1); for Flag'Size use 1; type Control_Register is record Start : Flag; I_Enable : Flag; Done : Flag; Chan : Channel; Error : Flag; end record;


261

EJEMPLO pragma Pack(Control_Register); for Control_Register use record Start at 0*Word range I_Enable at 0*Word range Done at 0*Word range Chan at 0*Word range Error at 0*Word range end record;

0..0; 6..6; 7..7; 8..13; 15..15;

for Control_Register'Size use Bits_In_Word; for Control_Register'Alignment use Word; for Control_Register'Bit_Order use Low_Order_First;


262

EJEMPLO type Data_Register is range 0..Max_Measure; for Data_Register'Size use Bits_In_Word; for Data_Register'Alignment use Word; Control_Reg_Address : constant Address:= To_Address(8#150002#); Data_Reg_Address : constant Address:= To_Address(8#150000#); ADC_Priority : constant Interrupt_Priority := 31; Control_Reg : Control_Register; for Control_Reg'Address use Control_Reg_Address; Data_Reg : Data_Register; for Data_Reg'Address use Data_Reg_Address;


263

EJEMPLO

protected Interrupt_Interface is entry Read (C : Channel; M : out Measurement); private entry Done (C : Channel; M : out Measurement); procedure Handler; pragma Attach_Handler( Handler, INTADC); pragma Interrupt_Priority( ADC_Priority); Interrupt_Occurred : Boolean := False; Next_Request : Boolean := True; end Interrupt_Interface;


264

EJEMPLO protected body Interrupt_Interface is entry Read (C : Channel; M : out Measurement) when Next_Request is begin Control_reg := (Start => Set, I_Enable => Set, Done => Down, Chan => Channel(C), Error => Down); Interrupt_Occurred := False; Next_Request := False; requeue Done; end Read;


265

EJEMPLO procedure Handler is begin Interrupt_Occurred := True; end Handler;

entry Done(C: Channel; M: out Measurement) when Interrupt_Occurred is begin Next_Request := True; if Control_reg.Done = Set and Control_reg.Error = Down then M := Measurement(Data_Reg); else raise Conversion_Error; end if; end Done; end Interrupt_Interface;


266

EJEMPLO procedure Read (C : Channel; M : out Measurement) is begin for I in 1.. 3 loop begin ADC_Interface.Read(C,M); return; exception when Conversion_Error => null; end; end loop; raise Conversion_Error; end Read; end ADC_Device_Driver;



TOLERANCIA A FALLOS. EXCEPCIONES

267


268

INTRODUCCIÓN En un sistema Tiempo Real no es permisible: Finalización inesperada Bloqueos Salidas erróneas Dos aproximaciones complementarias para obtener sistemas fiables: Prevención de fallos Tolerancia a fallos

Dos tipos de fallos: Fallos en el sistema de control Fallos en el sistema controlado Causas principales de fallos (sist. control): Errores en el desarrollo del software Fallos en las unidades de procesamiento Interferencias en el subsistema de comunicaciones


CONCEPTOS DE TOLERANCIA A FALLOS FALLO → ERROR → FRACASO

Tipos de fallos: Fallos transitorios (p.e. interferencias electro-magnéticas) Fallos permanentes (p.e. un error de diseño en un programa) Fallos intermitentes (p.e. un componente sensible a la temperatura)

Un sistema evoluciona por un conjunto de estados: Internos Externos (apreciable desde el exterior)

269


270

CONCEPTOS DE TOLERANCIA A FALLOS Comportamiento Observable FRACASO

Interno

FALLO

ERROR


CONCEPTOS DE TOLERANCIA A FALLOS ERROR: Estado interno no especificado de un sistema FRACASO: Estado externo no especificado de un sistema

Aproximaciones para conseguir un sistema fiable, esto es, sin fracasos: Prevención de fallos Tolerancia a fallos

271


272

PREVENCIÓN DE FALLOS Dos fases: Evitación de fallos durante la construcción del sistema. Con respecto al software: » Especificación de requisitos rigurosa o formal » Uso de metodologías de diseño probadas » Uso de lenguajes que faciliten la modularidad y abstracción de datos » Uso de herramientas CASE que faciliten el manejo de la complejidad del software

Eliminación de los fallos introducidos en el software, generalmente mediante tests del sistema. Problemas: » Un test sólo muestra la presencia de fallos, no su ausencia » No tests en condiciones reales


273

TOLERANCIA A FALLOS Diversos grados de tolerancia a fallos: Tolerancia a fallos completa Tolerancia con degradación Parada segura

Tolerancia a fallos ⇒ redundancia

Redundancia: incorporación de elementos extras (redundantes) no necesarios en funcionamiento normal. Redundancia estática: los componentes redundantes operan siempre incluso sin fallos (p.e. programación N-versión) Redundancia dinámica: los componentes redundantes operan cuando hay un fallo (p.e. bloques de recuperación, excepciones)


274

PROGRAMACIÓN N-VERSIÓN Un componente tolerante a fallos está compuesto por: N versiones independientes de un programa con las mismas especificaciones (N ≥ 3) Un controlador Independencia: Desarrollo: diferentes lenguajes de programación, diferentes entornos de desarrollo, diferentes programadores Ejecución: las versiones no comunican entre sí Funcionamiento: Cada diseño se comunica únicamente con el controlador Cada diseño emite un resultado (voto) El controlador compara los votos y elige el resultado más votado


275

PROGRAMACIÓN N-VERSIÓN Versión 1

Versión 2

CONTROL

Versión 3


276

REDUNDANCIA DINÁMICA Los componentes redundantes actuan únicamente cuando se ha detectado un fallo. Fases: Detección del error Evaluación del daño Recuperación del error Tratamiento del fallo Detección del error. Dos clases de técnicas:

Detección por el entorno donde se ejecuta la aplicación ("hardware", soporte "run-time"). Detección implícita. Detección por la propia aplicación mediante chequeos. Detección explícita. if not CONDICION_REQUERIDA then ERROR ; end if ;


277

REDUNDANCIA DINÁMICA Recuperación del error. Dos aproximaciones diferentes:

Recuperación hacia adelante: se intenta continuar desde un estado erróneo realizando correcciones selectivas en dicho estado. Recuperación hacia atrás: se restaura un estado correcto (punto de recuperación) anterior a la ocurrencia del error. Generalmente se continúa utilizando un procedimiento alternativo al que ha fallado.

... Proc. alternativo

Hacia adelante

ERROR


278

BLOQUES DE RECUPERACIÓN Ensure {test de aceptacion}by {modulo primario} else by {modulo alternativo} else by {modulo alternativo} … else by {modulo alternativo} else error Reestablece estado

no Pto. recuperación

Mod?

si

no

FRACASO

Siguiente módulo

Test

si

Pto. recuperación


279

PROBLEMAS Problemas en la programación N-versión y en los bloques de recuperación:

Costos de desarrollo grandes: ambas aproximaciones requieren algoritmos alternativos La programación N-versión requiere N veces los recursos de una versión. La recuperación del estado y la ejecución de una alternativa, en los bloques de recuperación, son actividades costosas Tolerancia a fallos del sistema de control, no del sistema controlado No existen actualmente lenguajes de tiempo real que presenten primitivas de soporte para estas técnicas.


280

EXCEPCIONES Características: Redundancia dinámica Recuperación hacia delante

Detección de un error

⇓ Levantamiento de una excepción

⇓ Ejecución de un manejador de la excepción


281

EXCEPCIONES

Petición servicio

Respuesta normal

Excepciones de interfase

Excepciones de fracaso

Vuelta servicio normal

Actividad normal

Petición Respuesta servicio normal

Manejadores de excepciones

Excepciones internas Excepciones Excepciones de interfase de fracaso


282

DOMINIO DEL MANEJADOR DE UNA EXCEPCIÓN Dentro de un programa puede haber varios manejadores de una misma excepción.

Cada uno tiene un dominio: si la excepción se levanta en ese dominio el manejador correspondiente se activa.

Lenguaje orientado a bloques ⇒ dominio = bloque


283

EXCEPCIONES. MODELOS. Modelo de reanudación (PEARL)

P

Q Ex

Manejador Ex


284

EXCEPCIONES. MODELOS. Modelo de terminación (Ada, CHILL)

P

Q Ex

Manejador Ex


285

PROPAGACIÓN DE EXCEPCIONES ¿Qué sucede si se levanta una excepción en un bloque donde no existe manejador para ella?

Dos aproximaciones:

Enlace estático: en tiempo de compilación se establece un enlace entre excepción-contexto y su manejador Enlace dinámico: búsqueda de un manejador a lo largo de la cadena de invocadores del bloque ⇒ propagación


286

PROPAGACIÓN DE EXCEPCIONES Propagación

P

Q

R Ei

Mi

P

Q

R

Propagación explícita

Ei

Mi

Mi

Mi raise

raise



PROGRAMACIÓN SECUENCIAL. ADA95

287


288

CUESTIONES BÁSICAS Ada95 es un lenguaje de la familia del Pascal Léxico: No hay distinciones entre mayúsculas y minúsculas. Los identificadores pueden contener cualquier número de caracteres. Puede utilizarse el carácter "_" en los identificadores para hacerlos más legibles:

Ejemplo_de_identificador

Los comentarios empiezan con "--" y van hasta el final de la línea


289

TIPOS DE DATOS Ada es un lenguaje fuertemente tipado. No se pueden copiar valores de un tipo en variables de otro. Creación de tipos Desde cero Basándose en otros » Subtipo

restricción de un cierto tipo base.

» Tipo derivado

copia (posiblemente restringida) de un tipo base.

Los subtipos de un mismo tipo son compatibles. No así los derivados. Tipos predefinidos: » integer, positive, ..., float » boolean » character


290

TIPOS DE DATOS Elementales

Compuestos

Access

Array

Scalar

Record

» Discrete –

Enumeration

–

Integer » Signed » Modular

» Real –

Fixed » Decimal » Ordinary

–

Floating

Protected Task


291

TIPOS DISCRETOS Son los enteros, enumerables, boolean y character. Tipos enteros » Predefinidos: integer y dos subtipos: subtype NATURAL is integer range 0..integer'last ; subtype POSITIVE is integer range 1..integer'last ;

» Es mejor usar tipos específicos: type INDICE is range 0..128 ; subtype INDICE_POSITIVO is INDICE range 1..128 ; -- derivado type OTRO_INDICE is new INDICE ;

» Operaciones predefinidas con los tipos enteros: + - * / rem mod abs **


292

TIPOS DISCRETOS Tipos enumerables type DIMENSION is (X,Y,Z); type MAP is (X,Y); subtype SUPERFICIE is DIMENSION range X..Y; type PROY is new DIMENSION range X..Y; -- distinto tipo

» Ejemplo de uso declare D : DIMENSION ; S : SUPERFICIE ; P : PROY ; begin D := S ; -- legal S := D ; -- legal, puede dar probs. P := D ; -- ilegal P := PROY(D) ; -- legal, conversion end ;


293

TIPOS DISCRETOS Tipo boolean type boolean is (false,true) ; » Las operaciones predefinidas son: not and or xor » También hay operadores relacionales: = /= < <= > >= » Y un operador de pertenencia, in, que se aplica a tipos discretos:

I in 0..10 X in POSITIVE D in X..Y

Tipo carácter » Comprende todos los caracteres ASCII » También hay tiras de caracteres. » 'C' es un carácter. "C" es una tira de un solo carácter.


294

TIPOS REALES En los sistemas de control es necesario utilizar valores reales. Hay dos formas de representar estos valores: Números con coma flotante: » Se representan como M*RE » Tiene una precisión relativa al tamaño del número (M longitud finita) » Son adecuados para realizar cálculos en los cuales no se necesiten resultados exactos

Coma fija, números con escala » Se representan como V*S » Tiene una precisión absoluta determinada » Son adecuados para representar valores analógicos en el computador

En Ada95 se pueden definir ambas formas de reales.


295

TIPOS REALES Coma flotante: El tipo float está predefinido, pero es mejor definir tipos específicos: type REAL is digits 8 range -1.0E18..1.0E18; subtype REAL_1 is REAL digits 2; subtype REAL_2 is REAL range 0.0..1000.0;

Tipos coma fija (con escala): No hay ningún tipo de coma fija predefinido. type ESCALA is delta 0.05 range -100.00..100.00; » Los valores del tipo ESCALA son: -100.00, -99.95, …

Las operaciones predefinidas son: Coma flotante:

+ - * / abs **

Coma fija:

+ - * / abs

Funciones matemáticas en paquetes.


296

TIPOS ESTRUCTURADOS Array

MAX: constant integer := 10; type T_LECTURA is array (0..MAX-1) of float; TAMAGNO: constant integer := MAX-1; type T_CONMUTADORES is array (0..TAMAGNO, 0..TAMAGNO) of boolean; LECTURA: T_LECTURA; CONMUTADORES: T_CONMUTADORES;

» Agregados

LECTURA(1) := 2.5 ; LECTURA := (2.5, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0); LECTURA := (1 => 2.5, 2..4 => 1.0, others => 0.0); LECTURA (1..3) := LECTURA (5..7) ;


297

TIPOS ESTRUCTURADOS Registros

» Agregados

type T_DIA is new integer range 1..31; type T_MES is new integer range 1..12; type T_AGNO is new integer range 1900..2050; type FECHA is record DIA: T_DIA := 1 ; MES: T_MES := 1 ; AGNO: Y_AGNO ; end record;

declare F: FECHA; begin F.AGNO := 1990 ; F:= (1, 3, 1990) ; F:= (AGNO => 1992, DIA => 1, MES => 4); end ;


298

OBJETOS DINÁMICOS Los tipos acceso permiten acceder a objetos dinámicos. type NODO; type ENLACE is access NODO; type NODO is record VALOR: integer ; SIGUIENTE: ENLACE ; end record; … V: integer ; NUEVO: ENLACE; begin … NUEVO := new NODO ; NUEVO.VALOR := V ; NUEVO.SIGUIENTE := null ; --por defecto … end; -- NUEVO.all es lo apuntado por el access NUEVO


299

ESTRUCTURAS DE CONTROL Secuencia

instruccion; instruccion; … instruccion;

Bloques declare begin exception end;

declare TEMP: integer := A ; begin A := B ; B := TEMP ; end ;

Siempre se puede poner un bloque en lugar de una instrucción.La parte declarativa (constantes, variables, tipos, subprogramas, paquetes y tareas) y la de excepciones son optativas.


ESTRUCTURAS DE CONTROL Selección if A /= 0 then if B/A > 10 then MAYOR := true ; else MAYOR := false ; end if ; end if ; -- tambien elsif, and then case ORDEN is when 'A' | 'a' => ACCION1 ; when 'b' => ACCION2 ; when 'x'..'z' => ACCION3 ; when others => null ; end case ;

300


ESTRUCTURAS DE CONTROL Iteración for I in 0..9 loop -- I local al bucle A(I) := I ; -- no se puede modificar end loop ; while CONDICION loop ACCION ; end loop ; loop ACCION_1 ; exit when CONDICION ; ACCION_2 ; end loop ; loop ACCION ; end loop ;

301


302

SUBPROGRAMAS Son los procedimientos y las funciones. Modos de los parámetros: in, out e in out Ejemplo: procedure CUADRATICA (A,B,C: in float; R1,R2: out float; OK : out boolean);

Un parámetro in se compota como una constante local cuyo valor es del parámetro real. Un parámetro out se comporta como una variable a la que sólo se le puede asignar valor. Este valor se copia al parámetro real. Un parámetro in out se comporta como una variable cuyo valor inicial es del parámetro real, y cuyo valor final se vuelve a copiar al mismo. El modo por defecto es in.


303

SUBPROGRAMAS Procedimientos Se puede declarar una especificación y después el cuerpo, o directamente éste. procedure CUADRATICA (A,B,C: in float; R1,R2: out float; OK : out boolean) is z: float ; begin Z:= B*B - 4.0*A*C ; if Z < 0.0 or A = 0.0 then OK:= false; R1 := 0.0 ; R2 := 0.0 ; return ; end if ; OK := true ; R1 := (-B + SQRT(Z))/(2.0*A) ; R2 := (-B - SQRT(Z))/(2.0*A) ; end CUADRATICA;


304

SUBPROGRAMAS Los procedimientos se invocan de la forma habitual: CUADRATICA(1.0,3.0,2.0,X,Y,VALE) ;

Hay otras formas. Ejemplos: type AJUSTE is (ABIERTO,CERRADO) ; type VALVULA is range 1..10 ; procedure AJUSTAR(VALVULA_N: VALVULA ; POSICION: AJUSTE := CERRADO) ; … -- llamada normal AJUSTAR(6,ABIERTO) ; -- parámetro por defecto AJUSTAR(3) ; -- notación nombrada AJUSTAR(POSICION => ABIERTO ; VALVULA_N => 9) ; …

En Ada, todos los subprogramas son reentrantes y se pueden llamar recursivamente.


305

SUBPROGRAMAS Funciones Son semejantes a los procedimientos function MINIMO (X,Y:integer) return integer is begin if X > Y then return Y; else return X ; end if ; end MINIMO ;

La invocación se hace de forma habitual: C := MINIMO(A,B) ;

Las formas de llamadas de los procedimientos son válidas también para las funciones.


306

GRANDES PROGRAMAS. FACILIDADES DEL LENGUAJE Grandes programas => Descomposición modular Módulo: es un colección de objetos y operaciones relacionados entre sí. En Ada95 los módulos se denominan paquetes (packages).

La estructura de módulos del Ada95 permite utilizar algunas técnicas que facilitan el desarrollo de programas grandes: Ocultamiento de información, tipos abstractos de datos Compilación separada Reutilización del Software Programación orientada a objeto


307

OCULTACIÓN DE LA INFORMACIÓN Un paquete permite controlar la visibilidad de sus objetos. Un paquete tiene dos partes: Especificación: Contiene las declaraciones y especificaciones que son visibles fuera del paquete (define su interfase). Cuerpo: Contiene los detalles de implementación que no son visibles fuera del paquete. package nombre_paquete is -- declaraciones visibles private -- declaracion tipos privados end nombre_paquete ; package body nombre_paquete is -- codigo y datos ocultos begin -- codigo de inicializacion end nombre_paquete ;


308

TIPOS ABSTRACTOS DE DATOS Tipo abstracto de datos: es un tipo de datos definido únicamente por las operaciones que se pueden efectuar con objetos del tipo. Ada: Especificación: declaración del tipo + operaciones Cuerpo: implementación operaciones

Tipo privado: es un tipo visible en la especificación de un paquete pero su implementación está oculta. Operaciones predefinidas: asignación, comparaciones de igualdad y no igualdad.

Tipo privado limitado: no tiene ninguna operación predefinida, sólo se le pueden aplicar las explícitamente definidas en la especificación del paquete.


309

EJEMPLO TAD COLA package COLAS is type COLA is limited private ; procedure INICIAR(C: in out COLA) ; function VACIA(C: COLA) return boolean ; procedure METER(C: in out COLA ; E: ELEMENTO) ; procedure SACAR(C: in out COLA ; E: ELEMENTO) ; private type NODO ; type ENLACE is access NODO ; type NODO is record CONTENIDO: ELEMENTO ; SIGUIENTE: ENLACE ; end record ; type COLA is record PRIMERO: ENLACE := null ; ULTIMO: ENLACE := null ; end record end COLAS ;


310

EJEMPLO TAD COLA package body COLAS is procedure INICIAR(C: in out COLA) is begin … end INICIAR; function VACIA(C: COLA) return boolean is begin … end VACIA; procedure METER(C: in out COLA ; E: ELEMENTO) is NUEVO: ENLACE; begin NUEVO:= new NODO'(CONTENIDO => E, SIGUIENTE => null); if VACIA(C) then C.PRIMERO:= NUEVO ; else C.ULTIMO.SIGUIENTE:= NUEVO ; end if ; C.ULTIMO:= NUEVO ; end METER ; procedure SACAR(C: in out COLA ; E: out ELEMENTO) is begin … end SACAR; end COLAS;


311

EJEMPLO TAD COLAS with COLAS ; procedure ejemplo is COLA_1: COLAS.COLA ; COLA_2: COLAS.COLA ; X, Y: ELEMENTO ; begin COLAS.INICIAR (COLA_1) ; COLAS.INICIAR (COLA_2) ; … COLAS.METER (COLA_1,X) ; … if not COLAS.VACIA(COLA_2) then COLAS.SACAR(COLA_2,Y); end if; … end ejemplo ;


312

COMPILACIÓN SEPARADA Un programa grande puede ser dividido en unidades de compilación, que se pueden compilar por separado: Especificación de paquetes Cuerpo de paquetes (primero hay que compilar la especificación) Subprogramas (procedimientos y funciones) Una de las unidades de compilación (un procedimiento) hace el papel de programa principal. Ada95 no tiene un constructor específico para el programa principal. El procedimiento principal no tiene parámetros.


313

COMPILACIÓN SEPARADA La dependencia entre unidades se indica con la cláusula with. with hace visibles las declaraciones del paquete a las que se refiere.

Se puede añadir use => no es preciso anteponer el nombre del módulo al del objeto referenciado. package PLANIFICADOR is -- especificación end PLANIFICADOR ; with COLAS ; use COLAS ; package body PLANIFICADOR is -- cuerpo con referencias a las -- operaciones del paquete COLA … METER(COLA_1,X) ; … end PLANIFICADOR ;


314

REUTILIZACIÓN DEL SOFTWARE Reutilización de componentes de software => mejora productividad y calidad. Tipado inconveniente. ¿Cómo hacer colas que no dependan del tipo de elemento? --> procedimientos, funciones o paquetes genéricos generic type ELEMENTO is private ; package COLAS is type COLA is limited private ; … procedure METER(C: in out COLA ; E: ELEMENTO) ; private … end COLAS ;

…

Se pueden crear ejemplares para cada tipo específico ELEMENTO: declare package COLAS_DE_ENTEROS is new COLAS(ELEMENTO => integer) ; use COLAS_DE_ENTEROS ; … begin … end ;


315

ENTRADAS SALIDAS. ASPECTOS BÁSICOS Las operaciones de entradas/salidas en Ada95 están definidas en paquetes estándar. Algunos genéricos

permiten su instanciación para diversos tipos.

Los paquetes estándar del Ada95 son: Ada.Direct_IO: Paquete genérico de acceso directo a ficheros binarios Ada.Sequential_IO: Paquete genérico de acceso secuencial a ficheros binarios Ada.Text_IO: Paquete para ficheros de texto y entradas-salidas por terminal. Contiene seis paquetes genéricos específicos: » Integer_IO » Float_IO » Fixed_IO » Enumeration_IO » Modular_IO » Decimal_IO


ENTRADAS SALIDAS. ASPECTOS BÁSICOS Un fichero en Ada95 es un objeto con los siguientes atributos: Name: nombre del fichero en el sistema Mode: IN_FILE, OUT_FILE, APPEND_FILE o INOUT_FILE. Form: String para atributos dependientes del sistema State: Open, Closed Index: Posicion en el fichero Size: Número de objetos almacenados en el fichero

316


317

ENTRADAS SALIDAS. ASPECTOS BÁSICOS Operaciones básicas: Create Delete Open Close Reset Read, Get (In_File o Inout_File) Write, Put (Out_File, Append_File or Inout_File) Name: devuelve el nombre del fichero

Mode: devuelve el modo del fichero Form: devuelve Form Index: devuelve el Index Is_Open: True si el fichero está abierto End_of_File: True si Index apunta al último elemento


FICHEROS DE ACCESO SECUENCIAL with Ada.io_exceptions; generic type element_type(<>) is private; package Ada.Sequential_io is type file_type is limited private; type file_mode is (In_File,Out_File,Append_File); -- Gestión de ficheros procedure create(file:in out file_type; mode:in file_mode:=out_file; name:in string:=""; form:in string:=""); procedure open(file:in out file_type; mode:in file_mode; name:in string; form:in string:=""); procedure close(file:in out file_type); procedure delete(file:in out file_type); procedure reset(file:in out file_type; mode:in file_mode); procedure reset(file:in out file_type); function mode(file:in file_type)return file_mode; function name(file:in file_type)return string; function form(file:in file_type)return string; function is_open(file:in file_type)return boolean; ...

318


319

FICHEROS DE ACCESO SECUENCIAL ... -- Operaciones de entrada/salida procedure read(file:in file_type; item:out element_type); procedure write(file:in file_type; item:in element_type); function end_of_file(file:in file_type)return boolean; -- Excepciones ... private -- Dependiente de la implementación end Ada.sequential_io;

Hay otro paquete similar para ficheros de acceso directo: Ada.Direct_IO. Primitivas adicionales: procedure SET_INDEX (FILE,TO); function function

INDEX (File) return POSITIVE_COUNT;; SIZE (File) return COUNT;


320

FICHEROS DE TEXTO with Ada.io_exceptions; package Ada.text_io is type file_type is limited private; type file_mode is (in_file,out_file, append_file); -- Nº de columna en una línea y de línea -- en una página, y formatos type count is range 0..dep_implementación; subtype positive_count is count range 1..count'last; unbounded:constant count:=0; subtype field is integer range 0..dep_implementación; subtype number_base is integer range 2..16; type type_set is (lower_case,upper_case); -- Gestión de ficheros: create, open, close, delete, reset, mode, -- name, form e is_open son iguales que en sequential_io -- Control de ficheros de e/s por defecto procedure set_output(file:in file_type); function standard_output return file_type; function current_output return file_type; -- Lo mismo para entrada, con 'input' ...


321

FICHEROS DE TEXTO ... -- Especificación de longitudes de línea y página procedure set_line_length(to:in count); procedure set_page_length(to:in count); function line_length return count; function page_length return count; -- Lo mismo con un parámetro file -- Control de columnas, líneas y páginas procedure new_line(spacing:in positive_count:=1); procedure skip_line(spacing:in positive_count:=1); function end_of_line return boolean; procedure new_page; procedure skip_page; function end_of_page return boolean; function end_of_file return boolean; procedure set_col(to:in positive_count); procedure set_line(to:in positive_count); function col return positive_count; function line return positive_count; function page return positive_count; -- Lo mismo con un parámetro file ...


322

FICHEROS DE TEXTO ... -- Entrada/salida de caracteres procedure get(item:out character); procedure put(item:in character); -- Lo mismo con un parámetro file -- Entrada/salida de cadenas de caracteres procedure get(item:out string); procedure put(item:in string); procedure get_line(item:out string; last:out natural); procedure put_line(item:in string); -- Lo mismo con un parámetro file ...


323

FICHEROS DE TEXTO Entradas-salidas de números enteros: subpaquete genérico. ... -- Paquete genérico de e/s de enteros generic type num is range <>; package integer_io is default_width:field:=num'width; default_base:number_base:=10; procedure get(item:out num; width:in field:=0); procedure put(item:in num; width:in field:= default_width; base:in number_base:= default_base); -- Lo mismo con un parámetro file procedure get(from:in string; item:out num; last:out positive); procedure put(to:out string; item:in num; base:in number_base:= default_base); end integer_io; ...


324

FICHEROS DE TEXTO Entradas-salidas de números de tipo módulo: subpaquete genérico.

... -- Paquete genérico de e/s de enteros modulo generic type num is mod <>; package modular_io is -- Lo mismo que en Integer_IO end modular_io ; ...


325

FICHEROS DE TEXTO Entradas-salidas de números coma flotante: subpaquete genérico. ... -- Paquete genérico de e/s de tipos reales(de coma flotante) generic type num is digits <>; package float_io is default_fore:field:=2; default_aft:field:=num'digits-1; default_exp:field:=3; procedure get(item:out num; width:in field:=0); procedure put(item:in num; fore:in field:=default_fore); -- Lo mismo con un parámetro file procedure get(from:in string; item:out num; last:out positive); procedure put(to:out string; item:in num; aft:in field:=default_aft; exp:in field:=default_exp); end float_io; ...


326

FICHEROS DE TEXTO Entradas-salidas de números coma fija: subpaquete genérico.

... -- Paquete genérico de e/s de tipos reales -- (de coma fija) generic type num is delta <>; package fixed_io is default_fore:field:=num’fore; default_aft:field:=num'aft; default_exp:field:=0; -- Lo mismo que en Float_IO end fixed_io ; ...


327

FICHEROS DE TEXTO Entradas-salidas de tipos enumerados: subpaquete genérico. ... -- Módulo genérico de e/s de tipos definidos por enumeración generic type enum is (<>); package enumeration_io is default_width:field:=0; default_setting:type_set:=upper_case; procedure get(item:out enum); procedure put(item:in enum; width:in field:= default_width; set:in type_set:= default_setting); -- Lo mismo con un parámetro file procedure get(from:in string; item:out enum; last:out positive); procedure put(to:out string; item:in enum; set:in type_set:= default_setting); end enumeration_io; -- Excepciones ... private -- Dependiente de la implementación end Ada.text_io;


328

FICHEROS DE TEXTO Los paquetes genéricos de Text_IO deben ser instanciados: with Ada.Text_IO; procedure Demo_Text_IO is type type type type

INDEX is range 0..100; PROBABILITY is digits 6 range 0.0..1.0; SENSOR_READING is delta 0.01 range -2.0..2.0; COIN is (Penny,Nickel,Dime,Quarter);

-- instantiation of I/O packages package package package package

INDEX_IO is new Ada.Text_IO.Integer_IO(INDEX); PROBABILITY_IO is new Ada.Text_IO.Float_IO(PROBABILITY); SENSOR_IO is new Ada.Text_IO.Fixed_IO(SENSOR_READING); COIN_IO is new Ada.Text_IO.Enumeration_IO(Coin);

-- lets make the IO operation directly visible -- to avoid a full scope specification use Text_IO, INDEX_IO,PROBABILITY_IO, SENSOR_IO, COIN_IO; -- The Put and Get operations are now over -- loaded with the types: Character,String, ...


329

FICHEROS DE TEXTO I P S C

: : : :

Index := 0; Probability := 0.0; Sensor_Reading := 0.0; Coin := Penny;

begin Put_Line("Enter an Index: "); Get(I); Put("You entered: "); Put(I); New_Line; Put_Line("Enter a Proability: "); Get(P); Put("You entered: "); Put(P); New_Line; Put_Line("Enter a Sensor_Reading: "); Get(S); Put("You entered: "); Put(S); New_Line; Put_Line("Enter a Coin: "); Get(C); Put("You entered: "); Put(C); New_Line; end Demo_Text_IO;



PROGRAMACIÓN CONCURRENTE. ADA95

330


331

ASPECTOS BÁSICOS Primitivas de concurrencia en Ada95 Procesos → task Monitores → protected Comunicación síncrona: cita extendida → entry Selección indeterminista → select Otros: » Requeue » Asynchronous transfert of control


332

TAREAS

En Ada95: Procesos = tareas (task) El manejo de tareas en Ada95 es realizado por un núcleo (RTS) que forma parte del entorno de ejecución.

Una tarea tiene dos partes: Especificación: declaración de los puntos de entrada Cuerpo


333

UN EJEMPLO Dos bucles de control: temperatura y nivel Especificación:

with TIPOS_BASICOS; use TIPOS_BASICOS; with ENT_SAL; use ENT_SAL; with METODOS_CONTROL ; use METODOS_CONTROL ; procedure SISTEMA_DE_CONTROL is task CONTROL_DE_TEMPERATURA ; task CONTROL_DE_NIVEL ;


334

UN EJEMPLO Cuerpo:

task body CONTROL_DE_TEMPERATURA is T: TEMPERATURA ; C: AJUSTE_DE_CALEFACTOR ; begin loop -- cada periodo de muestreo MEDIR(T) ; CALCULAR_ACCION(T,C) ; GENERAR(C) ; MOSTRAR(T) ; end loop ; end CONTROL_DE_TEMPERATURA ; task body CONTROL_DE_NIVEL is … begin … end CONTROL_DE_NIVEL ; begin -- SISTEMA_DE_CONTROL null ; end SISTEMA_DE_CONTROL ;


335

TIPOS TAREA Es útil poder definir grupos de tareas similares. La declaración de un tipo tarea permite disponer de una plantilla para crear tareas similares. Ejemplo: Control del brazo de un robot cartesiano procedure CONTROL_DE_ROBOT is type DIMENSION is (X,Y,Z) ; task type CONTROL is … end CONTROL ; SISTEMA_DE_CONTROL: array (DIMENSION) of CONTROL ;


336

TIPOS TAREA task body CONTROL is EJE: DIMENSION ; POSICION: integer ; DESPLAZAMIENTO: integer ; begin -- obtener el valor de EJE POSICION:= 0 ; loop CALCULAR_DESPLAZAMIENTO(EJE, DESPLAZAMIENTO) ; POSICION := POSICION+DESPLAZAMIENTO ; MOVER_BRAZO(EJE, POSICION) ; end loop ; end CONTROL ; begin -- CONTROL_DE_ROBOT for I in DIMENSION loop -- pasar el valor I -- SISTEMA_DE_CONTROL(I) end loop ; end CONTROL_DE_ROBOT;


337

TAREAS DINÁMICAS Se pueden crear dinámicamente tareas con un tipo acceso y el operador new. Las variables de acceso a tarea se pueden copiar y comparar declare task type T ; type REF_T is access T ; P: REF_T ; Q: REF_T := new T ; -- Q.all arranca begin P:= new T ; -- P.all arranca Q:= P ; -- la anterior se -- vuelve anonima end ;


338

DEPENDENCIA, ACTIVACIÓN, TERMINACIÓN Toda tarea depende de una unidad progenitora. Las tareas estáticas: Dependen del bloque, subprograma o cuerpo de tarea donde se declaran. Se activan justo antes de empezar la ejecución de la unidad progenitora. Una unidad no puede terminar hasta que terminen todas las tareas que dependen de ella. Las tareas dinámicas siguen reglas diferentes: No dependen de la unidad donde se crean, sino de la unidad donde se declara el tipo acceso. Se activan cuando se ejecuta el operador new. Pueden seguir existiendo después de que termine la unidad donde se crean.


DEPENDENCIA, ACTIVACIÓN, TERMINACIÓN Ejemplo:

declare task type T ; type REF_T is access T ; begin … declare X: T ; Y: REF_T := new T; begin … end ; -- espera que termine X … -- Y.all puede continuar end ; -- espera que termine Y.all

Una tarea puede terminar cuando: Completa la ejecución de su cuerpo. Se pone de acuerdo con otras tareas para terminar conjuntamente. Es abortada.

339


340

COMUNICACIÓN ENTRE TAREAS Cita extendida (rendez-vous)

Algunas características: Si varias tareas invocan a un mismo punto de entrada de otra tarea, se colocan en una cola (asociada a ese punto de entrada) » FIFO » Prioridad » Otras ...

La tarea que invoca un punto de entrada tiene que identificar a la tarea a la cual llama. Esta última no identifica a la tarea llamadora (puede ser cualquiera) A veces conviene que una tarea llamadora se identifique a sí misma mediante algún parámetro Se pueden definir familias de puntos de entrada


341

COMUNICACIÓN ENTRE TAREAS Volvemos al ejemplo del control del brazo de un robot cartesiano: ejemplo de entrada de inicialización.

procedure CONTROL_DE_ROBOT is type DIMENSION is (X,Y,Z) ; task type CONTROL is entry INICIAR(D: DIMENSION) ; end CONTROL ; SISTEMA_DE_CONTROL: array (DIMENSION) of CONTROL ;


COMUNICACIÓN ENTRE TAREAS task body CONTROL is EJE: DIMENSION ; POSICION: integer ; DESPLAZAMIENTO: integer ; begin accept INICIAR(D: DIMENSION) do EJE:= D ; end INICIAR ; POSICION:= 0 ; loop CALCULAR_DESPLAZAMIENTO(EJE, DESPLAZAMIENTO) ; POSICION := POSICION+DESPLAZAMIENTO ; MOVER_BRAZO(EJE, POSICION) ; end loop ; end CONTROL ; begin -- CONTROL_DE_ROBOT for I in DIMENSION loop SISTEMA_DE_CONTROL(I).INICIAR(I) ; end loop ; end CONTROL_DE_ROBOT;

342


343

SELECCIÓN DE LLAMADAS A veces no es posible prever en qué orden se van a invocar los distintos puntos de llamada de una tarea (por ejemplo en tareas servidoras --> proporcionan un servicio). Por ejemplo un monitor: task VARIABLE_COMUN is entry MODIFICAR(VALOR: TIPO) ; entry EXAMINAR(VALOR: out TIPO) ; end VARIABLE_COMUN ;

Alternancia estricta entre MODIFICAR y EXAMINAR

task body VARIABLE_COMUN is VARIABLE: TIPO ; begin loop accept MODIFICAR(VALOR: TIPO) do VARIABLE:= VALOR ; end MODIFICAR ; accept EXAMINAR(VALOR: out TIPO) do VALOR:= VARIABLE ; end EXAMINAR ; end loop ; end VARIABLE_COMUN ;


344

SELECCIÓN DE LLAMADAS Selección indeterminista: Es una estructura de control indeterminista que sólo puede ir en el cuerpo de una tarea: select or or … end select ;

Cada alternativa es una instrucción select que puede ir seguida de una secuencia de instrucciones.

Funcionamiento: Si se recibe una llamada a una de las entradas alternativas, se acepta y después se termina el select. Si se reciben llamadas a varias entradas simultáneamente, se acepta una de ellas de acuerdo a la política de colas establecida y después se termina el select. Si no hay llamadas pendientes, la tarea espera en el select hasta que llegue una.


345

SELECCIÓN DE LLAMADAS El ejemplo del monitor arreglado:

task body VARIABLE_COMUN is VARIABLE: TIPO ; begin loop select accept MODIFICAR(VALOR: TIPO) do VARIABLE:= VALOR ; end MODIFICAR ; or accept EXAMINAR(VALOR: out TIPO) do VALOR:= VARIABLE ; end EXAMINAR ; or terminate ; end select ; end loop ; end VARIABLE_COMUN ;

La alternativa terminate se selecciona cuando el progenitor está completado y todas las tareas hermanas o dependientes están completadas o esperando en un select con terminate. En este caso terminan todas simultáneamente.


346

OTRAS FORMAS DE ALTERNATIVAS Alternativas con else:

select … else -- secuencia de instrucciones end select ;

Si no se puede aceptar ninguna alternativa, se ejecuta la parte else. Hay también llamadas condicionales a puntos de entrada: select T.E(…) ; else -- instrucciones end select ;

Si la llamada no es aceptada inmediatamente, se abandona y se ejecuta la parte else. En esta forma no puede haber alternativas.


347

ALTERNATIVAS GUARDADAS A veces es necesario que alguna de las alternativas de un select se acepte sólo en determinadas condiciones. Esto se hace poniendo una guarda: when => accept do ...

En un select con guardas, se evalúan todas las guardas y sólo se consideran para la selección las que son ciertas (alternativas abiertas). Una alternativa sin guarda está siempre abierta.


348

ALTERNATIVAS GUARDADAS Ejemplo: un semáforo

task SEMAFORO is entry ESPERAR ; entry AVISAR ; end SEMAFORO ; task body SEMAFORO is VALOR: natural := 0 ; begin loop select when VALOR > 0 => accept ESPERAR ; VALOR := VALOR - 1 ; or accept AVISAR ; VALOR := VALOR + 1 ; or terminate ; end select ; end loop ; end SEMAFORO ;


349

PROTECTED Tienen una semántica similar a los monitores: Permiten controlar el acceso a datos compartidos por varios procesos Son pasivos, a diferencia de las tareas Ofrece tres clases de operaciones » Protected procedures: acceso en exclusión mútua a los datos protegidos » Protected functions: acceso concurrente, sólo lectura, a los datos » Entries: como las procedures, pero permiten especificar “barriers” (guardas).

Se pueden definir objetos y tipos protegidos (similar a las tareas).


350

EJEMPLO DE PROTECTED generic type Data_Item is private ; Mbox_size: positive ; package Mailbox_Pkg is subtype Data_Item_Count is integer range 0 .. Mbox_Size; subtype Data_Item_Index is integer range 1 .. Mbox_Size; type Data_Item_Array is array(Data_Item_Index) of Data_Item ; protected type Mailbox is entry Send (Item : Data_Item); entry Receive (Item : out Data_Item); procedure Clear; function Number_In_Box return Integer; private Count : Data_Item_count := 0; Out_Index : Data_Item_Index := 1; In_Index : Data_Item_Index := 1; Data : Data_Item_Array ; end Mailbox; end Mailbox_Pkg;


351

EJEMPLO DE PROTECTED package body Mailbox_Pkg is protected body

Mailbox is

entry Send ( Item : Data_Item) when Count < Mbox_Size is -- block until room begin Data ( In_Index ) := Item; In_Index := In_Index mod Mbox_size + 1; Count := Count + 1; end Send; entry Receive ( Item : out Data_Item ) when Count > 0 is -- block until non-empty begin Item := Data( Out_Index ); Out_Index := Out_Index mod Mbox_Size + 1; Count := Count -1; end Receive;


352

EJEMPLO DE PROTECTED procedure Clear is --only one user in Clear at a time begin Count := 0; Out_Index := 1; In_Index := 1; end Clear; function Number_In_Box return Integer is -- many users can check # in Box begin return Count; end Number_In_Box; end Mailbox; end Mailbox_Pkg;


353

PROTECTED Uso del protected

with mailbox_pkg ; procedure mp is package Integer_Mailbox_pkg is new Mailbox_pkg(integer, 100) ; use Integer_Mailbox_pkg ; MB: Mailbox ; i: integer ; begin ... MB.send (100) ; ... MB.receive (i) ; ... if MB.Number_In_Box > 0 then ... end if ; ... end ;


354

PRIVATE ENTRIES Existen varias razones para que una tarea declare como privada una entrada (no pública): La tarea tiene varias tareas declaradas internamente; estas tareas internas tienen acceso a las entradas privadas La entrada es usada internamente en una primitiva requeue La entrada tiene asociada una interrupción de hardware y el programador no quiere que ninguna otra tarea llame a esa entrada. Ejemplo de declaración y uso:

procedure Aplicacion is task Usuario ; task Controlador is entry Lectura(I: out integer); private entry Comienzo ; entry Completado (K: integer) ; end Controlador ; task body Usuario is ... -- Incluye llamadas -- a Lectura


355

REQUEUE Existen situaciones en las cuales las guardas no son suficientes: La aceptación de una cita no depende únicamente del estado del aceptador si no también del llamador » para aceptar o no una cita de haber un intercambio previo de información

Ejemplo: type Request_Range is range 1..Max ; protected Resource_Controller is entry Allocate (R: out Resource; Amount: Request_Range) ; procedure Release (R: Resource ; Amount: Request_Range) ; private ... end Resource_Controller ;


356

REQUEUE Solución: Entrada privada para encolar los pedidos que no pueden ser aceptados Los pedidos son tramitados type Request_Range is range 1..Max ; protected Resource_Controller is entry Allocate (R: out Resource; Amount: Request_Range) ; procedure Release (R: Resource ; Amount: Request_Range) ; private entry Assign (R: out Resource; Amount: Request_Range) ; Free: Request_Range := Request_Range’Last ; New_Resources_Released: Boolean:= False ; To_Try: Natural := 0 ; ... end Resource_Controller ;


357

REQUEUE

protected body Resource_Controller is entry Allocate (R: out Resource; Amount: Request_Range) when Free > 0 is begin if Amount<= Free then Free:= Free - Amount ; -- Allocate else requeue Assign ; end if ; end Allocate ;


358

REQUEUE

entry Assign (R: out Resource; Amount: Request_Range) when New_Resources_Released is begin To_Try := To_Try - 1 ; if To_Try = 0 then New_Resources_Released := False ; end if ; if Amonut <= Free then Free := Free - Amount ; -- allocate else requeue Assign ; end if ; end Assign ;


359

REQUEUE

procedure Release (R: Resource ; Amount: Request_Range) is begin Free := Free + Amount ; -- Free resources if Assign’count > 0 then To_Try := Assign’Count ; New_Resources_Released:= true ; end if ; end Release ; end Resource_Controller ;


360

ASYNCHRONOUS TRANSFER OF CONTROL codigo_abortable es ejecutado si la llamada no puede ser aceptada inmediatamente Si la llamada puede ser aceptada antes de que haya finalizado la ejecución de codigo_abortable, dicha ejecución es abortada Si codigo_abortable acaba su ejecución entonces la llamada es cancelada

select entry_call_statement then abort codigo_abortable end select ;


ASYNCHRONOUS TRANSFER OF CONTROL Ejemplo:

loop select Terminal.Wait_For_Interrupt; Ada.Text_IO.Put_Line(“Interrupted”); then abort Ada.Text_IO.Put_Line(“Enter Command--> “); Ada.Text_IO.Get_Line(Command, Last); Parse_and_Process (Command (1..Last) ) ; end select ; end loop; end Poll_Device;

361



MEDIDA Y CONTROL DEL TIEMPO EN ADA95

362


363

MEDIDA DE TIEMPOS EN ADA95 En Ada hay dos paquetes predefinidos que proporcionan funciones de reloj: Ada.Calendar » Reloj calendario orientado a dar la fecha y la hora » Define un tipo abstracto Time » La función Clock da un valor de tiempo para uso externo » Los intervalos de tiempo se representan con el tipo predefinido Duration

Ada.Real_Time » Reloj de tiempo real con granularidad más pequeña » Define un tipo abstracto Time » La función Clock da un valor monótono (durante más de 50 años desde el arranque de la aplicación) » Los intervalos de tiempo se representan con el tipo abstracto Time_Span


364

MEDIDA DE TIEMPOS EN ADA95 DURATION: Es un tipo predefinido que representa intervalos de tiempo en segundos. Es un tipo coma fija => no se pierde precisión al sumar o restar intervalos de tiempo: type DURATION is delta … range … ; Su precisión depende de la implementación. Su valor, DURATION'SMALL, no debe ser mayor de 20 ms, aunque se recomienda que no sobrepase los 50 µs. El intervalo de valores también depende de la implementación. Debe poder representar valores positivos y negativos hasta la duración de un día: -86400.0 .. +86400.0


365

Ada.Calendar TIME: Representa valores de tiempo absolutos. Es un tipo abstracto de dato especificado en un paquete predefinido denominado CALENDAR. Este paquete incluye un reloj, cuyo valor se lee con la función CLOCK, además de operaciones con los tipos TIME y DURATION. package Ada.Calendar is type TIME is private ; subtype subtype subtype subtype

YEAR_NUMBER is integer range 1901..2099 ; MONTH_NUMBER is integer range 1..12 ; DAY_NUMBER is integer range 1..31 ; DAY_DURATION is DURATION range 0.0..86400.0 ;

function CLOCK return TIME ;


366

Ada.Calendar function YEAR (DATE: TIME) return YEAR_NUMBER ; function MONTH (DATE: TIME) return MONTH_NUMBER ; function DAY (DATE: TIME) return DAY_NUMBER ; function SECONDS(DATE: TIME) return DAY_DURATION ; procedure SPLIT(DATE: in TIME ; YEAR: out YEAR_NUMBER ; MONTH: out MONTH_NUMBER ; DAY: out DAY_NUMBER ; SECONDS: out DAY_DURATION); function TIME_OF(YEAR: YEAR_NUMBER ; MONTH: MONTH_NUMBER ; DAY: DAY_NUMBER ; SECONDS:DAY_DURATION:=0.0) return TIME ;


367

Ada.Calendar function function function function

"+" "+" "-" "-"

(LEFT: (LEFT: (LEFT: (LEFT:

TIME; RIGHT: DURATION) return TIME ; DURATION; RIGHT: TIME) return TIME ; TIME; RIGHT: DURATION) return TIME ; TIME; RIGHT: TIME) return DURATION;

function function function function

"<" (LEFT, RIGHT: TIME) return boolean ; "<=" (LEFT, RIGHT: TIME) return boolean ; ">" (LEFT, RIGHT: TIME) return boolean ; ">=" (LEFT, RIGHT: TIME) return boolean ;

TIME_ERROR: exception ; private -- depende de la implementacion end;


368

Ada.Real_Time En el anexo Real-Time Systems se define un paquete para manejo del tiempo en aplicaciones de tiempo real: tiempo monotónico y reloj de alta resolución package Ada.Real_Time is type Time is private; Time_First : constant Time; Time_Last : constant Time; Time_Unit : constant := implementation-defined-real-number; type Time_Span is private; Time_Span_First : constant Time_Span; Time_Span_Last : constant Time_Span; Time_Span_Zero : constant Time_Span; Time_Span_Unit : constant Time_Span; Tick : constant Time_Span; function Clock return Time;


369

Ada.Real_Time


"+" "+" "-" "-"

(Left: (Left: (Left: (Left:


"<" (Left, "<="(Left, ">" (Left, ">="(Left,

function function function function function

"+" "-" "-" "*" "*"

Time; Right: Time_Span) return Time; Time_Span; Right: Time) return Time; Time; Right: Time_Span) return Time; Time; Right: Time) return Time_Span; Right: Right: Right: Right:

Time) Time) Time) Time)

return return return return

Boolean; Boolean; Boolean; Boolean;

(Left, Right: Time_Span) return Time_Span; (Left, Right: Time_Span) return Time_Span; (Right: Time_Span) return Time_Span; (Left: Time_Span; Right: Integer) return Time_Span; (Left: Integer; Right: Time_Span) return Time_Span;


370

Ada.Real_Time

function "/" (Left, Right : Time_Span) return Integer; function "/" (Left: Time_Span; Right: Integer) return Time_Span; function "abs"(Right : Time_Span) return Time_Span; function function function function

"<" (Left, "<="(Left, ">" (Left, ">="(Left,

Right Right Right Right

: : : :

Time_Span) Time_Span) Time_Span) Time_Span)

return return return return

Boolean; Boolean; Boolean; Boolean;


371

Ada.Real_Time function To_Duration (TS : Time_Span) return Duration; function To_Time_Span (D : Duration) return Time_Span; function Nanoseconds (NS : Integer) return Time_Span; function Microseconds (US : Integer) return Time_Span; function Milliseconds (MS : Integer) return Time_Span; type Seconds_Count is range implementation-defined; procedure Split(T : in Time; SC : out Seconds_Count; TS : out Time_Span); function Time_Of(SC : Seconds_Count; TS : Time_Span) return Time; private ... -- not specified by the language end Ada.Real_Time;


372

RETARDOS Y TIME-OUTS Los retardos en Ada95 se pueden realizan mediante dos instrucciones: delay ; delay until ; » Calendar.Time » Ada.Real_Time.Time


373

RETARDOS Y TIME-OUTS En Ada95, las relaciones con el entorno toman la forma de llamadas o aceptaciones de puntos de entrada. Conviene limitar el tiempo durante el cual una tarea puede estar suspendida llamando, aceptando o en selección de entradas. La limitación del tiempo de aceptación o selección se hace mediante una selección temporizada: select accept … or … or delay ; -- delay until ; end select ;

NOTA: el select puede tener como máximo: una parte else o una alternativa terminate o una o varias alternativas delay.


374

TIME-OUT task body VARIABLE_COMUN is CONTENIDO: VALOR ; DEFECTO: constant VALOR := … ; begin -- si en 10s no se modifica => defecto select accept MODIFICAR (V: VALOR) do CONTENIDO:= V ; end MODIFICAR ; or delay 10.0 CONTENIDO:= DEFECTO ; end select ; loop select accept MODIFICAR(VALOR: TIPO) do VARIABLE:= VALOR ; end MODIFICAR ; or ... end VARIABLE_COMUN ;


375

TIME-OUT Llamadas temporizadas Las llamadas temporizadas sirven para limitar el tiempo de espera en las llamadas a puntos de entrada. Un ejemplo:

task body CONTROL is begin loop … select CAPTADOR.MEDIR(Y) ; -- aqui puede haber una secuencia -- de instrucciones or delay 0.10 ; raise CAPTADOR_AVERIADO ; end select ; … end loop ; end CONTROL ;


376

RETARDOS Y TIME-OUTS En Ada95 se puede limitar el tiempo de ejecución de un código mediante un Asynchronous Transfer of Control:

select delay Time_out ; then abort codigo_con_plazo_de_respuesta ; end select ;


377

PRIORIDADES En Ada95 se asigna una prioridad a una tarea (o protected) o a todas las tareas (protected) de un tipo incluyendo un pragma PRIORITY en la especificación correspondiente:

task T is pragma PRIORITY() ; … end T ; task type TT is pragma PRIORITY() ; … end TT ;


378

PRIORIDADES La prioridad es una expresión estática del tipo predefinido SYSTEM.PRIORITY, que a su vez es un subintervalo del tipo integer. El intervalo de valores depende de la implementación. Los valores más altos corresponden a las tareas más prioritarias.

subtype Any_Priority is Integer range implementation-defined ; subtype Priority is Any_Priority range Any_Priority’first..implementation-defined ; subtype Interrupt_Priority is Any_Priority range Priority’last.. Any_Priority’last;


379

PRIORIDADES Propiedades del modelo de prioridades de Ada95: La planificación es expulsiva. Las prioridades son estáticas aunque se pueden cambiar explícitamente en tiempo de ejecución. Todas las tareas del mismo tipo tienen la misma prioridad. Existen pragmas que pueden configurar la política de planificación del RTS


380

POLITICAS DE PLANIFICACIÓN pragma Task_Dispatching_Policy (policy_identifier) Permite la política de planificación del RTS FIFO_Within_Priorities es la única política requerida y es la de defecto Los compiladores pueden implementar otras políticas pragma Locking_Policy (policy_identifier) Política de interacción entre las tareas y los objetos protegidos Ceiling_Locking está predefinida Los compiladores pueden implementar otras políticas pragma Queuing_Policy (policy_identifier) Especifica como se encolan las llamadas a un entry FIFO_Queuing y Priority_Queuing están predefinidas Los compiladores pueden implementar otras políticas


381

PRIORIDADES En Ada95 se puede cambiar de forma dinámica las prioridades de las tareas: with System; with Ada.Task_Identification; package Ada.Dynamic_Priorities is procedure Set_Priority (Priority: in System.Any_Priority; T : in Ada.Task_Identification.Task_ID := Ada.Task_Identification.Current_Task); function Get_Priority (T : Ada.Task_Identification.Task_ID := Ada.Task_Identification.Current_Task) return System.Any_Priority; end Ada.Dynamic_Priorities;



PROGRAMACIÓN DE BAJO NIVEL

382


383

Mecanismos de bajo nivel en Ada95 Ada 95 tiene varios mecanismos de bajo nivel que permiten acceder a registros, direcciones e interrupciones cláusulas de representación » permiten especificar la representación de tipos y objetos en la arquitectura de hardware –

atributos de representación (tamaño, dirección, alineación)

–

representación de tipos enumerados

–

representación de registros

manejadores de interrupciones » permiten asociar una interrupción a un procedimiento protegido

subprogramas en lenguaje de máquina » permiten un control total sobre la arquitectura de hardware


384

Paquete System En cada implementación de un compilador Ada95 hay un paquete predefinido (SYSTEM) que incluye la definición de características dependientes de la máquina, importantes para la programación bajo nivel. package System is pragma Preelaborate(System); type Name is implementation-defined-enumeration-type; System_Name : constant Name := implementation-defined; -- System-Dependent Named Numbers: Min_Int : constant := root_integer'First; Max_Int : constant := root_integer'Last; ... Tick : constant := implementation-defined; -- Storage-related Declarations: type Address is implementation-defined; Null_Address : constant Address; ...


385

Paquete System -- Address Comparison: function "<" (Left, Right : Address) return Boolean; function "<="(Left, Right : Address) return Boolean; ... -- Other System-Dependent Declarations: type Bit_Order is (High_Order_First, Low_Order_First); Default_Bit_Order : constant Bit_Order; -- Priority-related declarations (see D.1): subtype Any_Priority is Integer range implementation-defined; subtype Priority is Any_Priority range Any_Priority'First .. implementation-defined; subtype Interrupt_Priority is Any_Priority range Priority'Last+1 .. Any_Priority'Last; Default_Priority : constant Priority := (Priority'First + Priority'Last)/2; private ... -- not specified by the language end System;


ATRIBUTOS DE REPRESENTACION Para cualquier objeto, unidad de programa, etiqueta o entry X: X’address Para cualquier tipo o subtipo, u objeto X: X’size (en bits) Para cualquier tipo acceso o subtipo T: T’storage_size (en unidades de memoria) Para cualquier tipo tarea u objeto tarea T: T’storage_size (en unidades de memoria) Para cualquier componente C de un registro R: R.C’position (en unidades de memoria) R.C’first_bit (en bits) R.C’last_bit (en bits)

386


CLAUSULAS DE REPRESENTACIÓN Dirección del objeto: DATOS: REGISTRO_DE_DATOS; for DATOS’Address use System.Storage_Elements.To_Address(16#C200#) ;

Longitud (en bits) de los objetos de un tipo: type CANAL is range 0..63; for CANAL'SIZE use 6;

Representación de un tipo enumerado: type INDICADOR is (SI,NO); for INDICADOR use (SI => 1, NO => 0) ;

Alineación for REGISTRO_DE_DATOS’Alignment use 2;

387


388

CLAUSULAS DE REPRESENTACION Estructura de un registro type REGISTRO_DE_CONTROL is record ARRANCA : INDICADOR; INTERRUMPE: INDICADOR; TERMINADO : INDICADOR; ENTRADA : CANAL; ERROR : INDICADOR; end record;

for REGISTRO_DE_CONTROL use record ARRANCA at 0 range 0..0 INTERRUMPE at 0 range 6..6 TERMINADO at 0 range 7..7 ENTRADA at 1 range 0..5 ERROR at 1 range 7..7 end record;

; ; ; ; ;


389

CONVERSIÓN DE TIPOS A veces hay que interpretar un dato de un tipo como si fuera de otro tipo, copiando directamente su representación binaria. Se hace con un procedimiento genérico predefinido:

generic type SOURCE (<>) is limited private ; type TARGET (<>) is limited private ; function Ada.Unchequed_Conversion(S: SOURCE) return TARGET ;


390

CONVERSIÓN DE TIPOS Ejemplo: with unchecked_conversion, text_io ; procedure pru_to_word is type byte is range 0..16#FF# ; for byte'size use 8 ; type two_byte is record L: byte ; H: byte ; end record ; pragma pack (two_byte) ; for two_byte'size use 16 ; type word is range 0..16#FFFF# ; for word'size use 16 ; package wio is new text_io.integer_io (word) ; use wio ; function to_word is new unchecked_conversion (source => two_byte, target => word) ; begin put (to_word(two_byte'(1,1))) ; end ;


391

INTERRUPCIONES Los manejadores de interrupciones son procedimientos protegidos sin parámetros. Cada interrupción tiene un identificador único de tipo Interrupt_Id (definido en el paquete Ada. Interrupts ) El pragma Attach_Handler especifica que un procedimiento protegido es un manejador asociado a una interrupción pragma Attach_Handler (Handler_Name, Interrupt) ;

El pragma Interrupt_Handler permite especificar que un procedimiento protegido es un manejador, pero no lo asocia con ninguna interrupción » la asociación con una interrupción se hace dinámicamente pragma Interrupt_Handler (Handler_Name) ;


392

INTERRUPCIONES Se puede especificar la prioridad del manejador de una interrupción el pragma Interrupt_Priority en la especificación del objeto protegido pragma Interrupt_Priority (Priority_Value) ;

El valor de la prioridad debe pertenecer al subtipo: » System.Interrupt_Priority


393

INTERRUPCIONES

package Ada.Interrupts is type Interrupt_ ID is ...; type Parameterless_ Handler is access protected procedure; function Is_Reserved (Interrupt : Interrupt_ ID) return Boolean; function Is_Attached (Interrupt : Interrupt_ ID) return Boolean; function Current_Handler (Interrupt : Interrupt_ ID) return Parameterless_Handler; procedure Attach_Handler (New_Handler : Parameterless_ Handler; Interrupt : Interrupt_ ID); procedure Exchange_Handler (Old_Handler: out Parameterless_Handler; New_Handler: Parameterless_ Handler; Interrupt: Interrupt_ID); procedure Detach_Handler (Interrupt : Interrupt_ ID); ... end Ada. Interrupts;


394

INTERRUPCIONES protected body Interrupt_Handler is

E j e m p l o

procedure Handler is begin -- Code of handler Interrupt_Ocurred := true ; end ; entry Wait_for_Event when Interrupt_Ocurred is begin ... Interrupt_Ocurred := false ; ... end ; protected Interrupt_Handler is entry Wait_for_Event ; end ; private procedure Handler ; pragma Attach_Handler (Handler, Int_ID) ; pragma Interrupt_Priority (…) ; Interrupt_Ocurred : boolean := false ; end ;


395

SUBPROGRAMAS EN LENGUAJE MAQUINA A veces es necesario realizar algún componente de software en lenguaje ensamblador. En Ada95 se pueden escribir procedimientos en ensamblador de forma controlada, utilizando un paquete predefinido denominado MACHINE_CODE. Las instrucciones de estos procedimientos son todas de la forma: tipo'agregado donde tipo es un tipo registro definido en MACHINE_CODE que representa un formato de instrucción de máquina, y agregado es del tipo anterior. Además, puede haber pragmas específicos para indicar el uso de los registros del procesador u otras características de bajo nivel.


SUBPROGRAMAS EN LENGUAJE MAQUINA Ejemplo package System.Machine_Code is type OPERACION is (LOAD, STORE, ADD, …,SETI,CLI) ; type OPERANDO is range 0..4095 ; for OPERACION'SIZE use 4 ; for OPERANDO'SIZE use 12 ; type INSTRUCCION is record COP: OPERACION ; OPR: OPERANDO ; end record; for INSTRUCCION use record COP at 0 range 0..3 ; OPR at 0 range 4..15 ; end record; for INSTRUCCION'SIZE use 16 ; end MACHINE_CODE ;

396


SUBPROGRAMAS EN LENGUAJE MAQUINA

procedure INHIBIR_INTERRUPCIONES ; pragma INLINE(INHIBIR_INTERRUPCIONES) ; procedure INHIBIR_INTERRUPCIONES is use MACHINE_CODE; begin INSTRUCCION'(COP => CLI, OPR => 0) ; end INHIBIR_INTERRUPCIONES ;

397


SUBPROGRAMAS EN OTROS LENGUAJES El pragma INTERFACE permite utilizar subprogramas escritos en otros lenguajes de programación. Ejemplo: package FORTRAN_LIB is function SQRT(X: FLOAT) return FLOAT ; function EXP(X: FLOAT) return FLOAT ; … private pragma INTERFACE(FORTRAN, SQRT) ; pragma INTERFACE(FORTRAN, EXP) ; … end FORTRAN_LIB ;

398



EXCEPCIONES EN Ada95

399


400

MODELO. DECLARACIÓN Modelo de terminación. Enlace dinámico El tipo exception está predefinido. Se pueden declarar excepciones: ERROR_DE_PARIDAD: exception; FUERA_DE_LIMITES: exception; EXC1, EXC2: exception;

Hay excepciones predefinidas: » CONSTRAINT_ERROR: Rangos, índices, longitudes. » NUMERIC_ERROR: División por cero, sobrepasamiento. » PROGRAM_ERROR: Acceso a procedimientos, módulos, …, selección, … » STORAGE_ERROR: Variables y memoria dinámica. » TASKING_ERROR: Comunicación y ejecución de tareas.


401

ACTIVACIÓN Explícita (detección de errores por la aplicación): » raise ERROR_DE_PARIDAD ;

Implícita (detección de errores por el entorno): » el compilador genera el código para levantar las excepciones predefinidas.


402

MANEJADOR Manejador: se situa al final de un bloque, procedimiento o función, paquete o tarea. Maneja las excepciones levantadas en o propagadas hacia ese dominio declare ERROR_DE_PARIDAD: exception; begin … if not PARIDAD (C) then raise ERROR_DE_PARIDAD ; end if ; … exception when ERROR_DE_PARIDAD => ENVIAR(NACK) ; LEER(C) ; when NUMERIC_ERROR => raise ; when others => HACER_ALGO; end ;


403

EJEMPLO. CONVERSIÓN AD package IO_DIGITAL is type VALOR_DIGITAL is limited private ; procedure LEER_VALOR (V: out VALOR_DIGITAL) ; procedure SACAR_VALOR (V: in VALOR_DIGITAL) ; function CONVERTIR (V: in INTEGER) return VALOR_DIGITAL ; ERROR_LECTURA: exception ; ERROR_ESCRITURA: exception ; private type VALOR_DIGITAL is range 0..4095; for VALOR_DIGITAL'SIZE use 12 ; end IO_DIGITAL ;


404

EJEMPLO. CONVERSIÓN AD with IO_DIGITAL; use IO_DIGITAL ; task CONTROL is MAX_SATURACIONES: constant := 5 ; VECES_SATURADO: CARDINAL:= 0; Y, X, K, KI, KP: float ; FUERA_DE_CONTROL: exception ; begin loop … declare ENTRADA, SALIDA: VALOR_DIGITAL; begin LEER_VALOR(ENTRADA); X:= float(ENTRADA) ; Y:= K*X + … ; SALIDA:= VALOR_DIGITAL(Y) ; -- posible desbordamiento de SALIDA SACAR_VALOR(SALIDA) ; VECES_SATURADO:= 0 ;


405

EJEMPLO. CONVERSIÓN AD exception when CONSTRAINT_ERROR => if Y>0 then SACAR_VALOR(4095) ; else SACAR_VALOR(0) ; end if ; VECES_SATURADO:= VECES_SATURADO + 1 ; if VECES_SATURADO >= MAX_SATURACIONES then raise FUERA_DE_CONTROL ; end if ; when ERROR_LECTURA => … ; when ERROR_ESCRITURA => … ; end ; … end loop ; exception ; when FUERA_DE_CONTROL => ABRIR_VALVULA ; SONAR_ALARMA ; when others => … ; end CONTROL ;


EJEMPLO. BLOQUES DE RECUPERACIÓN Implementación de la técnica de los bloques de recuperación mediante excepciones. with recovery_cache; procedure recovery_block is primary_failure, secondary_failure, tertiary_failure: exception; recovery_block_failure : exception; type module is (primary, secondary, tertiary); function acceptance_test return boolean is begin -- code for the acceptance test return true; end acceptance_test;

406


EJEMPLO. BLOQUES DE RECUPERACIÓN

procedure primary is begin -- code for primary algorithm if not acceptance_test then raise primary_failure; end if; exception when primary_failure => -- forward recovery to return environment -- to the required state raise; when others => -- unexpected error -- forward recovery to return environment -- to the required state raise primary_failure; end primary;

407


EJEMPLO. BLOQUES DE RECUPERACIÓN procedure secondary is begin -- code for secondary algorithm if not acceptance_test then raise secondary_failure; end if; exception when secondary_failure => -- forward recovery to return environment -- to the required state raise; when others => -- unexpected error -- forward recovery to return environment -- to the required state raise secondary_failure; end secondary; procedure tertiary is begin ... end tertiary;

408


EJEMPLO. BLOQUES DE RECUPERACIÓN begin recovery_cache.save; for try in module loop begin case try is when primary => primary; exit; when secondary => secondary; exit; when tertiary => tertiary; end case; exception when primary_failure => recovery_cache.restore; when secondary_failure => recovery_cache.restore; when tertiary_failure => recovery_cache.restore; raise recovery_block_failure; when others => recovery_cache.restore; raise recovery_block_failure; end; end loop; end recovery_block;

409

Sistemas de Tiempo Real

Recommend Documents