Especificación Formal de Sistemas Concurrentes
Transcript of Especificación Formal de Sistemas Concurrentes
UNIDAD 2
ESPECIFICACIÓN FORMAL DE
SISTEMAS CONCURRENTES
Sentencias Concurrentes
Ahora es necesario, dado un programa concurrente,
saber que secciones del código son concurrentes y
cuáles no, además es indispensable especificarlo en un
lenguaje de programación.
No todas las sentencias son concurrentes, consideremos
el siguiente fragmento del programa:
S1: x:=x+1
S2: y:=x+2
En este caso las instrucciones no pueden ejecutarse de forma
independiente.
Sentencias Concurrentes Consideremos ahora:
x:=1
y:=2
z:=3
Cada una de las sentencias se pueden ejecutar concurrentemente
puesto que el orden en que se ejecuten no afecta el resultado final.
Si se tuvieran 3 procesadores en cada uno se colocaría cada
instrucción.
Aunque la intuición nos indique cuando ejecutar concurrentemente
Bernstein definió condiciones para garantizar la concurrencia.
Condiciones de Bernstein
Para determinar si dos conjuntos de instrucciones se
pueden ejecutar de forma concurrente se definen:
L(Sk)={a1,a2,…,an} conjunto de lectura del conjunto de
instrucciones Sk, formado por todas las variables cuyos
valores son leídos (referenciados) durante la ejecución
de las instrucciones en Sk.
E(Sk) ={b1,b2,…,bn} conjunto de escritura del conjunto
de instrucciones Sk, formado por todas las variables
cuyos valores son actualizados (se escriben) durante la
ejecución de las instrucciones en Sk.
Condiciones de Bernstein
Para que dos conjuntos de instrucciones Si y Sj, i≠j, i<j
se puedan ejecutar concurrentemente se tiene que
cumplir que:
1. L(Si) E(Sj)=
2. E(Si) L(Sj)=
3. E(Si) E(Sj)=
Ejemplo de Condiciones de Bernstein
Sean:
S1a:=x+y;
S2b:=z-1;
S3c:=a-b;
S4w:=c+1;
Se calculan los conjuntos de lectura y
escritura
L(S1)={x,y}
E(S1)={a}
L(S2)={z}
E(S2)={b}
L(S3)={a,b}
E(S3)={c}
L(S4)={c}
E(S4)={w}
Ejemplo de Condiciones de Bernstein Sean:
L(S1)={x,y}
E(S1)={a}
L(S2)={z}
E(S2)={b}
L(S3)={a,b}
E(S3)={c}
L(S4)={c}
E(S4)={w}
2.Aplicando las condiciones de Bernstein
Entre S1 y S2
1. L(S1) E(S2)=
2. E(S1) L(S2)=
3. E(S1) E(S2)=
Entre S1 y S3
1. L(S1) E(S3)=
2. E(S1) L(S3)={ a } ≠
3. E(S1) E(S3)=
Entre S1 y S4
1. L(S1) E(S4)=
2. E(S1) L(S4)=
3. E(S1) E(S4)=
Ejemplo de Condiciones de Bernstein
Sean:
L(S1)={x,y}
E(S1)={a}
L(S2)={z}
E(S2)={b}
L(S3)={a,b}
E(S3)={c}
L(S4)={c}
E(S4)={w}
2.Aplicando las condiciones de Bernstein
Entre S2 y S3
1. L(S2) E(S3)=
2. E(S2) L(S3)={ b } ≠
3. E(S2) E(S3)=
Entre S2 y S4
1. L(S2) E(S4)=
2. E(S2) L(S4)=
3. E(S2) E(S4)=
Entre S3 y S4
1. L(S3) E(S4)=
2. E(S3) L(S4)={ c } ≠
3. E(S3) E(S4)=
Tabla resultante al aplicar las condiciones de
Bernstein
En este caso se indica que sentencias se pueden
ejecutar concurrentemente y cuales no
S1 S2 S3 S4
S1
----
Si
No
Si
S2
----
----
No
Si
S3
----
----
----
No
S4
----
----
----
----
Especificación concurrente
Existen dos formas de realizar la
especificación concurrente:
Grafo de precedencia
Sentencias cobegin-coend
Grafos de precedencia
Es una notación gráfica.
Se representa como un grafo dirigido acíclico.
Cada nodo representa una parte del sistema
(conjunto de instrucciones).
Una flecha desde A hasta B representa que B
sólo se puede ejecutar cuando A haya finalizado.
Si aparecen dos nodos en paralelo, significa que
se pueden ejecutar concurrentemente.
Ejemplo de grafo de precedencia
S1a:=x+y;
S2b:=z-1;
S3c:=a-b;
S4w:=c+1;
S1
S2
S3
S4
S1
----
Si
No
Si
S2
----
----
No
Si
S3
----
----
----
No
S4
----
----
----
----
S1 S2
S3
S3
S1 S2
S3
S1 S2
S4
S3
S1 S2 S1 S2 S1 S2 S1 S2 S1
S3
S2 S1
S4
S3
S2 S1
S4
S3
S2 S1
Sentencias COBEGIN-COEND
Aquellas instrucciones que puedan ejecutarse
concurrentemente se introducen entre el par
cobegin/coend.
Las instrucciones en el bloque pueden ejecutarse
en cualquier orden, el resto de manera secuencial.
Ejemplo: S1a:=x+y;
S2b:=z-1;
S3c:=a-b;
S4w:=c+1;
Begin cobegin a:=x+y b:=z-1 coend c:=a-b; w:=c+1; end
Ejercicios 1. Construir un programa concurrente, utilizando
el par cobegin / coend, del siguiente grafo de
precedencia.
Solución S1;
Cobegin
S3
begin
S2;
S4
Cobegin
S5;
S6;
Coend;
end;
Coend;
S7;
Ejercicio Dato el siguiente código obtener el grafo de precedencia
S0;
Cobegin S1;
Begin
S2;
Cobegin
S3; S4
Coend;
S5
End;
S6
Coend;
S7
Solución S0;
Cobegin
S1;
Begin
S2;
Cobegin
S3; S4
Coend;
S5
End;
S6
Coend;
S7
Paralelo
Cobegin
P1
P2
P3
P4
Coend
Serie/Paralelo
Begin P1
Cobegin P6
Begin Cobegin
P2
P3
Coend
P4
End
Coend
P7
End
Ejercicio Construir dos programas concurrentes, usando cobegin/coend, que
correspondan con los siguientes grafos de precedencia.
Ejercicio
Usando las condiciones de Bernstein, construir el
grafo de precedencia del siguiente código y el
programa concurrente correspondiente usando el
par cobegin/coend.
S1: cuad:= x*x;
S2: m1:= a*cuad;
S3: m2:= b*x;
S4: z:= m1 + m2;
S5: y:= z + c;
Fork y Join
Fork y Join tienen dos funciones
Fork(label L), y join(int x)
Fork(label L) produce dos ejecuciones
concurrentes. Una inicia inmediatamente despues
de la instrucción fork, y la otra en la label L. Esto
tiene los efectos de dividir una ejecución de un
proceso en dos procesos concurrentes.
Join(int x) combina x procesos en 1.
Ejercicio
Modele el siguiente grafo usando fork-join
Solución
Ejercicio