Edición de «Práctica Abrazo Mortal (Sistemas Operativos)»

De Cuba-Wiki
Advertencia: no has iniciado sesión. Tu dirección IP se hará pública si haces cualquier edición. Si inicias sesión o creas una cuenta, tus ediciones se atribuirán a tu nombre de usuario, además de otros beneficios.

Puedes deshacer la edición. Antes de deshacer la edición, comprueba la siguiente comparación para verificar que realmente es lo que quieres hacer, y entonces publica los cambios para así efectuar la reversión.

Revisión actual Tu texto
Línea 1: Línea 1:
{{Back|Sistemas Operativos}}
==Ejercicio 01:==
 
<br>Solamente si el mismo tiene varios hilos.
===Ejercicio 1===
<br>
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 02:[*]==
 
<br>Si. Pero la administracion de procesador/memoria solucionan estos problemas. (Al hacerlos recursos compartibles entre varios procesos).  
===Ejercicio 2*===
<br>
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 03:==
 
<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.  
===Ejercicio 3===
<br>
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 04:[*]==
 
<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.  
===Ejercicio 4*===
<br>
La Inanición '''es una forma''' de Deadlock. No son lo mismo.
==Ejercicio 05:[*]==
 
<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.  
Lo que define la Inanición es la idea de un proceso que '''nunca consigue cierto recurso'''.
<br>
 
==Ejercicio 06:==
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>a) se puede.
 
<br>b) no se puede.
===Ejercicio 5*===
<br>c) no 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>d) se puede.
La ventaja es que si todo sale bien, el sistema sigue funcionando y no se perdió información.  
<br>e) se puede.
 
<br>f) se puede.  
===Ejercicio 6===
<br>
 
==Ejercicio 07:[*]==
a. Se puede.
<br>a)
 
<br>||Max ||Asignacion ||Necesidad ||
b. No se puede.
<br>||0 0 1 2 ||0 0 1 2 ||0 0 0 0 ||
 
<br>||1 7 5 0 ||1 0 0 0 ||0 7 5 0 ||
c. No se puede.
<br>||2 3 5 6 ||1 3 5 4 ||1 0 0 2 ||
 
<br>||0 6 5 2 ||0 6 3 2 ||0 0 2 0 ||
d. Se puede.
<br>||0 6 5 6 ||0 0 1 4 ||0 6 4 2 ||
 
<br>b)
e. No se puede.
<br>||Finish || Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
 
<br>||F F F F F || 1 5 2 0 || P[1] cumple -> Work += Asig[1] ||
f. Se puede.  
<br>||T F F F F || 1 5 3 2 || P[3] cumple -> Work += Asig[3] ||
 
<br>||T F T F F || 2 8 8 6 || P[2] cumple -> Work += Asig[2] ||
===Ejercicio 7*===
<br>||T T T F F || 3 8 8 6 || P[4] cumple -> Work += Asig[4] ||
a.
<br>||T T T T F || 3 14 11 8 || P[5] cumple -> Work += Asig[5] ||
{| class="wikitable" style="text-align:center"
<br>||T T T T T || 3 14 12 12 || LISTO ||
|
<br>Rta - Si.
{| border="1"
<br>Secuencia segura: P(1); P(3); P(2); P(4); P(5);
|+'''MAX'''
<br>c)
!Proceso !!R1 !!R2 !!R3 !!R4
<br>Corriendo el algoritmo del banquero:
|-
<br>Req[2] <= Nec[2]? (0 4 2 0) <= (0 7 5 0) si
! P1
<br>Req[2] <= Disp? (0 4 2 0) <= (1 5 2 0) si
|0||0||1||2
<br>Entonces se cambian:
|-
<br>Disp - = Req[2] -> Disp = (1 1 0 0)
! P2
<br>Asig[2] + = Req[2] -> Asig[2] = (1 4 2 0)
|1||7||5||0
<br>Nec[2] - = Req[2] -> Nec[2] = (0 3 3 0)
|-
<br>
! P3
<br>Corriendo el algoritmo de seguridad:
|2||3||5||6
<br>||Finish || Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
|-
<br>||F F F F F || 1 1 0 0 || P[1] cumple -> Work += Asig[1] ||
! P4
<br>||T F F F F || 1 1 1 2 || P[3] cumple -> Work += Asig[3] ||
|0||6||5||2
<br>||T F T F F || 2 4 6 6 || P[4] cumple -> Work += Asig[4] ||
|-
<br>||T F T T F || 2 10 8 8 || P[2] cumple -> Work += Asig[2] ||
! P5
<br>||T T T T F || 3 14 10 8 || P[5] cumple -> Work += Asig[5] ||
|0||6||5||6
<br>||T T T T T || 3 14 11 12 || LISTO ||
|}
<br>Rta - Si.
|
<br>
'''-'''
==Ejercicio 08:==
|
<br>Si. Luego ejecuto P(1); P(3); P(2);
{| border="1"
<br>
|+'''ASIGNACIÓN'''
==Ejercicio 09:[*]==
!Proceso !!R1 !!R2 !!R3 !!R4
<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.
|-
<br>
! P1
==Ejercicio 10:[*]==
|0||0||1||2
<br>||Max ||Asignacion ||Necesidad ||
|-
<br>||3 1 1 3 ||2 0 0 2 ||1 1 1 1 ||
! P2
<br>||3 2 3 4 ||0 1 1 0 ||3 1 2 4 ||
|1||0||0||0
<br>||3 3 2 2 ||0 1 0 1 ||3 2 2 1 ||
|-
<br>a)
! P3
<br>Corriendo el algoritmo del banquero:
|1||3||5||4
<br>Req[1] <= Nec[1]? (0 1 1 1) <= (1 1 1 1) si
|-
<br>Req[1] <= Disp? (0 1 1 1) <= (1 3 3 1) si
! P4
<br>Entonces se cambian:
|0||6||3||2
<br>Disp - = Req[1] -> Disp = (1 2 2 0)
|-
<br>Asig[1] + = Req[1] -> Asig[1] = (2 1 1 3)
! P5
<br>Nec[1] - = Req[1] -> Nec[1] = (1 0 0 0)
|0||0||1||4
<br>
|}
<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] ||
{| border="1"
<br>||T T F || 3 4 5 4 || P[3] cumple -> Work += Asig[3] ||
|+'''NECESIDAD'''
<br>||T T T || 3 5 5 5 || LISTO ||
!Proceso !!R1 !!R2 !!R3 !!R4
<br>Rta - Si.
|-
<br>
! P1
<br>b)
|0||0||0||0
<br>Corriendo el algoritmo del banquero:
|-
<br>Req[2] <= Nec[2]? (1 0 0 1) <= (3 1 2 4) si
! P2
<br>Req[2] <= Disp? (1 0 0 1) <= (1 3 3 1) si
|0||7||5||0
<br>Entonces se cambian:
|-
<br>Disp - = Req[2] -> Disp = (0 3 3 0)
! P3
<br>Asig[2] + = Req[2] -> Asig[2] = (1 1 1 1)
|1||0||0||2
<br>Nec[2] - = Req[2] -> Nec[2] = (2 1 2 3)
|-
<br>
! P4
<br>Corriendo el algoritmo de seguridad:
|0||0||2||0
<br>||Finish|| Work || P[i] tq Finish[i] = F y Nec[i] <= Work ||
|-
<br>||F F F || 0 3 3 0 || NO HAY ||
! P5
<br>Rta - No.
|0||6||4||2
<br>
|}
|}
 
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:[*]==
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>a) Mala idea pues es muy costoso hacerlo, y si se hace cada vez que se asigna un recurso peor.
 
<br>b) Puede tardarse bastante tiempo en detectarse el deadlock si el intervalo es muy grande, desperdiciando recursos en el transcurso.
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.  
 
<br>
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:==
 
<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.  
===Ejercicio 12===
<br>
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.
==Ejercicio 13:[*]==
 
<br>a) Secuencia: P3, P4, P1, P2. Esto significa que si ejecuto los procesos en ese orden, todos los programas terminaran satisfactoriamente.
Por estas razones, en la práctica no se suele utilizar el algoritmo del Banquero.
<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.
 
<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.  
===Ejercicio 13*===
<br>
a. Secuencia: '''P3 - P4 - P1 - P2'''. Esto significa que si ejecuto los procesos en ese orden, todos los programas terminaran satisfactoriamente.
==Ejercicio 14:[*]==
 
<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.  
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.
<br>
 
==Ejercicio 15:[*]==
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.
<br>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.
<br>b)
 
===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.
 
 
[[Category:Prácticas]]
Ten en cuenta que todas las contribuciones a Cuba-Wiki pueden ser editadas, modificadas o eliminadas por otros colaboradores. Si no deseas que las modifiquen sin limitaciones, no las publiques aquí.
Al mismo tiempo, asumimos que eres el autor de lo que escribiste, o lo copiaste de una fuente en el dominio público o con licencia libre (véase Cuba-Wiki:Derechos de autor para más detalles). ¡No uses textos con copyright sin permiso!

Para editar esta página, responde la pregunta que aparece abajo (más información):

Cancelar Ayuda de edición (se abre en una ventana nueva)

Plantilla usada en esta página:

Obtenido de «https://www.cubawiki.com.ar/index.php/Práctica_Abrazo_Mortal_(Sistemas_Operativos)»