• Author / Uploaded
• frutipan

• Categories
• Arquitectura de Computadores
• Datos de computadora
• Tecnología
• Áreas de informática
• Informática

Citation preview

PROBLEMAS SEMAFOROS - Problema propuesto 1 var em_fichero:semaphore; // inicializado a 1 em_sumado:semaphore; // inicializado a 1 sumado:integer; // inicializado a 0 Sfinal:integer; S:array[1..2] of integer; // inicializado a 0; fichero:…; // fichero compartido

SOLUCION process proceso(i:integer); var n:integer; begin wait(em_fichero); while not eof(fichero) do begin read(fichero,n); signal(em_fichero); S[i]:=S[i]+n; wait(em_fichero); end; signal(em_fichero); wait(e m_sumado); if (sumado=0) then sumado:=1; else Sfinal:=S[1]+S[2]; signal(em_sumado); end;

- Problema propuesto 2 type tipoelemento=record of proceso:integer; // inicializado a 0 inform:item; end; var mutex:semaphore; // inicializado a 1; huecos:semaphore; // inicializado a n; llenos:semaphore; // inicializado a 0; buffer:array[1..n] of tipoelemento;

Process productor(i:integer); // var item:item; k:integer; begin repeat producir(item); // wait(huecos); wait(mutex); k:=1; while buffer[k].proceso!=0 do k:=k+1; buffer[k].proceso:=i; buffer[k].inform:=item; signal(mutex); signal(llenos); forever end;

process consumidor(i:integer); // var item:item; k:integer; begin repeat wait(llenos); wait(mutex); k:=1; while buffer[k].proceso!=i do k:=k+1; item:=buffer[k].inform; buffer[k].proceso:=0; signal(mutex); signal(huecos); consumir(item); // forever end;

lleno:semaphore

llenos:array[1..2] of semaphore; //inicializado a 0

Process productor(i:integer); // var item:item; k:integer; begin repeat producir(item); // wait(huecos); wait(mutex); k:=1; while buffer[k].proceso!=0 do k:=k+1; buffer[k].proceso:=i; buffer[k].inform:=item; signal(mutex); signal(llenos[i]); // forever end;

process consumidor(i:integer); // var item:item; k:integer; begin repeat wait(llenos[i]); //SE CAMBIA wait(mutex); k:=1; while buffer[k].proceso!=i do k:=k+1; item:=buffer[k].inform; buffer[k].proceso:=0; signal(mutex); signal(huecos); consumir(item); // forever end;

Problema: Supongamos un buffer compartido por varios procesos consumidores y un proceso productor. Los consumidores extraen un elemento cada vez que acceden al buffer. Cuando el buffer queda vacío, el consumidor que lo detecta avisa al productor que llenará todo el buffer de elementos. El productor, por lo tanto, sólo accede al buffer cuando éste esté totalmente vacío y lo llena (suponemos que ya tiene generados tantos elementos como capacidad tiene el buffer). var llenar:semaphore; // inicializado a 1; espera:semaphore; // inicializado a 0 tamaño:integer; //inicializada a 0

process productor; begin wait(llenar); /*llenar el buffer;*/ tamaño:=N; signal(espera); end; process type consumidor; begin wait(espera); /*sacar un elemento*/ tamaño:=tamaño-1; if tamaño=0 then signal(llenar); else signal(espera); end;

Problema: Se tiene un sistema con un gran número de procesos que quieren acceder a un determinado recurso, e interesa que puedan acceder simultáneamente el máximo número de ellos. Por ejemplo, si 100 procesos quieren acceder al recurso, deben de poder hacerlo los 100 simultáneamente. Ahora bien, también es necesario impedir (por razones “supersticiosas”) que alguna vez estén trece procesos exactamente accediendo al recurso al mismo tiempo. Implementar los protocolos de entrada y de salida de un proceso tipo a la hora de acceder a dicho recurso. Consideraremos que un proceso ha abandonado el recurso (y por lo tanto no tiene acceso al recurso) cuando ha ejecutado con éxito el protocolo de salida. process type usuario; begin … Protocolo de entrada; Acceso al recurso; Protocolo de salida; Recurso abandonado; … end;

var mutex:semaphore; // inicializado a 1; espera:semaphore; // inicializado a 0 np,esp:integer; //inicializadas a 0

process type usuario; begin wait(mutex); np:=np+1; if (np=13) then begin esp:=esp+1; signal(mutex); wait(espera); esp:=esp-1; signal(mutex); end else if esp0 then signal(espera) else signal(mutex); ACCEDE AL RECURSO; wait(mutex); np:=np-1; if (np=13) then begin esp:=esp+1; signal(mutex); wait(espera); esp:=esp-1; signal(mutex); end else if esp0 then signal(espera) else signal(mutex); end;

Problema: Supongamos que estamos en una discoteca y resulta que está estropeado el servicio de chicas y todos tienen que compartir el de chicos. Se pretende establecer un protocolo de entrada al servicio usando semáforos en el que se cumplan las siguientes restricciones: • Chicas sólo puede haber una a la vez en el servicio. • Chicos puede haber más de uno, pero con un máximo de cinco. • (Versión machista) Los chicos tienen preferencia sobre las chicas. Esto quiere decir que si una chica está esperando y llega un chico, éste puede pasar. Incluso si no puede entrar en el servicio porque hay ya cinco chicos, pasará antes que la chica cuando salga algún chico. • (Versión feminista) Las chicas tienen preferencia sobre los chicos. Esto quiere decir que si un chico está esperando y llega una chica, ésta debe pasar antes. Incluso si no puede entrar en el servicio porque hay una chica, pasará antes que el chico cuando salga la chica. var mutex:semaphore; // inicializado a 1 chicos,chicas:semaphore; // inicializados a 0 nod,nad,noe,nae:integer; // inicializados a 0

Version Machista: process type chico(i:integer); begin wait(mutex); if ((nod0) and (nod0) then signal(chicos) else if((nae>0) and (nod=0)) then signal(chicas) else signal(mutex);

wait(mutex); nad:=nad-1; if (noe>0) then signal(chicos) else if (nae>0) then signal(chicas) else signal(mutex); end;

end;

Version Feminista: process type chico; begin wait(mutex); if ((nod0) and (nod0) then signal(chicas) else if (noe>0) then signal(chicos) else signal(mutex);

(* DENTRO *) wait(mutex); nod:=nod-1; if ((nae>0) and (nod=0)) then signal(chicas) else if((noe>0) and (nae=0)) then signal(chicos) else signal(mutex); end;

end;