P. CONCURRENTE. QUIZ. 14-04

P. CONCURRENTE. QUIZ. 14-04-2011
Apellidos:____________________________________________________ Nombre: _________________
1 [2.0] Para las expresiones CSP siguientes, escribir (V/F) y justificar la respuesta:
a) | | [P1::*[P2 ? x-> NULL TRUE -> x:= x+5] || [P2 :: P1 ! (3, 5, 7)]]
La ejecución del programa anterior produce el interbloqueo de ambos procesos.
__________________________________________________________________________
__________________________________________________________________________
________________________________________________________________________
b)
| | [P1::*[FALSE;var x: 1..10; P2 ? x -> NULL TRUE ->x:= x+5] || P2 :: P1 ! (-1) ]
La ejecución del programa anterior produce interbloqueo.
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
c)
P3 ? ( y, z) -> y:= y+1] || P2:: NULL || P3::P1 ! (6,0)]
| | [P1 :: *[P2 ? x -> x:= x+1
Si sustituimos P2:: NULL por P2:: P1 ! x, el programa anterior dejará de bloquearse.
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
d)
| | termina:= FALSE;
NOT termina; P2 ? x -> x:= x+5;
[P1::*[NOT termina;P3 ? x -> x:= x+5; termina:=true; P3 ! (0,1)
termina:= true] || P2::P1 ! 0 || P3:: P1 ! 0; P1 ? y]
Una posible ejecución del programa anterior produce el interbloqueo de procesos.
_______________________________________________________________________
________________________________________________________________________
________________________________________________________________________
e)
| | [P1::var x:positive:=1;*[x>0;P2 ? x -> x:= x+5 ] || P2:: P1 ! ( -5)]
En el programa anterior se bloquean ambos procesos porque el valor enviado por P2 es un entero
negativo y no se corresponde con el tipo de la variable objetivo que va a recibirlo.
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
f)
| | [P1::x:integer; *[P2 ? x -> x:= x+5 ] || P2::NULL]. Ambos procesos terminan.
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
g) | | [in(i:1..N)::IN || mux::*[(i:1..N) x:integer; in(i) ?x -> out ! (i, x)]; out ! true || out::x:bool; mux?x]
Si los procesos in(1), .., in(n) terminan ejecutando órdenes de la forma mux ! x , entonces los tres
procesos del programa anterior terminan.
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
h)
| | [P1 :: *[P2 ? x -> x:= x+1 P3 ? y -> y:= y+1] || P2:: x:= 4 || P3::P1 ! 6].
El proceso P1 podría llegar a bloquearse indefinidamente si dicho proceso siempre selecciona la
primera alternativa de su orden repetitiva.
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
i)
| | El siguiente programa no termina, ya que ambos procesos se bloquean porque sus órdenes
de entrada y salida no se corresponden:
[P1::x:integer;*[FALSE;P2 ? x -> x:= x+5 ] || P2:: P1 ! (0,1)]
________________________________________________________________________
________________________________________________________________________
________________________________________________________________________
j)
| | [P1::*[P2 ? x -> NULL] || P2::P1 ! x()]
El programa anterior termina en un bloqueo indefinido de ambos procesos.
________________________________________________________________________
________________________________________________________________________
2 [0.75] Escribir las condiciones de las guardas de la orden SELECT, y completar el código que falta en
dos de los ACCEPTs, del siguiente proceso Servidor para que implemente correctamente una cita
múltiple entre 10 procesos de tipo B y 1 proceso de tipo A.
Por su parte, los procesos clientes (de tipo A ó B) invocan el nombre del primer punto de entrada
(llamaA o llamaB) del servidor para notificarle su intención de participar en una cita múltiple. Los puntos
de entrada esperaA y esperaB sirven para detener a los procesos clientes que han invocado hasta se
den las condiciones para que se produzca la cita múltiple, es decir, hasta que llamen el número
suficiente de procesos de cada tipo.
Process Servidor
ENTRY llamaA; ENTRY esperaA;
ENTRY llamaB; ENTRY esperaB;
begin
while true do
SELECT
ACCEPT llamaA; NA++;
Process type TipoA
begin
while true do
Servidor.llamaA;
Servidor.esperaA
enddo;
end;
or ACCEPT llamaB; NB++;
Process type TipoB
begin
while true do
Servidor.llamaB;
Servidor.esperaB;
enddo;
end;
or (
)
and (
)=>
ACCEPT esperaA; NA--; NA’++
or (
)
and (
)=>
ACCEPT esperaB; NB--; NB’++
end; //SELECT
enddo
end;
3 [0.75] Para que exista bloqueo global o intebloqueo de los procesos que componen un programa en CSP
se ha de cumplir que ningún par de órdenes de entrada/salida entre procesos se correspondan y no
todos los procesos nombrados en las órdenes de entrada de las guardas hayan terminado y que no
fallen todas las guardas de las órdenes repetitivas.
P2?(x,y)
(1)[P1::*[P2?x → x:=x+5
→NULL] ⎥⎥ P2::P1!(-3)]
(2)[P1:: P2?x; *[x≥0;P2?y → x:=y+5]
⎥⎥ P2::P1!(-3); P1?z]
P2?(x,y)→
(3)[P1::*[P2?x → x:=x+5
(x,y):=(x-1, y-2)]
⎥⎥ P2::i:=0;*[i<2→P1!(-3);i:=i+1
i<2→P1!(1,2);i:=i+1]]
(4)[P1:: x:=-7;[ x≥0; P2?y → x:=y+5]
⎥⎥ P2::P1!(-2,-3)]
Responder (V/F) y explicar la respuesta identificando qué condiciones se cumplen o fallan:
|
| Existe una determinada secuencia de ejecución del fragmento (1) que conduce al interbloqueo.
________________________________________________________________________
________________________________________________________________________
| | (2) Se interbloquea porque las segundas órdenes de entrada (en negrita) de ambos procesos no se
corresponden
________________________________________________________________________
________________________________________________________________________
| | (3) Si el proceso P2 elije primero su segunda alternativa y envía (1, 2) y el proceso P1 elige la primera de
sus alternativas, entonces la ejecución del programa podría acabar en interbloqueo.
________________________________________________________________________
________________________________________________________________________
| | (4) Ambos procesos terminan bloqueándose.
________________________________________________________________________
________________________________________________________________________
4 [1.5] (a) Escribir un programa en CSP que implemente un proceso controlador de un cajero automático
que se encarga de garantizar que las operaciones de los clientes siempre se realizan correctamente.
Los procesos-cliente (suponemos que hay 1000 cuentas de clientes) obtienen dinero del cajero con la
operación reintegro(cantidad). Si la cuenta de un cliente determinado tiene suficiente dinero, entonces
el controlador ha de disminuir el dinero en la cantidad indicada por el cliente y termina enviándole un
mensaje con el dinero que queda en la cuenta; si no hay dinero suficiente, le envía un valor de error (-1).
Los procesos-cliente ingresan dinero en su cuenta con la operación ingresar(cantidad) y el controlador,
después de aumentar el dinero en la cuenta, les envía un mensaje con el nuevo valor al terminar dicha
operación.
Cada cliente tiene inicialmente100 unidades de efectivo en su cuenta.
Nota: para programarlo en CSP hay que declarar un array de 1000 elementos que representan las
cuentas de los clientes. Las operaciones anteriores (reintegro() e ingresar()) han de programarse en el
proceso controlador pedido como 2 órdenes con guarda que acaban en una orden de entrada para
cada cliente.
(b) Modificar el programa del controlador anterior para tener en cuenta ahora que el cajero automático
sólo dispone de 1000 unidades de efectivo para todas las peticiones de los clientes. Cuando el cajero
agota totalmente su efectivo, no podrá servir más peticiones de ningún tipo de los clientes y devuelve un
mensaje de error (-2). Los ingresos de los clientes no incrementan las unidades de efectivo del cajero.