SOLUCIONES A ALGUNOS DE LOS EJERCICIOS DE SINCRONIZACION Y COMUNICACION ENTRE PROCESOS

Transcripción

1 SOLUCIONES A ALGUNOS DE LOS EJERCICIOS DE SINCRONIZACION Y COMUNICACION ENTRE PROCESOS 1. Con las tres llamadas create, suspend, y resume, la estructura del programa sería la siguiente: process recoger; process guardar; process calcular; suspend(); suspend(); suspend(); suspend(); guardar*; suspend(); recoger*; resume(pid1); calcular*; resume(pid2);... resume(pid1); resume(pid3); resume(pid4); process imprimir; pid1 = create("recoger"); suspend(); pid2 = create("guardar"); imprimir*; pid3 = create("calcular"); resume(pid3); pid4 = create("imprimir");... resume(pid1); resume(pid1); resume(pid3); Esta solución presupone que las llamadas a resume() siempre tienen un correspondiente suspend() que las espera. En un sistema operativo si se hace una llamada para reanudar un proceso que no está suspendido el efecto es normalmente nulo. Pero si esto tuviera lugar en este programa ocasionaría la pérdida de señalizaciones con los correspondientes fallos de precedencia, y su funcionamiento sería incorrecto. Si suponemos que resume() devuelve un valor TRUE o FALSE dependiendo de si ha reanudado o no efectivamente el proceso que pretendía, podrían suplirse todas las llamadas a resume() por while (! resume(pid i )) { ; pero aunque de este modo la lógica del problema estaría correctamente resuelta, sería a costa de pérdida de eficacia de la solución al introducir bucles de reanudaciones que consumen tiempo de UCP sin hacer trabajo útil. S1. a) Es segura, sin interbloqueo, y con posible aplazamiento indefinido.. Basta para ello advertir que inicialmente los valores de las variables c (global), d de p1 (local) y e de p2 (local) que intervienen en la negociación del acceso a la sección crítica forman la tripleta (1,0,0) y que las únicas operaciones que se efectúan son intercambios indivisibles sin modificación de valores. Por tanto los valores que se pueden alcanzar son: (1,0,0) ==> p1 y p2 están fuera de sus Secciones Críticas (0,1,0) ==> p1 está en su Sección Crítica, y p2 está fuera de la suya (0,0,1) ==> p1 está fuera de su Sección Crítica y p2 dentro de la suya Luego la exclusión mutua es segura. Para producirse interbloqueo deberían alcanzarse los valores (0,0,0): ambos procesos fuera y sin posibilidad de entrar, lo cual no es posible. El aplazamiento indefinido es posible puesto que no hay ningún mecanismo que impida que los valores estén oscilando entre (1,0,0) y (0,1,0), por ejemplo, sin dar opción a p2 a pasar a su sección crítica. b) La generalización a n procesos es inmediata. Sólo hay que repetir el esquema de cualquiera de los procesos p1 o p2 el número de veces que haga falta, para negociar la exclusión mutua con un (n+1)-tuple de valores de los cuales uno vale 1 y el resto 0. c) Si XCHG no fuera indivisible ya no se aseguraría la existencia invariante de uno y sólo un 1, y ello podría ocasionar fallos de exclusión mutua (ej. (0,1,1)) e interbloqueos (ej.(0,0,0)). 1

2 S3. a) Definición original con cola de espera WAIT: if (s == 0)) suspender en s.q; else s = s - 1; SIGNAL: if (! s.q vacía) reanudar un proceso de s.q; else s = s + 1; Definición alternativa con cola de espera WAIT: s := s - 1; if (s < 0)) suspender en s.q; SIGNAL: if (! s.q vacía) reanudar un proceso de s.q; {punto de interrupción s := s + 1; La operación de decremento juntamente con la comprobación del valor de s debe formar un todo indivisible en la operación wait. Para la operación signal basta que sean indivisibles separadamente la operación de reanudación condicional y la de incremento. b) El valor negativo indica Ocupado con operación de espera (wait) en curso y, en el caso de implementación con cola de espera, el numero de procesos que han pasado a esperar desde la última señalización c) Sí afecta a SIGNAL. Hace que el incremento del valor del semáforo se haga siempre y no solo en el caso de que no haya ningún proceso esperando en cola. Otra posibilidad: Siendo P b (s) y V b (s) las operaciones de espera y señalización sobre semáforos binarios, es decir, P b (s) while (s == 0) { ; y V b (s) s = 1; definimos wait(s) : P b (mutex) s = s - 1; if (s < 0) { V b (mutex); P b (retardo) V b (mutex); signal(s): Pb(mutex) s = s + 1; if (s <= 0) V b (retardo) else V b (mutex); S5. Declaraciones globales sem_t sillon, afeitado; mutex_t mutex; int sillas; boolean esperando; const int MAX = 5; Procesos Barbero() Cliente() 2

3 lock(mutex); if (sillas == 0) { esperando = TRUE; unlock(mutex); wait(sillon); unlock(mutex); esperando = FALSE sillas = sillas-1; unlock(mutex); Afeitar; post(afeitado); lock(mutex); if (sillas < MAX) { sillas = sillas+1; if (esperando) post(sillon); unlock(mutex); wait(afeitado); else unlock(mutex); Inicialización (programa principal): sillas = 0; esperando = FALSE; sem_init(sillon, 0); sem_init(afeitado, 0); mutex_init(mutex); Barbero(); Clientes() //tantas instancias de Cliente como se precise S5. Posible segunda solución. - Funciona? Barbero Clientes wait (sala); lock (mutex); lock (mutex); if (sillas < MAX) { sillas = sillas-1; unlock (mutex); post (sala); post (afeitando); sillas = sillas+1; Afeitar unlock (mutex); wait (afeitando) else unlock (mutex) Inicialización: sillas = 0; sem_init (afeitando, 1); sem_init (sala, 0); // sala, semáforo general mutex_init (mutex); Barbero(); Clientes(),...; S7. (a) El proceso LEER hace usos de dos procedimientos: leetarjeta (car) que lee un tarjeta de 80 columnas y rellena el array car de 80 caracteres put(buf, car) que coloca el carácter car en la posición siguiente del buffer ilimitado buf El proceso MODIFICAR hace uso de dos procedimientos get(buf, car) que toma el siguiente carácter del buffer ilimitado buf y lo asigna a car 3

4 put(buf, car) Si el buffer esta vacío se queda esperando El proceso IMPRIMIR hace uso de dos procedimientos get(buf, car) imprime(línea) que saca a la impresora el array línea de 125 caracteres Si los buffers los definimos así: typedef struct buffer { int indent, indsal; char elementos[infinito]; sem_t contador; BUFFER; los procedimientos get() y put() serán: get(buffer buf; char car) { wait(buf.contador); car = buf.elementos[buf.indsal] buf.indsal = buf.indsal + 1; put(buffer buf:; char car) { buf.elementos[indent] = car; buf.indent = buf.indent + 1; post(buf.contador); y los procesos quedarían básicamente de la siguiente forma, comunicados a través de dos buffer infinitos buf1 y buf2: Leer: i=0; while (! eof) { leetarjeta (car); for (i=0; i<80; i++) put(buf1,car[i]); put(buf1,' ') put(buf1,eof); Modificar: get(buf1, car1); while (! eof) { get(buf1,car2); if ((car1=='*') && (car2=='*')) { ristra = TRUE; put(buf2,'/'); else if (ristra) ristra = false; else put(buf2, car1); car1=car2; if (! ristra) put(buf2,car) Imprimir: i=0; while (! eof) { get(buf2,car); linea[i]=car; i=i+1; if (i == 125) { imprime(linea); i=0; if (i!= 0) imprime(linea); S8. (b) // program PCconCE; {productor/consumidor con cuenta de eventos const int n = 5; contadores producido, consumido; elementos deposito[n]; void PRODUCTOR(int id) { int ip; ip = 0; await(consumido, ip-n); deposito[ip % n] := producir(); ip = ip+1; advance(producido); 4

5 void CONSUMIDOR(int id) { int ic; ic = 0; await(producido, ic); consumir(deposito[ic % n]); ic = ic+1; advance(consumido) main() { initial_event(producido,0); initial_event(consumido,0); PRODUCTOR(0); CONSUMIDOR(0);. MVC1. Una posible solución a este problema, con semáforos, es la siguiente: // Program Fumadores; sem_t ingrediente[3]; sem_t s[6]; mutex mutex ; sem_t sem; int t; void Agente() { int i, j; end; i = random(2) + 1; j = i; while (j == i) j = random(2) + 1; wait(sem); post(ingrediente[i]); post(ingrediente[j]); end; void Ayuda(int id) { void Fumador(int id) { const int incr[3] = {1,2,4 const int nec[3] = (6,5,3); wait(ingrediente[id]); wait(s[nec[id]]); lock(mutex); t = 0; t = t + incr[id]; post(sem); post(s[t]); --- FUMA --- unlock(mutex); 5

6 main() { t = 0; sem_init(sem, 1); mutex_init(mutex, 1); Agente(); Ayuda(0);Ayuda(1); Ayuda(2); Fumador(0);Fumador(1);Fumador(2);. mutex se encarga de forzar la exclusión mutua al operar con t sem (Agente espera y Fumador[ ] señala) : permite que Agente saque un nuevo par de ingredientes t acumula los identificadores de hasta 2 ingredientes Resuelto con mutexes y variables condicionales // Program Fumadores; struct ingredientes {boolean tabaco,cerillas,papel; = {FALSE,FALSE,FALSE mutex_t ingr_mutex; cond_t ingr_cond; void Agente() { int i, j; i = random(2) + 1; j = i; while (j == i) j = random(2) + 1; lock (ingr_mutex) while (tabaco cerillas papel) wait(ingr_cond2, ingr_mutex) tabaco = (i == 0) (j == 0); cerillas = (i == 1) (j == 1); papel = (i == 2) (j == 2); broadcast(ingr_cond1); unlock (ingr_mutex) void FumadorTC() { lock(ingr_mutex); while (!(tabaco && cerillas)) wait(ingr_cond1, ingr_mutex); tabaco = FALSE; cerillas = FALSE; signal(ingr_cond2); unlock(ingr_mutex); --- FUMA --- void FumadorPC() { semejante a Fumador TC pero con papel y cerillas void FumadorTP { semejante a Fumador TC pero con tabaco y papel main() { 6

7 MVC4. // programa ascensor Fichero CONTROL.c Agente(); FumadorTC(); FumadorPC(); FumadorTP(); const int Npisos = 10; cond_t Petpisos[Npisos], aviso; int NpetPiso[Npisos]; mutex_t ctrlme; int piso_actual=1, piso_nuevo=-1, peticiones=0; void PulsarBoton(int piso) { lock(ctrlme); signalc(aviso); peticiones = peticiones+1; NpetPiso[piso]++; waitc(petpisos[piso],ctrlme); NpetPiso[piso]--; unlock(ctrlme); void EsperarPeticiones() { lock(ctrlme); if (peticiones == 0) waitc(aviso,ctrlme); unlock(ctrlme); void ElegirMasCercano(int& dist) { int i; boolean sigue; lock(ctrlme); i= 0; sigue = TRUE; while ((i <= Npisos) && sigue) { if ((piso_actual+i <= Npisos) && (NpetPiso[piso_actual+i]>0)) { piso_nuevo = piso_actual+i; dist = i; sigue = FALSE; else if ((piso_actual-i > 0) && (NpetPiso[piso_actual+i]>0)) { piso_nuevo = piso_actual -i; dist = -i; sigue = FALSE; i = i + 1; unlock(ctrlme); void SubirBajar() { lock(ctrlme); while (NpetPiso[piso_nuevo])>0) { signal(petpisos[piso_nuevo]); peticiones = peticiones-1; 7

8 piso_actual = piso_nuevo unlock(ctrlme); void pasajero() { int origen, destino; origen = random(npisos)+1; PulsarBoton(origen); do { destino = random(npisos)+1 while (destino == origen); PulsarBoton(destino); origen = destino; sleep(random(10)); void servidor() { integer dist, EsperarPeticiones; ElegirMasCercano(dist); sleep(abs(dist)); SubirBajar; main() { servidor; pasajero();pasajero();pasajero();...; MVC5. La definición de las operaciones P (wait) y V (signal) para semáforos acotados son las siguientes: P(s): while (s <= 0) { s := s - 1; V(s): while (s >= smax) { s := s + 1; El monitor que fuerza este comportamiento es el siguiente: Fichero (monitor) Sa const int smax = N, sem[ns]; cond_t c, d; mutex_t Saem void P(int s) { lock(saem); while (sem[s] <= 0) wait(c,saem); 8

9 sem[s]--; signal(d); // if (sem[s] < smax) signal(c); unlock(saem); void V(int s); lock(saem); if (sem[s] >= smax) wait(d, Saem); sem[s]++; signal(c); // if (sem[s] > 0) signal(c); unlock(saem); MVC6. Fichero (monitor) LyE { int nlect=0, Lesp=0, Eesp=0; bool ocupado=false; cond_t condl, conde; mutex_t LyEem; void IniciarL () { if (ocupado (Eesp > 0)) { Lesp = Lesp+1; wait(condl,lyeem); Lesp = Lesp-1; nlect = nlect+1; signalc(condl); void IniciarE() { if (ocupado (nlect!=0) { Eesp = Eesp+1; wait(conde,lyeem); Eesp = Eesp-1; ocupado = TRUE; void AcabarL() { nlect = nlect-1; if (nlect == 0) signal(conde); void AcabarE() { ocupado = FALSE; if (Lesp > 0) signal(condl); else signal(conde); Otra solución, si se dispone de la función empty(cola) que devuelve un valor lógico true o false: Fichero (monitor) LyE { int nlect=0; boolean ocupado=false; cond_t condl, conde; mutext_t LyEem; 9

10 void IniciarL() { if (ocupado!empty(conde)) wait(condl, LyEem); nlect = nlect+1; signal(condl); void IniciarE; if (ocupado (nlect!= 0)) wait(conde, LyEem); ocupado = TRUE; void AcabarL() { nlect = nlect-1; if (nlect == 0) signal(conde); void AcabarE() { ocupado = FALSE; if (!empty(condl)) signal(condl); else signal(conde); MVC7. // programa Filosofos; Fichero(monitor) Mpalillos int Palillos[5]={2,2,2,2,2 // rango 0..2; cond_t OK_Comer[5]; mutex_t Mpalem; int j; void Coger_Palillos (int i){ lock(mpalem); while (Palillos[i]!= 2) wait(ok_comer[i],mpalem); Palillos[(i+1) % 5] = Palillos[(i+1) % 5] - 1; Palillos[(i-1) % 5] = Palillos[(i-1) % 5] 1 unlock(mpalem); void Soltar_Palillos (int i) { lock(mpalem); Palillos[(I+1) % 5] = Palillos[(I+1) % 5] + 1; Palillos[(I-1) % 5] = Palillos[(I-1) % 5] + 1; signal(ok_comer[(i+1) % 5]); signal(ok_comer[(i-1) % 5]); unlock(mpalem); // MPalillos. void Filosofo (int i) { Pensar; Comer; Coger_Palillos(i); Soltar_Palillos(i); 10

11 main() { Filosofo(0); Filosofo(1); Filosofo(2); Filosofo(3); Filosofo(4); Demostración de la no existencia de interbloqueo: Si hubiera interbloqueo, nadie estaría comiendo SUMA (Palillos[]) = 10 todos están en espera SUMA (Palillos[]) <= 5 lo cual, evidentemente, es una contradicción. Puede existir aplazamiento indefinido al no haber una política que controle la actuación de los filósofos, por lo cual dos de ellos inmediatamente no consecutivos pueden cooperar para impedir la entrada a comer del filósofo intermedio. ME1. Basta sustituir wait por receive(mutex,msg) y signal por send(mutex, null) Lector receive(mutex, msg); nlect = nlect + 1; if (nlect == 1) receive(escr, msg); send(mutex, null); LEER receive(mutex, msg); nlect = nlect - 1; if (nlect == 0) send(escr, null); send(mutex, null); Otro proceso; Escritor: receive(escr, msg); ESCRIBIR; send(escr, null); Otro_proceso inicialización nlect = 0; send(mutex, null); send(escr, null); lectores; escritores; ME2. a) Mira alternativamente en cada buzón cada cierto tiempo boolean mirar(buzon, &msg) { receive(buzon, m); if (m!=null) {msg=m;return TRUE else {send(buzon, null); return FALSE; while (mirar(m1,msg)) procesar(msg); while (mirar(m2,msg)) procesar(msg); sleep(rato); b) Emplea un proceso separado para atender a cada buzón y se comunica con ellos a través de un buzón común P1: receive(m1,msg);send(miym2, msg); P2: receive(m2,msg);send(miym2, msg); receive(m1ym2, msg); procesar(msg); 11

12 Nota: el mensaje null enviado en el apartado a) debe tener la menor prioridad posible, para garantizar que siempre es el último del buzón. 12