Ejercicios sincronizacion de procesos

1. PROGRAMANA NACIONAL DE FORMACIÓN EN INFORMÁTICA
UNIDAD CURRICULAR: SISTEMAS OPERATIVO.
Prof. Pura Castillo
Ejercicios Sincronización De Procesos
Semáforos
Enunciado 1
En un popular programa de televisión en el que invita a importantes personajes a
almorzar y conversar sobre sus vidas y sobre temas de actualidad. La dinámica
del programa es la siguiente:
• Al programa asisten N invitados. Los comensales se sientan a la mesa,
siendo el presentador el último en sentarse.
• Una vez que se sentó Presentador, los M mozos sirven la comida. Por
problemas de presupuesto, la cantidad de mozos es siempre menor a
la cantidad de invitados.
• Los mozos no deben servir más de N+1 platos. Cualquier comensal
(incluida Presentador) puede comenzar a comer, incluso si no han
terminado de servir a todos los invitados.
• Cuando Presentador termina de comer, ella lanza una pregunta
polémica. Esta pregunta puede ser respondida por cualquier invitado
que haya terminado de comer. Sólo un invitado debe responder la
pregunta.
• Para mantener alto el rating, Presentador se enoja muchísimo por la
respuesta polémica, se levanta y se va del estudio. Si Presentador ya
se ha levantado, los invitados pueden hacer lo mismo, pero sólo si ya
han terminado de comer.
Las primitivas disponibles son:
• sentarse()
• servir_comida()
• comer()
• enojarse()
• levantarse()
• lanzar_pregunta_polemica()
• lanzar_respuesta_polemica()

2. 1. Realice una solución usando semáforos para el problema descripto
anteriormente.
Solución
sem Presentador PuedeSentarse = -N + 1 // Para que Presentador espere que se
sienten todos los invitados sem puedenServir = 0 // Para contener a los mozos en
sus gateras
sem sePuedeComer = 0
int platosRestantes = N + 1 // Cantidad de platos que falta servir sem
mutexPR = 1 // Controla el acceso a los datos relacionados con platos
para evitar RC
bool seRespondio = 0 // Para coordinar que sólo uno responda a la
pregunta sem mutexSR = 1
sem huboPregunta = 0 // Para que los comensales esperen la
pregunta polémica sem huboRespuesta = 0 // Para que Presentador
espere la respuesta polémica sem sePuedenIr = 0 // Para que los
invitados no se levanten hasta la partida de Presentador
Presentador
wait(Presentador PuedeSentarse)
sentarse()
// Despierto M mozos
signal(puedenServir, M)
wait(sePuedeComer)
comer()
lanzar_pregunta_polemica()
signal(huboPregunta)
wait(huboRespuesta)
enojarse() levantarse()
signal(sePuedenIr, N)
Mozos
wait(puedenServir) while 1:
wait(mutexPR) if
platosRestantes > 0:
platosRestantes-
signal(mutexPR)
servir_comida()
signal(sePuedeComer) else:
signal(mutexPR)
Invitado
sentarse()
signal(Presentador
PuedeSentarse)
wait(sePuedeComer)
comer() wait(huboPregunta)
wait(mutexSR) if seRespondio ==
0: lanzar_respuesta_polemica()
seRespondio = 1
signal(huboRespuesta)
// Destrabo a los demás
comensales
// para que puedan levantarse
cuando hayan // terminado de
comer.
signal(huboPregunta, N-1)
signal(mutexSR)
wait(sePuedenIr) levantarse()
break // Ya terminé de servir

3. Enunciado 2
Considera el siguiente trozo de código del problema productor-consumidor
#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <pthread.h>
#include <unistd.h>
#include <stdbool.h>
#define MAX 10 #define FIN -1
int buffer[MAX];
sem t huecos, elementos;
int generar dato (void){ return random()%256; }
int numero aleatorio(void) { return random()%100; }
void ∗productor (void ∗p) {
int pos productor= 0;
int num, dato, n;
n= numero aleatorio();
printf ("Productor con%d datosn", n);
for(num= 0; num< n; num++) {
dato= generar dato(); sem wait (&huecos);
buffer[pos productor]= dato;
pos productor= (pos productor+ 1)%MAX;
sem post (&elementos);
}
buffer[pos productor]= FIN;
pthread exit (NULL);
}
void ∗consumidor(void ∗p){
int pos consumidor, dato;
bool continuar= true;
while (continuar) {
sem wait (&elementos);
dato= buffer[pos consumidor];
pos consumidor= (pos consumidor+1)%MAX; if (dato== FIN) continuar= false;
sem post (&huecos);
printf ("Numero aleatorio:%dn", dato);
}
pthread exit (NULL);

4. }
Nota: Este código c contiene errores y está incompleto .Corrige y completa .Haz
que el hilo consumidor muestre en pantalla todos los datos producidos por el
hilo productor.
Enunciado 3
Una peluquería en la que hay un barbero, una silla de peluquero y N sillas para
que se sienten los clientes en espera, si es que los hay. Si no hay clientes
presentes, el barbero se sienta en su silla de peluquero y se duerme. •Cuando
llega un cliente, éste debe despertar al barbero dormilón. Si llegan más clientes
mientras el barbero corta el cabello de un cliente, se sientan (si hay sillas
desocupadas) o salen de la peluquería (si todas las sillas están
ocupadas). Programar al barbero y los clientes. Corrige si existen errores
/* Solucion al problema del barbero dormilon. */
#define TRUE1
#define CHAIRS5
typedef struct
{
int value;
/* Lista de procesos. */
}
semaphore;
semaphore mutex, barber, customer;
int waiting = 0;
main ()
{
extern semaphore mutex, barber, customer;
InitSemaphore (mutex, 1);
InitSemaphore (barber, 0);
InitSemaphore (customer, 0);
/* Inicia los procesos barbero y clientes. */
}
void
Barber ()
{
while (TRUE)
{
/* Espera a que haya clientes. */
wait (customer);
/* Acceso exclusivo a waiting. */
wait (mutex);
/* Un cliente va a ser servido. */
waiting--;
/* Un barbero está libre. */
signal (barber);
signal (mutex);

5. /* Corta el pelo fuera de la seccion critica. */
CutHair ();
}
}
void
Customer ()
{
/* Acceso exclusivo a waiting. */
wait (mutex);
if (waiting < CHAIRS)
{
/* Si hay silla espera. */
waiting++;
/* Despierta al barbero. */
signal (customer);
signal (mutex);
/* Se va a dormir si no hay barberos. */
wait (barber);
GetHaircut ();
}
else
/* Se va si no hay sitio. */
signal (mutex);
}
Monitores
monitor lector_escritor {
int numerosdelectores = 0;
booleam ocupado = false;
condition okparaleer, okparaescribir;
Public:
Iniciarlectura{
If (ocupado | | (okparaescribir.cola) ) okparaleer.wait ();
Numerosdelectores = numerosdelectores + 1:
okparaleer.signal ();
};
Finalizarlectura {
Numerosdelectores = numerosdelectores – 1;
If (Numerosdelectores == 0) | | ocupado) okparaescribir.signal();
};
Iniciarescritura {
If (Numerosdelectores ¡= 0) | | ocupado)

6. okparaescribir.wait();
ocupado =true;
};
Finalizarescritura {
ocupado =false;
if (okparaescribir.cola)
okparaescribir.signal();
else
okparaleer.signal ();
};
};