Septiembre 2004

INGENIERÍA TÉCNICA en INFORMÁTICA de SISTEMAS
ASIGNATURA: PROGRAMACIÓN CONCURRENTE
CÓDIGO CARRERA: 40 (Sistemas)
CÓDIGO ASIGNATURA: 319
CONVOCATORIA: Septiembre. 1aP.P.
SEMANA : PRIMERA
DURACIÓN: 2 horas
Fecha: 3 de Septiembre de 2004
MATERIAL AUXILIAR: NINGUNO HORA: 18:30 h.
¡NO es necesario entregar la hoja del enunciado!
TEORÍA
Explicar las caracterı́sticas de la cita de Ada (rendez-vous). (2pt)
Se pueden encontrar dichas caracterı́sticas en la página 105 y siguientes del libro de
Jorge Pérez Martı́nez.
EJERCICIO
Blancanieves y los siete enanitos viven en una casa donde sólo existen cuatro sillas,
que los enanitos utilizan para comer.
Cuando un enanito vuelve de trabajar en la mina comprueba si hay una silla libre para sentarse. Si existe una silla libre, entonces indica a Blancanieves que ya
está sentado, y espera pacientemente su turno a que le sirvan. Cuando le ha servido,
Blancanieves le indica que puede empezar a comer. El enanito come y cuando acaba,
deja la silla libre y vuelve a la mina. Por su parte, Blancanieves cuando no tiene
ningún enanito pendiente de servirle, se va a dar una vuelta.
Se pide:
(a) Realice un análisis exhaustivo de los problemas de concurrencia que se pueden
dar en un sistema de este tipo. (1pt)
Como dice el libro de Palma et al. en la página 18, los problemas inherentes a
la programación concurrente son básicamente de dos tipos, de exclusión mutua
y de sincronización. En este caso concreto está claro que el acceso a los recursos
(las sillas y los turnos de Blancanieves) debe producirse en exclusión mutua,
pues de lo contrario podrı́a haber errores con respecto al número de sillas libres
o de los turnos. Por lo que respecta a la sincronización, es importante que
los enanos se sincronizen correctamente con respecto a Blancanieves, puesto
que de lo contrario podrı́an ponerse a comer en un plato vacı́o debido a que
Blancanieves no ha llenado los platos. Otra posibilidad serı́a que Blancanieves
no se sincronizara correctamente con los enanos y que se fuera a dar una vuelta
mientras los enanos están esperando. Finalmente otro tipo de problemas que
podrı́an darse serı́an el interbloqueo, según la implementación particular o la
inanición de un enano que no consiguiera jamas sentarse en una silla. Con una
implementación incorrecta podrı́an darse incluso otros problemas más exóticos.
(b) Seleccionar una herramienta de concurrencia explicando los motivos. (1pt)
Una posibilidad interesante es utilizar semáforos junto con variables compartidas. Los semáforos modelizan muy bien el acceso a recursos limitados (las
sillas en este caso). Una variable compartida puede comunicar si hay enanos o
no esperando a comer. El acceso a esta variable deberı́a hacerse en exclusión
mutua, pero resulta sencillo implementarla con otro semáforo. Finalmente, la
señales entre los enanos y Blancanieves (estoy esperando a comer y la comida
ya está lista) pueden modelizarse con sendos semáforos.
Otras opciones como regiones crı́ticas o RCC’s también serı́an válidas. Los
eventos no parecen especialmente adecuados puesto que el escaso número de
procesos implicados no precisa una gestión explı́cita de colas. Las primitivas
de alto nivel como los monitores o la cita de Ada siempre son apuestas seguras,
pero para este problema tan sencillo quizás no merezca la pena complicarse
más.
(c) Explicar las caracterı́sticas principales de la herramienta elegida en el
apartado anterior. (1.5pt)
Estás descritas en el libro de Jorge Pérez Martı́nez a partir de la página 44 y
siguientes.
(d) Partiendo del análisis realizado y la herramienta de concurrencia seleccionada,
proponga una solución en pseudo-código que resuelva el problema descrito.
Utilizar únicamente dos tipos de proceso: Enanito y Blancanieves.(4.5pt)
PROGRAM Bosque;
VAR silla, mutex, turno : SEMAPHORE;
esperando_turno : SHARED INTEGER;
i : INTEGER;
PROCESS Enano(i : INTEGER);
BEGIN
REPEAT
writeln(’Enano : ’, i , ’ estoy trabajando en el campo’);
writeln(’Enano : ’, i, ’ quiero sentarme en una silla’);
wait(silla);
writeln(’Enano :’, i, ’ ya he conseguido una silla’);
wait(mutex);
esperando_turno := esperando_turno + 1;
signal(mutex);
wait(turno);
wait(mutex);
esperando_turno := esperando_turno - 1;
signal(mutex);
writeln(’Enano : ’, i, ’ estoy comiendo’);
signal(silla);
FOREVER;
END;
PROCESS Blancanieves;
BEGIN
REPEAT
wait(mutex);
IF esperando_turno = 0 then
BEGIN
signal(mutex);
writeln(’Blancanieves :
me voy
END
ELSE
BEGIN
signal(mutex);
writeln(’Blancanieves :
writeln(’Blancanieves :
signal(turno);
END
FOREVER;
END;
(* Programa principal *)
BEGIN
Init(silla, 4);
Init(mutex, 1);
Init(turno, 0);
esperando_turno := 0;
Blancanieves;
FOR i := 1 to 7 DO Enano(i);
END.
Como no hay ningún enano esperando
a dar una vuelta.’);
Estoy cocinando para un enanito.’);
La comida ya está lista.’);