Diferencia entre revisiones de «Práctica Programación Concurrente (Sistemas Operativos)»

De Cuba-Wiki
Sin resumen de edición
(No se muestran 2 ediciones intermedias del mismo usuario)
Línea 1: Línea 1:
== Ejercicio 01: ==  
==Ejercicio 01:==
<br>||S1 a = b+c ||R(S1) = {b,c} ||W(S1) = {a} ||
<br>||S2 d = b+e ||R(S2) = {b,e} ||W(S2) = {d} ||
<br>||S3 f = c+e ||R(S3) = {c,e} ||W(S3) = {f} ||
<br>||S4 g = fun1[a,d,f] ||R(S4) = {a,d,f} ||W(S4) = {g} ||
<br>||S5 f = sen[w] ||R(S5) = {w} ||W(S5) = {f} ||
<br>Condiciones de Bernstein: R(Si) n W(Sj) = W(Si) n R(Sj) = W(Si) n W(Sj) = {}
<br>Se pueden ejecutar concurrentemente S1 y S2, S1 y S3, S1 y S5, S2 y S5
<br>
==Ejercicio 02:[*]==
<br>a)
<br> count2 = 2
<br> count = 3
<br> s1
<br> fork L2
<br> fork L3
<br> fork L4
<br> jump Sigo
<br> L2:
<br> s2
<br> jump Sigo2
<br> L3:
<br> s3
<br> Sigo2:
<br> join count2
<br> jump Sigo
<br> L4:
<br> s4
<br> Sigo:
<br> join count
<br>
<br>b)
<br> s1
<br> parbegin
<br> begin
<br> parbegin
<br> s2
<br> s3
<br> parend
<br> s5
<br> end
<br> s4
<br> parend
<br> s6
<br>
==Ejercicio 03:[*]==
<br>Que es indivisible? --> Indivisible es que es atomica. Que no puede ser interrumpida a la mitad. Esto es necesario ya que join mantiene una cuenta de cuantos procesos esta esperando, y si no fuera atomica, podria funcionar mal, y por ejemplo "matar" a todos los dos o mas procesos que tenian que unirse ahi.
<br>
==Ejercicio 04:[*]==
<br>a) Me parece que es el tipo de grafos que no pueden ser representados con parbegin/parend. PREGUNTAR
<br>b) PREGUNTAR ESTO TB
<br>
==Ejercicio 05:==
<br>a) Agarramos el grafo de antes, sacamos la flecha de S5 a S6 y ponemos una flecha de S5 a S7, de S6 a S7 y de S4 a S7...
<br>b)
<br>
==Ejercicio 06:==
<br>a)
<br>b)
<br>
<br>NOTA: Ejercicios del 7 al 10. Preguntar estos... Tienen pinta de entrar seguro :)
<br>
==Ejercicio 07:==


S1 a = b+c              R(S1) = {b,c}  W(S1) = {a}
NOTA: PREMISAS DE DIJKSTRA:


S2 d = b+e              R(S2) = {b,e} W(S2) = {d}
1) No deben hacerse suposiciones sobre las instrucciones de máquina ni la cantidad de procesadores. Sin embargo, se supone que las instrucciones de máquina (Load, Store, Test) son ejecutadas atómicamente, o sea que si son ejecutadas simultáneamente el resultado es equivalente a su ejecución secuencial en un orden desconocido.


S3 f = c+e              R(S3) = {c,e}  W(S3) = {f}
2) No deben hacerse suposiciones sobre la velocidad de los procesos.


S4 g = fun1(a,d,f)     R(S4) = {a,d,f}  W(S4) = {g}
3) Cuando un proceso no está en su región crítica no debe impedir que los demás ingresen a su región crítica.


S5 f = sen(w)           R(S5) = {w}    W(S5 = {f}
4) La decisión de qué procesos entran a una parte crítica no puede ser pospuesta indefinidamente.
Los puntos 3) y 4) evitan bloqueos mutuos.


Condiciones de Bernstein: R(Si) ∩ W(Sj) = W(Si) ∩ R(Sj) = W(Si) ∩ W(Sj) = {}
5)- Debe existir un límite al número de veces que otros procesos están habilitados a entrar a secciones críticas
después que un proceso haya hecho su pedido.


Se pueden ejecutar concurrentemente S1 y S2 y S3, S1 y S5, S2 y S5
<br>


== Ejercicio 02:(*) ==  
==Ejercicio 08:==
 
<br>
a.
==Ejercicio 09:==
count2 = 2
<br>
 
==Ejercicio 10:==
count = 3
<br>
 
==Ejercicio 11:==
s1
<br>a)
 
<br>b)
fork L2
<br>
 
==Ejercicio 12:[*]==
fork L3
<br>Porque como cambian el valor del semaforo y despues lo evalua, al haber concurrencia se pueden quedar en WAIT dos ejecuciones de P. Ver Test-And-Set
 
<br>
fork L4
==Ejercicio 13:==
 
<br>Si alguien llega al puente, y no hay nadie esperando de ninguno de los dos lados, se lo pone a cruzar. Si hay alguien cruzando o esperando, y alguien llega, esa persona espera. Cuando una persona termina de cruzar el puente, si hay alguien esperando del lado que llego, le dice che, ahora cruza vos. Y si no, mira para atras, y si del otro lado hay alguien esperando para cruzar le grita cheeeeeeeeeee cruza vooooooooosss.  
jump Sigo
<br>
 
==Ejercicio 14:[*]==
L2:
<br> Monitor ej14  
 
<br> var: bandera : condicion  
s2
<br>
 
<br> procedure P(x)  
jump Sigo2
<br> begin  
 
<br> x = x-1  
L3:
<br> if (x<0) then  
 
<br> Wait(bandera)  
s3
<br> endif  
 
<br> end  
Sigo2:
<br>
 
<br> procedure V(x)  
join count2
<br> begin  
 
<br> x = x+1  
jump Sigo
<br> if (x<=0) then  
 
<br> Signal(Bandera)  
L4:
<br> endif  
 
<br> end  
s4
<br>
 
<br>ver pag 19 al final
Sigo:
<br>
 
==Ejercicio 15:[*]==
join count
<br>a)
 
<br> E = 1; S = 0  
<br>
 
<br> procedure Productor  
b.
<br> begin  
 
<br> P(E)  
s1
<br> ....  
 
<br> V(S)  
parbegin
<br> end  
 
<br>
begin
<br> procedure Consumidor  
 
<br> begin  
parbegin
<br> P(S)  
 
<br> ....  
s2
<br> V(E)  
 
<br> end  
s3
<br>
 
<br>b)
parend
<br>Esta el mismo Ejercicio en la pagina 19 del capitulo 19.  
 
<br>
s5
==Ejercicio 16:[*]==
 
<br>[Diego Edit: esta mal. La idea es que cuando hay alguien escribiendo no puede haber nadie leyendo. Lo hicieron en clase a este programa [Multiples Lectores, un solo escritor]. ]
end
<br>
 
<br> X = 1  
s4
<br>
 
<br> procedure Leer  
parend
<br> begin  
 
<br> //leo el archivo  
s6
<br> end  
 
<br>
 
<br> procedure Escribir  
 
<br> begin  
== Ejercicio 03:(*) ==  
<br> P(X)  
 
<br> //escribo el archivo  
Que es indivisible? --> Indivisible es que es atomica. Que no puede ser interrumpida a la mitad.
<br> V(X)  
Esto es necesario ya que join mantiene una cuenta de cuantos procesos esta esperando, y si no fuera atomica, podria funcionar mal, y por ejemplo "matar" a todos los dos o mas procesos que tenian que unirse ahi.
<br> end  
 
<br>
== Ejercicio 04:(*) ==  
<br> begin Prog-Principal(operacion)  
 
<br> if (operacion == "Leer") then  
a. Me parece que es el tipo de grafos que no pueden ser representados con parbegin/parend. PREGUNTAR
<br> Leer  
b. PREGUNTAR ESTO TB
<br> else
 
<br> Escribir  
== Ejercicio 05: ==
<br> endif  
a. Agarramos el grafo de antes, sacamos la flecha de S5 a S6 y ponemos una flecha de S5 a S7, de S6 a S7 y de S4 a S7...
<br> end  
b.
<br>
 
==Ejercicio 17:==
== Ejercicio 06: ==
<br>
 
==Ejercicio 18:==
 
<br>a)
 
<br> // en este esquema cualquiera de los dos puede entrar primero, si entra deshabilita al otro el acceso:
== Nota Ejercicios 07 al 10: ==
<br> x=1
NOTA: Ejercicios del 7 al 10. Preguntar estos... Tienen pinta de entrar seguro :)
<br> Procedure Romanos
 
<br> Begin
== Ejercicio 07: ==
<br> P(x)
 
<br> .....
 
<br> V(x)
== Ejercicio 08: ==
<br> End
 
<br> Procedure Egipcios
 
<br> Begin
 
<br> P(x)
== Ejercicio 09: ==
<br> .....
 
<br> V(x)
 
<br> End
 
<br> Do forever
== Ejercicio 10: ==
<br> Parbegin
 
<br> Egipcio;Romanos
 
<br> End
 
<br>
== Ejercicio 11: ==
<br>b)
 
<br> x=1
 
<br> colaegipcios=0
 
<br> w=1-colaegipcios
 
<br> Procedure Romanos
 
<br> Begin
== Ejercicio 12:(*) ==
<br> P(excl)//este semaforo no se si hace falta ay que analizarlo
 
<br> P(w)
Porque como cambian el valor del semaforo y despues lo evalua, al haber concurrencia se pueden quedar en  
<br> P(x)
WAIT dos ejecuciones de P. Ver Set-And-Test
<br> V(excl)
 
<br> .....
== Ejercicio 13: ==
<br> P(excl)
Si alguien llega al puente, y no hay nadie esperando de ninguno de los dos lados, se lo pone a cruzar. Si hay alguien cruzando o esperando, y alguien llega, esa persona espera.
<br> V(x)
Cuando una persona termina de cruzar el puente, si hay alguien esperando del lado que llego, le dice che, ahora cruza vos. Y si no, mira para atras, y si del otro lado hay alguien esperando para cruzar le grita cheeeeeeeeeee cruza vooooooooosss.
<br> V(w)
 
<br> P(excl)
== Ejercicio 14:(*) ==
<br>
 
<br> End
Monitor ej14
<br> Procedure Egipcios
 
<br> Begin
var:
<br> P(excl)
 
<br> // en esta parte incremento la cola, que hace que w sea negativo y los romanos se queden esperando
bandera : condicion
<br> V(colaegipcios)
 
<br> P(x)
<br> P(excl)
 
<br> .......
procedure P(x)
<br> P(excl)
 
<br> V(x)
begin
<br> P(colaegipcios)
 
<br> P(excl)
x = x-1
<br>
 
<br> End
if (x<0) then
<br> Do forever
 
<br> Parbegin
Wait(bandera)
<br> Egipcios
 
<br> Romanos
endif
<br> End
 
<br>c)
end
<br>
 
==Ejercicio 19:[*]==
<br> Monitor PeruanosLocos
 
<br> var: HayCarretilla: Boolean
procedure V(x)
<br> CintaOcupada, CintaLibre : condition
 
<br>
begin
<br> Procedure CargarCarretilla
 
<br> Begin
x = x+1
<br> If (HayCarretilla) then
 
<br> wait(CintaLibre)
if (x<=0) then
<br> HayCarretilla = true
 
<br> Signal(CintaOcupada)
Signal(Bandera)
<br> End
 
<br>
endif
<br> Procedure RetirarCarretilla
 
<br> Begin
end
<br> If (!HayCarretilla) then
 
<br> wait(CintaOcupada)
 
<br> HayCarretilla = false
 
<br> Signal(CintaLibre)
== Ejercicio 15:(*) ==
<br> End
 
<br>
a.
<br> Begin Body
 
<br> HayCarretilla = false
E = 1; S = 0
<br> End
 
<br>
<br> End Monitor
 
<br>
procedure Productor
<br> Procedure ObreroCargador
 
<br> Begin
begin
<br> CargarCarretilla
 
<br> End
P(E)
<br>
 
<br> Procedure ObreroRetirador
....
<br> Begin
 
<br> RetirarCarretilla
V(S)
<br> End
 
<br>
end
<br> Begin Main
 
<br> Parbegin
<br> ObreroCargador
 
<br> ObreroRetirador
procedure Consumidor
<br> Parend
 
<br> End
begin
<br>
 
==Ejercicio 20:==
P(S)
<br>La b). Ya que siempre uno llega primero y "espera" y el otro sigue de largo. La c tambien. Por la misma razon.  
 
<br>
....
==Ejercicio 21:[*]==
 
<br>Ni idea que quieren  
V(E)
<br>
 
==Ejercicio 22:[*]==
end
<br>Estoy harto de esos ejercicios que te meten enunciados al pedo== ==
 
<br>
 
==Ejercicio 23:[*]==
 
<br>Por que estamos diciendo que se puede ejecutar en paralelo:
b.
<br>a = b + c y
 
<br>e = a / b + n * n
Esta el mismo ejercicio en la pagina 19 del capitulo 19.
<br>y no es lo mismo ejecutarlas en paralelo, que en forma secuencial ya que la 2nda instruccion tiene una dependencia de datos con la primera.  
 
<br>
 
 
== Ejercicio 16:(*) ==
 
[Diego Edit: Esto esta mal. La idea es que cuando hay alguien escribiendo no puede haber nadie leyendo. Lo hicieron en clase a este programa [Multiples Lectores, un solo escritor]. ]
X = 1
 
procedure Leer
 
begin
 
//leo el archivo
 
end
 
 
procedure Escribir
 
begin
 
P(X)
 
//escribo el archivo
 
V(X)
 
end
 
 
 
begin Prog-Principal(operacion)
 
if (operacion == "Leer) then
 
Leer
 
else
 
Escribir
 
endif
 
end
 
 
 
== Ejercicio 17: ==
 
== Ejercicio 18: ==
 
 
 
== Ejercicio 19:(*) ==  
 
Muy largo como para leerlo
 
 
 
== Ejercicio 20: ==
La b. Ya que siempre uno llega primero y "espera" y el otro sigue de largo.
La c tambien. Por la misma razon.
 
 
 
== Ejercicio 21:(*) ==
 
Ni idea que quieren
 
 
 
== Ejercicio 22:(*) ==
 
Estoy harto de esos ejercicios que te meten enunciados al pedo!!
 
 
 
== Ejercicio 23:(*) ==
 
Por que estamos diciendo que se puede ejecutar en paralelo:
a = b + c;
y
e = a / b + n * n;
y no es lo mismo ejecutarlas en paralelo, que en forma secuencial
ya que la 2nda instruccion tiene una dependencia de datos con la primera.

Revisión del 23:38 4 nov 2006

Ejercicio 01:


||S1 a = b+c ||R(S1) = {b,c} ||W(S1) = {a} ||
||S2 d = b+e ||R(S2) = {b,e} ||W(S2) = {d} ||
||S3 f = c+e ||R(S3) = {c,e} ||W(S3) = {f} ||
||S4 g = fun1[a,d,f] ||R(S4) = {a,d,f} ||W(S4) = {g} ||
||S5 f = sen[w] ||R(S5) = {w} ||W(S5) = {f} ||
Condiciones de Bernstein: R(Si) n W(Sj) = W(Si) n R(Sj) = W(Si) n W(Sj) = {}
Se pueden ejecutar concurrentemente S1 y S2, S1 y S3, S1 y S5, S2 y S5

Ejercicio 02:[*]


a)
count2 = 2
count = 3
s1
fork L2
fork L3
fork L4
jump Sigo
L2:
s2
jump Sigo2
L3:
s3
Sigo2:
join count2
jump Sigo
L4:
s4
Sigo:
join count

b)
s1
parbegin
begin
parbegin
s2
s3
parend
s5
end
s4
parend
s6

Ejercicio 03:[*]


Que es indivisible? --> Indivisible es que es atomica. Que no puede ser interrumpida a la mitad. Esto es necesario ya que join mantiene una cuenta de cuantos procesos esta esperando, y si no fuera atomica, podria funcionar mal, y por ejemplo "matar" a todos los dos o mas procesos que tenian que unirse ahi.

Ejercicio 04:[*]


a) Me parece que es el tipo de grafos que no pueden ser representados con parbegin/parend. PREGUNTAR
b) PREGUNTAR ESTO TB

Ejercicio 05:


a) Agarramos el grafo de antes, sacamos la flecha de S5 a S6 y ponemos una flecha de S5 a S7, de S6 a S7 y de S4 a S7...
b)

Ejercicio 06:


a)
b)

NOTA: Ejercicios del 7 al 10. Preguntar estos... Tienen pinta de entrar seguro :)

Ejercicio 07:

NOTA: PREMISAS DE DIJKSTRA:

1) No deben hacerse suposiciones sobre las instrucciones de máquina ni la cantidad de procesadores. Sin embargo, se supone que las instrucciones de máquina (Load, Store, Test) son ejecutadas atómicamente, o sea que si son ejecutadas simultáneamente el resultado es equivalente a su ejecución secuencial en un orden desconocido.

2) No deben hacerse suposiciones sobre la velocidad de los procesos.

3) Cuando un proceso no está en su región crítica no debe impedir que los demás ingresen a su región crítica.

4) La decisión de qué procesos entran a una parte crítica no puede ser pospuesta indefinidamente. Los puntos 3) y 4) evitan bloqueos mutuos.

5)- Debe existir un límite al número de veces que otros procesos están habilitados a entrar a secciones críticas después que un proceso haya hecho su pedido.


Ejercicio 08:


Ejercicio 09:


Ejercicio 10:


Ejercicio 11:


a)
b)

Ejercicio 12:[*]


Porque como cambian el valor del semaforo y despues lo evalua, al haber concurrencia se pueden quedar en WAIT dos ejecuciones de P. Ver Test-And-Set

Ejercicio 13:


Si alguien llega al puente, y no hay nadie esperando de ninguno de los dos lados, se lo pone a cruzar. Si hay alguien cruzando o esperando, y alguien llega, esa persona espera. Cuando una persona termina de cruzar el puente, si hay alguien esperando del lado que llego, le dice che, ahora cruza vos. Y si no, mira para atras, y si del otro lado hay alguien esperando para cruzar le grita cheeeeeeeeeee cruza vooooooooosss.

Ejercicio 14:[*]


Monitor ej14
var: bandera : condicion

procedure P(x)
begin
x = x-1
if (x<0) then
Wait(bandera)
endif
end

procedure V(x)
begin
x = x+1
if (x<=0) then
Signal(Bandera)
endif
end

ver pag 19 al final

Ejercicio 15:[*]


a)
E = 1; S = 0

procedure Productor
begin
P(E)
....
V(S)
end

procedure Consumidor
begin
P(S)
....
V(E)
end

b)
Esta el mismo Ejercicio en la pagina 19 del capitulo 19.

Ejercicio 16:[*]


[Diego Edit: esta mal. La idea es que cuando hay alguien escribiendo no puede haber nadie leyendo. Lo hicieron en clase a este programa [Multiples Lectores, un solo escritor]. ]

X = 1

procedure Leer
begin
//leo el archivo
end

procedure Escribir
begin
P(X)
//escribo el archivo
V(X)
end

begin Prog-Principal(operacion)
if (operacion == "Leer") then
Leer
else
Escribir
endif
end

Ejercicio 17:


Ejercicio 18:


a)
// en este esquema cualquiera de los dos puede entrar primero, si entra deshabilita al otro el acceso:
x=1
Procedure Romanos
Begin
P(x)
.....
V(x)
End
Procedure Egipcios
Begin
P(x)
.....
V(x)
End
Do forever
Parbegin
Egipcio;Romanos
End

b)
x=1
colaegipcios=0
w=1-colaegipcios
Procedure Romanos
Begin
P(excl)//este semaforo no se si hace falta ay que analizarlo
P(w)
P(x)
V(excl)
.....
P(excl)
V(x)
V(w)
P(excl)

End
Procedure Egipcios
Begin
P(excl)
// en esta parte incremento la cola, que hace que w sea negativo y los romanos se queden esperando
V(colaegipcios)
P(x)
P(excl)
.......
P(excl)
V(x)
P(colaegipcios)
P(excl)

End
Do forever
Parbegin
Egipcios
Romanos
End
c)

Ejercicio 19:[*]


Monitor PeruanosLocos
var: HayCarretilla: Boolean
CintaOcupada, CintaLibre : condition

Procedure CargarCarretilla
Begin
If (HayCarretilla) then
wait(CintaLibre)
HayCarretilla = true
Signal(CintaOcupada)
End

Procedure RetirarCarretilla
Begin
If (!HayCarretilla) then
wait(CintaOcupada)
HayCarretilla = false
Signal(CintaLibre)
End

Begin Body
HayCarretilla = false
End

End Monitor

Procedure ObreroCargador
Begin
CargarCarretilla
End

Procedure ObreroRetirador
Begin
RetirarCarretilla
End

Begin Main
Parbegin
ObreroCargador
ObreroRetirador
Parend
End

Ejercicio 20:


La b). Ya que siempre uno llega primero y "espera" y el otro sigue de largo. La c tambien. Por la misma razon.

Ejercicio 21:[*]


Ni idea que quieren

Ejercicio 22:[*]


Estoy harto de esos ejercicios que te meten enunciados al pedo== ==

Ejercicio 23:[*]


Por que estamos diciendo que se puede ejecutar en paralelo:
a = b + c y
e = a / b + n * n
y no es lo mismo ejecutarlas en paralelo, que en forma secuencial ya que la 2nda instruccion tiene una dependencia de datos con la primera.