METODOLOGÍA DE LA PROGRAMACIÓN PARALELA

Análisis de algoritmos paralelos

REFERENCIAS
La mayoría de los libros de la bibliografía, en particular:

• Foster, cap 3
• Kumar, Grama, Gupta, Karypis, cap 4
• Wilkinson, Allen, cap 2.3 y 2.4
• Quinn
y, por supuesto, el de Introducción a la Programación
Paralela
1
 Análisis de algoritmos paralelos

Los procesadores paralelos se usan para acelerar la

resolución de problemas de alto coste computacional.

La finalidad principal consiste en reducir el tiempo de

ejecución:
si el tiempo secuencial t(n)
se intentará que usando p procesadores el tiempo
se reduzca a t(n)/p.

Ver algunas medidas que nos dan idea de la "bondad"

de un algoritmo paralelo.

2
 Tiempo secuencial

• El tiempo de ejecución de un programa secuencial

depende de:
tamaño de la entrada,
compilador,
máquina,
programador...,
si nos olvidamos de valores constantes dependientes del
sistema (por ejemplo el coste de una operación aritmética
en la máquina donde ejecutamos el programa) podemos
considerar el tiempo función del tamaño de la entrada:
t(n).
El tiempo desde que empieza la ejecución del programa
hasta que acaba.

3
 Tiempo de ejecución paralelo

• En un programa paralelo la estimación del tiempo es

más compleja.
Además de los parámetros anteriores, depende de:
número de procesadores t(n,p),
de la manera en que están conectados entre sí
(topología) y con los módulos de memoria (memoria
compartida o distribuida)

• Es el tiempo transcurrido desde que empieza la

ejecución del primero de los procesadores hasta que
acaba el último de ellos.

4
 Tiempo de ejecución paralelo

DIFICULTADES:

• No siempre es fácil determinar el orden en que los

procesadores empiezan y acaban.

• A lo largo de la ejecución de un programa paralelo hay

puntos de sincronización de los que no siempre podemos
determinar su duración al no saber en el orden en que
van a llegar los distintos procesos a estos puntos.

5
 Tiempo de ejecución paralelo

• Esquema de programa paralelo:

Computación 1
Comunicación 1 (sincronización en memoria compartida)
Computación 2
Comunicación 2
...

t(n,p)=ta(n,p)+tc(n,p)

ta(n,p) : suma de los tiempos de las distintas partes de

computación
tc(n,p) : suma de los tiempos de las distintas partes de
comunicación
6
 Tiempo de ejecución paralelo, ejemplo

• Programa paralelo en dos procesadores:

Computación 1 2 3

Comunicación 1 1 1

Computación 2 3 2

Comunicación 2 1 1

t(n,p)=ta(n,p)+tc(n,p)=7 (si se suman los tiempo por separado)

treal(n,p)=ta(n,p)+tc(n,p)+toverhead(n,p)=8
7
 Tiempo de ejecución paralelo, ejemplo

2 3

t(n,p)=ta(n,p)+tc(n,p)=15

treal(n,p)=ta(n,p)+tc(n,p)-tsolapamiento(n,p)=14
8
 Tiempo de ejecución

• Overhead debido a:
sincronización,
puesta en marcha de los procesos,
sobrecarga de la red de comunicación,
...

• Se suele considerar:

t(n,p)=ta(n,p)+tc(n,p)+to(n,p)-ts(n,p)

• Minimizar el tiempo de overhead.

• Maximizar el solapamiento.

9
 Suma de n números
• Secuencial: t(n)=n-1

• Paralelo con n/2 procesadores, como mínimo t(n)/(n/2)=2

En cada Pi, i=0,1,...,n/2-1

inicio=2*i
desplazamiento=1
activo=true
para k=1,2,...,log n
si activo
a[inicio]=a[inicio]+a[inicio+desplazamiento]
desplazamiento=desplazamiento*2
finsi
si i mod desplazamiento <>0
activo=false
finsi
finpara

10
 Suma de n números
• Pasos: log n

• Trabajo adicional (overhead):

Comprobación de si el procesador trabaja,
Uso de las variables,
Actualización de las variables.

• Con n=64
si cada paso secuencial y paralelo igual coste:
t(n)≅8*t(n,p)
si cada paso secuencial coste 2 y paralelo coste 5:
t(n)≅3.5*t(n,p)
• Y en memoria distribuida problema de acceso a los datos.

11
 Suma de n números. En hipercubo
• Cada procesador tiene dos valores, a y b

En cada Pi, i=0,1,...,n/2-1

desplazamiento=1
activo=true
para k=1,2,...,log n-1
si activo
a=a+b
desplazamiento=desplazamiento*2
si i mod desplazamiento <>0
activo=false
enviar a a i-desplazamiento/2
en otro caso
recibir en b de i+desplazamiento/2
finsi
finsi
finpara
si i=0
a=a+b
finsi 12
 Suma de n números. En hipercubo

P0 P1 P0 P1 P0 P1
0 1 2 3 1 1 5 3 1 5 5 3

P2 P3 P2 P3 P2 P3
4 5 6 7 9 5 13 7 9 13 13 7

P0 P1 P0 P1 P0 P1
6 5 5 3 6 22 5 3 28 22 5 3

P2 P3 P2 P3 P2 P3
22 13 13 7 22 13 13 7 22 13 13 7

13
 Suma de n números. En hipercubo
• Pasos: log n

• Trabajo adicional (overhead):

Comprobación de si el procesador trabaja,
Uso de las variables,
Actualización de las variables,
Comprobación de enviar o recibir,
Envío o recepción.

• Con n=64
si cada paso secuencial coste 2 y paralelo coste 7:
t(n)≅2,5*t(n,p)
si ts=2*tw y tw=2*tc:
t(n)≅1,5*t(n,p)
si ts=10*tw y tw=10*tc:
t(n)≅0,16*t(n,p)

14
Suma de n números. En malla

15
 Suma de n números. En malla

• Si p=2n

2*(1+2+22+...+2n/2-1 )= 2n/2+1 comunicaciones

• Con n=64
si ts=2*tw y tw=2*tc:
t(n)≅1,4*t(n,p)
si ts=10*tw y tw=10*tc:
t(n)≅0,1*t(n,p)

16
 Suma de n números. En anillo

• Si p=2n
1+2+22+...+2n-1 = 2n –1= p-1 comunicaciones
• Con n=64
si ts=2*tw y tw=2*tc:

t(n)≅0,74*t(n,p)
si ts=10*tw y tw=10*tc:

t(n)≅0,04*t(n,p)
17
 Coste de comunicaciones
• Son de los siguientes órdenes:
Comunicación vecinos Comunicación todos
hipercubo log p/2 log p/2
malla 2*√p log p/2
anillo p-1 log p/2
red p-1

• Además, la red puede estar congestionada al haber

muchos mensajes por haber muchos procesadores.
• Problemas:
Problema de poco coste y no apropiado para resolver en
paralelo,
granularidad pequeña, sólo como ayuda para diseñar un
programa pero no como programa final.

18
 Causas de reducción de las prestaciones
• Contención de memoria:
En memoria compartida el acceso a datos comunes o que están en el
mismo bloque de memoria producirá contención.
Si los datos son de lectura puede no haber ese problema.
En el ejemplo los procesadores escriben en zonas distintas. No hay
problema de coherencia, pero puede haber de contención si hay datos
en los mismos bloques de memoria.

• Código secuencial:
Puede haber parte imposible de paralelizar, como puede ser la I/O.
En el ejemplo la inicialización de variables. Además, si los datos están
inicialmente en un procesador y hay que difundirlos el coste es lineal.

• Tiempo de creación de procesos:

El programa empieza a ejecutarse con un proceso que pone en marcha
los demás.
El coste de creación de los procesos puede ser importante si la
granularidad de éstos es pequeña.
19
 Causas de reducción de las prestaciones
• Computación extra:
Si se obtiene programa paralelo a partir de secuencial, son necesarias
computaciones adicionales por:
uso de variables de control,
comprobación de identificadores de proceso,
cálculos adicionales o comunicaciones para obtener datos
calculados por otro procesador...

• Comunicaciones:
En memoria distribuida, es tiempo adicional al aritmético.
Pueden implicar trabajo de procesadores intermedios.

• Tiempo de sincronización:
Cuando un proceso tiene que esperar a que estén disponibles datos
procesados por otro.
Conlleva comunicaciones en memoria distribuida.

20
 Causas de reducción de las prestaciones
• Desbalanceo de la carga:

El volumen total de la computación no se distribuye por igual entre

todos los procesadores:

en el ejemplo, en el primer paso trabajan todos pero en los pasos

siguientes va disminuyendo el número de procesadores que trabajan,

también es posible que partamos de una entrada que no se

puede balancear, por ejemplo si tenemos 12 datos para 8
procesadores,

o que el volumen de datos varíe a lo largo de la ejecución, con lo

que se necesitaría balanceo dinámico.

21
 Granularidad de la computación
• Uso de muchos procesadores no es realista:
No dispondremos de tantos procesadores.
Aunque dispongamos de ellos hay caída de las prestaciones.

• La granularidad del sistema (sistema físico+algoritmo) indica la

cantidad de computación y datos asignados a cada procesador:
Grano fino: si a cada procesador se asignan pocos datos o se realiza poca
computación entre comunicaciones.
Grano grueso: si a cada procesador se asignan muchos datos o se realiza
mucha computación entre comunicaciones.

• Interesa programación paralela cuando el paralelismo es de

grano grueso. A partir de qué punto interesa depende de los costes
en el sistema (no será lo mismo en saturno que en marte+mercurio)

• En sistólicos y GPUs el paralelismo es de grano fino.

22
 Suma de n números con p procesadores
En cada Pi, i=0,1,...,p-1
suma=0
para j=i*n/p, ...,(i+1)*n/p-1
suma=suma+a[j]
finpara
sincronización
a[i]=suma
inicio=i*2
desplazamiento=1
si i mod 2=0
activo=true
en otro caso
activo=false
finsi
para k=1,2,...,log p-1
si activo
a[inicio]=a[inicio]+a[inicio+desplazamiento]
desplazamiento=desplazamiento*2
finsi
si i mod desplazamiento <>0
activo=false
finsi
finpara 23
 Suma, en memoria distribuida
En cada Pi, i=0,1,...,p-1
suma=0
para j=0, ...,n/p-1 suma=suma+a[j] finpara
si i mod 2=0
recibir en b de i+1 activo=true
en otro caso
enviar suma a i-1 activo=false
finsi
desplazamiento=2
para k=1,2,...,log p-2
si activo
suma=suma+b
desplazamiento=desplazamiento*2
si i mod desplazamiento <>0
activo=false
enviar suma a i-desplazamiento/2
en otro caso
recibir en b de i+desplazamiento/2
finsi
finsi
finpara
si i=0 suma=suma+b finsi
24
 Suma de n números con p procesadores
• En memoria compartida todas las variables son locales
salvo el array a.
• En memoria distribuida la sincronización por el paso de
mensajes.
• El tamaño del problema (n) es múltiplo del número de
procesadores (p). Se puede generalizar fácilmente.
• t(n,p)=2*n/p*tc+6*(log p-1)*(ts+tw)
si p<<<n podemos tener en cuenta sólo los términos de
mayor orden y t(n)/t(n,p)=p, que es lo mejor que se puede
obtener
para ir 10 veces más rápido:
con ts=2*tw y tw=2*tc,
si n=1000000, 100000, 10000, p=10
con ts=10*tw y tw=10*tc, es n=330*p*log p
si n=1000000 p=10, 100000 p=11, 10000 no posible

25
 Speed-up
• Mide la ganancia de velocidad que se obtiene con un programa
paralelo.
• Es el cociente entre el tiempo secuencial y el paralelo:
S(n,p)=t(n)/t(n,p)
• ¿Qué t(n)?
 El del mejor algoritmo secuencial que resuelve el
problema, pero ¿cuál es el “mejor algoritmo secuencial”?
depende del tamaño de la entrada, distribución de los datos,
máquina..., y puede no conocerse (Por ejemplo, ¿cuál es el
coste de la multiplicación de matrices?).
 El del mejor algoritmo secuencial conocido. Pero depende
de los mismos parámetros anteriores.
 Tiempo de ejecución en un procesador del algoritmo
paralelo. Pero puede que el mejor esquema para paralelizar
no sea bueno en secuencial.
 El tiempo de ejecución de un algoritmo secuencial
“razonablemente bueno”. Habrá que indicar cuál se usa.
26
 Speed-up
• El speed-up será menor que el número de procesadores
usado. Si no podría hacerse un algoritmo secuencial mejor
que el que se usa, simulando el algoritmo paralelo.
• En algunos casos puede haber speed-up superlineal por
mejor gestión de la memoria al usar más procesadores.

•Para un tamaño de 40

problema fijo se aleja 35

del valor óptimo al 30

p=10
aumentar el número 25
p=20
de procesadores. 20 p=30
• Para un número de 15 p=40
p=50
procesadores fijo 10
aumenta al aumentar 5
el tamaño del 0
problema. 1000 2000 3000 4000 5000

27
 Speed-up, suma con n/2 procesadores

• En memoria compartida:
n/log n→∞

• En hipercubo, y malla o anillo con comunicaciones

directas:
n/((1+ts+tw)*log n)→∞

• En malla sin comunicaciones directas:

n/(log n+(ts+tw)*2*√n)→∞

• En anillo sin comunicaciones directas y en red:

n/(log n+(ts+tw)*n)→1/(ts+tw)

28
 Eficiencia
• Da idea de la porción de tiempo que los procesadores se
dedican a trabajo útil.
• Es el speed-up partido por el número de procesadores:
E(n,p)=S(n,p)/p=t(n)/(p*t(n,p))
• Valor entre 0 y 1.
1
• Para un tamaño de
0,9
problema fijo se aleja 0,8
del valor óptimo (1) al 0,7 p=10
aumentar el número 0,6 p=20
de procesadores. 0,5 p=30
• Para un número de 0,4 p=40
procesadores fijo 0,3 p=50

aumenta al 0,2
0,1
aumentar el tamaño
0
del problema. 1000 2000 3000 4000 5000

29
 Eficiencia, suma con n/2 procesadores

• En memoria compartida:
2/log n→0

• En hipercubo, y malla o anillo con comunicaciones

directas:
2/((1+ts+tw)*log n)→0

• En malla sin comunicaciones directas:

2/(log n+(ts+tw)*2*√n)→0

• En anillo sin comunicaciones directas y en red:

2/(log n+(ts+tw)*n)→0

30
 Speed-up, suma con p procesadores
Con p fijo

• En memoria compartida:
n/(n/p+log p)→p

• En hipercubo, y malla o anillo con comunicaciones

directas:
n/(n/p+(1+ts+tw)*log p)→p

• En malla sin comunicaciones directas:

n/(n/p+log p+(ts+tw)*2*√p)→p

• En anillo sin comunicaciones directas y en red:

n/(n/p+log p+(ts+tw)*p)→p

31
 Eficiencia, suma con p procesadores
Con p fijo

• En memoria compartida:
n/(n+p*log p)→1

• En hipercubo, y malla o anillo con comunicaciones

directas:
n/(n+(1+ts+tw)*p*log p)→1

• En malla sin comunicaciones directas:

n/(n+p*log p+(ts+tw)*2*p*√p)→1

• En anillo sin comunicaciones directas y en red:

n/(n+p*log p+(ts+tw)*p2)→1

32
 Coste
• Representa el tiempo (el trabajo) realizado por todo el
sistema en la resolución del problema.

• Es el tiempo de ejecución por el número de procesadores

usados:
C(n,p)=p*t(n,p)

• En algoritmo óptimo coincidiría con el tiempo secuencial, pero

en general es mayor.

• La diferencia se llama función overhead:

to(n,p)=C(n,p)-t(n)=p*t(n,p)-t(n)
Es distinto de la idea de overhead vista anteriormente y
difícilmente medible.

33
 Distribución del trabajo

• Es importante para mejorar el balanceo.

• En memoria distribuida puede reducir el coste de las

comunicaciones asignando datos que se comunican
frecuentemente a procesadores vecinos.
Evita comunicaciones, congestión de la red y colisiones.

• En memoria compartida puede influir en el coste de los

accesos a memoria, si procesadores distintos acceden a
bloques distintos. Normalmente que los procesadores
accedan a bloques de datos. Esto además mejora el uso de
la jerarquía de memoria.

34
Distribución de datos. Suma de n números. En
malla
5 4 6 7

1 0 2 3

9 8 10 11

13 12 14 16

35
Distribución de datos. Suma de n números. En
anillo

7 comunicaciones

3 2 0 1 5 4 6 7

5 comunicaciones

36
 Escalabilidad
• Para un sistema paralelo interesa que las prestaciones se sigan
manteniendo en cierta medida al aumentar el tamaño de sistema.

• No se puede seguir manteniendo las prestaciones manteniendo

el tamaño del problema fijo y aumentando el número de
procesadores.

• Se tratará de mantener las prestaciones al aumentar el tamaño

del sistema pero aumentando el tamaño del problema. Los
sistemas (físicos o lógicos) que cumplen esto se dicen
escalables.

• La idea es, para un determinado programa, ser capaces de

determinar si en el futuro, cuando aumente el número de
procesadores y el tamaño de problemas que se quieren resolver,
se seguirán manteniendo las prestaciones.
37
 Función de isoeficiencia
• Da idea de cómo debe crecer la entrada del problema
en función del número de procesadores para mantener la
eficiencia constante.

to(n,p)=p*t(n,p)-t(n)

t(n,p)=(to(n,p)+t(n))/p

E(n,p)=t(n)/(to(n,p)+t(n))

t(n)=(E(n,p)/(1-E(n,p))*to(n,p)=K*to(n,p)

Para obtener cómo debe crecer n en función de p para

mantener la eficiencia constante basta comparar el tiempo
secuencial con la función overhead del paralelo.
38
 Isoeficiencia, suma con p procesadores
Sin constantes, pues interesa la forma en que crece

• En memoria compartida, hipercubo, y malla o anillo con

comunicaciones directas :
t(n)=n ∝ to(n,p)=n+p*log p
Función de isoeficiencia: p*log p

• En malla sin comunicaciones directas:

t(n)=n ∝ to(n,p)=n+p*log p+p*√p
Función de isoeficiencia: p1.5 (la mayor)

• En anillo sin comunicaciones directas y en red:

t(n)=n ∝ to(n,p)=n+p*log p+ p2
Función de isoeficiencia: p2 (la mayor)
39
 Isoeficiencia, suma con p procesadores
Para mantener las prestaciones al variar de p1 a p2
procesadores, el tamaño debe aumentar proporcional a
f(p2)/f(p1)

Procesadores: 4 a 16 16 a 64 64 a 256

memoria compartida,
hipercubo, y malla o anillo 8 6 5.33
con comunicaciones
directas

malla sin 8 8 8
comunicaciones directas

anillo sin comunicaciones 16 16 16

directas y en red

Todos escalables. Unos más que otros.

40
 Speed-up escalado
• Representa la relación entre el tiempo de ejecución
secuencial y el paralelo, pero aumentando
proporcionalmente el número de procesadores:
Se(n,p)=t(n)*p/t(n*p,p)

• En hipercubo:
Se(n,p)=n*p/(n+(1+ts+tw)*log p)

• En malla:
Se(n,p)=n*p/(n+(ts+tw)*√p+log p)

• El de hipercubo es más escalable pues su cociente es

menor.

41
 Estudio experimental de la escalabilidad
• Se estudia el número de operaciones por segundo
(flops) por procesador:
Variando el tamaño de la entrada al variar el número de
procesadores,
O utilizando el máximo tamaño de la entrada que cabe en
la memoria del sistema

buena escalabilidad peor

proc tam flops proc tam flops

1 100 100 1 100 100
5 500 99 5 500 102
25 2500 96 25 2500 90
125 12500 91 125 12500 46
42
 Estudio experimental
• Diseño de experimentos que nos permitan obtener
conclusiones:
- Determinar qué tipo de conclusiones se quiere obtener: en
cuanto a speed-up, escalabilidad.
- Definir el rango de los experimentos: número de
procesadores y tamaño del problema.
- Comparar los resultados experimentales con los teóricos.
- Si no coinciden revisar los estudios teóricos o la forma en
que se han hecho los experimentos.

• Pueden consistir en:

- Estudiar el programa completo.
- Estudiar el comportamiento en los distintos procesadores:
¿balanceo de la carga? ¿sincronización? ...
- Dividir el programa en partes para estudiarlas por separado.

Hay herramientas de análisis: profilers, gráficas, Vtune, MPE...

43
 Comparación estudio teórico-experimental

• Se pueden estimar los valores constantes en las fórmulas

teóricas:
- En particular ts y tw se obtienen con un ping-pong, o
pueden tener valores distintos para distintas operaciones
de comunicación.
- El coste de la computación se puede estimar ejecutando
parte del programa en un procesador.

• Ajuste del modelo teórico con datos experimentales:

- Obtener valores constantes en el estudio teórico
haciendo ajuste de mínimos cuadrados con resultados
experimentales.
- Estudio asintótico: comportamiento teniendo en cuenta el
término de mayor orden de la fórmula teórica, compararlo
con la gráfica experimental.
44