Sistemas de Tiempo Real

SISTEMAS DE TIEMPO REAL

Optativa de 2 ciclo Ingeniera Informtica Ingeniera de Telecomunicacin Ingeniera Industrial
Jos Luis Villarroel Salcedo

Departamento de Informtica e Ingeniera de Sistemas Centro Politcnico Superior Universidad de Zaragoza
NDICE
Introduccin Nociones sobre concurrencia Medida y control del tiempo Planificacin cclica Planificacin basada en prioridades estticas Planificacin basada en prioridades dinmicas Manejadores de dispositivos Tolerancia a fallos. Excepciones Programacin secuencial. Ada2005 Programacin concurrente. Ada2005 Medida y control del tiempo en Ada2005 Programacin de bajo nivel. Ada2005 Excepciones en Ada2005 3 15 50 91 136 218 246 260 280 323 350 376 393
INTRODUCCIN
DEFINICIN
Un sistema de Tiempo Real es un sistema informtico que: Interacciona con su entorno fsico Responde a los estmulos del entorno dentro de un plazo de tiempo determinado No basta con que las acciones del sistema sean correctas, sino que, adems, tienen que ejecutarse dentro de un intervalo de tiempo determinado.
Los sistemas tiempo real suelen estar integrados en un sistema de ingeniera ms general, en el que realizan funciones de control y/o monitorizacin: SISTEMAS EMPOTRADOS (embedded systems)
CLASES
Sistemas de Tiempo Real: Crticos (hard real-time systems):
los plazos de respuesta deben respetarse siempre estrictamente. una sola respuesta tarda a un suceso externo puede tener consecuencias fatales.
Acrticos (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 explcitos
EJEMPLO
Robot mvil de inspeccin
EJEMPLO
Varias tareas: Control automtico de velocidad y posicin (50 ms) Lectura del lser y evitacin de obstculos (100 ms) Toma de imgenes y procesamiento (1 s)
Reconocimiento de objetos Lectura de matrculas
Comunicacin con la consola

Recepcin de rdenes Envo de imgenes y otros datos ...
CARACTERISTCAS
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 antieconmica 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 diseo
CARACTERISTCAS
Concurrencia Los componentes del sistema controlado funcionan simultneamente El sistema de control debe atenderlo y generar las acciones de control simultneamente 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 simultnea La programacin de sistemas concurrentes es compleja
10
CARACTERSTICAS
Interaccin con dispositivos fsicos 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, perifricos especiales, ...) Los componentes del software que controlan el funcionamiento de estos dispositivos (manejadores, "drivers") son, en general, dependientes del sistema concreto
11
PROGRAMACIN
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 temporizacin
Lenguajes concurrentes (Ada2005, extensin tiempo real Java...)

Las funciones de concurrencia y tiempo real forman parte del lenguaje
12
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 comn temporizacin: medida de tiempos y ejecucin peridica planificacin: 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, MarteOS, RT-Linux, ....
13
POSIX Portable Operating System Interface + X

Conjunto de normas IEEE/ISO que definen servicios que pueden ofrecer los sistemas operativos Normas bsicas, con interfaces para C Interfaces para Ada y otros lenguajes Perfiles de aplicacin
14
PROGRAMACIN
Ada2005
Se desarroll especficamente para sistemas empotrados por encargo del DoD (Ministerio de Defensa de EEUU) --> Ada 83 Revisin 1995 --> Ada95 Revisin 2005 --> Ada2005 Soporta tecnologas de software avanzadas

descomposicin, abstraccin, reutilizacin programacin 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 slo militares), especialmente en Europa Transportabilidad, Legibilidad, Eficiencia, Seguridad (chequeos compilador) Anexos especializados (aplicaciones distribuidas, sistemas de informacin, ...)
15
NOCIONES SOBRE CONCURRENCIA
16
PROCESOS CONCURRENTES
Procesos concurrentes: Se dice que dos o ms procesos son concurrentes si pueden ejecutarse en paralelo, de forma que alguno de ellos comience a ejecutarse antes que termine algn otro. Programa concurrente: Es un programa que especifica dos o ms procesos concurrentes o, de forma equivalente, un programa cuya ejecucin se realiza segn varios flujos de control que avanzan en paralelo. Paralelismo virtual Monoprocesador: Un nico procesador va alternando la ejecucin de los diversos procesos (entrelazado) Paralelismo real Multiprocesador: Cada proceso se ejecuta en un procesador diferente. Zona de memoria comn (datos comunes). Sistema distribuido: Multiprocesador sin memoria compartida.
17
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, comunicacin y sincronizacin entre threads es ms eficiente Se necesitan mecanismos para evitar las interferencias entre los threads.
Nos centraremos en procesos ligeros: threads o tareas
18
ESTADOS DE UN PROCESO
kernel
nuevo preparado
espera
activo
ejecucin
terminado
En un sistema con N procesadores, slo puede haber N procesos en ejecucin
19
NCLEO DE TIEMPO REAL

Los procesos concurrentes se ejecutan con ayuda de un ncleo de ejecucin (run-time kernel) El ncleo se encarga de la creacin, terminacin y entrelazado de los procesos
El ncleo puede tomar varias formas: Ncleo desarrollado como parte de la aplicacin
ejemplo: ejecutivo cclico
Ncleo del entorno de ejecucin del lenguaje

ejemplo: lenguaje Ada 2005
Ncleo de un sistema operativo de tiempo real

ejemplo: VxWorks, LynxOS, RTEMS, RT-Linux, QNX, ...
20
Ejemplo: control de temperatura y nivel
T: temperatura H: nivel de lquido C: ajuste del calefactor V: ajuste de la vlvula
V H C T
Periodo de muestreo deseado:

Temperatura: 5 s Nivel: 1 s
21
Ejemplo: Ejecutivo cclico (C)
void CONTROL_DE_TEMPERATURA(void) { TEMPERATURA T ; AJUSTE_DE_CALEFACTOR C ; MEDIR(&T) ; CALCULAR_ACCION(T,&C) ; GENERAR(C) ; MOSTRAR(T) ; } void CONTROL_DE_NIVEL(void) { ALTURA H ; AJUSTE_DE_VALVULA V ; MEDIR(&H) ; CALCULAR_ACCION(H,&V) ; GENERAR(V) ; MOSTRAR(H) ; } } 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 }
22
Ejemplo: Tareas en Ada 2005
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 ;
23
Ejemplo: Threads en POSIX
#include <pthread.h> 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 } } ......
24
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 */ }
25
ENTRELAZADO
Entrelazado y operaciones atmicas Proceso P ; x,y: entero ; P1: x:=1 ; P2: y:=x+2 ; fin P ; Proceso Q ; z,u: entero ; Q1: z:=3 ; Q2: u:=z+1 ; fin Q ;
Posibles ejecuciones: (P1; P2; Q1; Q2) (P1; Q1; P2; Q2) (Q1; P1; P2; Q2) ...
26
ENTRELAZADO
Cada instruccin de alto nivel: varias instrucciones cdigo mquina.
Por ejemplo: x := y + z ; copiar copiar sumar copiar y, r1 z, r2 r1, r2 r2, x
Operaciones atmicas.
27
COMPETENCIA / EXCLUSIN MUTUA

Dos procesos compiten cuando comparten: un recurso una variable El acceso al recurso o a la variable debe ser en exclusin mutua. Regin crtica: secuencia de instrucciones que deben ejecutarse en exclusin mutua
28
COMPARTICIN DE UN RECURSO
Ejemplo: dos procesos (P y Q) comparten una cinta magntica. libre:= true; proceso P; proceso Q; principio repetir repetir nada; hasta libre; libre:= false; usar cinta; libre:= true; otras cosas; fin repetir; fin ;
principio repetir repetir nada; hasta libre; libre:= false; usar cinta; libre:= true; otras cosas; fin repetir; fin ;
29
COMPARTICIN 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;
30
COMPARTICIN DE UNA VARIABLE

Posibles trazas: (escribir n; n:=0; n:=n+1) (escribir n; n:=n+1; n:=0) --> Prdida de pulso (n:=n+1; escribir n; n:=0) n := n + 1 ; copiar sumar copiar n, r1 r1, 1 r1, n / (escritor) n:=0; => Prdida de la puesta a cero de n
Pb: entrelazado de las instrucciones en el acceso a la variable comn. Solucin en ambos casos: garantizar el acceso en exclusin mutua al elemento compartido.
31
REGIN CRTICA
Se garantiza que dos procesos no estarn ejecutando a la vez una misma regin crtica Ejemplo: dos procesos (P y Q) comparten una cinta magntica. 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;
32
REGIN CRTICA
Ejemplo: dos procesos (P y Q) comparten una cinta magntica. 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 ;
33
REGIN CRTICA: REALIZACIN

Varias posibles realizaciones: Mutex (semforo binario)
POSIX, VxWorks, RTEMS, ...
Monitor
Protected (Ada2005)
Aplicacin tiempo real: tareas + ncleo El ncleo es el que ejecuta las primitivas de exclusin mutua El ncleo no puede ser expulsado
El ncleo es el que decide qu tarea est en el procesador en cada momento
34
MUTEX
Es una variable booleana
S : mutex := valor_inicial ; wait(S): si S = true, signal(S): si hay procesos esperando, pasar uno de ellos a preparado si no, S := true S := false si no, suspender el proceso
Las operaciones signal y wait son atmicas. Los semforos tienen asociada una cola de procesos suspendidos en espera. Los semforos son gestionados por el ncleo de ejecucin
35
MUTEX
La exclusin mutua puede asegurarse con un semforo binario, inicializado a uno (true)
mutex: mutex_semaphore := 1 ; proceso P1; principio repetir Wait(mutex) ; <seccin crtica> Signal(mutex) <seccin no crtica> fin repetir; fin P1 ; proceso P2; principio repetir Wait(mutex) ; <seccin crtica> Signal(mutex) <seccin no crtica> fin repetir; fin P2 ;
CUIDADO: si un proceso olvida liberar el mutex, el recurso queda bloqueado
36
MONITOR (protected Ada2005)

No se puede acceder a las variables definidas en un monitor salvo a travs de los procedimientos definidos en l. El nmero de procesos que pueden ejecutar a la vez procedimientos de un monitor est limitado a uno => exclusin mutua en el acceso a las variables protected body contador is procedure incremento is begin n := n+1 ; end ; procedure escribe_borra is begin escribir (n) ; n := 0 ; end ; end ;
protected contador is procedure incremento ; procedure escribe_borra ; private n: integer := 0 ; end ;
37
MONITOR
Pueden programarse mediante mutex
/* fichero contador.c */ #include contador.h #include <semaphore.h> /* 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) ; }
/* fichero contador.h */ void incrementa(void) ; void escribe_borra(void) ;
38
EXCLUSIN MUTUA E INTERRUPCIONES

Las rutinas de servicio de interrupciones (ISR) se ejecutan en concurrencia con el resto de procesos. Exclusin 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() ; }
39
COOPERACION / COMUNICACION
Interacciones ms directas entre procesos que cooperan en la realizacin de alguna tarea. Cooperacin => intercambio de datos
Comunicacin asncrona:
buzones semforos.
Comunicacin sncrona:
cita cita extendida.
40
BUZON
Comunicacin asncrona Un proceso P produce y enva 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 disposicin 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.
41
BUZON
Restricciones: El proceso emisor no puede exceder la capacidad finita del buzn. Si el buzn est lleno el emisor espera para depositar su mensaje. El proceso receptor no puede consumir mensajes ms deprisa de lo que se producen. Si el buzn est vaco 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) => exclusin mutua en el acceso => un buzn es una regin crtica. Es posible que un buzn tenga varios procesos emisores y varios receptores.
42
BUZN
La poltica de manejo de un buzn puede ser: Si al enviar un mensaje el buzn est lleno:
el emisor espera hasta que haya espacio el emisor espera, con un tiempo mximo el mensaje se descarta se descarta otro mensaje (p.ej. el ms antiguo)
Si al solicitar un mensaje el buzn est vaco:

el receptor espera hasta que haya mensaje el receptor espera, con un tiempo mximo se le indica que no hay mensaje y puede continuar
43
BUZONES EN POSIX Y VXWORKS

Algunos sistemas ofrecen paquetes de manejos de buzones con posibilidades adicionales: Colas de mensajes en POSIX
Consulta del nmero de mensajes pendientes Opcin 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 nmero de mensajes pendientes Opcin de no bloqueo y de tiempo mximo 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
44
SEMFORO
Si los mensajes no encierran ninguna informacin el buzn se denomina SEMAFORO. No interesa el contenido de los mensajes sino solamente su nmero => el semforo 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 atmicas. Cola de procesos suspendidos en espera. Los semforos son gestionados por el ncleo de ejecucin
45
SEMFORO
El problema de hacer cuadernillos:
programa GRAPAR_HOJAS ; var S: semaphore; proceso AMONTONAR; principio repetir coger una hoja de cada montn ; 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 ;
46
CITA
Una cita supone: Una sincronizacin de dos procesos Un intercambio de informacin La cita es un mecanismo no simtrico: un proceso ejerce de llamador y otro de aceptador de la llamada. Proceso Aceptador Proceso Llamador El intercambio de informacin puede ser bidireccional (Ada) o unidireccional (OCCAM).
envo datos
aceptacin de la llamada
respuesta
47
CITA EXTENDIDA
Cita extendida (rendez-vous de Ada): es una cita en la que el proceso aceptador ejecuta un cdigo en la aceptacin: Procesamiento datos recibidos Preparacin datos a enviar Sintaxis (proceso aceptador): entry NOMBRE_ENT (DEC_PARAMETROS) ; accept NOMBRE_ENT(DEC_PARAMETROS) do cdigo de la cita extendida; end NOMBRE_ENT; Proceso llamador ( llamada procedimiento): P_ACEPTADOR.NOMBRE_ENT(PARAMETROS) ;
48
CITA EXTENDIDA
BAR: El camarero y los clientes
procedure BAR is task CLIENTE ; task CAMARERO is entry COBRAR (DINERO: in out integer) ; end CAMARERO ; task body CLIENTE is MONEDERO: integer := 100 ; begin -- tomar una consumicin ; 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 ;
49
SELECCIN NO DETERMINISTA
BAR: El camarero mejorado
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 ;
task C1 ; task body C1 is begin ... CAMARERO.SERVIR (_) ; ... CAMARERO.COBRAR (_) ; ... end C1 ;
50
MEDIDA Y CONTROL DEL TIEMPO
51
INTRODUCCIN
Caracterstica ms 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 duracin de las acciones del sistema
Ms concretamente hace falta: Mecanismos para medir el tiempo: relojes y temporizadores Mecanismos para activar tareas y/o eventos en instantes determinados Mecanismos para reconocer fallos en los plazos de ocurrencia de ciertos eventos: timeouts Mecanismos para especificar y asegurar los plazos de ejecucin de las acciones: planificadores de tiempo real
52
INTRODUCCIN
Adems un sistema tiempo real es un sistema concurrente, compuesto por procesos. Desde el punto de vista del tiempo, principalmente dos tipos de procesos:
Procesos peridicos: son aquellos que se activan regularmente en instantes de tiempo separados por un perodo de tiempo determinado.
proceso P; cada T repetir actividad; fin repetir; fin P;
Procesos espordicos: son aquellos que se activan de forma irregular, cada vez que se producen ciertos eventos externos.
proceso P; repetir esperar E ; actividad; fin repetir; fin P;
53
TIEMPO
El tiempo es una magnitud fsica 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. Seal UTC del GPS) Utilizar un reloj de hardware interno que proporciona una aproximacin del paso del tiempo en el entorno Utilizar un reloj interno + sincronizaciones con sistema de referencia externo
54
TIEMPO
Sistemas de referencia estndar Astronmicos
Tiempo universal (UT0):Tiempo solar en el meridiano Greenwich UT1, UT2: correcciones por el desplazamiento polar y por variaciones de la velocidad de rotacin de la Tierra
Atmicos
Tiempo Atmico Internacional (IAT): Basado en un reloj atmico de cesio Tiempo Universal Coordinado (UTC): Reloj IAT sincronizado con UT2 mediante la adicin de ticks ocasionales
55
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
Paro
]
t2
Temporizador Reloj t = t2-t1
56
RELOJES
Reloj: es un mdulo (de hardware y software) que proporciona el valor del tiempo real cuando se lee. Un reloj est compuesto por: Un circuito que genera impulsos peridicos Un contador que acumula los impulsos Un software de gestin
Lectura del tiempo Puesta en hora Conversin del contador en unidades de tiempo (segundos, minutos, ...) ...
Las caractersticas ms importantes de un reloj son: Precisin (granularidad). Depende de la frecuencia de los impulsos. Intervalo de valores. Depende de la precisin y de la capacidad del contador.
57
MEDIDA DEL TIEMPO

Unidad de tiempo: tick El contador es de capacidad limitada
desbordamiento Tiempo computador tick
vida aplicacin (t. no montono)
reinicio cuenta
tiempo
tiempo montono, la aplicacin tiene una vida menor que el tiempo de desbordamiento. tiempo no montono, la aplicacin vive ms que el tiempo de desbordamiento
58
MEDIDA DEL TIEMPO

La monotona del tiempo depende de: el tiempo de vida de la aplicacin el tamao del contador en relacin con el tamao del tick.
Problemas del tiempo no montono 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
59
TIPOS DE RELOJES
Reloj calendario Mantenimiento de la fecha y hora de una aplicacin No montono
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 Montono o no montono

No monotona slo por desbordamiento No puesta en hora
Generalmente de ms precisin
60
EJEMPLOS DE RELOJES
POSIX.1b: CLOCK_REALTIME, CLOCK_MONOTONIC nmero entero de segundos (32 bits) nmero entero de nanosegundos (32 bits) Resolucin en la representacin: 1ns Granularidad
Depende de la implementacin Como mximo 20 ms
Ada2005: Ada.Real_Time Tipo abstracto de dato con funciones de manejo y conversin poca: arranque de la aplicacin intervalo: igual o mayor a 50 aos Resolucin en la representacin: mnimo 20 s Granularidad
Depende de la implementacin Como mnimo 1 ms
intervalo: 232 s = 136 aos
61
CLOCK_REALTIME, CLOCK_MONOTONIC
struct timespec { time_t tv_sec ; /* segundos */ long tv_nsec; /* nanosegundos */ }; typedef .. clockid_t ; /* leer la hora */ int clock_gettime (clockid_t clockid, struct timespec *tp); /* poner en hora */ /* no se puede usar con CLOCK_MONOTONIC */ int clock_settime (clockid_t clockid, struct timespec *tp); /* obtener la resolucion del reloj */ int clock_getres (clockid_t clockid, struct timespec *tp);
CLOCK_REALTIME y CLOCK_MONOTONIC son constantes del tipo clockid_t
62
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;
63
EJEMPLO DE MEDIDA DEL TIEMPO

Medida del tiempo de ejecucin de una actividad
use Ada.Real_Time; declare Old_Time, New_Time : Time; Interval : Time_Span; begin Old_Time := Clock; -- actividad cuya duracin se mide New_Time := Clock; Interval := New_Time - Old_Time; end;
64
EJEMPLO DE MEDIDA DEL TIEMPO

Tcnica de doble bucle Slo es vlido si la secuencia de instrucciones se ejecuta de una vez (sin ceder el procesador a otras tareas o al ncleo)
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;
65
RELOJES CALENDARIO
Reloj calendario Fecha Hora oficiales Un reloj calendario no es montono Horario de invierno Horario de verano En el cambio a horario de verano el reloj se atrasa
Un reloj de estas caractersticas no se puede utilizar en tiempo real
66
Relojes de tiempo de cmputo.

Existe un reloj de tiempo de computo por cada thread Se pone en marcha cuando el thread entra en ejecucin Se detiene cuando sale de la CPU Mide el tiempo que la CPU le dedica a un thread Manejo igual que otros relojes se refiere al reloj del thread en
CLOCK_THREAD_CPUTIME_ID ejecucin
clock_settime (CLOCK_THREAD_CPUTIME_ID, &timespec_value); clock_gettime (CLOCK_THREAD_CPUTIME_ID, &timespec_value);
67
ACTIVACIN DE TAREAS
Mecanismos bsicos de activacin de tareas: Por interrupcin
Tareas peridicas Tareas espordicas
Con retardos
Tareas peridicas
Primitivas de comunicacin/sincronizacin (tareas que activan a otras tareas)

Semforos, buzones Cita Tareas peridicas o espordicas
68
ACTIVACIN POR INTERRUPCIN

La estructura de la aplicacin depende del hardware disponible:
La activacin es realizada directamente por el hardware Se asocia una interrupcin a cada tarea Tareas peridicas -> un timer (hardware) por cada tarea
Con esta aproximacin la aplicacin es dependiente del hardware:

Hardware especfico, no de propsito general Falta de transportabilidad Mucha eficiencia
69
EJEMPLO INTERRUPCIONES
Ada2005
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 ;
70
EJEMPLO INTERRUPCIONES
VxWorks
void task (void) { while (TRUE){
void Int_Handler (void) { ... ; semGive (syncSem) ; }
semTake (syncSe, WAIT_FOREVER) ; Event_Processing () ; } }
71
RETARDOS
Los retardos permiten controlar el tiempo de activacin de las tareas. Esta tcnica de activacin no depende del hardware Hardware propsito general Transportabilidad En Ada2005 y otros lenguajes y sistemas operativos se realizan mediante la instruccin: delay <duracion> ; / nanosleep (<duracion>) ; Efecto: suspende la ejecucin de la tarea durante, al menos, la duracin especificada, a partir del momento en que se invoca. La ejecucin puede verse retrasada durante una duracin mayor a la especificada debido a: Precisin del reloj menor que la precisin de la duracin especificada. Un mtodo de planificacin que selecciona otra tarea para la ejecucin antes que la retrasada.
72
TAREAS PERIDICAS Y RETARDOS

Los retardos se pueden utilizar para realizar tareas peridicas:
task PERIODICA; task body PERIODICA is PERIODO: constant DURATION := ; begin loop -- accin periodica delay PERIODO ; end loop ; end PERIODICA ;
Problema: deriva acumulativa. Los retrasos que se producen en cada periodo (deriva local) se van acumulando.
73

Esquema que elimina la deriva acumulativa (no la local):
task body PERIODICA is PERIODO: constant DURATION := ; SIGUIENTE: TIME ; begin SIGUIENTE:= CLOCK ; loop -- accin periodica SIGUIENTE:= SIGUIENTE + PERIODO ; delay SIGUIENTE - CLOCK ; end loop ; end PERIODICA ;
74

P=50 ms a1 a2 a3 a4
A1
delay 0.05
A2
50 ms
delay 0.05
A3
50 ms
DL
DA
DL
DA
Primera aproximacin
A1
A2 delay 0.01
delay 0.02
A3
delay 0.03
A4
DL
DL
DL=0
DL
Aproximacin buena
75

En POSIX
void periodic () { struct timespec dt, now, next, period; if (clock_gettime (CLOCK_MONOTONIC, &next) != 0) error(); period.tv_sec = 0; period.tv_nsec = 10.0E6; /* 10 ms */ while (1) { /* accin peridica */ next = sum (&next, &period) ; clock_gettime (CLOCK_MONOTONIC, &now) dt = diff (&next, &now) ; nanosleep (&dt, 0) ; } }
76
DELAY UNTIL
Resuelve el problema de la no atomicidad de la instruccin: delay SIGUIENTE - CLOCK ; utilizando tiempo absoluto
task body PERIODICA is PERIODO: constant DURATION := ; SIGUIENTE: TIME ; begin SIGUIENTE:= CLOCK ; loop -- accin periodica SIGUIENTE:= SIGUIENTE + PERIODO ; delay until SIGUIENTE ; end loop ; end PERIODICA ;
Ada 2005
77
DELAY UNTIL
En POSIX
void periodic () { struct timespec next, period; if (clock_gettime (CLOCK_MONOTONIC, &next) != 0) error(); period.tv_sec = 0; period.tv_nsec = 10.0E6; /* 10 ms */ while (1) { /* accin peridica */ next = sum (&next, &period) ; clock_nanosleep (CLOCK_MONOTONIC, TIMER_ABSTIME, &next, 0) ; } }
78
COMUNICACIN / SINCRONIZACIN
Tarea peridica con supervisor Es posible tratar posibles prdidas de activacin 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 ;
79
ACTIVACIN DE EVENTOS
Se utilizan temporizadores (timers) Un temporizador es un mecanismo (de hardware y software) que permite avisar de que ha transcurrido un cierto tiempo una sola vez desde que se arma peridicamente El mecanismo por el cual se avisa depende del sistema operativo y del lenguaje de programacin POSIX: seales Ada: mecanismos de lenguaje (seleccin temporizada)
80
TIME-OUT
A veces es necesario limitar el tiempo durante el cual una tarea espera que ocurra algn evento. Una tarea queda suspendida cuando requiere: una operacin de entrada/salida u otro servicio del sistema operativo una comunicacin con otra tarea Pb: si el dispositivo o la tarea cooperante falla la tarea suspendida nunca volver a estar activa Solucin: Time-out, tiempo mximo en el cual la tarea quedar suspendida
81
TIME OUT
Limitacin del tiempo de espera Sincronizacin condicional: semforo con time-out
Ejemplo: en VxWorks
semTake(semaforo, NO_WAIT) ; semTake(semaforo, WAIT_FOREVER) ; semTake(semaforo, num_ticks) ;
Paso de mensajes: buzn 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) ;
82
TIME OUT
Limitar el tiempo de ejecucin de una accin si se supera el tiempo mximo, puede ser necesaria una accin de recuperacin
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) ; <cdigo vigilado> wdCancel(miwdog) ; ... }
83
PLANIFICACION
Adems de la limitacin del tiempo de espera aparecen otras restricciones que afectan al tiempo de ejecucin de sus actividades:
Periodicidad Tiempo de respuesta ante un evento Completar el trabajo antes de un plazo
Cmo planificar la ejecucin de las actividades de forma que se satisfagan las restricciones temporales?
84
PLANIFICACIN
Marco temporal de una tarea: es el conjunto de atributos temporales asociados.
Tiempo de activacin: ta Periodo de ejecucin: P T; o separacin mnima: S Retardo: r ; retardo mximo: R
Jitter: variacin en r
Tiempo de cmputo: c ; id. mximo: C Tiempo de ejecucin transcurrido: e Tiempo de finalizacin: tf Tiempo de respuesta: d Plazo de respuesta: D (deadline) Tiempo lmite: tl
t a (k) r d D P t a (k+1)
activacin comienzo k fin activacin k+1
c1
c = c1 + c2 + c3 c2 c3 e t f (k) t l (k)
85
PLANIFICACIN
Las restricciones temporales ms 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 crticas. No admiten que se sobrepase el tiempo lmite en ningn caso. Tareas de tiempo real acrticas. Admiten que se sobrepase el tiempo lmite ocasionalmente. Tareas interactivas. No tienen plazo de respuesta estricto, aunque el tiempo de respuesta debe ser lo ms corto posible.
86
PLANIFICACIN
Objetivo: Planificar el uso de los recursos del sistema (en particular, el procesador), para poder garantizar los requisitos temporales de las tareas
Un mtodo de planificacin consta de: Un algoritmo de planificacin, que determina el orden de acceso de las tareas a los recursos del sistema Un mtodo de anlisis que permite calcular el comportamiento temporal del sistema
Para comprobar que los requisitos estn garantizados en todos los casos Se estudia siempre el peor caso Es necesario conocer la duracin de las tareas en el peor caso
87
PLANIFICACIN
Mtodos: Planificacin esttica off-line
Planificacin cclica
Planificacin basada en prioridades

Prioridades estticas

Prioridad al ms frecuente (Rate monotonic) Prioridad al ms urgente (Deadline monotonic)
Prioridades dinmicas

Proximidad del plazo de respuesta (Earliest deadline first) Prioridad al de menor holgura (Least Laxity First)
88
PLANIFICACIN CCLICA
Ejecutivo cclico: estructura de control o programa cclico que entrelaza de forma explcita la ejecucin de diversos procesos peridicos en un nico procesador. El entrelazado es fijo. Planificacin cclica: especificacin del entrelazado de varios procesos peridicos durante un periodo de tiempo (ciclo principal) de tal forma que su ejecucin cclica 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 C 6 D1 10 A B 14 D2 20
89
PRIORIDADES
Son un mecanismo elemental para planificar la ejecucin de un conjunto de tareas. La prioridad es un atributo de las tareas normalmente ligado a su importancia relativa en el conjunto de tareas. Planificacin por prioridades: en cada momento se ejecuta la tarea ms prioritaria de entre todas las ejecutables (preparadas). Planificacin expulsiva: se abandona inmediatamente la ejecucin de la tarea en ejecucin cuando otra ms prioritaria pasa al estado preparada para ejecucin. La prioridad de una tarea puede ser: Esttica: la prioridad permanece constante a lo largo de la existencia de la tarea. Dinmica: la prioridad puede variar en funcin del estado o modo de funcionamiento del sistema.
90
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
91
PLANIFICACION CCLICA
92
MODELO DE TAREAS
Consideraremos inicialmente un modelo de tareas simple: Conjunto de tareas esttico Todas las tareas son peridicas Las tareas son independientes entre s Se conoce el tiempo de ejecucin mximo de cada tarea C i Cada tarea tiene un plazo de respuesta D i T i
Despus veremos como incorporar tareas espordicas
93
PLAN PRINCIPAL
Ejecutivo cclico: estructura de control o programa cclico que entrelaza de forma explcita la ejecucin de diversos procesos peridicos 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: especificacin del entrelazado de varios procesos peridicos durante un perodo de tiempo (ciclo principal) de tal forma que su ejecucin cclica garantiza el cumplimiento de los plazos de los procesos La duracin del ciclo principal es igual al mnimo comn mltiplo de los perodos de los procesos
M = mcm (Ti) se supone tiempo entero (p.e. Nmero de ticks) el comportamiento temporal del sistema se repite cada ciclo principal
94
PLANES SECUNDARIOS
Cada plan principal es dividido en uno o ms planes secundarios o marcos (frames) que se ejecutarn de forma secuencial. Cada comienzo/fin de un marco en el ejecutivo cclico se sincroniza con el reloj. Son puntos donde se fuerza la correccin del tiempo real. Por simplicidad, en la prctica, la duracin de todos los marcos es la misma. A esta duracin se le denomina ciclo secundario. Si las acciones definidas en un marco acaban antes de que concluya el ciclo secundario el ejecutivo cclico 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 duracin de una accin es superior al ciclo secundario debe ser descompuesta en subacciones
95
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 C 6 D1 10 A B 14 D2 20
Ciclo principal: 20 ms Ciclo secundario: 10 ms
96
EJEMPLO
Ejecutivo cclico:
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 ;
97
EJEMPLO (C+VxWorks)
Ejecutivo cclico:
#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) ; } }
98
PROPIEDADES
No hay concurrencia en la ejecucin
Cada ciclo secundario es una secuencia de llamadas a procedimientos No se necesita un ncleo de ejecucin multitarea
Los procedimientos pueden compartir datos

No se necesitan mecanismos de exclusin mutua como los semforos o monitores
99
DETERMINACION DE LOS CICLOS

Sea un conjunto de procesos peridicos {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 activacin de cada proceso y su plazo lmite exista un marco o ciclo secundario completo m - mcd(m,Ti) es el retraso mximo entre la activacin de un proceso y el comienzo del siguiente marco esta condicin incluye a la primera
100
EJEMPLO
Considrese tres procesos
P E F G C 1 2 3 T 14 20 22 D 14 20 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
101
EJEMPLO
para m = 4
i 1 2 3 Ti 14 20 22 mcd(m,Ti) retraso 2 4 2 2 0 2 m+retraso 6 4 6 < < < Di 14 20 22
m=4
14 6
20 4 6
22
E F G
102
EJEMPLO
para m = 10
i 1 Ti 14 mcd(m,Ti) retraso 2 8 m+retraso 18 > Di 14 NO
18 14 m = 10
E F G
14
28
42
56
103
INCLUSIN 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 ejecucin k-sima de un proceso Pi caracterizado por ternas (Ci, Ti, Di) podr ser incluida en los marcos j-simos que comienzan despus de la activacin de Pik y terminan antes del deadline de Pik:
(k 1)Ti ( j 1)m jm (k 1)Ti + Di
Para que la ejecucin 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
104
PLANIFICACIN
Objetivo: asignacin de procesos (o subprocesos) a los marcos de forma que se cumplan los requisitos temporales Planteamiento: bsqueda en el espacio de estados Estado: asignacin parcial Algoritmo: bsqueda en profundidad con retroceso
se pretende encontrar una nica solucin
Guiado de la bsqueda: heursticas

sobre el siguiente proceso a asignar

primero el ms urgente o el ms frecuente primero el de tiempo de proceso ms grande
si varios marcos cumplen las condiciones:

el primer marco que cumpla las condiciones el marco con menor tiempo de cmputo libre
105
EJEMPLO: PLANIFICACIN
Conjunto de procesos a planificar:
Proceso P1 P2 P3 P4 C 2 3 1 2 T 8 8 6 12 D 8 8 6 12
Ciclo principal: M = mcm(6,8,12) = 24 Nmero de ejecuciones a planificar

ne1 = M/8 = 3 ne2 = M/8 = 3 ne3 = M/6 = 4 ne4 = M/12 = 2
106
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}
107
Ordenacin procesos: primero el ms urgente
Proceso P1 P2 P3 P4 C 1 3 2 2 T 6 8 8 12 D 6 8 8 12 n 4 3 3 2
Se intenta planificar primero para m=4 (la complejidad del problema disminuye con el nmero de marcos) Un planificacin consta de 6 marcos consecutivos
108
EJEMPLO: PLANIFICACION
Pik puede ir en el marco j si:
(k 1)Ti ( j 1)m jm (k 1)Ti + Di
P11
P12 4 8 12 P22 8 12 P32 8 P41 12
P13 16 20
P14 24
P1 P2 P3 P4
P21 0 4 P31 0 4
P23 16 20 P33 16 P42 20 24 24
12
16
20
24
109
1 1 1 1 1 2 1 2 1 2 1 1 3 1 1 2 1 1 2 1 2 1 2 1 1 2 1 1 2 1 1 2 1 1 2 2 1 1 3 1 1 2 1 1 2 1 1 2 2 1 1 2 1 1 2 1 1 2 1 2 1 1 2 1 3 1 1 3 1 1 3 1 1 3 1 2 2 3 2 2 2 3 2 4 4
2 2 3 3
3 2 3 3
2 3 2 3
3 3 2 3
110
PARTICIN DE PROCESOS
Hay casos en que un conjunto de procesos que no es planificable: Si el tiempo de cmputo de uno es mayor que el plazo de algn otro: Ci > Dk => No existe valor de m que cumpla a la vez:
m min(Di) m max(Ci)
Si para una ejecucin de un proceso no queda ningn marco con suficiente tiempo libre Solucin: 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 crticas relacin de precedencia en cada una de las ejecuciones a mantener en la planificacin: Pi1Pi2Pi3...
111
RELACIONES DE PRECEDENCIA
Sean Pi1 y Pi2 dos procesos entre los que existe una relacin de precedencia Pi1Pi2, En la ordenacin de los procesos para su inclusin en la planificacin se mantiene el orden de precedencia (los dos subprocesos tienen las mismas restricciones temporales) Para incluir la ejecucin k-sima de Pi2, Pi2k, en la planificacin:
obtener los valores {j,...,j+h} de los marcos donde puede ser incluida a partir de: (k 1)T ( j 1)m
jm (k 1)Ti + Di
i
Debido al orden de inclusin 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 condicin
Ci2 m Cl l,Pl x
112
EJEMPLO: PARTICIN DE PROCESOS

Proceso P1 P2 P3 C 2 2 8 T 6 8 24 D 6 8 20
Ciclo principal
M = mcm(6,8,24) = 24
Ciclo secundario
m min(6,8,20) => m = 1..6 m max(2,2,8) => no hay ningn m que lo cumpla
Es preciso partir el proceso P3 en varios subprocesos con tiempo de cmputo menor que 6 unidades de tiempo Particin en P31 P32 con igual tiempo de cmputo, 4 unidades
113

Proceso P1 P2 P31 P32 C 2 2 4 4 T 6 8 24 24 D 6 8 20 20
Ciclo principal
M = mcm(6,8,24) = 24
Nmero de ejecuciones a planificar

ne1 = M/6 = 4 ne2 = M/8 = 3 ne31 = M/24 = 1 ne32 = M/24 = 1
114

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 planificacin m=4 Ordenacin de procesos: primero el ms urgente manteniendo relaciones de precedencia
Misma tabla anterior P1 P2 P31 P32
Un planificacin consta de 6 marcos consecutivos: M = 6m
115
1 1 1 1 1 1 1 2 1 1 31 1 1 2 1 1 1 1 1 1 31 1 1 1 1 31 1 1 32 1
2 2
2 2 2 2 2 2 2 2 2
2 2
116
PARTICIN CON SECCIONES CRTICAS

Si es preciso partir algn proceso en subprocesos, no deben partirse las secciones crticas con objeto de preservar la exclusin mutua Ejemplo: Planificar la ejecucin de los siguientes procesos:
P P1 P2 P3 C 20 25 90 T 100 150 300 D 100 150 300
Dichos procesos acceden a una seccin crtica comn tal y como muestra el siguiente esquema:
P1 P2 P3
15 15 15 5 10 20 15 40
117

Ciclo principal
M = mcm(100,150,300) = 300

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} Ordenacin procesos: primero el ms urgente

Misma ordenacin que en el enunciado
Un planificacin consta de 3 marcos consecutivos
118

No existe planificacin porque no queda ningn marco donde quepa el proceso P3 Particin de P3
Tiempo sobrante en los marcos: 55, 80, 55 ms P31: primera seccin crtica + segundo segmento cdigo P32: segunda seccin crtica + cuarto segmento cdigo
1 1 1
1 1 1
2 2
119
PARTICION CON SECCIONES CRITICAS

Nueva especificacin de procesos:
P P1 P2 P31 P32 C 20 25 35 55 T 100 150 300 300 D 100 150 300 300
Ciclo principal
M = mcm(100,150,300) = 300

ne1 = M/100 = 3 ne2 = M/150 = 2 ne31 = M/300 = 1 ne32 = M/300 = 1
120

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 2
1 1 1
2 32 2
31
121
PROCESOS ESPORDICOS
Proceso espordico E: atencin a eventos externos aperidicos SE : separacin mnima entre eventos DE : plazo lmite ( normalmente DE SE ) CE : tiempo de cmputo mximo En un ejecutivo cclico los procesos espordicos pueden programarse de dos formas: Por muestreo peridico del evento
Por interrupcin
122
ESPORDICOS POR MUESTREO

Se programa el proceso espordico como un proceso peridico que consulta si ha llegado un evento, y en tal caso, lo procesa. Transformamos el proceso espordico en peridico con D = T DE / 2, y lo planificamos de la forma convencional
Si el proceso peridico cumple sus plazos, cualquier evento se atiende en su plazo DE T Proceso peridico
DE evento Se consulta, y no hay evento Hay evento, y se procesa CE
123
EJEMPLO 1
Proceso E P1 P2 C 1 3 2 6 12 T D 8 6 12 S 20
Proceso peridico equivalente: D = T= 4 DE / 2

Proceso PE P1 P2 C 1 3 2 T 4 6 12 D 4 6 12
Ciclo principal
M = mcm(4,6,12) = 12
Ejecuciones a planificar: nE = M/4 = 3 ; n1 = M/6 = 2 ; n2 = M/24 = 1
124
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 duracin m=4
E E E E E E E E E 1 1 1 2 1
125
ESPORDICOS POR INTERRUPCIN

La llegada del evento produce una interrupcin, y el evento se trata inmediatamente
Basta con reservar tiempo en cada marco para atender el mximo nmero de eventos que pueden llegar en un marco:
m Cres = C E SE
126
EJEMPLO 2
Conjunto de procesos a planificar (primero el ms urgente):
Proceso E P2 P3 P4 C 1 3 2 2 8 8 12 T D 7 8 8 12 S 10
Calculamos los ciclos con los peridicos Ciclo principal

M = mcm(8,12) = 24

ne2 = M/8 = 3 ne3 = M/8 = 3 ne4 = M/12 = 2
127
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 duracin m=8 En cada uno reservamos tiempo para atender un evento
m Cres = CE SE
128
EJEMPLO 2
E E E E E E E E E E E E P2 P2 P2 P2 P2 P2 P2 P2 P2 P3 P3 P3 P3 P3 P3 P4 P4
129
PROGRAMACIN 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 A B C D1 D2 C 1 3 2 2 6 T 10 10 20 20 20 D 10 10 20 20 20
Planificacin:
M = 20, m=10
0 A B C
6 D1
10 A B
14 D2
20
130
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 ;
131
EJECUTIVO - 1
Ventajas: Independiente del hardware: transportable, no hardware especfico, ... Inconvenientes: El desbordamiento de marco slo es detectado despus de acabar el marco Sobrecarga por la ejecucin del delay
aritmetica del tipo TIME costosa (normalmente 64 bits) acceso al reloj costoso (p.e. en exclusin mutua con la actualizacin) manejo de la tarea por el RTS costoso
132
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 ;
133
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
134
EJECUTIVO - 3
task cyclic_executive_3 is pragma priority (system.prioritylast) ; 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 ;
135
VENTAJAS/INCONVENIENTES
Ventajas Predecibilidad del sistema: la ejecucin est predeterminada Al no requerirse cambios de contexto la sobrecarga introducida por el ncleo es muy pequea Inconvenientes La introduccin de cualquier cambio es muy costosa (replanificacin, reprogramacin) Ante un conjunto de procesos no planificable, la particin de procesos no es evidente
136
PLANIFICACIN BASADA EN PRIORIDADES ESTTICAS
137
INTRODUCCIN
Planificacin basada en prioridades estticas Prioridad al ms frecuente (Rate monotonic)
RMS/RMA: Rate Monotonic Scheduling / Analysis Plazo de respuesta = perodo en tarea peridicas
Prioridad al ms urgente (Deadline monotonic)

DMS/DMA: Deadline Monotonic Scheduling / Analysis Plazo de respuesta perodo en tarea peridicas
Plazos de respuesta arbitrarios Es un marco terico que proporciona una base para el diseo de sistemas de tiempo real. Proporciona directrices para asignar prioridades ptimas Proporciona un marco analtico para verificar los requisitos temporales Ayuda a identificar cuellos de botella Permite la separacin de los aspectos temporales y funcionales
138
TAREAS PERIDICAS CRTICAS. RATE MONOTONIC.

Factor de utilizacin Es una medida de la carga del procesador. El factor de utilizacin de una tarea Ti es:
Ui = Ci Pi
n
El factor de utilizacin total del sistema es
U = U i =
i =1
Ci i i =1 P
Se trata de encontrar mtodos que proporcionen planificaciones admisibles con factores de utilizacin lo ms altos posible. Con un solo procesador, el factor de utilizacin est limitado a
U1
En general para M procesadores

UM
139

Planificacin basada en prioridades Consideraremos prioridades estticas y planificacin expulsiva. Frecuentemente se asignan prioridades a las tareas segn su "importancia". De esta forma no se puede calcular si se pueden garantizar los plazos o no. Puede fallar incluso con factores de utilizacin muy bajos. Ejemplo: T
T1 T2
C
10 2
P
50 10
U
0.20 0.20 0.40
a T1 a T2 0 a fallo 10 20 30 a a
Si hacemos p1 > p2, T2 falla.
fin
140

Prioridad al ms frecuente (RMS). Plazo = periodo. La asignacin de prioridades ms altas a las tareas ms frecuentes (perodo ms corto) es ptima (Liu & Layland, 1973). Por ptima se entiende que no hay ninguna otra planificacin mejor. Si de esta forma no se obtiene un plan admisible, no se puede obtener con ningn otro mtodo basado en prioridades estticas. Ejemplo: T
T1 T2
C
10 2
P
50 10
U
0.20 0.20 0.40
a T1 a T2 0 10 20 30 a a a
Hacemos ahora p2 > p1 ( P2 < P1) las dos tareas terminan a tiempo
141
TAREAS PERIDICAS CRTICAS. DEADLINE MONOTONIC.

Prioridad al ms urgente (DMS). Plazo periodo. La asignacin de prioridades ms altas a las tareas ms urgentes (plazo de respuesta ms corto) es ptima (Leung & Whitehead, 1982). Por ptima se entiende que no hay ninguna otra planificacin mejor. Si de esta forma no se obtiene un plan admisible, no se puede obtener con ningn otro mtodo basado en prioridades estticas. Ejemplo:
T T1 T2 C 6 6 D 15 10
T1 T2 0 5 10 15 20 25 30 35 40
P 15 20
DMS => Pr1 < Pr2
142
CONDICIONES DE GARANTA DE PLAZOS (RM)

Teorema 1 (Liu & Layland): En un sistema de n tareas peridicas 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 i =1 P U0(n) es la utilizacin mnima 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
143

Ejemplo:
T T1 T2 T3 C 5 10 20 P 20 40 80 U 0.25 0.25 0.25 0.75
La utilizacin total es 0.75 < U(3) = 0.779 => los plazos de las tres tareas estn garantizados si: pr1 > pr2 > pr3 El 25% del tiempo de CPU utilizable en clculos sin requerimientos temporales
144

En muchos caso se pueden garantizar plazos con factores de utilizacin mayores que U0(n). Teorema 1: condicin suficiente, no necesaria Ejemplo:
T T1 T2 T3 C 7 10 20 P 20 40 80 U 0.35 0.25 0.25 0.85
U = 0.85 > U0(3) = 0.779 Los plazos de respuesta de las tareas no estn garantizados, segn el Teorema 1 Sin embargo asignando prioridades RMA se cumplen los plazos de respuesta
145
CONDICIONES DE GARANTA DE PLAZOS

Teorema 2 (Liu & Layland): En un sistema de n tareas peridicas independientes con prioridades estticas, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si cuando se activan todas ellas simultneamente, cada tarea acaba dentro del plazo en su primera ejecucin. En el ejemplo anterior: U1.2 = 0.60 < 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
146

Test de Tiempo de Finalizacin El tiempo de finalizacin de una tarea Ti (tfi) es:
t t Ci 1 + Ci = t t fi = min C1 + ... + t >0 P Pi 1 1

Por lo tanto la tarea Ti cumplir su primer plazo si:
t fi Di
Justificacin:
Ti finaliza cuando no hay ms trabajo de prioridad pri pendiente. El trabajo solicitado en el instante t (tPi), suponiendo que todas las tareas han empezado en t=0, es:
i t t t Wi (t ) = C1 + ... + Ci 1 + Ci = C j P Pi 1 1 j =1 Pj
Wi : carga parcial de grado i en el instante t
147

Clculo del tiempo de finalizacin Se puede usar el siguiente mtodo iterativo:
k +1
Wi
Wi k Wi k = C1 + ... + Ci 1 + Ci P Pi 1 1
El clculo se realiza iterativamente hasta que se repite el resultado anterior:
Wi k +1 = Wi k = t fi
148

Clculo del tiempo de finalizacin:
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
149
CONDICIONES DE GARANTA DE PLAZOS (DM)

Test 1: En un sistema de n tareas peridicas 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
150

Se trata de una condicin suficiente pero no necesaria
T T1 T2 T3 C 2 2 4 D 3 6 11 P 5 15 20
C1 + I1 = 2 + 0 D1 = 3 D 6 C2 + 2 C1 = 2 + 2 = 6 D2 = 6 5 P 1 D D C3 + 3 C1 + 3 C2 = P P2 1 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
151

Ejemplo:
T T1 T2 T3 C 2 2 4 D 3 6 11 P 5 15 20
Mismo ejemplo anterior. Anlisis:

C1 + I1 = 2 + 0 D1 = 3 D 6 C2 + 2 C1 = 2 + 2 = 6 D2 = 6 5 P 1 D D 11 11 C3 + 3 C1 + 3 C2 = 4 + 2 + 2 = 12 > D3 = 11 5 15 P P2 1
Clculo del tiempo de finalizacin para T3
152

Tiempo de finalizacin: tf3
W30 = 0
1 W3 = 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
153

Reformulacin Punto de planificacin: Los puntos de planificacin de una tarea Ti son todos los instantes lmite (es decir los finales de los perodos) 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 simultneamente. Si es el conjunto de puntos de planificacin de la tarea Ti:
D Si = Di , k p j j = 1..i 1; k = 1.. i Pj
Teorema 3 (Lehoczky, Sha & Ding): En un sistema de n tareas peridicas independientes con prioridades asignadas en orden de urgencia, se cumplen todos los plazos de respuesta, para cualquier desfase inicial de las tareas, si y slo si
i Cj i,1 i n, min tSi j =1 t t 1 Pj
154

Ejemplo:
T T1 T2 T3 C 7 10 20 P 20 40 80 U 0.35 0.25 0.25 0.85
S1 = {20} S2 = {20, 40} S3 = {20, 40, 60, 80}
155

t 20 W1(t) (7*1)=7
t 20
W2(t) (7*1 + 10*1)=17
t 20 40 60 80
W3(t) (7*1 + 10*1 + 20*1)=37 (7*2 + 10*1 + 20*1)=44 (7*3 + 10*2 + 20*1)=61 (7*4 + 10*2 + 20*1)=68
156
TIEMPO DE CAMBIO DE CONTEXTO

Tiempo de cambio de contexto de peor caso:
Cs = Csa + Csb
Csa: Salvar el contexto de la tarea en ejecucin Csb: Planificar y recuperar el contexto de la nueva tarea
C sb T1
Csa
C sb T2 Csa
157

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 expulsin Esto implica aadir 2Cs al tiempo de ejecucin de cada tarea para el anlisis
158

Ejemplo: Se supone un tiempo de cambio de contexto Cs = 2ms
T T1 T2 T3 C 20+4 40+4 100+4 P 100 150 350 U 0.240 0.293 0.271 0.831
U = 0.831 > U0(3) = 0.779 => Test de tiempos de finalizacin:
t f 1 = C1 + 2CS = 24ms 68 t f 2 = (C1 + 2CS ) + C2 + 2CS = 68ms P 1 264 264 tf3 = (C1 + 2CS ) + P (C2 + 2CS ) + C3 + 2CS = 264ms P 2 1
159
TAREAS PERIODICAS CRTICAS/ACRTICAS

Cuando hay tareas acrticas podemos admitir fallos ocasionales en sus tiempos de respuesta. Se trata de garantizar: Los plazos de todas las tareas (crticas y acrticas) con los tiempos de cmputo medios. Los plazos de las tareas crticas con los tiempos de cmputo mximos.
La planificacin con prioridades es estable: fallan primero las tareas menos prioritarias. Si las tareas crticas no son las ms frecuentes, se puede hacer una transformacin de perodos. Se puede acortar el perodo de las tareas crticas o alargar el de las acrticas.
160
TAREAS PERIODICAS CRITICAS/ACRITICAS

Ejemplo:
T T1 T2 T3 cm 6 8 10 C 10 10 12 P 30 40 50 um 0.200 0.200 0.200 0.600 U 0.333 0.250 0.240 0.823
um = 0.600 < U0(3) = 0.779 Se pueden garantizar los plazos de todas las tareas con los tiempos de cmputo medios. U = 0.823 > U0(3) = 0.779 U1.2 = 0.583 < U0(2) = 0.828 Con los tiempos de cmputo mximos, slo se pueden garantizar T1 y T2. Si T3 es crtica y T2 no: acortar el perodo de T3 => subir su prioridad.
161
T1 T2 T3 0 20 30 40 50 10 Tiempos de ejecucin medios
T1 T2 fallo T3 T3 0 20 30 40 50 10 Tiempos de ejecucin mximos
162

Transformacin de T3: Descomponemos T3 en dos segmentos, T31 y T32, cuyos tiempos de cmputo son la mitad del de T3. Construimos una nueva tarea, T3', que cada vez que se activa ejecuta uno de estos segmentos, alternativamente. El perodo de la nueva tarea es P3' = P3/2 = 25
T T3' T1 T2 cm 5 6 8 C 6 10 10 P 25 30 40 um 0.200 0.200 0.200 0.600 U 0.240 0.333 0.250 0.823
El factor de utilizacin sigue siendo el mismo, pero ahora T3 tiene la prioridad ms alta
163
T1 fallo T2
(9 u.)
T2
T31 T32
T3' 20 30 40 50 10 0 Tiempos de ejecucin mximos, con T3 transformada
164

El cdigo 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 ;
165
COMUNICACIN ENTRE TAREAS

El anlisis de tareas con comunicaciones es un problema de gran complejidad => simplificaciones: las comunicaciones se restringen a variables compartidas protegidas mediante monitores (servidores) las primitivas de los monitores no pueden estar guardadas La segunda simplificacin evita que una tarea se quede bloqueada durante un tiempo no acotado.
No se permiten por lo tanto cita entre tareas o buzones y semforos bloqueantes
Pb. : INVERSION DE PRIORIDADES.
166

Ejemplo de monitor o servidor de comunicacin:
T1 VARIABLE_COMUN MODIFICAR T2 EXAMINAR
/* Variable_Comun.h */ 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 ;
167

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 ; }
168

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 ;
169

Ejemplo comunicacin 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
170
INVERSIN DE PRIORIDADES
A veces una tarea puede verse retrasada por la ejecucin de otra menos prioritaria. Este fenmeno se denomina inversin de prioridades, y puede ocurrir cuando hay interaccin entre tareas. Ejemplo:
INVERSION DE PRIORIDAD
T1 T2 T3
Ejecucin de servicios S2
Pb.: el retraso de una tarea por inversin de prioridad puede no estar acotado
171
PROTOCOLOS DE COMUNICACIN
Los siguientes protocolos evitan la inversin de prioridad sin lmite: Seccin crtica no expulsable Herencia de prioridad Techo de prioridad Techo de prioridad inmediato
Inversin de prioridad Existen secciones crticas activas cuando se activa una tarea de ms prioridad
172
SECCIN CRTICA NO EXPULSABLE

Un servidor ejecutando un servicio no puede perder el procesador. Pb.: Introduce inversin de prioridad aunque la tarea ms prioritaria sea independiente y no solicite ningn servicio.
T1 T2 T3
173
SECCIN CRTICA NO EXPULSABLE

Implementacin Kernel Enmascaramiento interrupciones
Sin MUTEX
Elevacin 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 ; }
174
HERENCIA DE PRIORIDAD
Los clientes tienen prioridades estticas y los servidores dinmicas. Est basado en las siguientes reglas: Cuando un servidor est realizando un servicio o bloqueando a algn cliente hereda la prioridad ms 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 semforo que protege el servidor Se produce inversin 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 activacin.
175
Puede haber mas de un bloqueo por inversin de prioridad durante una ejecucin.
T1 T2 T3
Bloqueo indirecto (Push-trough blocking)
T1 T2 T3
Ejecucin de servicios S1 Ejecucin de servicios S2
176
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 ms 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 del cliente est ya ejecutando un servicio para otro cliente. Caractersticas bsicas: Bloqueo nico: En una ejecucin de una tarea, sta slo se puede ver bloqueada, por inversin de prioridad, durante la ejecucin de un servicio. Es un protocolo para sistemas monoprocesador.
177
TECHO DE PRIORIDAD
BLOQUEO UNICO: Protocolo de techo de prioridad
T1 T2 T3
Ejecucin de servicios S1 Ejecucin de servicios S2
178
TECHO DE PRIORIDAD INMEDIATO

Con este protocolo, una tarea que accede a un recurso hereda inmediatamente el techo de prioridad del servidor Las propiedades son las mismas que las del protocolo del techo de prioridad
Bloqueo nico
Es ms fcil de implementar que el protocolo bsico Es ms eficiente (menos cambios de contexto) Se producen ms bloqueos que en el caso del protocolo de techo de prioridad
Comportamiento idntico de peor caso Peor comportamiento medio
179
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. Implementacin Elevacin prioridad

void Servicio (...) { Nominal = Get_Priority () ; Set_Priority (Server_Ceiling+1) Service_Code() ; Set_Priority (Nominal) ; return ; }
180
HERENCIA/TECHO DE PRIORIDAD
Ejemplo
T1 P=100 C=10
T2
S1 4
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
P=150 C=30
20
T3
P=250 C=50
4 5
T4 2 P=300 C=30 8
S2
T1
P=500 C=50
181
Techo de prioridad
T1 T2 T3 T4 T5
techo directo
S2
S1
4 forzado

S2
S1 S1 S1 S1
182
Herencia de prioridad
directo
T1 T2 T3 T4 T5
S2
5 directo forzado directo
S1
4 forzado forzado
S2 S2
2
S1 S1
S1
183

La inversin de prioridad puede ser tenida en cuenta en el anlisis mediante la incorporacin de un trmino denominado tiempo de bloqueo: bi
Tiempo de bloqueo de peor caso Cada protocolo proporciona tiempos de bloqueo diferentes Anlisis => clculo de los tiempos de bloqueo
Interferencias de una tarea

Tareas de ms prioridad Tareas de menor prioridad expulsiones bloqueos por inversin de prioridad
184

Seccin crtica no expulsable Una tarea puede ser bloqueada como mximo por un servicio Clculo
sjk servicio k usado por la tarea j D(sjk) duracin del servicio
Bi = MAX MAX (D (s jk )) j k
j >i
185

Protocolo de Herencia de Prioridad Una tarea T pude ser bloqueada como mximo por MIN(n,m) servicios
n: nmero de tareas de menor prioridad que T que la pueden bloquear m: nmero 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 ejecucin cuando se active T y que puedan bloquearle (bloqueo directo o indirecto por aumento de prioridad) Difcil de sistematizar: Algoritmo que calcula una cota superior del tiempo de bloqueo
Condicin suficiente
186

Algoritmo para calcular Bi Ceiling(): prioridad del ms prioritario de los clientes Dj,k: duracin de un servicio
Bil
j =i +1 m
MAX [D j ,k : Ceiling (S k ) Pi ] k
n k =1 j >i
Bis = MAX D j ,k : Ceiling (S k ) Pi Bi = MIN Bil , Bis
187

Protocolo de techo de prioridad El valor mximo del tiempo de bloqueo de una tarea Ti, bi, es igual a la duracin del servicio ms largo de los requeridos, a cualquiera de los servidores, por tareas de prioridad inferior (pritecho 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
188

Teorema 4 (Sha, Rajkumar & Lehoczky): En un sistema de n tareas peridicas 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 P Pi Pi 1
Corolario (Sha, Rajkumar & Lehoczky): Se cumple lo mismo si
max Pi + i=1..n1 Pi n(21/ n 1) = U 0 (n )

n
b
i
i =1
Condicin suficiente ms restrictiva.
189

Teorema 5 (Sha, Rajkumar & Lehoczky): En un sistema de n tareas peridicas 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 tSi j =1 t
t bi + 1 Pj t
Test de tiempo de finalizacin: El tiempo de finalizacin de una tarea Ti (tfi) es:
t t t fi = min C1 + ... + Ci 1 + Ci + bi = t t >0 P Pi 1 1

En el tiempo de finalizacin de Ti slo influye bi
190

Anlisis del ejemplo Seccin crtica no expulsable:
Tarea P T1 T2 T3 100 150 350 C 20 40 100 b 20 20 0 p 3 2 1
C1 b1 20 20 + = + = 0.400 1.0 = U 0 (1) P P 100 100 1 1 C1 C 2 b2 20 40 20 + + = + + = 0.600 0.828 = U 0 (2 ) P P2 P2 100 150 150 1 C1 C 2 C3 b3 20 40 100 0 + + + = + + + = 0.753 0.779 = U 0 (3) P P2 P3 P3 100 150 350 350 1
191

Anlisis del ejemplo Herencia de prioridad:
Tarea P T1 T2 T3 S1 S2 100 150 350 C 20 40 100 b 30 20 0 3 3 tp p 3 2 1
S1 S2 T1 10 2 T2 10 T3 - 20
192

Anlisis del ejemplo: Techo de prioridad:
Tarea P T1 T2 T3 S1 S2 100 150 350 C 20 40 100 b 20 20 0 3 3 tp p 3 2 1
193

Clculo de los tiempos de finalizacin
t f 1 = C1 + b1 = 40ms 80 t f 2 = C1 + C 2 + b2 = 80ms P 1 240 240 tf3 = C1 + P C 2 + C3 + b3 = 240ms P 2 1 b3 = 0
194

Otro ejemplo (techo de prioridad):
Tarea P T1 T2 T3 S1 S2
T1 P=100 ms D=100 ms C=20 ms
D 100 90 310
C 20 40 120
b 20 10 0
tp
p 2 3 1
100 150 350
3 2
S1 10 ms T2 P=150 ms D=90 ms C=40 ms 10 ms
S2 2 ms
T3 P=350 ms D=300 ms C=100 ms
20 ms
195

Condicin suficiente:
Ci + I i + bi Di C2 + I 2 + b2 = 40 + 0 + 10 = 50 D2 = 90 D 100 40 + 20 = 80 D1 = 100 C1 + 1 C2 + b1 = 20 + 150 P2 D D 310 310 C3 + 3 C2 + 3 C1 + b3 = 120 + 40 + 100 20 + 0 = 320 > D3 = 310 150 P P2 1
Tiempo de finalizacin para T3:

t t t f 3 = min C1 + C2 + C3 + b3 = t t >0 P P2 1 260 260 260 = 20 + 150 40 + 120 + 0 < 310 100
196
TAREAS ESPORDICAS Y APERIDICAS

Tareas que se ejecutan como respuesta a un evento => NO PERIODICAS. Se consideran dos tipos: Tareas aperidicas: no tienen requisitos de tiempo real crticos. Generalmente se desea que tengan un comportamiento estadstico adecuado, p.e. el valor del tiempo medio de respuesta est limitado. Tareas espordicas: tienen plazo de respuesta crtico.
197
TAREAS APERIDICAS
Se pueden ejecutar de varias formas: Como tareas de segundo plano (sin requisitos de tiempo real). Solucin ms sencilla, tiempo de respuesta medio excesivo. Procesado directo de eventos (a alta prioridad). Tiempo de respuesta muy bueno pero puede haber una expulsin excesiva sobre tareas de menos prioridad que sean crticas. Mediante servidores aperidicos. Son tareas que ejecutan las actividades aperidicas en momentos oportunos para no perturbar a las tareas crticas. Se van a considerar dos:
Servidor de muestreo (polling server). Tarea peridica que en cada activacin ejecuta las actividades correspondientes a eventos aperidicos pendientes de atender. T = D. Se debe limitar su tiempo de cmputo, tiempos de respuesta elevados. Servidor espordico (sporadic server). Se basa en la idea de reservar tiempo para atender eventos aperidicos. Si queda tiempo reservado, un evento se atiende inmediatamente (a la prioridad que le corresponda).
198
TAREAS APERIODICAS
Procesado en segundo plano
tr
Procesado directo
Exceso expulsin
Muestreo
Periodo
Servidor espordico
Procesado del evento Relleno Llegada del evento
199
SERVIDOR ESPORDICO
Varias posibles implementaciones dependiendo de la poltica de relleno. Una de las ms sencillas est basada en: Perodo de relleno. Igual al ritmo medio de llegada de los eventos. Capacidad de ejecucin. Tiempo de peor caso en el procesado de un evento. Asignacin de prioridades. En el peor caso el servidor espordico se comporta como una tarea peridica de perodo el tiempo de renovacin. El plazo de respuesta = periodo.
relleno tiempo renovacin
relleno
200
SERVIDOR ESPORDICO
En Ada
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 ;
201
SERVIDOR ESPORDICO
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 ;
202
SERVIDOR ESPORDICO
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, ...) ; }
203
TAREAS ESPORDICAS
Para poder garantizar plazos es preciso suponer una separacin mnima entre eventos, si. En el peor caso tarea peridica de perodo si y plazo de respuesta Di
Si la separacin est garantizada:

task body Sporadic_Server is begin loop Interrupt_Handler.Wait_for_Event ; Event_Processing ; end loop ; end Sporadic_Server ;
204
TAREAS ESPORDICAS
Rechazo de eventos que no cumplen el requisito de separacin mnima
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 ;
205
TAREAS ESPORDICAS
Ejemplo:
T T1 T2 T3 T4 C 1 2 2 2 D 5 6 7 8 P/S 6 8 9 10 Espordica Espordica
206
TAREAS ESPORDICAS
Anlisis:
C1 + I1 = 1 + 0 D1 = 5 D 6 C2 + 2 C1 = 2 + 1 = 3 D2 = 6 6 P 1 D D 7 7 C3 + 3 C1 + 3 C2 = 2 + 1 + 2 = 6 D3 = 7 6 8 P P2 1 D D D 8 8 8 C4 + 4 C1 + 4 C2 + 4 C3 = 2 + 1 + 2 + 2 = 8 D4 = 8 9 6 8 P P2 P3 1
por lo tanto todas las tareas cumplen sus plazos de respuesta
207
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 invocacin previa haya concluido su ejecucin Ni la asignacin de prioridades en orden de frecuencia ni la asignacin en orden de urgencia son ptimas Otro algoritmo de asignacin de prioridades
208

Ecuacin del tiempo de respuesta para sistemas con prioridades:
t t t fi = min C1 + ... + Ci 1 + Ci = t P t >0 1 Pi 1
Qu ocurre si tfi > Pi? Nueva activacin de Ti

Si Di Pi no importa porque la tarea no es planificable Si Di > Pi la primera ejecucin interfiere en la segunda y por lo tanto puede tener un tfi mayor
NO SIRVE LA ECUACIN
209

Ejemplo
T T1 T2
C 15 9
D 20 40
P 41 16
T1 T2
10
20
30
40
50
60
70
80
90
Periodo de ocupacin nivel 2
210

Teorema (Tindell, Burns & Wellings 1994): En un conjunto de tareas ordenadas por prioridad, el tiempo de respuesta de peor caso es:
t fi =
q = 0,1, 2,...Q
max
( wi (q ) qPi )
donde: wi(q) se calcula con:

wi ( q ) = (q + 1)Ci + Bi + wi (q ) C j Pj jhp (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 }
211

Aplicacin al ejemplo:
w (q) w (q) w2 ( q ) = C2 (1 + q ) + 2 C1 = 9(1 + q ) + 2 15 41 P 1
q=0
w (0) w2 (0) = 9 + 2 15 = 24 41 w2 (0) = 24 > 16 = (1 + q) P2 w (1) w2 (1) = 9(1 + 1) + 2 15 = 33 41 w2 (1) = 33 > 32 = (1 + q ) P2 w ( 2) w2 (2) = 9(1 + 2) + 2 15 = 57 41 w2 (2) = 57 > 48 = (1 + q ) P2
q=1
q=2
212

q=3
w (3) w2 (3) = 9(1 + 3) + 2 15 = 66 41 w2 (3) = 66 > 64 = (1 + q ) P2 w ( 4) w2 (4) = 9(1 + 4) + 2 15 = 75 41 w2 (4) = 75 80 = (1 + q ) P2
q=4
CONDICION DE PARADA CUMPLIDA

tf 2 =
max{24,33 16,57 32,66 48,75 64} = max{24,17,25,18,11} = 25
q = 0,1, 2,3, 4
max
( w2 ( q ) qP2 ) =
213
ASIGNACIN DE PRIORIDADES
La asignacin de prioridades DMS deja de ser ptima con plazos de respuesta arbitrarios Audsley (1991) desarroll un algoritmo de asignacin de prioridades estticas 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
214
Ejemplo:
T T1 T2 T3 C 2 9 15 D 50 40 20 P 50 16 41
ordered = 3, task = T1 => T1 mnima 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 mnima 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 P P3 1
215
q=0
w ( 0) w (0) w2 (0) = 9 + 2 2 + 2 15 = 26 50 41 w2 (0) = 26 > 16 = (1 + q ) P2 w (1) w (1) w2 (1) = 9(1 + 1) + 2 2 + 2 15 = 35 41 50 w2 (1) = 35 > 32 = (1 + q ) P2 w (1) w (1) w2 (2) = 9(1 + 2) + 2 2 + 2 15 = 61 50 41 w2 (2) = 61 > 48 = (1 + q ) P2
q=1
q=2
216
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 w (4) w ( 4) w2 (4) = 9(1 + 4) + 2 2 + 2 15 = 79 50 41 w2 (4) = 79 80 = (1 + q ) P2
q=4
tf 2 =
max{26,35 16,61 32,70 48,79 64} = max{26,19,29,22,15} = 29 < 40 = D2
q = 0,1, 2,3, 4
max
( w2 (q ) qP2 ) =
schedulable, ordered:= ordered - 1, finished, extract (T2)
217
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 mxima

t f 3 = C3 = 15 < 20 = D3
schedulable, ordered:= ordered - 1, finished
ordered = 0 => FIN
218
PLANIFICACIN BASADA EN PRIORIDADES DINMICAS - EDF -
219
PRIORIDADES DINMICAS - EDF

Asignar en cada instante la prioridad ms alta al proceso cuyo plazo de respuesta est ms prximo (Earliest Deadline First, EDF) La prioridad de una tarea se calcula en tiempo de ejecucin La prioridad de una tarea puede cambiar a lo largo de su ejecucin y en diferentes activaciones
Prioridades dinmicas
T T1 T2 T3
C 8 4 7
D 20 6 15
Activacin 0 6 9
T1 T2 T3 0 5 10 15 20 25
220
EDF
Earliest Deadline First es un mtodo de planificacin ptimo bajo las siguientes restricciones: Tareas independientes Planificacin expulsiva Sistemas monoprocesador
221
BASES DEL ANLISIS

Conjunto sncrono: todas las tareas se activan por primera vez en el mismo instante temporal Peor caso de una tarea espordica: activacin cada separacin mnima entre eventos = tarea peridica Un sistema de tareas espordicas cumple sus plazos de respuesta si y slo si su correspondiente conjunto de tareas peridicas sncronas cumple sus plazos de respuesta Peor caso de un conjunto de tareas peridicas: conjunto sncrono Un sistema hbrido de tareas (espordicas y peridicas) cumplir sus plazos de respuesta si y slo si su correspondiente conjunto de tareas peridicas sncronas cumple sus plazos de respuesta
222
FACTOR DE CARGA
Demanda de procesador
h[t ,t ) =
1 2
1 2
t1 rk , d k < t 2
1 2
Ck
t1 rk < t 2
h[t ,t ) W[t ,t ) = Ck
T1 T2 T3 0
3 5 6 12 14
18
h[3,18 ) = 4 + 4 + 6 = 14 h[0,13) = 4
La demanda slo cambia en rk y en dk
10
15
20
25
223
FACTOR DE CARGA
Factor de carga
u[t1 ,t2 ) =
t2 t1
h[t1 ,t2 )
Factor de carga absoluto
u = max u[t1 ,t2 ) 0t <t

1 2
T1 T2 T3 0
3 5 6 12 14
18
10
15
20
25
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 ) =
224
FACTOR DE CARGA
Teorema (Spuri, 1995): Un conjunto de tareas planificadas mediante el algoritmo EDF cumple sus plazos de respuesta si y slo si
u 1
T1 T2 T3 0
3 5 6 12 14
18
fallo
10
15
20
25
225
UTILIZACIN DEL PROCESADOR

Tareas peridicas, independientes, plazo de respuesta igual al perodo Teorema (Liu&Layland 1973): En un sistema de n tareas peridicas, sncronas, 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 slo si
U =
Ci 1 Ti i =1
En 1976 Coffman extiende el resultado para un conjunto de tareas peridicas asncronas
226
UTILIZACIN DEL PROCESADOR

Demostracin
U=
T Ci = T i =1 Ti
n
T Ci
i =1 i
= u[0,T )
(T = hiperperiodo )
t1 rk , d k t 2
Ck
n C t 2 t1 Ci = (t 2 t1 ) i u[t1 ,t2 ) U i =1 Ti i =1 Ti
u =U
227
DEMANDA DE PROCESADOR
Teorema: Cualquier conjunto hbrido de tareas con prioridades asignadas mediante el algoritmo EDF cumple sus plazos de respuesta si y slo si
t , h(t ) t
h(t) = h[0,t) en un sistema sncrono el factor absoluto de carga se da en un intervalo de la forma [0,t) u 1 h(t) t
228
Clculo de la demanda Sistema sncrono hiperperiodo = T = mcm(Ti)
h(t ) =
1 + T i Ci D t i
i
t D
La demanda slo cambia en los plazos de respuesta
S = {e j e j = mTi + Di ; m = 0,1,...; i [1, n]; e j T }
229
Ejemplo T1: C=3, D=4, P=4 T2: C=2, D=18, P=20 T3: C=1, D=3, P=10
T1 T2 T3 0
12
16
20 18 20
13
23
10
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 2c1 + c3 3c1 + c3 3c1 + 2c3 4c1 + 2c3 4c1 + c2 + 2c3 5c1 + c2 + 2c3
230
Teorema (Liu&Layland 1973, Spuri 1995, Ripoll&Crespo&Mok 1996): Si en un sistema sncrono de tareas con DiTi i y prioridades asignadas mediante el algoritmo EDF no cumple sus plazos de respuesta, entonces existe un fallo de plazo sin tiempo libre antes.
Clculo de la demanda durante el primer intervalo de ocupacin completa del procesador Longitud del intervalo (L): solucin ms pequea de la ecuacin
x = W (x) t W (t ) = Ci i =1 Ti
n
Clculo de la demanda en los puntos
S = {e j e j = mTi + Di ; m = 0,1,...; i [1, n]; e j L}
231
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 2c1 + c3 3c1 + c3 3c1 + 2c3 4c1 + 2c3
T1 T2 T3 0
12
16
20 18 20
13
23
10
15
20
25
232
NIVEL DE EXPULSIN
Una tarea Tj expulsar a otra Ti si:
t ai t aj t di t dj
Esta situacin slo se puede dar si Dj Di
Ti Tj
tai taj tdj
tdi
233
NIVEL DE EXPULSIN
El nivel de expulsin de una tarea Ti se denota i Una tarea Ti que puede expulsar a otra Tj tiene un nivel de expulsin 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 expulsin si
234
BLOQUEOS
Cundo una tarea puede sufrir un bloqueo con inversin de prioridades? La tarea Ti est activa y dentro de una seccin crtica La tarea Tj expulsa a la Ti (tdj < tdi) Para que esto suceda: i > j
Ti Tj
tai taj tdj
tdi
En EDF, una tarea Tj puede ser bloqueada por otra Ti de menor prioridad slo si Ti tiene mayor nivel de expulsin que Tj (i > j)
235
PROTOCOLOS
En EDF son vlidos los protocolos: Seccin crtica no expulsable Herencia de prioridades Techo de prioridad Aspectos a tener en cuenta: La definicin de los protocolos es la misma que con prioridades estticas El clculo de los tiempos de bloqueo es el mismo que con prioridades estticas pero atendiendo a los niveles de expulsin de las tareas, no a su prioridad (que cambia segn la situacin)
236
Tareas peridicas 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
C +b D + iD i 1 j =1 j i
i 1
Cj
Condicin suficiente, no necesaria Tareas ordenadas por nivel de expulsin
237
TECHO DE PRIORIDAD
Tareas peridicas 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 1 Pi i =1
n
Condicin suficiente, no necesaria
238
TECHO DE PRIORIDAD
Ejemplo:
Tarea P
T1 T2 T3 100 150 350
C
20 40 100
b
0 10 0
T1 P=100 ms C=20 ms
T2 P=150 ms C=40 ms S2 5 ms T3 P=350 ms C=100 ms 10 ms
iP i =1 i
C + bi
20 40 + 10 100 + + = 0.819 1 100 150 350
239
PLANIFICACIN DINMICA
Tipos de planificaciones: Planificacin Esttica
Se realiza la planificacin antes del tiempo de ejecucin Se requiere un conocimiento previo de todas las caractersticas de las tareas el sistema Poco coste en ejecucin Planificacin cclica, RMS, DMS, ...
Planificacin Dinmica
Se construye el plan en tiempo de ejecucin Se adapta a cambios
Llegada de nuevas tareas al sistema Desaparicin de tareas Cambios en el entorno
Gran coste de ejecucin EDF permite la planificacin dinmica
240
PLANIFICACIN DINMICA
Se conocen a priori todas las tareas y sus caractersticas Anlisis previo de planificabilidad Todas las tareas cumplirn plazos No se conocen las tareas y sus caractersticas. Dos aproximaciones cuando llega el evento de activacin de una tarea: Control de admisin. La ejecucin de la tarea se iniciar slo si pasa un test de planificabilidad, esto es, todas las tareas del sistema incluyendo la nueva cumplirn sus plazos. Si no pasa el test:
la activacin es rechazada una accin correctora puede ser ejecutada
No se realiza un test de aceptacin. No se sabe a priori si una tarea que ha comenzado su ejecucin cumplir su plazo de respuesta:
una tarea puede ser abortada una accin correctora puede ser ejecutada
241
PROGRAMACIN DE UN PLANIFICADOR
Caractersticas Prioridades dinmicas Ada 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.PriorityLast ; 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 ;
242
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 ;
243
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 ;
244
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 ;
245
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 ;
246
MANEJADORES DE DISPOSITIVOS
247
MECANISMOS DE ENTRADA-SALIDA
Los sistemas tiempo real se conectan a los sistemas fsicos que controlan por medio de dispositivos de entrada y salida especficos (sensores, actuadores, etc.), que suelen requerir un tratamiento especial en cada caso. Esquema genrico:
SISTEMA CONTROL MANEJADOR DE DISPOSITIVO CONTROLADOR DE DISPOSITIVO
DISPOSITIVO
248
Los controladores presentan como interfase al procesador un conjunto de registros (estado, control, datos). Existen dos formas bsicas de conectar un controlador a una cierta arquitectura: Mediante un bus especfico 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 mquina 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
249
El manejo de un controlador de dispositivos: Activacin de la operacin
Por programa Autnoma Exterior
Paso de los datos

Interrupcin: el controlador interrumpe al procesador cuando termina una operacin y fuerza la ejecucin de un manejador. DMA: acceso directo a memoria Muestreo: el procesador interroga cada cierto tiempo al controlador sobre el estado de la operacin.
250
EJEMPLO
Supondremos un sistema de entradasalida con direccionamiento en espacio de memoria. Cada controlador tiene dos tipos de registros: Registros de control y estado (CSR). Se dividen en campos correspondientes a operaciones o componentes de estado. Registros de datos (DBR). Contienen datos que se transmiten hacia o desde el dispositivo. Por ejemplo, el registro de control y estado de un convertidor analgicodigital con 64 canales de entrada podra tener esta estructura:
Bits Funcin 0 Arranca 1-5 No utilizados 6 Interrupcin permitida 7 Terminado 8-13 Canal 14 No utilizado 15 Error
Extrado de las transparencias de Tiempo Real de Juan Antonio de la Puente (DIT/UPM)
251
EJEMPLO
0 1
63
MUX
A/D
12 bits
LCI
6 bits
14 13
15
12 11
TI
16 bits
A
RD 8#176560#
M
16 bits
RC 8#176562#
BUS DEL SISTEMA
INTERRUPCION Vector: 8#100#
252
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 ;
253
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;
254
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;
255
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;
256
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;
257
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;
258
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;
259
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;
260
TOLERANCIA A FALLOS. EXCEPCIONES
261
INTRODUCCIN
En un sistema Tiempo Real no es permisible: Finalizacin inesperada Bloqueos Salidas errneas Dos aproximaciones complementarias para obtener sistemas fiables: Prevencin 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
262
CONCEPTOS DE TOLERANCIA A FALLOS FALLO ERROR FRACASO
Tipos de fallos: Fallos transitorios (p.e. interferencias electro-magnticas) Fallos permanentes (p.e. un error de diseo 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)
263
CONCEPTOS DE TOLERANCIA A FALLOS Comportamiento Observable

FRACASO
Interno
FALLO
ERROR
264
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: Prevencin de fallos Tolerancia a fallos
265
PREVENCIN DE FALLOS
Dos fases: Evitacin de fallos durante la construccin del sistema. Con respecto al software:
Especificacin de requisitos rigurosa o formal Uso de metodologas de diseo probadas Uso de lenguajes que faciliten la modularidad y abstraccin de datos Uso de herramientas CASE que faciliten el manejo de la complejidad del software
Eliminacin de los fallos introducidos en el software, generalmente mediante tests del sistema. Problemas:
Un test slo muestra la presencia de fallos, no su ausencia No tests en condiciones reales
266
TOLERANCIA A FALLOS
Diversos grados de tolerancia a fallos: Tolerancia a fallos completa Tolerancia con degradacin Parada segura
Tolerancia a fallos redundancia
Redundancia: incorporacin de elementos extras (redundantes) no necesarios en funcionamiento normal.

Redundancia esttica: los componentes redundantes operan siempre incluso sin fallos (p.e. programacin N-versin) Redundancia dinmica: los componentes redundantes operan cuando hay un fallo (p.e. bloques de recuperacin, excepciones)
267
PROGRAMACIN N-VERSIN
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 programacin, diferentes entornos de desarrollo, diferentes programadores Ejecucin: las versiones no comunican entre s Funcionamiento: Cada diseo se comunica nicamente con el controlador Cada diseo emite un resultado (voto) El controlador compara los votos y elige el resultado ms votado
268
PROGRAMACIN N-VERSIN
Versin 1 Versin 2 Versin 3
CONTROL
269
REDUNDANCIA DINMICA
Los componentes redundantes actuan nicamente cuando se ha detectado un fallo. Fases: Deteccin del error Evaluacin del dao Recuperacin del error Tratamiento del fallo
Deteccin del error. Dos clases de tcnicas:
Deteccin por el entorno donde se ejecuta la aplicacin ("hardware", soporte "run-time"). Deteccin implcita. Deteccin por la propia aplicacin mediante chequeos. Deteccin explcita.
if not CONDICION_REQUERIDA then ERROR ; end if ;
270
REDUNDANCIA DINMICA
Recuperacin del error. Dos aproximaciones diferentes:
Recuperacin hacia adelante: se intenta continuar desde un estado errneo realizando correcciones selectivas en dicho estado. Recuperacin hacia atrs: se restaura un estado correcto (punto de recuperacin) anterior a la ocurrencia del error. Generalmente se contina utilizando un procedimiento alternativo al que ha fallado.
...
Proc. alternativo Hacia adelante
ERROR
271
BLOQUES DE RECUPERACIN
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. recuperacin Mod?
si
Siguiente mdulo
Test
si
Pto. recuperacin
no
FRACASO
272
PROBLEMAS
Problemas en la programacin N-versin y en los bloques de recuperacin:
Costos de desarrollo grandes: ambas aproximaciones requieren algoritmos alternativos La programacin N-versin requiere N veces los recursos de una versin. La recuperacin del estado y la ejecucin de una alternativa, en los bloques de recuperacin, 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 tcnicas.
273
EXCEPCIONES
Caractersticas: Redundancia dinmica Recuperacin hacia delante
Deteccin de un error
Levantamiento de una excepcin
Ejecucin de un manejador de la excepcin
274
EXCEPCIONES
Peticin servicio
Respuesta normal
Excepciones de interfase
Excepciones de fracaso
Vuelta servicio normal Manejadores de excepciones
Actividad normal
Peticin Respuesta servicio normal
Excepciones internas Excepciones Excepciones de interfase de fracaso
275
DOMINIO DEL MANEJADOR DE UNA EXCEPCIN

Dentro de un programa puede haber varios manejadores de una misma excepcin.
Cada uno tiene un dominio: si la excepcin se levanta en ese dominio el manejador correspondiente se activa.
Lenguaje orientado a bloques dominio = bloque
276
EXCEPCIONES. MODELOS.
Modelo de reanudacin (PEARL)
Q Ex
Manejador Ex
277
EXCEPCIONES. MODELOS.
Modelo de terminacin (Ada, CHILL)
Q Ex
Manejador Ex
278
PROPAGACIN DE EXCEPCIONES
Qu sucede si se levanta una excepcin en un bloque donde no existe manejador para ella?
Dos aproximaciones:
Enlace esttico: en tiempo de compilacin se establece un enlace entre excepcin-contexto y su manejador Enlace dinmico: bsqueda de un manejador a lo largo de la cadena de invocadores del bloque propagacin
279
PROPAGACIN DE EXCEPCIONES
Propagacin
P Q R Ei
Mi
R Ei
Propagacin explcita
Mi Mi raise
Mi raise
280
PROGRAMACIN SECUENCIAL. ADA2005
281
CUESTIONES BSICAS
Ada2005 es un lenguaje de la familia del Pascal Lxico: No hay distinciones entre maysculas y minsculas. Los identificadores pueden contener cualquier nmero de caracteres. Puede utilizarse el carcter "_" en los identificadores para hacerlos ms legibles:
Ejemplo_de_identificador
Los comentarios empiezan con "--" y van hasta el final de la lnea
282
TIPOS DE DATOS
Ada es un lenguaje fuertemente tipado. No se pueden copiar valores de un tipo en variables de otro. Creacin de tipos Desde cero Basndose en otros
Subtipo restriccin de un cierto tipo base. copia (posiblemente restringida) de un tipo base. Tipo derivado
Los subtipos de un mismo tipo son compatibles. No as los derivados. Tipos predefinidos:
integer, positive, ..., float boolean character
283
TIPOS DE DATOS
Elementales Access Scalar
Discrete

Compuestos Array Record Protected Task
Enumeration Integer Signed Modular
Real
Fixed Decimal Ordinary
Floating
284
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 especficos:

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 **
285
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 ;
286
TIPOS DISCRETOS
Tipo boolean
type boolean is (false,true) ;
Las operaciones predefinidas son: not and or xor Tambin 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 carcter
Comprende todos los caracteres ASCII Tambin hay tiras de caracteres. 'C' es un carcter. "C" es una tira de un solo carcter.
287
TIPOS REALES
En los sistemas de control es necesario utilizar valores reales. Hay dos formas de representar estos valores: Nmeros con coma flotante:
Se representan como M*RE Tiene una precisin relativa al tamao del nmero (M longitud finita) Son adecuados para realizar clculos en los cuales no se necesiten resultados exactos
Coma fija, nmeros con escala

Se representan como V*S Tiene una precisin absoluta determinada Son adecuados para representar valores analgicos en el computador
En Ada se pueden definir ambas formas de reales.
288
TIPOS REALES
Coma flotante: El tipo float est predefinido, pero es mejor definir tipos especficos:
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 ningn 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: Coma fija: + - * / abs ** + - * / abs
Funciones matemticas en paquetes.
289
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) ;
290
TIPOS ESTRUCTURADOS
Registros
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;
Agregados
declare F: FECHA; begin F.AGNO := 1990 ; F:= (1, 3, 1990) ; F:= (AGNO => 1992, DIA => 1, MES => 4); end ;
291
OBJETOS DINMICOS
Los tipos acceso permiten acceder a objetos dinmicos.
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
292
ESTRUCTURAS DE CONTROL
Secuencia
instruccion; instruccion; instruccion;
Bloques
declare <parte declarativa> begin <secuencia de instrucciones> exception <manejadores de excepciones> end;
declare TEMP: integer := A ; begin A := B ; B := TEMP ; end ;
Siempre se puede poner un bloque en lugar de una instruccin.La parte declarativa (constantes, variables, tipos, subprogramas, paquetes y tareas) y la de excepciones son optativas.
293
Seleccin
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 ;
294
Iteracin
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 ;
295
SUBPROGRAMAS
Son los procedimientos y las funciones. Modos de los parmetros: in, out e in out Ejemplo:
procedure CUADRATICA (A,B,C: in float; R1,R2: out float; OK : out boolean);
Un parmetro in se compota como una constante local cuyo valor es del parmetro real. Un parmetro out se comporta como una variable a la que slo se le puede asignar valor. Este valor se copia al parmetro real. Un parmetro in out se comporta como una variable cuyo valor inicial es del parmetro real, y cuyo valor final se vuelve a copiar al mismo. El modo por defecto es in.
296
SUBPROGRAMAS
Procedimientos Se puede declarar una especificacin y despus 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;
297
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) ; -- parmetro por defecto AJUSTAR(3) ; -- notacin nombrada AJUSTAR(POSICION => ABIERTO ; VALVULA_N => 9) ;
En Ada, todos los subprogramas son reentrantes y se pueden llamar recursivamente.
298
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 invocacin se hace de forma habitual:

C := MINIMO(A,B) ;
Las formas de llamadas de los procedimientos son vlidas tambin para las funciones.
299
GRANDES PROGRAMAS. FACILIDADES DEL LENGUAJE

Grandes programas => Descomposicin modular Mdulo: es un coleccin de objetos y operaciones relacionados entre s. En Ada los mdulos se denominan paquetes (packages).
La estructura de mdulos del Ada permite utilizar algunas tcnicas que facilitan el desarrollo de programas grandes: Ocultamiento de informacin, tipos abstractos de datos Compilacin separada Reutilizacin del Software Programacin orientada a objeto
300
OCULTACIN DE LA INFORMACIN
Un paquete permite controlar la visibilidad de sus objetos. Un paquete tiene dos partes: Especificacin: Contiene las declaraciones y especificaciones que son visibles fuera del paquete (define su interfase). Cuerpo: Contiene los detalles de implementacin 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 ;
301
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: Especificacin: declaracin del tipo + operaciones Cuerpo: implementacin operaciones
Tipo privado: es un tipo visible en la especificacin de un paquete pero su implementacin est oculta. Operaciones predefinidas: asignacin, comparaciones de igualdad y no igualdad.
Tipo privado limitado: no tiene ninguna operacin predefinida, slo se le pueden aplicar las explcitamente definidas en la especificacin del paquete.
302
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 ;
303
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;
304
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 ;
305
COMPILACIN SEPARADA
Un programa grande puede ser dividido en unidades de compilacin, que se pueden compilar por separado: Especificacin de paquetes Cuerpo de paquetes (primero hay que compilar la especificacin) Subprogramas (procedimientos y funciones) Una de las unidades de compilacin (un procedimiento) hace el papel de programa principal. Ada no tiene un constructor especfico para el programa principal. El procedimiento principal no tiene parmetros.
306
COMPILACIN SEPARADA
La dependencia entre unidades se indica con la clusula with.
with hace visibles las declaraciones del paquete a las que se refiere.
Se puede aadir use => no es preciso anteponer el nombre del mdulo al del objeto referenciado.
package PLANIFICADOR is -- especificacin 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 ;
307
REUTILIZACIN DEL SOFTWARE

Reutilizacin de componentes de software => mejora productividad y calidad. Tipado inconveniente. Cmo hacer colas que no dependan del tipo de elemento? --> procedimientos, funciones o paquetes genricos
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 especfico ELEMENTO:

declare package COLAS_DE_ENTEROS is new COLAS(ELEMENTO => integer) ; use COLAS_DE_ENTEROS ; begin end ;
308
ENTRADAS SALIDAS. ASPECTOS BSICOS

Las operaciones de entradas/salidas en Ada estn definidas en paquetes estndar. Algunos genricos permiten su instanciacin para diversos tipos.
Los paquetes estndar del Ada son: Ada.Direct_IO: Paquete genrico de acceso directo a ficheros binarios Ada.Sequential_IO: Paquete genrico de acceso secuencial a ficheros binarios Ada.Text_IO: Paquete para ficheros de texto y entradas-salidas por terminal. Contiene seis paquetes genricos especficos:
Integer_IO Float_IO Fixed_IO Enumeration_IO Modular_IO Decimal_IO
309

Un fichero en Ada 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: Nmero de objetos almacenados en el fichero
310

Operaciones bsicas: 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
311
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); -- Gestin 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; ...
312
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 implementacin 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;
313
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 lnea y de lnea -- en una pgina, y formatos type count is range 0..dep_implementacin; subtype positive_count is count range 1..count'last; unbounded:constant count:=0; subtype field is integer range 0..dep_implementacin; subtype number_base is integer range 2..16; type type_set is (lower_case,upper_case); -- Gestin 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' ...
314
FICHEROS DE TEXTO
... -- Especificacin de longitudes de lnea y pgina 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 parmetro file -- Control de columnas, lneas y pginas 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 parmetro file ...
315
FICHEROS DE TEXTO
... -- Entrada/salida de caracteres procedure get(item:out character); procedure put(item:in character); -- Lo mismo con un parmetro 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 parmetro file ...
316
FICHEROS DE TEXTO
Entradas-salidas de nmeros enteros: subpaquete genrico.
... -- Paquete genrico 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 parmetro 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; ...
317
FICHEROS DE TEXTO
Entradas-salidas de nmeros de tipo mdulo: subpaquete genrico.
... -- Paquete genrico de e/s de enteros modulo generic type num is mod <>; package modular_io is -- Lo mismo que en Integer_IO end modular_io ; ...
318
FICHEROS DE TEXTO
Entradas-salidas de nmeros coma flotante: subpaquete genrico.
... -- Paquete genrico 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 parmetro 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; ...
319
FICHEROS DE TEXTO
Entradas-salidas de nmeros coma fija: subpaquete genrico.
... -- Paquete genrico de e/s de tipos reales -- (de coma fija) generic type num is delta <>; package fixed_io is default_fore:field:=numfore; default_aft:field:=num'aft; default_exp:field:=0; -- Lo mismo que en Float_IO end fixed_io ; ...
320
FICHEROS DE TEXTO
Entradas-salidas de tipos enumerados: subpaquete genrico.
... -- Mdulo genrico de e/s de tipos definidos por enumeracin 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 parmetro 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 implementacin end Ada.text_io;
321
FICHEROS DE TEXTO
Los paquetes genricos 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, ...
322
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;
323
PROGRAMACIN CONCURRENTE. ADA2005
324
ASPECTOS BSICOS
Primitivas de concurrencia en Ada Procesos task Monitores protected Comunicacin sncrona: cita extendida entry Seleccin indeterminista select Otros:
Requeue Asynchronous transfert of control
325
TAREAS
En Ada: Procesos = tareas (task) El manejo de tareas en Ada2005 es realizado por un ncleo (RTS) que forma parte del entorno de ejecucin.
Una tarea tiene dos partes:

Especificacin: declaracin de los puntos de entrada Cuerpo
326
UN EJEMPLO
Dos bucles de control: temperatura y nivel Especificacin:
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 ;
327
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 ;
328
TAREAS
Tipos tarea Es til poder definir grupos de tareas similares. La declaracin de un tipo tarea permite disponer de una plantilla para crear tareas similares. Tareas dinmicas Se pueden crear dinmicamente tareas new.
Son arrancadas en el momento que se crean
329
DEPENDENCIA, ACTIVACIN, TERMINACIN

Toda tarea depende de una unidad progenitora. Las tareas estticas: Dependen del bloque, subprograma o cuerpo de tarea donde se declaran. Se activan justo antes de empezar la ejecucin de la unidad progenitora. Una unidad no puede terminar hasta que terminen todas las tareas que dependen de ella. Las tareas definidas en paquetes dependen del programa principal. Las tareas dinmicas 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 despus de que termine la unidad donde se crean.
330

Cita extendida (rendez-vous)
Algunas caractersticas: 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 algn parmetro Se pueden definir familias de puntos de entrada
331

Ejemplo de entrada de inicializacin.
with ; use ; procedure System is task T1 is entry initialize (P: parameters) ; end T1 ; task T2 is entry initialize (P: parameters) ; end T2 ; task body T1 is begin accept initialize (P: parameters) do local_parameters := P ; end initialize ; loop ; end loop ; end T1 ; task body T2 is begin accept initialize (P: parameters) do local_parameters := P ; end initialize ; loop ; end loop ; end T2 ; begin read_parameters_file (P12) ; T1.initialize (P12.T1) ; T2.initialize (P12.T1) ; end System ;
332
SELECCIN DE LLAMADAS
Seleccin indeterminista: Es una estructura de control indeterminista que slo puede ir en el cuerpo de una tarea: select <alternativa_1> or <alternativa_2> or end select ; Funcionamiento: Si se recibe una llamada a una de las entradas alternativas, se acepta y despus se termina el select. Si se reciben llamadas a varias entradas simultneamente, se acepta una de ellas de acuerdo a la poltica de colas establecida y despus se termina el select. Si no hay llamadas pendientes, la tarea espera en el select hasta que llegue una.
Cada alternativa es una instruccin select que puede ir seguida de una secuencia de instrucciones.
333
SELECCIN DE LLAMADAS
El ejemplo de monitor:
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 estn completadas o esperando en un select con terminate. En este caso terminan todas simultneamente.
334
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 tambin 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.
335
ALTERNATIVAS GUARDADAS
A veces es necesario que alguna de las alternativas de un select se acepte slo en determinadas condiciones. Esto se hace poniendo una guarda:
when <condicion> => accept <entrada> do ...
En un select con guardas, se evalan todas las guardas y slo se consideran para la seleccin las que son ciertas (alternativas abiertas). Una alternativa sin guarda est siempre abierta.
336
ALTERNATIVAS GUARDADAS
Ejemplo: un semforo
task semaphore is entry wait ; entry signal ; end semaphore ; task body semaphore is value: natural := 0 ; begin loop select when value > 0 => accept wait ; value := value - 1 ; or accept signal ; value := value + 1 ; or terminate ; end select ; end loop ; end semaphore ;
337
PROTECTED
Tienen una semntica 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 exclusin mutua a los datos protegidos Protected functions: acceso concurrente, slo lectura, a los datos Entries: como las procedures, pero permiten especificar barriers (guardas).
Se pueden definir objetos y tipos protegidos (similar a las tareas).
338
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;
339
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;
340
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;
341
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 ;
342
PRIVATE ENTRIES
Existen varias razones para que una tarea o protected declare como privada una entrada (no pblica): 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 interrupcin de hardware y el programador no quiere que ninguna otra tarea llame a esa entrada. Ejemplo de declaracin 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
343
REQUEUE
Existen situaciones en las cuales las guardas no son suficientes: La aceptacin de una cita no depende nicamente del estado del aceptador si no tambin del llamador
para aceptar o no una cita de haber un intercambio previo de informacin
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 ;
344
REQUEUE
Solucin: 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_RangeLast ; New_Resources_Released: Boolean:= False ; To_Try: Natural := 0 ; ... end Resource_Controller ;
345
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 ;
346
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 ;
347
REQUEUE
procedure Release (R: Resource ; Amount: Request_Range) is begin Free := Free + Amount ; -- Free resources if Assigncount > 0 then To_Try := AssignCount ; New_Resources_Released:= true ; end if ; end Release ; end Resource_Controller ;
348
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 ejecucin de codigo_abortable, dicha ejecucin es abortada Si codigo_abortable acaba su ejecucin entonces la llamada es cancelada
select entry_call_statement then abort codigo_abortable end select ;
349
ASYNCHRONOUS TRANSFER OF CONTROL

Ejemplo:
loop select Terminal.Wait_For_Interrupt; Put_Line(Interrupted); then abort Put_Line(Enter Command--> ); Get_Line(Command, Last); Parse_and_Process (Command (1..Last) ) ; end select ; end loop ;
protected Terminal is entry Wait_for_Interrupt ; private procedure Ctrl_C ; end Terminal ; protected body Terminal is entry Wait_for_Interrupt when Int_Received is begin Int_Received := false ; end ; procedure Ctrl_C is begin Int_Received := true ; end ; end Terminal ;
350
MEDIDA Y CONTROL DEL TIEMPO EN Ada 2005
351
MEDIDA DE TIEMPOS EN Ada 2005

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 funcin 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 ms pequea Define un tipo abstracto Time La funcin Clock da un valor montono (durante ms de 50 aos desde el arranque de la aplicacin) Los intervalos de tiempo se representan con el tipo abstracto Time_Span
352
MEDIDA DE TIEMPOS EN Ada 2005

DURATION: Es un tipo predefinido que representa intervalos de tiempo en segundos. Es un tipo coma fija => no se pierde precisin al sumar o restar intervalos de tiempo: type DURATION is delta range ; Su precisin depende de la implementacin. Su valor, DURATION'SMALL, no debe ser mayor de 20 ms, aunque se recomienda que no sobrepase los 50 s. El intervalo de valores tambin depende de la implementacin. Debe poder representar valores positivos y negativos hasta la duracin de un da: -86400.0 .. +86400.0
353
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 funcin CLOCK, adems 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 ;
354
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 ;
355
Ada.Calendar
function function function function 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;
"<" (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;
356
Ada.Real_Time
En el anexo Real-Time Systems se define un paquete para manejo del tiempo en aplicaciones de tiempo real: tiempo monotnico y reloj de alta resolucin
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;
357
Ada.Real_Time
function function function function function function function function function function function function function
"+" "+" "-" "-"
(Left: (Left: (Left: (Left:
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, "<="(Left, ">" (Left, ">="(Left, "+" "-" "-" "*" "*"
(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;
358
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;
359
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;
360
RETARDOS Y TIME-OUTS
Los retardos en Ada 2005 se pueden realizan mediante dos instrucciones: delay <duracion> ; delay until <time> ;
Calendar.Time Ada.Real_Time.Time
361
En Ada 2005, 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 seleccin de entradas. La limitacin del tiempo de aceptacin o seleccin se hace mediante una seleccin temporizada:
select accept <entrada> or or delay <duracion> ; -- delay until <time> ; <instrucciones> end select ;
NOTA: el select puede tener como mximo: una parte else o una alternativa terminate o una o varias alternativas delay.
362
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 ;
363
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 ;
364
En Ada 2005 se puede limitar el tiempo de ejecucin de un cdigo mediante un Asynchronous Transfer of Control:
select delay Time_out ; <instrucciones> then abort codigo_con_plazo_de_respuesta ; end select ;
365
RELOJES DE TIEMPO DE EJECUCIN

Son relojes que permiten medir el tiempo de cmputo de una tarea individual
with Ada.Task_Identification; with Ada.Real_Time; use Ada.Real_Time; package Ada.Execution_Time is type CPU_Time is private; CPU_Time_First : constant CPU_Time; CPU_Time_Last : constant CPU_Time; CPU_Time_Unit : constant := implementation-defined-real-number; function Clock (T : Ada.Task_Identification.Task_Id := Ada.Task_Identification.Current_Task) return CPU_Time; function function function function "+" "+" "-" "-" (Left (Left (Left (Left : : : : CPU_Time; Right : Time_Span) return CPU_Time; Time_Span; Right : CPU_Time) return CPU_Time; CPU_Time; Right : Time_Span) return CPU_Time; CPU_Time; Right : CPU_Time) return Time_Span;
366
RELOJES DE TIEMPO DE EJECUCIN
function function function function
"<" (Left, Right : CPU_Time) return Boolean; "<=" (Left, Right : CPU_Time) return Boolean; ">" (Left, Right : CPU_Time) return Boolean; ">=" (Left, Right : CPU_Time) return Boolean;
procedure Split (T : in CPU_Time; SC : out Seconds_Count; TS : out Time_Span); function Time_Of (SC : Seconds_Count; TS : Time_Span := Time_Span_Zero) return CPU_Time; private ... -- not specified by the language end Ada.Execution_Time;
367
TEMPORIZADORES DE TIEMPO DE EJECUCIN

Permiten activar eventos en funcin del tiempo de cmputo consumido por una tarea
with System; package Ada.Execution_Time.Timers is type Timer (T : access Ada.Task_Identification.Task_Id) is tagged limited private; type Timer_Handler is access protected procedure (TM : in out Timer); Min_Handler_Ceiling : constant System.Any_Priority := implementation-defined; procedure Set_Handler (TM : in In_Time Handler procedure Set_Handler (TM : in At_Time Handler out Timer; : in Time_Span; : in Timer_Handler); out Timer; : in CPU_Time; : in Timer_Handler);
368
function Current_Handler (TM : Timer) return Timer_Handler; procedure Cancel_Handler (TM : in out Timer; Cancelled : in out Boolean); function Time_Remaining (TM : Timer) return Time_Span; Timer_Resource_Error : exception; private ... -- not specified by the language end Ada.Execution_Time.Timers;
369

Ejemplo
Periodic_Id : aliased Ada.Task_Identification.Task_Id := Periodic'Identity; WCET_Timer : Ada.Execution_Time.Timers.Timer (Periodic_Id'Access); task body Periodic is Next_Start : Ada.Real_Time.Time := Ada.Real_Time.Clock; WCET : constant Time_Span := Milliseconds(1); Period : constant Time_Span := Milliseconds(100);; OK : Boolean; begin loop Set_Handler (WCET_Timer, WCET, Supervisor.OverrunAccess); -- actividad peridica Cancel_Handler (WCET_Timer, OK); Next_Start := Next_Start + Period; delay until Next_Start; end loop; end Periodic;
370

Ejemplo
protected Supervisor is procedure Overrun; private end Supervisor; protected body Supervisor is procedure Overrun is begin end Overrun; end Supervisor;
371
PRIORIDADES
En Ada 2005 se asigna una prioridad a una tarea (o protected) o a todas las tareas (protected) de un tipo incluyendo un pragma PRIORITY en la especificacin correspondiente:
task T is pragma PRIORITY(<prioridad>) ; end T ; task type TT is pragma PRIORITY(<prioridad>) ; end TT ;
372
PRIORIDADES
La prioridad es una expresin esttica del tipo predefinido SYSTEM.PRIORITY, que a su vez es un subintervalo del tipo integer. El intervalo de valores depende de la implementacin. Los valores ms altos corresponden a las tareas ms prioritarias.
subtype Any_Priority is Integer range implementation-defined ; subtype Priority is Any_Priority range Any_Priorityfirst..implementation-defined ; subtype Interrupt_Priority is Any_Priority range Prioritylast.. Any_Prioritylast;
373
PRIORIDADES
Propiedades del modelo de prioridades de Ada 2005: La planificacin predefinida es expulsiva con prioridades estticas. Existen pragmas que pueden configurar la poltica de planificacin del RTS Las prioridades estticas se pueden cambiar explcitamente en tiempo de ejecucin. Todas las tareas del mismo tipo tienen la misma prioridad.
374
POLITICAS DE PLANIFICACIN
pragma Task_Dispatching_Policy (policy_identifier) Permite elegir la poltica de planificacin del RTS
FIFO_Within_Priorities Non_Preemtive_ FIFO_Within_Priorities Round_Robin_ Within_Priorities EDF_Across_ Priorities
Los compiladores pueden implementar otras polticas pragma Locking_Policy (policy_identifier) Poltica de interaccin entre las tareas y los objetos protegidos Ceiling_Locking est predefinida Los compiladores pueden implementar otras polticas pragma Queuing_Policy (policy_identifier) Especifica como se encolan las llamadas a un entry FIFO_Queuing y Priority_Queuing estn predefinidas Los compiladores pueden implementar otras polticas
375
PRIORIDADES
En Ada 2005 se puede cambiar en tiempo de ejecucin 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;
376
PROGRAMACIN DE BAJO NIVEL
377
Mecanismos de bajo nivel en Ada

Ada tiene varios mecanismos de bajo nivel que permiten acceder a registros, direcciones e interrupciones clusulas de representacin
permiten especificar la representacin de tipos y objetos en la arquitectura de hardware

atributos de representacin (tamao, direccin, alineacin) representacin de tipos enumerados representacin de registros
manejadores de interrupciones
permiten asociar una interrupcin a un procedimiento protegido
subprogramas en lenguaje de mquina

permiten un control total sobre la arquitectura de hardware
378
Paquete System
En cada implementacin de un compilador Ada hay un paquete predefinido (SYSTEM) que incluye la definicin de caractersticas dependientes de la mquina, importantes para la programacin bajo nivel.
package System is pragma Pure(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; ...
379
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;
380
ATRIBUTOS DE REPRESENTACIN
Para cualquier objeto, unidad de programa, etiqueta o entry X: Xaddress Para cualquier tipo o subtipo, u objeto X: Xsize (en bits) Para cualquier tipo acceso o subtipo T: Tstorage_size (en unidades de memoria) Para cualquier tipo tarea u objeto tarea T: Tstorage_size (en unidades de memoria) Para cualquier componente C de un registro R: R.Cposition (en unidades de memoria) R.Cfirst_bit (en bits) R.Clast_bit (en bits)
381
CLAUSULAS DE REPRESENTACIN
Direccin del objeto:
DATOS: REGISTRO_DE_DATOS; for DATOSAddress 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;
Representacin de un tipo enumerado:

type INDICADOR is (SI,NO); for INDICADOR use (SI => 1, NO => 0) ;
Alineacin
for REGISTRO_DE_DATOSAlignment use 2;
382
CLAUSULAS DE REPRESENTACIN
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;
; ; ; ; ;
383
CONVERSIN DE TIPOS
A veces hay que interpretar un dato de un tipo como si fuera de otro tipo, copiando directamente su representacin binaria. Se hace con un procedimiento genrico predefinido:
generic type SOURCE (<>) is limited private ; type TARGET (<>) is limited private ; function Ada.Unchequed_Conversion(S: SOURCE) return TARGET ;
384
CONVERSIN 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 ;
385
INTERRUPCIONES
Los manejadores de interrupciones son procedimientos protegidos sin parmetros. Cada interrupcin 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 interrupcin
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 interrupcin
la asociacin con una interrupcin se hace dinmicamente pragma Interrupt_Handler (Handler_Name) ;
386
INTERRUPCIONES
Se puede especificar la prioridad del manejador de una interrupcin el pragma Interrupt_Priority en la especificacin del objeto protegido
pragma Interrupt_Priority (Priority_Value) ;
El valor de la prioridad debe pertenecer al subtipo:

System.Interrupt_Priority
387
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;
388
INTERRUPCIONES
E j e m p l o
protected body Interrupt_Handler is 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 ;
389
SUBPROGRAMAS EN LENGUAJE MAQUINA

A veces es necesario realizar algn componente de software en lenguaje ensamblador. En Ada 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 instruccin de mquina, y agregado es del tipo anterior. Adems, puede haber pragmas especficos para indicar el uso de los registros del procesador u otras caractersticas de bajo nivel.
390

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 ;
391
procedure INHIBIR_INTERRUPCIONES ; pragma INLINE(INHIBIR_INTERRUPCIONES) ; procedure INHIBIR_INTERRUPCIONES is use MACHINE_CODE; begin INSTRUCCION'(COP => CLI, OPR => 0) ; end INHIBIR_INTERRUPCIONES ;
392
SUBPROGRAMAS EN OTROS LENGUAJES

El pragma IMPORT permite utilizar subprogramas escritos en otros lenguajes de programacin. Ejemplo:
package FORTRAN_LIB is function SQRT(X: FLOAT) return FLOAT ; function EXP(X: FLOAT) return FLOAT ; private pragma import(FORTRAN, SQRT) ; pragma import(FORTRAN, EXP) ; end FORTRAN_LIB ;
393
EXCEPCIONES EN Ada2005
394
MODELO. DECLARACIN
Modelo de terminacin. Enlace dinmico 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: Divisin por cero, sobrepasamiento. PROGRAM_ERROR: Acceso a procedimientos, mdulos, , seleccin, STORAGE_ERROR: Variables y memoria dinmica. TASKING_ERROR: Comunicacin y ejecucin de tareas.
395
ACTIVACIN
Explcita (deteccin de errores por la aplicacin):
raise ERROR_DE_PARIDAD ;
Implcita (deteccin de errores por el entorno):

el compilador genera el cdigo para levantar las excepciones predefinidas.
396
MANEJADOR
Manejador: se situa al final de un bloque, procedimiento o funcin, 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 ;
397
EJEMPLO. CONVERSIN 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 ;
398
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 ;
399
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 ;
400
EJEMPLO. BLOQUES DE RECUPERACIN

Implementacin de la tcnica de los bloques de recuperacin 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;
401
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;
402

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;
403

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;

Sistemas de Tiempo Real

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Sistemas de Tiempo Real

Загружено:

Авторское право:

Доступные форматы

SISTEMAS DE TIEMPO REAL