Diferencia entre revisiones de «Práctica Abrazo Mortal (Sistemas Operativos)»

De Cuba-Wiki
 
(No se muestran 10 ediciones intermedias de 3 usuarios)
Línea 1: Línea 1:
==Ejercicio 01:==
{{Back|Sistemas Operativos}}
<br>Solamente si el mismo tiene varios hilos.
 
<br>
===Ejercicio 1===
==Ejercicio 02:[*]==
En principio, no. Es cierto que se puede fabricar un deadlock entre distintos threads de un mismo proceso, pero no es a lo que apunta la pregunta.
<br>Si. Pero la administracion de procesador/memoria solucionan estos problemas. (Al hacerlos recursos compartibles entre varios procesos).  
 
<br>
===Ejercicio 2*===
==Ejercicio 03:==
En el caso del procesador, no es específicamente un deadlock sino un caso de inanición. En el caso de la memoria y disco sí, sólo que no se trata de tener un recurso 'exclusivo' sino de conseguir espacio (sería tener 2 programas en los que cada uno tiene el 50% del espacio disponible, quieren un poco más, y cada uno espera que el otro libere). Estos problemas se suelen solucionar por medio del desalojo en el caso del procesador y la memoria y con preasignación de espacio en el caso del disco.
<br>¿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.  
 
<br>
===Ejercicio 3===
==Ejercicio 04:[*]==
Dado que hay 4 instancias y 3 procesos, sea cual sea la asignación uno de los procesos va a obtener las 2 instancias que requiere, garantizando su finalización y dejando libres suficientes recursos como para estar seguros de que los otros 2 también van a finalizar.
<br>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.  
 
<br>
===Ejercicio 4*===
==Ejercicio 05:[*]==
La Inanición '''es una forma''' de Deadlock. No son lo mismo.
<br>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.  
 
<br>
Lo que define la Inanición es la idea de un proceso que '''nunca consigue cierto recurso'''.
==Ejercicio 06:==
 
<br>a) se puede.
Lo que define al Deadlock es la '''espera circular''' donde hay un conjunto de procesos en espera en el cual cada proceso requiere algo que tiene otro proceso del conjunto.
<br>b) no se puede.
 
<br>c) no se puede.
===Ejercicio 5*===
<br>d) se puede.
Una dificultad de hacer roll-back es que se deshacen todos los acciones anteriores recorriendo el "log", pero hay operaciones que no se pueden deshacer (por ej: imprimir algo). Ademas es muy costoso mantener la información para poder hacer un roll back.
<br>e) se puede.
La ventaja es que si todo sale bien, el sistema sigue funcionando y no se perdió información.  
<br>f) se puede.  
 
<br>
===Ejercicio 6===
==Ejercicio 07:[*]==
 
<br>a)
a. Se puede.
<br>||Max ||Asignacion ||Necesidad ||
 
<br>||0 0 1 2 ||0 0 1 2 ||0 0 0 0 ||
b. No se puede.
<br>||1 7 5 0 ||1 0 0 0 ||0 7 5 0 ||
 
<br>||2 3 5 6 ||1 3 5 4 ||1 0 0 2 ||
c. No se puede.
<br>||0 6 5 2 ||0 6 3 2 ||0 0 2 0 ||
 
<br>||0 6 5 6 ||0 0 1 4 ||0 6 4 2 ||
d. Se puede.
<br>b)
 
<br>||Finish || Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
e. No se puede.
<br>||F F F F F || 1 5 2 0 || P[1] cumple -> Work += Asig[1] ||
 
<br>||T F F F F || 1 5 3 2 || P[3] cumple -> Work += Asig[3] ||
f. Se puede.  
<br>||T F T F F || 2 8 8 6 || P[2] cumple -> Work += Asig[2] ||
 
<br>||T T T F F || 3 8 8 6 || P[4] cumple -> Work += Asig[4] ||
===Ejercicio 7*===
<br>||T T T T F || 3 14 11 8 || P[5] cumple -> Work += Asig[5] ||
a.
<br>||T T T T T || 3 14 12 12 || LISTO ||
{| class="wikitable" style="text-align:center"
<br>Rta - Si.
|
<br>Secuencia segura: P(1); P(3); P(2); P(4); P(5);
{| border="1"
<br>c)
|+'''MAX'''
<br>Corriendo el algoritmo del banquero:
!Proceso !!R1 !!R2 !!R3 !!R4
<br>Req[2] <= Nec[2]? (0 4 2 0) <= (0 7 5 0) si
|-
<br>Req[2] <= Disp? (0 4 2 0) <= (1 5 2 0) si
! P1
<br>Entonces se cambian:
|0||0||1||2
<br>Disp - = Req[2] -> Disp = (1 1 0 0)
|-
<br>Asig[2] + = Req[2] -> Asig[2] = (1 4 2 0)
! P2
<br>Nec[2] - = Req[2] -> Nec[2] = (0 3 3 0)
|1||7||5||0
<br>
|-
<br>Corriendo el algoritmo de seguridad:
! P3
<br>||Finish || Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
|2||3||5||6
<br>||F F F F F || 1 1 0 0 || P[1] cumple -> Work += Asig[1] ||
|-
<br>||T F F F F || 1 1 1 2 || P[3] cumple -> Work += Asig[3] ||
! P4
<br>||T F T F F || 2 4 6 6 || P[4] cumple -> Work += Asig[4] ||
|0||6||5||2
<br>||T F T T F || 2 10 8 8 || P[2] cumple -> Work += Asig[2] ||
|-
<br>||T T T T F || 3 14 10 8 || P[5] cumple -> Work += Asig[5] ||
! P5
<br>||T T T T T || 3 14 11 12 || LISTO ||
|0||6||5||6
<br>Rta - Si.
|}
<br>
|
==Ejercicio 08:==
'''-'''
<br>Si. Luego ejecuto P(1); P(3); P(2);
|
<br>
{| border="1"
==Ejercicio 09:[*]==
|+'''ASIGNACIÓN'''
<br>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.
!Proceso !!R1 !!R2 !!R3 !!R4
<br>
|-
==Ejercicio 10:[*]==
! P1
<br>||Max ||Asignacion ||Necesidad ||
|0||0||1||2
<br>||3 1 1 3 ||2 0 0 2 ||1 1 1 1 ||
|-
<br>||3 2 3 4 ||0 1 1 0 ||3 1 2 4 ||
! P2
<br>||3 3 2 2 ||0 1 0 1 ||3 2 2 1 ||
|1||0||0||0
<br>a)
|-
<br>Corriendo el algoritmo del banquero:
! P3
<br>Req[1] <= Nec[1]? (0 1 1 1) <= (1 1 1 1) si
|1||3||5||4
<br>Req[1] <= Disp? (0 1 1 1) <= (1 3 3 1) si
|-
<br>Entonces se cambian:
! P4
<br>Disp - = Req[1] -> Disp = (1 2 2 0)
|0||6||3||2
<br>Asig[1] + = Req[1] -> Asig[1] = (2 1 1 3)
|-
<br>Nec[1] - = Req[1] -> Nec[1] = (1 0 0 0)
! P5
<br>
|0||0||1||4
<br>Corriendo el algoritmo de seguridad:
|}
<br>||Finish|| Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
|
<br>||F F F || 1 3 3 1 || P[1] cumple -> Work += Asig[1] ||
'''='''
<br>||T F F || 3 4 4 4 || P[2] cumple -> Work += Asig[2] ||
|
<br>||T T F || 3 4 5 4 || P[3] cumple -> Work += Asig[3] ||
{| border="1"
<br>||T T T || 3 5 5 5 || LISTO ||
|+'''NECESIDAD'''
<br>Rta - Si.
!Proceso !!R1 !!R2 !!R3 !!R4
<br>
|-
<br>b)
! P1
<br>Corriendo el algoritmo del banquero:
|0||0||0||0
<br>Req[2] <= Nec[2]? (1 0 0 1) <= (3 1 2 4) si
|-
<br>Req[2] <= Disp? (1 0 0 1) <= (1 3 3 1) si
! P2
<br>Entonces se cambian:
|0||7||5||0
<br>Disp - = Req[2] -> Disp = (0 3 3 0)
|-
<br>Asig[2] + = Req[2] -> Asig[2] = (1 1 1 1)
! P3
<br>Nec[2] - = Req[2] -> Nec[2] = (2 1 2 3)
|1||0||0||2
<br>
|-
<br>Corriendo el algoritmo de seguridad:
! P4
<br>||Finish|| Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
|0||0||2||0
<br>||F F F || 0 3 3 0 || NO HAY ||
|-
<br>Rta - No.
! P5
<br>
|0||6||4||2
|}
|}
 
b.
{| class="wikitable" style="text-align:center"
|
{| border="1"
|+ '''AB'''
!PASO
|-
|0
|-
|1
|-
|2
|-
|3
|-
|4
|-
|5
|}
||
{| border="1"
|+'''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
|}
||
{| border="1"
|+'''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
|}
||
{| border="1"
|+'''ENTONCES'''
!Puedo Seguir?
|-
|P1 cumple <math>\to</math> Work += Asig[1]
|-
|P3 cumple <math>\to</math> Work += Asig[3]
|-
|P2 cumple <math>\to</math> Work += Asig[2]
|-
|P4 cumple <math>\to</math> Work += Asig[4]
|-
|P5 cumple <math>\to</math> 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] <math>\le</math> Nec[2]? (0 4 2 0) <math>\le</math> (0 7 5 0) Sí
*Req[2] <math>\le</math> Disp? (0 4 2 0) <math>\le</math> (1 5 2 0) Sí
 
Entonces se cambian:
*Disp -= Req[2] <math>\to</math> Disp = (1 1 0 0)
*Asig[2] += Req[2] <math>\to</math> Asig[2] = (1 4 2 0)
*Nec[2] -= Req[2] <math>\to</math> Nec[2] = (0 3 3 0)
 
Corriendo el algoritmo de Seguridad:
{| class="wikitable" style="text-align:center"
|
{| border="1"
|+ '''AB'''
!PASO
|-
|0
|-
|1
|-
|2
|-
|3
|-
|4
|-
|5
|}
||
{| border="1"
|+'''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
|}
||
{| border="1"
|+'''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
|}
||
{| border="1"
|+'''ENTONCES'''
!Puedo Seguir?
|-
|P1 cumple <math>\to</math> Work += Asig[1]
|-
|P3 cumple <math>\to</math> Work += Asig[3]
|-
|P4 cumple <math>\to</math> Work += Asig[4]
|-
|P2 cumple <math>\to</math> Work += Asig[2]
|-
|P5 cumple <math>\to</math> Work += Asig[5]
|-
|'''SUCCESS'''
|}
|}
 
Por lo tanto, el pedido puede ser satisfecho.
 
===Ejercicio 8===
Sí. Luego ejecuto '''P1 - P3 - P2'''.
 
===Ejercicio 9*===
Hay 2 maneras en que es posible que un sistema en estado unsafe no termine en un deadlock. La primera es que alguno de los procesos en ejecución libere alguno de los recursos que estaba utilizando, de manera que otro obtiene todo lo que requería y puede finzalizar satisfactoriamente. Otra posibilidad es que uno de los procesos termine su ejecución sin pedir todo lo que tenía declarado en el MAX, liberando los recursos que estaba consumiendo.
 
===Ejercicio 10*===
{| class="wikitable" style="text-align:center"
|
{| border="1"
|+'''MAX'''
!Proceso !!R1 !!R2 !!R3 !!R4
|-
! P1
|3||1||1||3
|-
! P2
|3||2||3||4
|-
! P3
|3||3||2||2
|}
|
{| border="1"
|+'''ASIGNACIÓN'''
!Proceso !!R1 !!R2 !!R3 !!R4
|-
! P1
|2||0||0||2
|-
! P2
|0||1||1||0
|-
! P3
|0||1||0||1
|}
|
{| border="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] <math>\le</math> Nec[1]? (0 1 1 1) <math>\le</math> (1 1 1 1) Sí
*Req[1] <math>\le</math> Disp? (0 1 1 1) <math>\le</math> (1 3 3 1) Sí
 
Entonces se cambian:
*Disp -= Req[1] <math>\to</math> Disp = (1 2 2 0)
*Asig[1] += Req[1] <math>\to</math> Asig[1] = (2 1 1 3)
*Nec[1] -= Req[1] <math>\to</math> Nec[1] = (1 0 0 0)
 
Corriendo el algoritmo de seguridad:
 
{| class="wikitable" style="text-align:center"
|
{| border="1"
|+ '''AB'''
!PASO
|-
|0
|-
|1
|-
|2
|-
|3
|}
||
{| border="1"
|+'''FINISH'''
!P1 !!P2 !!P3
|-
|F||F||F
|-
|T||F||F
|-
|T||T||F
|-
|T||T||T
|}
||
{| border="1"
|+'''WORK'''
!R1 !!R2 !!R3 !!R4
|-
|1||3||3||1
|-
|3||4||4||4
|-
|3||4||5||4
|-
|3||5||5||5
|}
||
{| border="1"
|+'''ENTONCES'''
!Puedo Seguir?
|-
|P1 cumple <math>\to</math> Work += Asig[1]
|-
|P2 cumple <math>\to</math> Work += Asig[2]
|-
|P3 cumple <math>\to</math> Work += Asig[3]
|-
|'''SUCCESS'''
|}
|}
 
Por lo tanto, este pedido puede ser satisfecho.
 
b.
Corriendo el algoritmo del banquero:
*Req[2] <math>\le</math> Nec[2]? (1 0 0 1) <math>\le</math> (3 1 2 4) Sí
*Req[2] <math>\le</math> Disp? (1 0 0 1) <math>\le</math> (1 3 3 1) Sí
 
Entonces se cambian:
*Disp -= Req[2] <math>\to</math> Disp = (0 3 3 0)
*Asig[2] += Req[2] <math>\to</math> Asig[2] = (1 1 1 1)
*Nec[2] -= Req[2] <math>\to</math> Nec[2] = (2 1 2 3)
 
Corriendo el algoritmo de seguridad:
 
{| class="wikitable" style="text-align:center"
|
{| border="1"
|+ '''AB'''
!PASO
|-
|0
|}
||
{| border="1"
|+'''FINISH'''
!P1 !!P2 !!P3
|-
|F||F||F
|}
||
{| border="1"
|+'''WORK'''
!R1 !!R2 !!R3 !!R4
|-
|0||3||3||0
|}
||
{| border="1"
|+'''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.
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:[*]==
===Ejercicio 11*===
<br>a) Mala idea pues es muy costoso hacerlo, y si se hace cada vez que se asigna un recurso peor.
a. Si bien es terriblemente ineficiente, tiene la ventaja de que el sistema logra averiguar cómo se cerró el deadlock y puede tratarlo mejor, por lo que elegirlo es una respuesta posible.
<br>b) Puede tardarse bastante tiempo en detectarse el deadlock si el intervalo es muy grande, desperdiciando recursos en el transcurso.
 
<br>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.  
b. Puede tardarse bastante tiempo en detectarse el deadlock si el intervalo es muy grande, desperdiciando recursos en el transcurso.
<br>
 
==Ejercicio 12:==
c. Elegir este es lo más correcto, porque se corre el algoritmo una cantidad mínima de veces. Su desventaja es que es muy complicado establecer las cotas de tiempo y rendimiento que equilibren entre no correr el algoritmo muchas veces y no dejar el sistema bloqueado mucho tiempo.
<br>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.  
 
<br>
===Ejercicio 12===
==Ejercicio 13:[*]==
El algoritmo del banquiero requiere de ser ejecutado cada vez que se pide un recurso, lo que lo hace ineficiente. Otro problema es que quizas se bloquean muchos procesos para no entrar en estados inseguros, que realmente no terminarian en deadlock, deteriorando mucho la performance del sistema. Además, requiere información sobre los programas (relacionada con cuánto es el máximo de recursos que van a consumir) que no siempre está disponible.
<br>a) Secuencia: P3, P4, P1, P2. Esto significa que si ejecuto los procesos en ese orden, todos los programas terminaran satisfactoriamente.
 
<br>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.
Por estas razones, en la práctica no se suele utilizar el algoritmo del Banquero.
<br>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.  
 
<br>
===Ejercicio 13*===
==Ejercicio 14:[*]==
a. Secuencia: '''P3 - P4 - P1 - P2'''. Esto significa que si ejecuto los procesos en ese orden, todos los programas terminaran satisfactoriamente.
<br>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.  
 
<br>
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 válida para el nuevo estado.
==Ejercicio 15:[*]==
 
<br>a)
c. No puede ser satisfecho. Porque pide mas recursos de los que la matriz 'necesidad' indica que faltan. Es decir, P4 declaró que usará 1 de ese recurso. La matriz asignación indica que ya se lo otorgué y por lo tanto la necesidad sobre ese recurso queda en cero. Pero P4 vuelve a pedirme una instancia de ese recurso. Por lo tanto se produce un error y se ejecutara alguna rutina del sistema operativo, como por ejemplo eliminar ese proceso del sistema y liberar los recursos que poseía.
NOTESE la diferencia siguiente. P4 NO VA A ESPERA, ya que el error se produjo cuando banquero chequeó las 2 desigualdades pertinentes, y no cuando el algoritmo de seguridad advirtió sobre un paso a un estado UNSAFE. En ese último caso, sí iria a espera P4 y se retrotraerían los valores de las matrices que banquero cambió. En este caso, directamente NO se llega ni a llamar al algoritmo de seguridad. Luego, se CANCELA P4.
 
===Ejercicio 14*===
#Si los recursos son únicos, estoy en deadlock.
#Si hay mas de una instancia de algún recurso, entonces puede que no, ya que otro proceso que no está en esa espera circular, podría liberar una instancia de uno de los recursos requeridos, rompiendo el círculo.
 
===Ejercicio 15*===
a.
 
{| class="wikitable" style="text-align:center"
|
{| border="1"
|+'''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
|}
|
{| border="1"
|+'''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:
 
{| class="wikitable" style="text-align:center"
|
{| border="1"
|+ '''AB'''
!PASO
|-
|0
|-
|1
|-
|2
|-
|3
|-
|4
|-
|5
|}
||
{| border="1"
|+'''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
|}
||
{| border="1"
|+'''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
|}
||
{| border="1"
|+'''ENTONCES'''
!Puedo Seguir?
|-
|P1 cumple <math>\to</math> Work += Asig[1]
|-
|P3 cumple <math>\to</math> Work += Asig[3]
|-
|P2 cumple <math>\to</math> Work += Asig[2]
|-
|P4 cumple <math>\to</math> Work += Asig[4]
|-
|P5 cumple <math>\to</math> Work += Asig[5]
|-
|'''SUCCESS'''
|}
|}
 
b. Hay que aplicar Shoshani-Coffman.


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


<br>b)
[[Category:Prácticas]]

Revisión actual - 14:15 17 oct 2009

Plantilla:Back

Ejercicio 1[editar]

En principio, no. Es cierto que se puede fabricar un deadlock entre distintos threads de un mismo proceso, pero no es a lo que apunta la pregunta.

Ejercicio 2*[editar]

En el caso del procesador, no es específicamente un deadlock sino un caso de inanición. En el caso de la memoria y disco sí, sólo que no se trata de tener un recurso 'exclusivo' sino de conseguir espacio (sería tener 2 programas en los que cada uno tiene el 50% del espacio disponible, quieren un poco más, y cada uno espera que el otro libere). Estos problemas se suelen solucionar por medio del desalojo en el caso del procesador y la memoria y con preasignación de espacio en el caso del disco.

Ejercicio 3[editar]

Dado que hay 4 instancias y 3 procesos, sea cual sea la asignación uno de los procesos va a obtener las 2 instancias que requiere, garantizando su finalización y dejando libres suficientes recursos como para estar seguros de que los otros 2 también van a finalizar.

Ejercicio 4*[editar]

La Inanición es una forma de Deadlock. No son lo mismo.

Lo que define la Inanición es la idea de un proceso que nunca consigue cierto recurso.

Lo que define al Deadlock es la espera circular donde hay un conjunto de procesos en espera en el cual cada proceso requiere algo que tiene otro proceso del conjunto.

Ejercicio 5*[editar]

Una dificultad de hacer roll-back es que se deshacen todos los acciones anteriores recorriendo el "log", pero hay operaciones que no se pueden deshacer (por ej: imprimir algo). Ademas es muy costoso mantener la información para poder hacer un roll back. La ventaja es que si todo sale bien, el sistema sigue funcionando y no se perdió información.

Ejercicio 6[editar]

a. Se puede.

b. No se puede.

c. No se puede.

d. Se puede.

e. No se puede.

f. Se puede.

Ejercicio 7*[editar]

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 Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[1]
P3 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[3]
P2 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[2]
P4 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[4]
P5 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} 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] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} Nec[2]? (0 4 2 0) Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} (0 7 5 0) Sí
  • Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} Disp? (0 4 2 0) Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} (1 5 2 0) Sí

Entonces se cambian:

  • Disp -= Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Disp = (1 1 0 0)
  • Asig[2] += Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Asig[2] = (1 4 2 0)
  • Nec[2] -= Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \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 Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[1]
P3 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[3]
P4 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[4]
P2 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[2]
P5 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[5]
SUCCESS

Por lo tanto, el pedido puede ser satisfecho.

Ejercicio 8[editar]

Sí. Luego ejecuto P1 - P3 - P2.

Ejercicio 9*[editar]

Hay 2 maneras en que es posible que un sistema en estado unsafe no termine en un deadlock. La primera es que alguno de los procesos en ejecución libere alguno de los recursos que estaba utilizando, de manera que otro obtiene todo lo que requería y puede finzalizar satisfactoriamente. Otra posibilidad es que uno de los procesos termine su ejecución sin pedir todo lo que tenía declarado en el MAX, liberando los recursos que estaba consumiendo.

Ejercicio 10*[editar]

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] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} Nec[1]? (0 1 1 1) Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} (1 1 1 1) Sí
  • Req[1] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} Disp? (0 1 1 1) Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} (1 3 3 1) Sí

Entonces se cambian:

  • Disp -= Req[1] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Disp = (1 2 2 0)
  • Asig[1] += Req[1] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Asig[1] = (2 1 1 3)
  • Nec[1] -= Req[1] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \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 Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[1]
P2 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[2]
P3 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[3]
SUCCESS

Por lo tanto, este pedido puede ser satisfecho.

b. Corriendo el algoritmo del banquero:

  • Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} Nec[2]? (1 0 0 1) Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} (3 1 2 4) Sí
  • Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} Disp? (1 0 0 1) Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \le} (1 3 3 1) Sí

Entonces se cambian:

  • Disp -= Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Disp = (0 3 3 0)
  • Asig[2] += Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Asig[2] = (1 1 1 1)
  • Nec[2] -= Req[2] Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \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*[editar]

a. Si bien es terriblemente ineficiente, tiene la ventaja de que el sistema logra averiguar cómo se cerró el deadlock y puede tratarlo mejor, por lo que elegirlo es una respuesta posible.

b. Puede tardarse bastante tiempo en detectarse el deadlock si el intervalo es muy grande, desperdiciando recursos en el transcurso.

c. Elegir este es lo más correcto, porque se corre el algoritmo una cantidad mínima de veces. Su desventaja es que es muy complicado establecer las cotas de tiempo y rendimiento que equilibren entre no correr el algoritmo muchas veces y no dejar el sistema bloqueado mucho tiempo.

Ejercicio 12[editar]

El algoritmo del banquiero requiere de ser ejecutado cada vez que se pide un recurso, lo que lo hace ineficiente. Otro problema es que quizas se bloquean muchos procesos para no entrar en estados inseguros, que realmente no terminarian en deadlock, deteriorando mucho la performance del sistema. Además, requiere información sobre los programas (relacionada con cuánto es el máximo de recursos que van a consumir) que no siempre está disponible.

Por estas razones, en la práctica no se suele utilizar el algoritmo del Banquero.

Ejercicio 13*[editar]

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 válida para el nuevo estado.

c. No puede ser satisfecho. Porque pide mas recursos de los que la matriz 'necesidad' indica que faltan. Es decir, P4 declaró que usará 1 de ese recurso. La matriz asignación indica que ya se lo otorgué y por lo tanto la necesidad sobre ese recurso queda en cero. Pero P4 vuelve a pedirme una instancia de ese recurso. Por lo tanto se produce un error y se ejecutara alguna rutina del sistema operativo, como por ejemplo eliminar ese proceso del sistema y liberar los recursos que poseía. NOTESE la diferencia siguiente. P4 NO VA A ESPERA, ya que el error se produjo cuando banquero chequeó las 2 desigualdades pertinentes, y no cuando el algoritmo de seguridad advirtió sobre un paso a un estado UNSAFE. En ese último caso, sí iria a espera P4 y se retrotraerían los valores de las matrices que banquero cambió. En este caso, directamente NO se llega ni a llamar al algoritmo de seguridad. Luego, se CANCELA P4.

Ejercicio 14*[editar]

  1. Si los recursos son únicos, estoy en deadlock.
  2. Si hay mas de una instancia de algún recurso, entonces puede que no, ya que otro proceso que no está en esa espera circular, podría liberar una instancia de uno de los recursos requeridos, rompiendo el círculo.

Ejercicio 15*[editar]

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 Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[1]
P3 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[3]
P2 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[2]
P4 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[4]
P5 cumple Error al representar (SVG o PNG como alternativa (MathML puede ser habilitado mediante plugin de navegador): respuesta no válida («Math extension cannot connect to Restbase.») del servidor «https://en.wikipedia.org/api/rest_v1/»:): {\displaystyle \to} Work += Asig[5]
SUCCESS

b. Hay que aplicar Shoshani-Coffman.

Obtenido de «https://www.cubawiki.com.ar/index.php?title=Práctica_Abrazo_Mortal_(Sistemas_Operativos)&oldid=7191»