Ejercicio de Dekker

Las flechas entre los códigos sirven para simular el paso del CPU entre un
proceso y otro, así se crea un escenario para que los dos procesos entren en la
Región Crítica.

int flag[2];
int turn;

void main() {
flag[0] = 0;
flag[1] = 0;
turn = 0;
Paralel (process0, process1);
}

I parte
process0 (){ process1 ()
... {
while (1) { /* ciclo infinito */ ...
while (1) { /* ciclo infinito */
flag[0] = 1; /* para indicar que flag[1] = 1;
quiere entrar a la SC */ while (turn != 1) {
while (turn != 0) { while (flag[0]==1);
while (flag[1]==1); turn = 1;
turn = 0; }
} /* sección crítica */
/* sección crítica */ flag[1] = 0;
flag[0] = 0; }
... ...
} }
...
}

2da parte
process0 (){ process1 ()
... {
while (1) { /* ciclo infinito */ ...
while (1) { /* ciclo infinito */
flag[0] = 1; /* para indicar que 2 flag[1] = 1;
quiere entrar a la SC */ while (turn != 1) {
while (turn != 0) { while (flag[0]==1);
while (flag[1]); 1 turn = 1;
3 turn = 0; 4 }
} /* sección crítica */
/* sección crítica */ flag[1] = 0;
flag[0] = 0; }
 ... ...
} }
...
}

Ejercicio de las Botellas y las cajas

En una fábrica se tienen dos procesos que modelan una planta embotelladora de bebidas, y que
trabajan en conjunto:

– El proceso “embotellador” se encarga de preparar las botellas de un litro. – Otro proceso

“empaquetador” se encarga de empaquetar y reponer las cajas donde se van colocando las
botellas.

Cada vez que el embotellador prepara una botella, ésta se coloca en una caja, que tiene una
capacidad de 10 litros (10 botellas). Si al colocar la botella, la caja queda llena, se envía una señal
al empaquetador, que toma la caja, la sella y la guarda en un almacén. El empaquetador deposita
una nueva caja de 10 litros, totalmente vacía. Mientras el empaquetador está haciendo su labor, el
embotellador no puede colocar sus botellas, ya que en esos momentos no hay una caja disponible.

Encontrar una solución basada en semáforos que sincronice el problema de concurrencia citado.

void main() {
Paralel (embotellador, empaquetador);
semaphore empaquetador = 0, embotellador = 1;
}

Embotellador Empaquetador
while (true) { while (true) {
semWait(embotellador); semWait(empaquetador);
botella = 0; colocarcaja();
while (botella < 10) { liberarnuevacaja();
colocarbotellacaja(); semSignal(embotellador);
botella++;
} }
semSignal(empaquetador);

}
Ejercicio de los Hamsters

semaforo accederRueda;
semaforo accederComida;
main()
{
/*Arranca los procesos hamster*/
sem_init(&accederComida, 0, 3);
sem_init(&accederRueda,0, 1);

paralel(crearhamster(h1),crearhamster(h2),...,crearhamster(hn));

crearHamster(int hamster)
{
while(true) {
funcionComida();
funcionRueda();
}

Correcciones

funcionRueda(int hamster) funcionComida(int hamster)

{ {
sem_wait(&accederRueda);
ejercicio(); sem_wait(accederComida);
sem_post(&accederRueda); comer();
} sem_post(accederComida);

Ejercicio de Sincronización de Procesos

Dados los siguientes procesos.

A B C
X = X + 1; Y= X/100; Z = Y -100 ;
printf(X); W = Y – 2; A = C + D;
print (W);
Sincronizarlos, usando semáforos, de forma tal que se ejecuten de la siguiente forma:

- Siempre en la secuencia ABCABC….

A B C
Inicialización:
Semaphore sa=1, sb=0, sc=0;

While(true) { While (true) { While (true) {

semWait(sa) semWait(sb) semWait(sc)
X = X + 1; Y= X/100; Z = Y -100 ;
printf(X); W = Y – 2; A = C + D;
semSignal(sb); print (W); semSignal(sa);
} semSignal(sc); }
}

- Siempre en la secuencia A(B ó C)A(B ó C) ….

A B C
Inicialización:
Semaphore sa=1, sb=0

While(true) { While (true) { While (true) {

semWait(sa) semWait(sb) semWait(sb)
X = X + 1; Y= X/100; Z = Y -100 ;
printf(X); W = Y – 2; A = C + D;
semSignal(sb); print (W); semSignal(sa);
} semSignal(sa); }
}