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:
! I1: x:=x+1 L(I1)={x}, E(L1)={x}
! I2: y:=x+2IIIIIL(I2)={x},IE(L2)={y}

! EnIesteIcasoIlasIinstruccionesInoIpuedenIejecutarseIdeIformaI
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(Ik)={a1,a2,…,an} conjunto de lectura del conjunto de

instrucciones Ik, formado por todas las variables cuyos
valores son leídos (referenciados) durante la ejecución
de las instrucciones en Ik.

" E(Ik) ={b1,b2,…,bn} conjunto de escritura del conjunto

de instrucciones Ik, formado por todas las variables
cuyos valores son actualizados (se escriben) durante la
ejecución de las instrucciones en Ik.
 Condiciones de Bernstein
! Para que dos conjuntos de instrucciones Ii y Ij, i≠j, i<j
se puedan ejecutar concurrentemente se tiene que
cumplir que:
I1: x:=x+1 L(I1)={x}, E(L1)={x}
I2: y:=x+2CCCCCL(I2)={x},CE(L2)={y}
1. L(Ii) ! E(Ij)= "
1<2
2. E(Ii) ! L(Ij)= " L(I1)yCE(I2)=C{}
E(I1)yCL(I2)={x}
3. E(Ii) ! E(Ij)= " E(l1)yE(I2)={}
 Ejemplo de Condiciones de Bernstein
! Sean: Se calculan los conjuntos de lectura y
escritura
# L(I1)={x,y}
I1"a:=x+y, E(I1)={a}
I2"b:=z01, # L(I2)={z}
I3"c:=a0b, E(I2)={b}
L(Ii) ! E(Ij)= "
I4"w:=c+1, # L(I3)={a,b} E(Ii) ! L(Ij)= "
E(I3)={c} E(Ii) ! E(Ij)= "
# L(I4)={c}
E(I4)={w}
 Ejemplo de Condiciones de Bernstein
! Sean: 2.Aplicando las condiciones de Bernstein
L(I1)={x,y} Entre I1 y I2
E(I1)={a} 1. L(I1) ! E(I2)= "={}
I1"a:=x+yF
2. E(I1) ! L(I2)= "
L(I2)={z} I2"b:=zG1F
3. E(I1) ! E(I2)= " I3"c:=aGbF
E(I2)={b}
I4"w:=c+1F
L(I3)={a,b} Entre I1 y I3
E(I3)={c} 1. L(I1) ! E(I3)= "
2. E(I1) ! L(I3)={ a } ≠"
L(I4)={c}
3. E(I1) ! E(I3)= "
E(I4)={w} L(Ii) ! E(Ij)= "
Entre I1 y I4 E(Ii) ! L(Ij)= "
1. L(I1) ! E(I4)= " E(Ii) ! E(Ij)= "
2. E(I1) ! L(I4)= "
3. E(I1) ! E(I4)= "
 Ejemplo de Condiciones de Bernstein
! Sean: 2.Aplicando las condiciones de Bernstein
L(I1)={x,y} Entre I2 y I3
E(I1)={a} 1. L(I2) ! E(I3)= " I1"a:=x+yF
2. E(I2) ! L(I3)={ b } ≠ " I2"b:=zG1F
L(I2)={z} 3. E(I2) ! E(I3)= " I3"c:=aGbF
E(I2)={b} Entre I2 y I4 I4"w:=c+1F
1. L(I2) ! E(I4)= "
L(I3)={a,b}
2. E(I2) ! L(I4)="
E(I3)={c} L(Ii) ! E(Ij)= "
3. E(I2) ! E(I4)= " E(Ii) ! L(Ij)= "
L(I4)={c} Entre I3 y I4 E(Ii) ! E(Ij)= "
E(I4)={w} 1. L(I3) ! E(I4)= "
2. E(I3) ! L(I4)={ c } ≠ "
3. E(I3) ! E(I4)= "
Tabla resultante al aplicar las condiciones de
Bernstein
! En este caso se indica que sentencias se pueden
ejecutar concurrentemente y cuales no
I1 I2 I3 I4
I1"a:=x+y=
I2"b:=z51=
I1 5555 Si No Si I3"c:=a5b=
I4"w:=c+1=
I2 5555 5555 No Si

I3 5555 5555 5555 No

I4 5555 5555 5555 5555

Ejercicio

! Usando'las'condiciones'de'Bernstein,'construir'la'
tabla'de'concurrencia.
1 3

" I1: cuad:='x*x9

" I2: m1:='a*cuad9
" I3: m2:='b*x9 2

" I4: z:='m1'+'m29

4
" I5: y:='z'+'c9

5
Ejercicio

! Usando'las'condiciones'de'Bernstein,'construir'la'
tabla'de'concurrencia.

" I1: a:='08

" I2: b:='18
" I3: c:='a+18
" I4: d:='b'+'a8
" I5: e:='d'+'18
" I6: f:='c'+'d8
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
I1 I2 I3 I4

I1 #### Si No Si
S1
S1
I1 S2
S2
I2

I2 #### #### No Si

FORK:L1:
S3
S3
I3
I2:
I3 #### #### #### No GOTO:L3:
L1:I1: I1!a:=x+y1
L3::JOIN:2: I2!b:=z#11
I3:
I4 #### #### #### #### I3!c:=a#b1
I4 S3
S4
I4
I4!w:=c+11
 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.
Begin
! Ejemplo: cobegin
" S1#a:=x+yA a:=x+y
" S2#b:=zD1A b:=z01
" S3#c:=aDbA
coend
c:=a0b;
" S4#w:=c+1A
w:=c+1;
end
Ejercicios
1. Construir+un+programa+concurrente,+utilizando+
el+par+cobegin /+coend,+del+siguiente+grafo+de+
precedencia. Begin+ S1
S1 FORK+L2
Cobegin+ S3
Begin+ GOTO+L7
S2+ L2:S2
S4
S4+ FORK+L5
Cobegin+ S6
S5+ GOTO+L7+
S6+ L5:S5
Coend+ GOTO+L7+
End+ L7:+JOIN+3
S7
S3+
Coend+
S7
End
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
Begin
" S07
" Cobegin
! S17
! Begin
" S27
" Cobegin
# S37%S4
" Coend7
" S5
! End7
! S6
" Coend7
" S7
End
Solución
! S0#
! Cobegin
" S1#

" Begin
! S2#
! Cobegin
# S3#/S4
! Coend#
! S5
" End#
" S6

! Coend#
! S7
Solución
S0
Fork'L1'
Fork'l2'
S6'
Goto'L7'
L1:'S1'
Goto'L7'
L2:S2'
Fork'L3'
S4'
Goto'L5'
L3:S3'
L5:'join'2'
S5'
L7:'join'3'
S7
Paralelo
FORK2L12
! Cobegin FORK2L22
FORK2L32
" P1 P42
GOTO2L2
" P2 L1:P12
GOTO2L2
" P3 L2:P22
GOTO2L2
" P4 L3:P32
L:JOIN24
! Coend
Serie/Paralelo

Begin&
p1&
cobegin&

begin&
cobegin&
p2-p3&
coend&
p4&
end&
p6
coend&
p7&
end
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.

begin) Begin)
s1) s1)
cobegin) begin)
s5) cobegin)
begin) s3)
s2) begin)
cobegin) s2)
s3)s4) s4)
coend) end)
end) coend)
coend) cobegin)
s6) s5)
end s6)
coend)
end)
s7)
End)
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&después&
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.
L2: L3:

L4:

L7:
Ejercicio

! Modele&el&siguiente&grafo&usando&fork1join

S1&
FORK&L2&
S3&
GoTo&L&
L2:S2&
L:&Join&2&
S4
Solución
Ejercicio
P1
Fork'L2
Fork'L5
P7
Goto'L8
L2:P2
Fork'L3
P4
Goto'L6
L3:'P3
Goto'L8
L5:'P5
L6:Join'2
P6
L8:Join'3
P8
Ejercicio
S1
FORK'L1'
FORK'L2'
S2'
FORK'L3'
Goto'L4'
L2:'S4'
Goto'L4'
L1:'S3'
FORK'L3'
Goto'L4'
L3':'Join'2'
S5'
Goto'L5'
L4:'Join'3'
S6'
Goto'L5'
L5':'Join'2'
S7