Práctica Abrazo Mortal (Sistemas Operativos)

Ejercicio 1

Solamente si el mismo tiene varios hilos.

Ejercicio 2*

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

Ejercicio 3

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 4*

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 5*

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 6

a. se puede.

b. no se puede.

c. no se puede.

d. se puede.

e. se puede.

f. se puede.

Ejercicio 7*

a.

MAX Proceso R1 R2 R3 R4 P1 0 0 1 2 P2 1 7 5 0 P3 2 3 5 6 P4 0 6 5 2 P5 0 6 5 6

-

ASIGNACIÓN Proceso R1 R2 R3 R4 P1 0 0 1 2 P2 1 0 0 0 P3 1 3 5 4 P4 0 6 3 2 P5 0 0 1 4

=

NECESIDAD Proceso R1 R2 R3 R4 P1 0 0 0 0 P2 0 7 5 0 P3 1 0 0 2 P4 0 0 2 0 P5 0 6 4 2

b.

AB PASO 0 1 2 3 4 5

FINISH P1 P2 P3 P4 P5 F F F F F T F F F F T F T F F T T T F F T T T T F T T T T T

WORK R1 R2 R3 R4 1 5 2 0 1 5 3 2 2 8 8 6 3 8 8 6 3 14 11 8 3 14 12 12

ENTONCES Puedo Seguir? P1 cumple -> Work += Asig[1] P3 cumple -> Work += Asig[3] P2 cumple -> Work += Asig[2] P4 cumple -> Work += Asig[4] P5 cumple -> Work += Asig[5] SUCCESS

Por lo tanto, el sistema está en estado seguro. La secuencia segura es P1 - P3 - P2 - P4 - P5

c. Corriendo el algoritmo del banquero:

• Req[2] $\leq$ Nec[2]? (0 4 2 0) $\leq$ (0 7 5 0) Sí
• Req[2] $\leq$ Disp? (0 4 2 0) $\leq$ (1 5 2 0) Sí

Entonces se cambian:

• Disp -= Req[2] $\to$ Disp = (1 1 0 0)
• Asig[2] += Req[2] $\to$ Asig[2] = (1 4 2 0)
• Nec[2] -= Req[2] $\to$ Nec[2] = (0 3 3 0)

Corriendo el algoritmo de Seguridad:

AB PASO 0 1 2 3 4 5

FINISH P1 P2 P3 P4 P5 F F F F F T F F F F T F T F F T F T T F T T T T F T T T T T

WORK R1 R2 R3 R4 1 1 0 0 1 1 1 2 2 4 6 6 2 10 8 8 3 14 10 8 3 14 11 12

ENTONCES Puedo Seguir? P1 cumple -> Work += Asig[1] P3 cumple -> Work += Asig[3] P4 cumple -> Work += Asig[4] P2 cumple -> Work += Asig[2] P5 cumple -> Work += Asig[5] SUCCESS

Por lo tanto, el pedido puede ser satisfecho.

Ejercicio 8

Sí. Luego ejecuto P1 - P3 - P2.

Ejercicio 9*

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 Proceso R1 R2 R3 R4 P1 3 1 1 3 P2 3 2 3 4 P3 3 3 2 2

ASIGNACIÓN Proceso R1 R2 R3 R4 P1 2 0 0 2 P2 0 1 1 0 P3 0 1 0 1

NECESIDAD Proceso R1 R2 R3 R4 P1 1 1 1 1 P2 3 1 2 4 P3 3 2 2 1

a. Corriendo el algoritmo del banquero:

• Req[1] $\leq$ Nec[1]? (0 1 1 1) $\leq$ (1 1 1 1) Sí
• Req[1] $\leq$ Disp? (0 1 1 1) $\leq$ (1 3 3 1) Sí

Entonces se cambian:

• Disp -= Req[1] $\to$ Disp = (1 2 2 0)
• Asig[1] += Req[1] $\to$ Asig[1] = (2 1 1 3)
• Nec[1] -= Req[1] $\to$ Nec[1] = (1 0 0 0)

Corriendo el algoritmo de seguridad:

AB PASO 0 1 2 3

FINISH P1 P2 P3 F F F T F F T T F T T T

WORK R1 R2 R3 R4 1 3 3 1 3 4 4 4 3 4 5 4 3 5 5 5

ENTONCES Puedo Seguir? P1 cumple -> Work += Asig[1] P2 cumple -> Work += Asig[2] P3 cumple -> Work += Asig[3] SUCCESS

Por lo tanto, este pedido puede ser satisfecho.

b. Corriendo el algoritmo del banquero:

• Req[2] $\leq$ Nec[2]? (1 0 0 1) $\leq$ (3 1 2 4) Sí
• Req[2] $\leq$ Disp? (1 0 0 1) $\leq$ (1 3 3 1) Sí

Entonces se cambian:

• Disp -= Req[2] $\to$ Disp = (0 3 3 0)
• Asig[2] += Req[2] $\to$ Asig[2] = (1 1 1 1)
• Nec[2] -= Req[2] $\to$ Nec[2] = (2 1 2 3)

Corriendo el algoritmo de seguridad:

AB PASO 0

FINISH P1 P2 P3 F F F

WORK R1 R2 R3 R4 0 3 3 0

ENTONCES Puedo Seguir? FAILED

Por lo tanto, este pedido no puede ser satisfecho.

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.

ASIGNACIÓN Proceso R1 R2 R3 R4 P1 0 1 0 0 P2 2 0 0 1 P3 3 0 3 0 P4 2 1 1 1 P5 0 0 2 0

NECESIDAD Proceso R1 R2 R3 R4 P1 0 0 0 0 P2 2 0 2 0 P3 0 0 0 0 P4 1 0 0 0 P5 0 0 2 1

Corriendo el algoritmo de seguridad:

AB PASO 0 1 2 3 4 5

FINISH P1 P2 P3 P4 P5 F F F F F T F F F F T F T F F T T T F F T T T T F T T T T T

WORK R1 R2 R3 R4 0 0 0 0 0 1 0 0 3 1 3 0 5 1 5 0 7 2 6 1 7 2 8 1

ENTONCES Puedo Seguir? P1 cumple -> Work += Asig[1] P3 cumple -> Work += Asig[3] P2 cumple -> Work += Asig[2] P4 cumple -> Work += Asig[4] P5 cumple -> Work += Asig[5] SUCCESS

b.