Especificación Formal de Sistemas Concurrentesmtovar/doc/PCP/Unidad2Especificacion... · Cada una...
-
Upload
trankhuong -
Category
Documents
-
view
213 -
download
0
Transcript of Especificación Formal de Sistemas Concurrentesmtovar/doc/PCP/Unidad2Especificacion... · Cada una...
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.
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
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.