Junio 2004

Examen de SISTEMAS DE TIEMPO REAL
Duración 90 minutos (con libros y apuntes)
24 de junio de 2004
NOMBRE:
Pregunta 1 (1 punto)
¿Cuál es la ventaja principal del método de planificación con prioridades fijas frente a los métodos de
planificación dinámica como el de planificar primero a la tarea más urgente (Earliest Deadline First)?
La principal ventaja del método de planificación con prioridades fijas frente a los métodos de planificación dinámica es su estabilidad. Es decir, en caso de sobrecarga transitoria empezarán a perder sus
plazos de respuestas las tareas menos prioritarias. Los métodos de planificación dinámica tienen un comportamiento impredecible en caso de sobrecarga.
Pregunta 2 (1 punto)
¿Qué ventajas tiene el protocolo del techo de prioridad frente al protocolo de herencia de prioridad?
¿Presenta alguna desventaja?
Los protocolos de techo de prioridad permiten obtener unos tiempos máximos de bloqueo menores
que el protocolo de herencia de prioridad. Además evitan los interbloqueos, los bloqueos encadenados y
proporcionan exclusión mutua, en monoprocesadores, sin mecanismos adicionales.
Sin embargo, como son más restrictivos al permitir el acceso a recursos compartidos, se producen
bloqueos que con el protocolo de herencia de prioridad no se producirı́an. Por lo tanto, los tiempos medios
de bloqueo son mayores.
Pregunta 3 (2 puntos)
El siguiente fragmento de programa Ada se corresponde con el de una tarea de prioridad media en un
sistema donde hay tareas de mayor y menor prioridad. ¿Cuánto podrı́a llegar a ser el lı́mite mı́nimo y
máximo de tiempo de ejecución de Periodic Activity? ¿Es necesario algún mecanismo adicional para
establecer correctamente dicho lı́mite? ¿Cuál?
task body Periodic is
pragma Priority (Medium Priority);
use Ada.Real Time;
Period : Time Span := Milliseconds (1 000);
Next Time : Time := Clock;
begin
loop
delay until Next Time;
Next Time := Next Time + Period;
select
delay 0.1;
raise Time Faliure
then abort
Periodic Activity;
end select;
end loop;
end Periodic;
5
10
15
El lı́mite máximo de tiempo de ejecución de Periodic Activity es de 100 milisegundos, ya que ası́
está limitado por la transferencia ası́ncrona de control. Sin embargo, el lı́mite minimo puede ser igual a 0.
En efecto, si justo antes de comenzar la ejecución de Periodic Activity la tarea Periodic es desalojada por tareas de mayor prioridad durante un lapso de tiempo mayor o igual a 100 milisegundos, al volver
a ejecución la temporización de la transferencia ası́ncrona de control habrı́a expirado. En este caso, se suspenderı́a inmediatamente la ejecución de Periodic Activity y se activarı́a la excepción Time Faliure.
Para establecer correctamente un lı́mite de tiempo de ejecución son necesarios relojes y temporizadores
basados en el tiempo de ejecución y no en el tiempo transcurrido, como es el caso del reloj de Ada.Real Time.
Pregunta 4 (3 puntos)
Un sistema de tiempo real tiene 4 tareas, TA-TD, y 2 objetos protegidos, PA y PB. Las siguientes tablas
contienen los atributos temporales de las tareas y los tiempos de ejecución de las actividades que ejecutan.
Tarea
TA
TB
TC
TD
Tipo
P
S
P
P
Perı́odo
150
120
15
60
Plazo de respuesta
150
40
15
60
Actividades
a1 , a2 , a3
b1 , b2 , b3
c1 , c2
d1
Suponiendo que el método de planificación es el de prioridades fijas con desalojo, y el acceso a los
objetos protegidos se realiza mediante el protocolo del techo de prioridad inmediato, se pide:
Actividad
a1
a2
a3
b1
b2
b3
c1
c2
d1
Tiempo de cómputo
5
6
5
5
2
3
4
4
10
Recurso
No
PB
PA
No
PA
PB
No
PA
No
1. Asignar prioridades a las tareas y calcular los techos de prioridad de los objetos protegidos.
2. Calcular los tiempos de bloqueo máximos de las tareas.
3. Calcular el tiempo de respuesta en el peor caso de las tareas TB y TC.
La asignación de prioridades basada en dar mayor prioridad a las tareas con menor plazo de respuesta,
permite planificar el conjunto de tareas con los siguientes tiempos de bloqueo y respuesta1 :
Response time analysis for task set Sample
-----------------------------------------Id Task
A PR Period Offset Jitter
WCET
Block Deadline Response Sch
-- --------- - -- ------- ------- ------- ------- ------- -------- -------- --1 TC
P 4 15.000
0.000
0.000
8.000
5.000
15.000
13.000 Yes
2 TB
S 3 120.000
0.000
0.000 10.000
6.000
40.000
40.000 Yes
3 TD
P 2 60.000
0.000
0.000 10.000
6.000
60.000
58.000 Yes
4 TA
P 1 150.000
0.000
0.000 16.000
0.000 150.000 102.000 Yes
Priority ceilings for shared resources
-------------------------------------Id Name
PR
-- --------- -1 PA
4
2 PB
3
Total processor utilization :
1 La cálculos han
89.00%
sido realizados con la herramienta RTA (ftp://ftp.dit.upm.es/str/software/rta/) que se distribuye con licencia GNU.
Pregunta 5 (3 puntos)
Dado el siguiente programa:
1. ¿Qué hace? Explique su funcionamiento.
2. ¿Qué mecanismos de comunicación y sincronización emplearı́amos en Ada 95 para hacer lo mismo?
3. ¿Hay algún error? Si lo hay indique en qué lı́nea y como se resolverı́a.
Código del servidor
/* estructura de un mensaje */
struct mensaje
char buffer[1024]; /* datos a enviar */
char cliente[256]; /* cola del cliente */
;
5
/* mutex y var. condicionales protección de la copia del mensaje */
pthread mutex t mutex mensaje;
int mensaje no copiado = TRUE;
pthread cond t cond;
10
void main(void)
mqd t q servidor;
/* cola del servidor */
struct mensaje mess; /* mensaje a recibir */
struct mq attr q attr; /* atributos de la cola */
pthread attr t t attr; /* atributos de los threads */
q attr.mq maxmsg = 20;
q attr.mq msgsize = sizeof(struct mensaje);
q servidor = mq open("SERVIDOR", O CREAT O RDONLY, 0700, &q attr);
pthread mutex init(&mutex mensaje, NULL);
pthread cond init(&cond, NULL);
pthread attr init(&t attr);
pthread attr setscope(&t attr,PTHREAD SCOPE SYSTEM);
pthread attr setdetachstate(&t attr, PTHREAD CREATE DETACHED);
while (TRUE)
mq receive(q servidor, &mess, sizeof(struct mensaje), NULL);
15
20
pthread create(&thid, &t attr, tratar mensaje, &mess);
/* se espera a que el thread copie el mensaje */
pthread mutex lock(&mutex mensaje);
while (mensaje no copiado)
pthread cond wait(&cond, &mutex mensaje);
mensaje no copiado = TRUE;
pthread mutex unlock(&mutex mensaje);
25
30
35
40
void tratar mensaje(struct mensaje *mes)
struct mensaje mensaje local;
struct mqd t q cliente; /* cola del cliente */
struct mensaje respuesta; /* mensaje de respuesta al cliente */
/* el thread copia el mensaje */
pthread mutex lock(&mutex mensaje);
memcpy((char *) &mensaje local, (char *)&mes, sizeof(struct mensaje));
/* ya se puede despertar al servidor*/
mensaje no copiado = FALSE;
pthread cond signal(&cond);
pthread mutex unlock(&mutex mensaje);
45
50
/* ejecutar la petición del cliente y preparar respuesta */
/* responder al cliente a su cola */
q cliente = mq open(mensaje local.cliente, O WRONLY);
mqsend(q cliente, (char *) &respuesta, sizeof(respuesta), 0);
mq close(q cliente);
pthread exit(0);
55
60
Código del cliente
struct mensaje /* estructura mensaje */
char buffer[1024]; /* datos envı́o */
char cliente[256]; /* cola cliente */
;
5
void main(void)
mqd t
mqd t
struct
struct
struct
q servidor; /* cola servidor */
q cliente; /* cola cliente */
mq attr attr; /* atr. cola */
mensaje peticion; /* peticion al servidor */
mensaje respuesta; /* respuesta del servidor */
attr.mq maxmsg = 1;
attr.mq msgsize = sizeof(struct mensaje);
10
15
q cliente = mq open("CLIENTE",
O CREAT O RDONLY, 0700, 0);
q servidor = mq open("SERVIDOR", O WRONLY);
20
/* preparar peticion */
mq send(q servidor, &peticion,
/* esperar respuesta */
mq receive(q cliente, &respuesta,
mq close(q servidor);
mq close(q cliente);
mq unlink("CLIENTE");
exit(0);
sizeof(struct mensaje), 0);
sizeof(struct mensaje), NULL);
25
30