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