Práctica Abrazo Mortal (Sistemas Operativos)

Ejercicio 01:

Solamente si el mismo tiene varios hilos.

Ejercicio 02:[*]

Si. Pero la administracion de procesador/memoria solucionan estos problemas. (Al hacerlos recursos compartibles entre varios procesos).

Ejercicio 03:

¿Como se demuestra esto? La idea informal es: Si hay un solo proceso, lo ejecuto y como hay 4 y usa 2 anda todo bien. Si hay n, supongo "inductivamente" que para n - 1 no hay deadlock. Si hay algun proceso que tiene 2, ese tiene todo lo que necesita y puede terminar. Si no, como maximo son 3 procesos, cada uno tiene maximo 1, entonces sobra uno y todos tienen uno, entonces se lo doy a alguno y ese termina, o sobran 2 o mas, y se los doy a uno ese termina y recursivamente con n-1 no hay deadlock.

Ejercicio 04:[*]

Deadlock es que un proceso espera un evento que nunca va a ocurrir. En tiempo infinito los procesos del deadlock van a seguir blockeados... Inhanicion es que no recive, o recive poco procesador un proceso. En tiempo infinito, el proceso terminaria ejecutandose completamente.

Ejercicio 05:[*]

Una dificultad de hacer roll-back es que se deshacen todos los acciones anteriores recorriendo el "log", y esto puede hacer que se deshagan los cambios de otros procesos. Otra dificultad es que hay operaciones que no se pueden deshacer (Ej: imprimir algo). Ademas es caro mantener informacion para poder hacer un roll back. Las ventajas es que si todo sale bien, el sistema sigue funcionando y no se perdio informacion.

Ejercicio 06:

a) se puede.
b) no se puede.
c) no se puede.
d) se puede.
e) se puede.
f) se puede.

Ejercicio 07:[*]

a)
||Max ||Asignacion ||Necesidad ||
||0 0 1 2 ||0 0 1 2 ||0 0 0 0 ||
||1 7 5 0 ||1 0 0 0 ||0 7 5 0 ||
||2 3 5 6 ||1 3 5 4 ||1 0 0 2 ||
||0 6 5 2 ||0 6 3 2 ||0 0 2 0 ||
||0 6 5 6 ||0 0 1 4 ||0 6 4 2 ||
b)
||Finish || Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
||F F F F F || 1 5 2 0 || P[1] cumple -> Work += Asig[1] ||
||T F F F F || 1 5 3 2 || P[3] cumple -> Work += Asig[3] ||
||T F T F F || 2 8 8 6 || P[2] cumple -> Work += Asig[2] ||
||T T T F F || 3 8 8 6 || P[4] cumple -> Work += Asig[4] ||
||T T T T F || 3 14 11 8 || P[5] cumple -> Work += Asig[5] ||
||T T T T T || 3 14 12 12 || LISTO ||
Rta - Si.
Secuencia segura: P(1); P(3); P(2); P(4); P(5);
c)
Corriendo el algoritmo del banquero:
Req[2] <= Nec[2]? (0 4 2 0) <= (0 7 5 0) si
Req[2] <= Disp? (0 4 2 0) <= (1 5 2 0) si
Entonces se cambian:
Disp - = Req[2] -> Disp = (1 1 0 0)
Asig[2] + = Req[2] -> Asig[2] = (1 4 2 0)
Nec[2] - = Req[2] -> Nec[2] = (0 3 3 0)

Corriendo el algoritmo de seguridad:
||Finish || Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
||F F F F F || 1 1 0 0 || P[1] cumple -> Work += Asig[1] ||
||T F F F F || 1 1 1 2 || P[3] cumple -> Work += Asig[3] ||
||T F T F F || 2 4 6 6 || P[4] cumple -> Work += Asig[4] ||
||T F T T F || 2 10 8 8 || P[2] cumple -> Work += Asig[2] ||
||T T T T F || 3 14 10 8 || P[5] cumple -> Work += Asig[5] ||
||T T T T T || 3 14 11 12 || LISTO ||
Rta - Si.

Ejercicio 08:

Si. Luego ejecuto P(1); P(3); P(2);

Ejercicio 09:[*]

Tengo dos procesos que tienen MAX 10 y cada uno tiene 6. En esta sesion uno de los procesos con sus 6 llega a terminar, los libera, y el otro puede terminar tranquilamente.

Ejercicio 10:[*]

||Max ||Asignacion ||Necesidad ||
||3 1 1 3 ||2 0 0 2 ||1 1 1 1 ||
||3 2 3 4 ||0 1 1 0 ||3 1 2 4 ||
||3 3 2 2 ||0 1 0 1 ||3 2 2 1 ||
a)
Corriendo el algoritmo del banquero:
Req[1] <= Nec[1]? (0 1 1 1) <= (1 1 1 1) si
Req[1] <= Disp? (0 1 1 1) <= (1 3 3 1) si
Entonces se cambian:
Disp - = Req[1] -> Disp = (1 2 2 0)
Asig[1] + = Req[1] -> Asig[1] = (2 1 1 3)
Nec[1] - = Req[1] -> Nec[1] = (1 0 0 0)

Corriendo el algoritmo de seguridad:
||Finish|| Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
||F F F || 1 3 3 1 || P[1] cumple -> Work += Asig[1] ||
||T F F || 3 4 4 4 || P[2] cumple -> Work += Asig[2] ||
||T T F || 3 4 5 4 || P[3] cumple -> Work += Asig[3] ||
||T T T || 3 5 5 5 || LISTO ||
Rta - Si.

b)
Corriendo el algoritmo del banquero:
Req[2] <= Nec[2]? (1 0 0 1) <= (3 1 2 4) si
Req[2] <= Disp? (1 0 0 1) <= (1 3 3 1) si
Entonces se cambian:
Disp - = Req[2] -> Disp = (0 3 3 0)
Asig[2] + = Req[2] -> Asig[2] = (1 1 1 1)
Nec[2] - = Req[2] -> Nec[2] = (2 1 2 3)

Corriendo el algoritmo de seguridad:
||Finish|| Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
||F F F || 0 3 3 0 || NO HAY ||
Rta - No.
Si esta nueva situación mantiene al sistema en estado "seguro", los recursos son adjudicados. Si el nuevo estado es "inseguro", p(i) debe esperar y, además, se restaura el anterior estado de asignación total de recursos.

Ejercicio 11:[*]

a) Mala idea pues es muy costoso hacerlo, y si se hace cada vez que se asigna un recurso peor.
b) Puede tardarse bastante tiempo en detectarse el deadlock si el intervalo es muy grande, desperdiciando recursos en el transcurso.
c) Elijo este, porque se corre el algoritmo una cantidad minima de veces, y su desventaja es como establecer la cota para que no corra muy seguido ni que detecte el deadlock muy tarde.

Ejercicio 12:

La frecuencia es ejecutarlo cada vez que se pide un recurso, si no no anda. Los problema es que es un algoritmo muy costoso para ejecutarlo cada vez que se pide un recurso. Otro problema es que quizas se blockean muchos procesos para no entrar en estados inseguros, que realmente no terminarian en deadlock, deteriorando mucho la performance del sistema.

Ejercicio 13:[*]

a) Secuencia: P3, P4, P1, P2. Esto significa que si ejecuto los procesos en ese orden, todos los programas terminaran satisfactoriamente.
b) Por que P3 tiene todos los recursos que necesita para finalizar, entonces si existia una secuencia antes, agarro esa secuencia, pongo P3 al principio, y me da una secuencia segura valida para el nuevo estado.
c) No puede ser satisfecho. El sistema debe blockear P4, y esperar a que se le puedan dar los recursos sin pasar a un estado no seguro.

Ejercicio 14:[*]

Si los recursos son unicos (es decir el MAX de todos es 1), estoy en deadlock. Si hay mas de 1 del recurso, entonces puede que no, ya que otro proceso que no esta en esa espera circular, libera 1 instancia de un recurso de los que 1 esta esperando, y rompe el circulo y todo termina normalmente.

Ejercicio 15:[*]

a)
b)