Paradigmas de Computación Paralela, Concurrente y Distribuida

Paradigmas de Computación
Paralela, Concurrente y
Distribuida
Dra. Veronica Gil-Costa
e-mail: gvcosta@unsl.edu.ar
ggvcosta@gmail.com
Bibliografía
•
O. Bonorden et all - PUB library, Release 6.0 - User guide and function reference. 1998.
•
O. Bonorden et all - The Puderborn University BSP (PUB) Library- Desing, Implementation and
performance. 1999.
•
M. Goudreau et all - Towards Efficiency and Portability: Programming with the BSP model. 1996.
•
J. Keller et all - Practical PRAM programming. John Wiley & Sons inc.. 2001.
•
C. Leopold - Parallel and Distributed Computing: A survey of models, paradigms, and approaches.
2001.
•
W.F. Mccoll - BSP Programming. 1994.
•
M. Quinn - Parallel Computing. Theory and Practice. Second Edition. McGraw-Hill. Inc. 1994.
•
L.G. Valiant - A Bridging Model for Parallel Computation. 1990.
•
General Purpose parallel Architectures. 1990.
•
B. Wilkinson, et all - Parallel Programming: Tecniques and Aplications using Networked
Workstations and Parallel Computers. 1999.
Modelo de Computación Secuencial
Computadora von Neumann
Clock
CPU
Memoria de
Programa
Cómo se escriben los programas?
Memoria
RAM
..
Mi
..
M1
M0
ALU
Registros
Contador de Programa
Qué es la computación paralela?
Tradicionalmente el soft. se escribe
en forma serial
Es el uso simultáneo de múltiples
recursos de cómputos para resolver un
problema
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
ARPANET
1969
1976 1987
1990
1993
1995
1999
2005
2007
tiempo
ARPANET
Primera red de computadoras
básico
Experimento militar
Comienzo de la Internet
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
ARPANET
Cray-1
1969
1976 1987
1990
1993
1995
1999
2005
2007
tiempo
Cray-1
Procesamiento vectorial: Usa la misma instrucción
para realizar la misma operación sobre varios
argumentos
150millones de operaciones por segundo de punto
flotante
Computadores grandes, costosos
Dueños: Universidades, gobierno, grandes
industrias.
Usuarios experimentados (tarjetas perforadas)
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
prototipo Parallel
Inference Machine
(PIM)
ARPANET
Cray-1
1969
1976 1987
1990
1993
1995
1999
2005
2007
tiempo
Computación Paralela
Popular a fines de los ’80 principios
de los ’90
Primera Crisis
Problema: el software limitado a la
investigación y la milicia
Los lenguajes de alto nivel para el
modelo de Von- Neumann: C y
Fortran
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
prototipo Parallel
Inference Machine
(PIM)
Redes de Comp.
ARPANET
Cray-1
1969
1976 1987
NOW
1990
1993
Beowulf
1995
1999
2005
2007
tiempo
Redes de Computadoras
NOW: proyecto de la Universidad de Bekeley
Primer cluster de computadoras más poderoso del
mundo
Beowulf: es un estilo de cluster diseñado para
realizar cálculos paralelos HPC
Tenía 16 computadores personales Intel 200MHz
conectados por medio de un switch Ethernet
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
prototipo Parallel
Inference Machine
(PIM)
Redes de Comp.
ARPANET
Cray-1
1969
1976 1987
NOW
1990
1993
GRID
Beowulf
1995
1999
2005
2007
Hacer del poder computacional tan fácil como la red eléctrica
Proyecto SETI: Globus Toolkit
tiempo
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
prototipo Parallel
Inference Machine
(PIM)
Redes de Comp.
ARPANET
PVM
Cray-1
1969
1976 1987
MPI
NOW
1990
1993
GRID
Beowulf
1995
1999
OpenMP
Multi-core
2005
2007
tiempo
Línea Temporal
Línea Temporal
Top 500 http://www.top500.org/lists/2010/11
229376 GB
186368 Cores
Intel EM64T Xeon X56xx
(Westmere-EP) 2930 MHz (11.72
GFlops)
Noviembre 2010
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
prototipo Parallel
Inference Machine
(PIM)
Redes de Comp.
ARPANET
PVM
Cray-1
1969
1976 1987
MPI
NOW
1990
1993
GRID
Beowulf
1995
1999
OpenMP
Cloud
Multi-core Comp.
2005
2007
tiempo
Cloud Computing
Es un paradigma que ofrece servicios a través de
internet.
Los usuarios acceden sin conocimiento de la
gestión de internet
Utilizan cachés temporales de clientes (equipos de
escritorio, portátiles, etc.).
A pesar de que las capacidades de las PC han
mejorado, gran parte de su potencial se
desperdicia
Línea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
prototipo Parallel
Inference Machine
(PIM)
Redes de Comp.
ARPANET
PVM
Cray-1
1969
1976 1987
MPI
NOW
1990
1993
GRID
Beowulf
1995
1999
GPU
OpenMP
Cloud
Multi-core Comp.
2005
2007
tiempo
GPU
Descienden de los chips gráficos de finales de los
’80.
Usualmente no tenían soporte para dibujo de
figuras.
La velocidad de las CPU de la década del ’90 no
permitieron implementar GPUs más avanzados
Popularidad reciente: alta especialización de las
GPU para cáclulo con valores de punto flotantes
(gráficos 3D)
Computación Paralela
Características del problema
Aplicaciones
Por qué usar computación Paralela?
Computación Paralela:
Características del problema
Se puede dividir en partes discretas de trabajo
que se pueden resolver simultáneamente
Ejecutar múltiples instrucciones de programa en
cualquier instante de tiempo
Se resuelve en menos tiempo con múltiples
recursos que con uno sólo
Aplicaciones
Sistema de predicción del tiempo
Superficie de USA + Candada = 20.000.000 Km2
Altitud de 20 km
20 M Km2 * 20 Km = 400 M km3
….
4 * 1013 cálculos computacionales para predecir 1 hs.
Si queremos saber la predicción de 2 días y con un procesador
se ejecuta 1 billón de cálculos por seg
4 * 1013 * 48 horas = 2 * 1015 cálculos
2 * 1015 cal./ 109 calc. por seg. = 2 * 106 seg. = 23 días!!!
Aplicaciones
Calcular las orbitas planetarias y
galácticas
Movimiento de las placas tectónicas
¿Qué tienen estas aplicaciones en común?
Tráfico de vehículos en horas extremas
Operaciones de mercado (bancos,
Se
caracterizan por requerir el procesamiento de una
economía)
gran cantidad de información en forma rápida
Explotación de petróleo
Por qué usar Computación Paralela?
Razones principales:
Ahorrar tiempo
Resolver grandes problemas
OtrasParalela
razones:
LaComp.
es la evolución de la computación
secuencial
que intenta
emular
lo que sucede
en el
Aprovechar
el uso
de recursos
no locales
mundo real, donde varios eventos
Ahorrar costos: usar varias computadoras
complejos e interrelacionados suceden simultáneamente
económicas
Evitar problemas de memoria
Paradigmas de Computación
Paralela, Concurrente y
Distribuida
Introducción a los Sistemas Paralelos
Terminología
Tarea: programa o un conjunto de
instrucciones (tipo-programa) que
se ejecuta en un procesador.
Paradigmas de computación Paralelas
Computación Concurrente
Es la simultaneidad en la ejecución de múltiples
tareas interactivas. Es la base de la Comp. Paralela.
Son tareas que se ejecutan en el mismo instante.
Es una colección de procesos o hilos secuenciales
que se ejecutan (lógicamente) en paralelo.
Pseudo-paralelismo: cuando las tareas se ejecutan
en una máquina secuencial.
Como se puede implementar la
concurrencia?
Multiprogramación:
Multiprocesamiento:
Los threads multiplexan su ejecución sobre
una máquina secuencial
Los threads multiplexan su ejecución sobre
multicores o multiprocesadores
Procesamiento distribuido:
Los procesos multiplexan su ejecución sobre
diferentes máquinas
Coherencia y seguridad
Si los threads acceden a recursos
compartidos se logra seguridad si:
Todos los accesos no tienen efecto
sobre los recursos (ej. variables)
Sólo un acceso a la vez
(exclusión mutua)
Problema de “Too much milk”
Tiempo
Tu
3:00
Llegas a casa
3:05
Miras en la heladera
no hay leche
Vas al mercado
3:10
3:15
compañero de cuarto
Llega a casa
3:20
Llegas al mercado
Mira la heladera, no hay leche
Hay que SINCRONIZAR y actualizar datos correctamente
3:25
Compras la leche
Va al mercado
3:30
3:35
3:45
Llegas a casa
Pones en la heladera
Llega al mercado
Compra la leche
Llega a casa, Oh! No!!!
Problema: “filósofos cenando”
Hay 5 filósofos sentados en una mesa
redonda
Entre cada filósofo hay un chopstick.
Cada filósofo hace dos cosas: pensar y
comer
El filósofo piensa por un rato
Cuando tiene hambre
Agarra el chopstick derecho e izquierdo
No puede comer sin los 2 chopstick, sino espera
Cuando termina de comer libera los chopstick.
Problemas: Competencia, coherencia y seguridad por los recursos
semáforos, mutex, etc.
Paradigmas de computación Paralelas
Computación Paralela vs.
Computación Distribuida
Divide una aplicación en tareas que se
ejecutan al mismo tiempo
Divide una aplicación en tareas que se
ejecutan usando diferentes recursos
Paradigmas de computación Paralelas
Computación Paralela
vs.
Computación Distribuida
diferentes
recursos
Divide una aplicación en tareas Utiliza
físicamente separados
que se ejecutan simultáneamente
(fuertemente acoplado)
Se consideran varias aplicaciones
Se considera una aplicación por a la vez (pueden pertenecer a
diferentes usuarios).
vez.
Objetivo: acelerar la ejecución de Objetivo: permitir que varios
usuarios
trabajen
en
forma
una aplicación
cooperativa
Se ejecutan sobre arquitecturas Se ejecutan sobre arquitecturas
abiertas
y
homogéneas
con
memoria heterogéneas,
dinámicas
compartida
Sistema Distribuido
Cada procesador tiene su propia memoria: La
dirección de memoria de un procesador no mapea
en otro procesador (no hay direcciones globales a
través de los procesadores).
Cada procesador opera independientemente
El acceso a los datos de otro procesador lo define
explícitamente el usuario (pasaje de mjes, sync.,
etc.)
Sistema Distribuido
Ventajas:
Memoria escala con el número de procesadores
Cada procesador accede a su propia memoria
sin interferencia ni overhead causado por
mantener la coherencia de la memoria
Desventajas:
El programador es responsable de la
comunicación
Difícil mapear datos basados en memoria
global
Paradigmas de computación Paralelas
Sin embargo tienen muchas características en común:
Múltiples procesadores
Los procesadores están interconectados por alguna
red
Múltiples procesos están en progreso al mismo
tiempo y cooperan unos con otros
Paradigmas de computación Paralelas
Multiplicación de un vector por una
matriz un procesador
0
1
0
x
1
2
3
2
Si para cada resultado 5 t. 4
5
6
5
7
8
9
8
Total 15 t. en 1 procesador
Multiplicación de un vector por una
matriz varios procesadores
0
1
0
x
0*1+1*2+0*3
Proc0
1
2
3
4
5
6
0*4+1*5+0*6
Proc1
7
8
9
0*7+1*8+0*9
Proc2
Si para cada resultado 5 t. Total 5 t. en 3 procesadores
Terminología
Tarea Paralela: se ejecuta en varios
procesadores en forma segura
(resultados correctos).
Terminología
Comunicación:
A través de pasaje de mensajes
A través de memoria compartida
Acceso a memoria remota
Sincronización:
Coordinación de tareas paralelas en tiempo
real.
Terminología
El tamaño de un proceso puede ser
descrito por su granularidad
TAMAÑO DE COMPUTACIÓN ENTRE DOS
PUNTOS CONSECUTIVOS DE
COMUNIACIÓN Y SINCRONIZACIÓN
Terminología
Granularidad gruesa:
Comunicación y sincronización
Cómputo
Comunicación y sincronización
Mucho computo. Mas oportunidad para mejorar la performance.
Terminología
Granularidad fina:
Comunicación y sincronización
Cómputo
Comunicación y sincronización
Cómputo
Comunicación y sincronización
Cómputo
Comunicación y sincronización
Más overhead de comunicación.
Menos oportunidad para mejorar la performance.
Granularidad
Como métrica de granularidad se
puede utilizar una relación entre
computación y comunicación:
Granularidad = Tcomp/Tcomm
Aumentar la granularidad:
• Reduce los costos de creación de procesos y
comunicación entre procesos
• Reduce el número de procesos concurrentes y la
cantidad de paralelismo
Terminología
Speed-up: aceleración del código paralelo respecto
del código secuencial
speed-up( P ) T1/ T(P)
Speed-up
Super-lineal
Speed-up lineal
Speed-up típico
Numero de procesadores P
Eficiencia: se define como el ratio entre el speed-up
y el número de procesadores
Ef( P ) = speed-up(P)/P
Limites del Paralelismo
No todos los programas son
fácilmente paralelizables
Los programas tienen una parte
secuencial y una parte paralelizable
Parte secuencial
Dependencia de datos?
Parte paralela
a = b + c;
d = a + 1;
e = d + a;
for (i=0; i < e; i++)
M[i] = 1;
Ley Amadahl’s
Todo cómputo posee una porción
serial “s” que no puede ser
paralelizable. Sin importar la
cantidad de procesadores P que se
utilicen, el tiempo de ejecución no
puede ser menor que “s”.
Tpo secuencial
f
No se puede paralelizar:
Límite de la mejora que se
puede obtener
Ley Amadahl’s
tiempo
Usando 5 procesadores para el
trabajo paralelo
25 seg.
+
50 seg.
+
25 seg.
100 seg.
secuencial
paralelo
25 seg.
secuencial
+
10 seg.
25 seg.
secuencial
secuencial
60 seg.
Speed- up = Tsec/Tpar
= 100 seg./ 60 seg. = 1.67
Administración de tareas
Overhead agregado por la
administración de un conjunto de tareas
Overhead: Tiempo requerido para
coordinar las tareas paralelas (opuesto al
hacer trabajo útil)
Tiempo de Start-up
Sincronización
Comunicación de datos
Software overhead, threads,
Tiempo de finalización de las tareas
Balance de carga
Es difícil dividir el trabajo uniformemente
entre los P procesadores
No basta con asignar el mismo trabajo a
todos los procesadores porque el tamaño
de las tareas puede variar dependiendo
de los datos que use.
Ejemplo: guía telefónica
Cómputo - Comunicación
Balance de Carga
Los procesos que terminan antes
deben esperar al proceso que más
se demora
Tiempo ocioso
Menor utilización
Balance de Carga Estática
El programador decide a priori la cantidad
de trabajo que se le asigna a cada
proceso
Funciona bien en sistemas homogéneos
Todos los procesadores tienen las mismas
características
Cada proceso tiene la misma cantidad de
trabajo
No funciona bien en sistemas
heterogéneos
Balance de Carga Dinámica
Cuando un proceso finaliza su tarea,
saca más trabajo del proceso más
cargado
Ideal para sistemas heterogéneos
con carga de trabajo no uniforme
No funciona bien
en sistemas
distribuidos
Terminología
Escalabilidad: Habilidad de demostrar
un incremento en el speed-up
paralelo
Término impreciso: se puede usar
para describir el hardware o el
software.
Escalabilidad
Hardware
Al incrementar el número máquinas
mejora la performance del sistema
Escalabilidad con tamaño de problema fijo
Analizar cómo varía el tiempo paralelo y la eficiencia al aumentar P
¿Cuántos P necesito para obtener una eficiencia del 50%?
Escalabilidad
Software
Al aumentar el tamaño del
problema no decrece la
performance del sistema
Tamaño del problema: Tamaño del
input o número de pasos en el
mejor algoritmo secuencial
Terminología
Latencia: tiempo que toma en transmitir
un mensaje de un lugar a otro. (Demora)
Bandwidth: cantidad de bits que pueden
ser transferidos por segundo. Costo alto
en sistemas heterogéneos.
Costo de comunicación =
Latencia + Bandwith
Terminología
Portabilidad
Características de ciertos programas
que les permite ser utilizados en
distintas arquitecturas sin que precise
Modificaciones de importancia
Clasificación de las
Computadoras Paralelas
Aspectos del Hardware
Clasificación de Flynn (1972)
SISD: único flujo de instrucciones
aplicado a un único flujo de datos
SIMD: único flujo de instrucciones
aplicado a múltiples flujos de datos
MIMD: múltiplo flujo de instrucciones
aplicado a múltiple flujo de datos
SISD
Todas las computadoras con un único
procesador, desde computadoras personales
hasta supercomputadoras
PC, Workstations
Programa
IS
CU
Procesador
Datos
DS
PU
MM
SIMD
PU1
DS1
DS2
PU2
CU
PUN
IS
load Ai
Load Bi
Ci = Ai*Ci
MM2
IS
DSN
Ejemplo:
MM1
SINCRONISMO
MMN
MIMD
IS1
CU
IS2
CU
CU
ISN
PU1
DS1
DS2
PU2
DSN
PUN
ISN
ASINCRONO
MM1
MM2
MMN
IS1
MIMD
MIMD
C. Distribuidas
y Paralelas
Memoria
Distribuida (privada)
Memoria
Compartida
Multiprocesador
BUS
Switch
Multicomputador
BUS
Switch
Paradigmas de computación Paralelas
Memoria Compartida
Memoria Distribuida
Mecanismos de locks y
Sincronización.
Responsabilidad del
programador
Mecanismos de
comunicación
Todos los procesadores
ven los mismos datos
Cada procesador ve
datos diferentes
Distribución de datos
M. Compartida vs. M. Distribuida
M.Compartida
Se puede compartir datos rápidamente entre las
tareas
Acceso a datos en forma amigable para el
programador
Escalabilidad pobre entre CPUs y memoria.
Son caras
M.Distribuida
Escalable
No
existe problemas de coherencia de memoria.
Costo bajo.
Puede ser difícil mapear estructuras de datos en
diferentes procesadores (SAT-tree).
MIMD- Hardware
Topologías de M. Compartida
Arquitectura basada en BUS
Existe saturación del bus
Coherencia de cache
Performace limitada al bandwidth del bus
Arquitecturas basadas en Switch
Puede ser visualizada como una grilla de
cables con SW en las intersecciones y memoria
y procesadores en las terminales.
Muy cara
MIMD- Hardware
Topologías de M. Distribuida
Redes basadas en BUS
Muy sencillas
No escalables
Redes basadas en SW
Rápidas
Jerarquía de SW: Fat-tree
Fat-Tree
Como programar en M. Compartida?
Los procesadores 1.. N
requieren la variable x
Sólo hay un lugar donde
buscar
Condiciones de competencia:
Usar Sync. Para evitar conflictos
Como programar en M. Compartida?
Un único proceso puede crear
múltiples threads concurrentes
Cada thread encapsula su propia ruta de ejecución
Cada thread tiene estados locales y recursos compartidos
Los threads se comunican a través de recursos compartidos como
la memoria
Como programar en M. Distribuida?
Los procesadores 1.. N requieren la
variable x
Hay n lugares donde buscar
Cada procesador tiene su
propia X
El valor de X puede variar
Para que el P1 busque X en P2:
P1 envía una petición de X a P2
P2 envía una copia de X a P1
P1 recibe la copia
P1 la almacena en su memoria
Pasaje de Mensajes
Y
Creación de Procesos
Creación de procesos
Estática:
Todos los procesos se especifican antes
de la ejecución
El sistema ejecutará un número fijo de
procesos
El programador lo determina por línea
de comando
SPMD y MPMD(Master-Slave)
Creación de procesos
Dinámica:
Un proceso puede ser creado e inicializado
durante la ejecución de otro proceso
También pueden ser destruidos
La creación y destrucción puede realizarse en
forma condicional (varía el número de procesos)
MPMD
tiempo
spawn()
Proceso 1
Proceso 2
Pasaje de mensajes
Las arquitecturas con memoria distribuida
usan comunicación explícita para
intercambiar datos
El intercambio de datos requiere sincronización
(cooperación) entre los senders-receivers
Cómo se describen los datos?
Cómo se identifican los procesos?
Qué significa que se complete un envío o recepción?
Ejemplo
Se quiere calcular la distancia entre cada punto de
A[1..4] y B[1..4] y guardar los resultados en
C[1..4][1..4]
Ejemplo
Se quiere calcular la distancia entre cada punto de
A[1..4] y B[1..4] y guardar los resultados en
C[1..4][1..4]
Podemos dividir el
Trabajo entre dos
procesadores
P1 envía datos a P2
P1 y P2 computan
P2 envía datos a P1
Ejemplo
Patrones de comunicación
Al usar pasaje de mensajes los programas
deben entender el cómputo y organizar la
comunicación correctamente
Punto a Punto
Broadcast (1 a todos) Reduce (todos a 1)
All to all
Scatter (1 a varios) Gather (varios a 1)
Point-to-Point
Método básico de comunicación entre 2
procesos
El procesador origen envía un mensaje al
procesador destino
El procesador destino recibe el mensaje y lo
procesa
El mensaje generalmente incluye
Datos
Longitud del mensaje
Dirección destino y posiblemente un tag
Synchronous vs. Asynchronous
Synchronous
No utiliza buffers
El receptor notifica cuando
recibe el mensaje
El proceso que envía espera
a que el destino reciba todo el
mensaje
tiempo
tiempo
send()
Solicita envío
Acknowledgement
send()
Mensaje
recv()
recv()
Synchronous vs. Asynchronous
Asynchronous
No existe confirmación
Un usa buffers
Blocking vs. Non-Blocking
Blocking = Sync && Non-Blocking = Async
MPI son diferentes
tiempo
send()
recv()
Blocking vs. Non-Blocking
No Bloqueante
Permite ejecutar la próxima instrucción sin importar
que la rutina send() haya sido localmente completada
Es responsabilidad del programador que los datos que
se envían no sean modificados en las próximas
instrucciones
Fuente de Deadlock - Bloqueante
Si no hay suficiente capacidad en el buffer,
las operaciones send esperan hasta que
haya suficiente espacio disponible
Qué sucede con este código:
Depende del
tamaño del
buffer
Soluciones
Incrementar el tamaño del buffer
Ordenar las operaciones send y recv en
forma más cuidadosa
Broadcast
Un
proceso envía la misma
información a otros
procesadores
Se identifican los procesos que van a participar
en el broadcast
Mediante un nombre de grupo que es usado
como parámetro por la función de broadcast
El proceso que hace broadcast también puede
recibir el mensaje
Incluye send+sync
Broadcast
Si queremos paralelizar:
Scatter
Envía un conjunto de elementos de un
arreglo desde el procesador origen a un
conjunto de procesos
Process 0
Process 1
dato
dato
Process N
dato
Acción
buf
Código
scatter
scatter
scatter
Gather
Un procesador recolecta los valores de
otros procesadores
Se utiliza luego de realizar cómputos en
forma paralela
Process 0
Process 1
dato
dato
Process N
dato
Acción
buf
Código
scatter
scatter
scatter
Gather - Ejemplo
Processor 0..N
{
…
int r = rand();
int k = 0;
int buff[N];
Gatther( 0, &buff, r, pid );
for (i=0;i<N;i++)
k+=buff[i];
…
}
P0
P1
P2 P3 P4
4
7
8
19
30
11
K= 433
27
8
3
P5
3
r
Reduction
Cada procesador comienza con un valor y
necesita conocer la suma de los valores
almacenados en otros procesadores
Un “reduction” combina datos de todos los
procesadores y los retorna a través de una
operación
Algunas operaciones que se pueden aplicar son:
ADD, OR, AND, MAX, MIN, etc.
Ningún procesador puede finalizar un “reduction”
antes que los otros procesadores hayan
contribuido con sus valores
Ejemplo
Ejemplo en Paralelo
Paralelismo de datos
Paralelismo de tareas
y
Diseño de software paralelo
Paralelismo de Datos
Se caracteriza por la ejecución paralela de
las mismas operaciones sobre diferentes
partes de un conjunto de datos
suficientemente grande
Tipos de paralelismo de datos:
SPMD y MPMD
Paralelismo de Datos
Es simple de programar
Existe una única estructura de control o
ejecución
El paralelismo aparece via pasos de
paralelismo de datos
Forma de particionar los datos
Paralelismo de Datos
for all i: A[i]=2*A[i]
P0
4
2
P1
8
7
1
P2
0
4
5
3
4
8
1
Paralelismo de datos
8
4
16 14 2
0
8
10 6
8
16 2
for all i>0: A[i]=A[i]+A[i-1]
8
12 20 30 16 2
8
Suma = 0….
18 16 14 24 18
Paralelismo de datos
secuencial
Paralelismo de Tareas o funcional
Ejecuta diferentes operaciones sobre
los mismos o diferentes datos
Se enfoca en la división
de tareas
Paralelismo de Tareas
v = alpha();
w = beta();
x = gamma(v, w);
y = delta();
printf ("%6.2f\n", epsilon(x,y));
alpha
Se puede ejecutar
alpha, beta, Y gamma, delta
en paralelo.
beta
gamma
delta
INDEPENDENCIA DE DATOS
epsilon
Ejemplo 2
Procesamiento de Señales: Un conjunto signal-data de
audio se transmite a través de tres filtros computacionales
distintos.
Cada filtro es un proceso independiente. El primer
segmento de datos debe pasar por el primer filtro antes
de pasar al segundo.
Cuando lo hace, el segundo segmento de datos pasa por
el primer filtro.
En el momento en el tercer segmento de datos se
encuentra en el primer filtro, las tres tareas están
ocupadas.
Divide y Vencerás
Es un método elegante para resolver problemas
Se divide el problema en problemas más pequeños,
luego se resuelven las partes en forma separada y
se combinan los resultados parciales para obtener
el resultado final
Se utiliza recursivamente para dividir el problema
hasta alcanzar un punto en el que el problema es
trivial
X0 …. Xn/m-1 xn/m…. X2n/m-1
….
suma
x(m-1)n/m-1….. Xn-1
Divide y Vencerás
MASTER
s = n/m;
//cantidad de elementos para los slaves
for ( i=0, x=0; i<m; i++, x = x+s )
send( &numbers[x], s, Pi );
//envía s números al slave Pi
result = 0;
for( i=0;i<m; i++ )
recv( &part_sum, Pany);
sum += part_sum;
//Espera resultados de los slaves
//Acumula suma parciales
SLAVE
recv( numbers, s, Pmaster );
part_sum = numbers[0];
for( i=0; i< s; i++ )
part_sum += numbers[i];
send( &part_sum, Pmaster );
//Recibe s números del master
//Realiza la suma
//Envía resultados
Con broadcast?
Divide y Vencerás: Análisis
El algoritmo secuencial requiere n sumas, con
una complejidad de O(n).
El algoritmo paralelo utiliza m+1 procesos.
Dividimos el análisis en etapa de cómputo y
comunicación
Etapa 1: Comunicación:
m slaves leen n/m números con un costo de
tcomm1=m*(tstartup+(n/m)tdata)
Etapa 2: Cómputo:
Los procesos esclavos suman n/m números
requiriendo n/m sumas.
tcomp1 = n/m
Divide y Vencerás: Análisis
Etapa 3: Comunicación:
Se envían los resultados parciales de las sumas
tcomm2 = m(tstartup+tdata)
Etapa 4: Cómputo:
Suma final de m sumas parciales
tcomp2 = m;
Costo total
tp = tcomm1 + tcomm2 + tcomp1 + tcomp2
= m(tstartup+(n/m)tdata)+m(tstartup+tdata) + n/m + m
= 2mtstartup+(n+m) tdata + n/m + m
Divide y Vencerás: Recursivo
Esta formulación crea un árbol binario de
procesos
Al inicio, el problema raíz del árbol toma un
problema y lo divide en dos partes más chicas
La división del problema continúa hasta que las
hojas del árbol han recibido los problemas más
básicos
Cada hoja retorna la solución de su problema al
nodo padre
Cada proceso padre combina y/o aplica alguna
operación a la solución entregada por los nodos
hijos
Eventualmente la raíz genera la solución al
problema original
Divide y Vencerás: Recursivo
add( int *s)
{
if( numbers(s)<= 2 ) return (s[0] + s[1]);
else
{
Divide (s, s1, s2 ); //Divide s en dos grupos
part_sum1 = add(s1);
part_sum2 = add(s2);
return( part_sum1 + part_sum2);
}
Problema inicial
}
Divide el problema
Tareas finales
Divide y Vencerás: Implementación
Paralela
En una implementación secuencial
se visita un nodo del árbol por vez
Una implementación paralela
permite visitar varios nodos
simultáneamente
Si se asigna un proceso a cada nodo
P0
Cada proceso solo
P1
estará activo
en un nivel del árbol
P3
2m sub-tareas
2m+1-1 procesos
P2
P4
P5
P6
Divide y Vencerás: Implementación
Paralela
una solución mas eficiente es re-usar los procesos existentes
P0
P0
P4
P0
P0
P2
P1
P2
P4
P3
P4
P6
P5
P6
P7
También se puede aplicar a tareas que son divididas en más de dos
partes
Bucket sort: Secuencial
La mayoría de los algoritmos de ordenación
secuencial se basan en las operaciones de
“comparar” e “intercambiar”
Bucket sort:
Es un algoritmo de partición
Funciona bien si los números se distribuyen
uniformemente en un intervalo [0..a-1]
El intervalo se divide en m regiones denominadas
buckets
Para ubicar un número en un bucket, i/m y usar el
resultados para identificar el bucket
--------------------------------------------
buckets
sort
merge
Bucket sort: Secuencial
Algoritmo secuencial:
Se divide el número i por el número de buckets y me
da el identificador del bucket donde lo debería ubicar.
Es decir los números se distribuyen uniformemente en
buckets. Si los números están uniformemente
distribuidos, en cada bucket hay n/m números.
Eso permite balancear la carga de trabajo asignada a
cada bucket.
luego se ordenan en forma secuencial los números de
cada buckets y finalmente se aplica una función de
merge
--------------------------------------------
buckets
sort
merge
Bucket sort: Paralelo
Alternativa 1: Asignar un bucket a cada
procesador (todos los procesadores mantienen
el arreglo de números desordenados)
Números desordenados
--------------------------------------------
Buckets
grandes
sort
merge
Bucket sort: Paralelo
Alternativa 2:
Se divide la secuencia en m regiones, una para cada procesador.
Cada procesador genera buckets más pequeños y distribuye los
números en esos buckets.
Estos buckets pequeños se vacían en P buckets mas grandes para
ser ordenados.
Para ello c/procesador envía un bucket chico a c/u de los otros
procesadores (bucket i al procesador i)
Números desordenados
-------------------------------------------procesadores
Buckets mas pequeños
Buckets
grandes
sort
merge
D&V Paralelo
Tipos de Algoritmos (Input-Output)
Los problemas se pueden clasificar según sus
datos de entrada y salida
Común-Común (CC): las variables paralelas de
entrada y salida son comunes (replicadas) a todos
los procesadores del grupo
Común-Privado (CP): las variables paralelas de
entrada son comunes (replicadas) pero las
variables resultado quedan privadas en cada
procesador
Privada-Común (PC): las variables paralelas de
entrada son privadas de cada procesador y las
variables resultado son replicadas
Privada-Privada (PP): las variables de entrada y
salida son privadas
Caso de estudio:
Algoritmo shortest path
Un grafo G(V,E), donde V es el conjunto
de vértices y E es el conjunto de arcos
conectando vértices en V.
En un grafo dirigido cada arco tiene una
dirección
Un grafo puede ser representado como
una matriz de adyacencia
Aij = 0 si no hay un arco que une i con j
Aij = 1 si hay un arco que une i con j
Caso de estudio:
Algoritmo shortest path
Es un problema importante en la teoría de grafos
y tiene gran aplicación en problemas de
comunicación y otros problemas computacionales
El problema involucra encontrar el paso más corto
entre todos los pares de vértices
0
3
1
2
0
1
2
3
0 1 2 3
0 1 0 0
0 0 1 1
0 0 0 0
1 0 1 0
Matriz de Adyacencia:
dice si hay un arco que une 2 vértices
Algoritmo shortest path
La idea es determinar si el paso
desde el vértice vi al vértice vj vía
vk, es más corto que el menor paso
conocido
vk
vi
vj
Algoritmo shortest path
El paso desde el vértice vi la vértice vj es la
secuencia de arcos que los une y ningún arco se
repite 2 veces.
El problema requiere que encontremos el camino
mas corto
El algoritmo toma como entrada una matriz de
adyacencia A (NxN) y computa una matriz S(NxN)
Sij tendrá la longitud del paso más corto entre vi y
vj, o -1
Algoritmo shortest path
El algoritmo obtiene la matriz S en N pasos,
construyendo en cada paso k una matriz
intermedia I(k) que contiene el paso más corto
conocido entre cada par de vértices.
Inicialmente I(0) contiene la longitud entre (vi,vj),
si existe un arco, de lo contrario será 0.
Durante el k-ésimo paso se evalúa nuevamente Iij
para determinar si:
El mejor paso conocido entre vi, vj es más largo que
las longitudes combinadas desde vi a vk y desde vk
a vj. De ser así se actualiza Iij
Algoritmo shortest path
Algoritmo shortest path: Paralelo
Repartir las filas en P procesadores
en forma consecutiva
J=0;
for (i=0;i<P;i++)
{
for (;j< (N/P); j++)
send(i, fila j);
if(i==(P-1))
send(i, fila j+1)
}
Asigna un bloque contiguo a
cada procesador
Г
Cada tarea es root de al menos un broadcast
Los datos requeridos en el késimo paso no le pertenecen
al procesador
Computación
Pipelined
Pipelined
T0
T1
T2
T3
El problema se divide en tareas que se
completan una después de otra.
En la programación paralela cada tarea se
ejecuta en un procesador diferente
Cada etapa contribuye a resolver el
problema y pasa información necesaria
para la siguiente etapa
Pipelined
Es posible incrementar la velocidad
de ejecución:
1.
2.
3.
Si se ejecuta mas de una instancia del
problema
Si una serie de datos se procesan con
múltiples operaciones
Si los datos pueden ser enviados a las
siguientes etapas antes que la etapa
actual finalice
Pipelined
Si se ejecuta mas de una instancia
del problema
procesos
1.
P4
Inst.1 Inst.2
P3
Inst.1 Inst.2 Inst.3
P2
Inst.1 Inst.2 Inst.3 Inst.4
P1 Inst.1 Inst.2 Inst.3 Inst.4 Inst.5
tiempo
Se utiliza para ejecutar simulaciones con diferentes parametros para
obtener resultados comparativos.
Pipelined
1.
Si una serie de datos se procesan
con múltiples operaciones
Elementos de vector
2.
d4
P0
P1
P0
P1
P2
P1
P2
P3
P1
P2
tiempo
P3
P4
d3
d2
d1
P0
P0
Cada proceso realiza una operación diferente sobre los elementos
Se utiliza para cálculos aritméticos, como multiplicar elementos de vectores
1.
2.
3.
Pipelined
Si los datos pueden ser enviados a
las siguientes etapas antes que la
etapa actual finalice
P4
Se transfiere
suficiente inf.
para comenzar
la siguiente etapa
P4
P3
P3
P2
P2
P1
P1
P0
P0
tiempo
tiempo
Ejemplo
Problema: Sumar una lista de
números almacenados en diferentes
procesadores
∑
P1
∑
∑
P2
P3
∑
P4
recv( Pi-1, acumulation );
accumulation += number;
send( Pi+1, accumulation)
P5
Tipos de Paralelismos
Threads
La estructura más común para
especificar procesos concurrentes es
FORK-JOIN
Programa principal
FORK
FORK
FORK
JOIN
JOIN
JOIN
Sistema de memoria compartida.
Threads
IP
Son rutinas livianas que comparten la misma zona
de memoria y las variables globales
code
Heap
IP
code
Heap
stack
threads
Rutinas de
Interrupción
stack
IP
Files
Files
stack
Proceso
Rutinas de
Interrupción
Threads
La creación de threads es 3 ordenes
de magnitud menor a la creación de
un proceso
La sync de los threads se puede
realizar más eficientemente que la
sincronización de procesos
Threads: Ejemplo
Threads: memoria compartida
Instrucción
x = x+1;
Proceso 1
read x
compute x+1
write x
tiempo
Proceso 2
read x
compute x+1
write x
Variable x
write
write
read
read
+1
+1
Proceso 1
Proceso 2
Secciones Críticas
- Locks
El problema de variable compartida puede ser generalizada a cualquier recurso.
Por ej. I/O dispositivos
Locks
Locks: son variables de 1 bit que se
coloca en 1 para indicar que el proceso
ha ingresado a la sección critica. Y se
coloca en 0 para indicar que no hay
procesos en la sección critica.
Estos mecanismos generalmente se
implementan por hardware.
Pthread
El programa principal es un thread.
Un thread separado puede ser creado y destruido
utilizando:
pthread_t thread1;
pthread_create( &thread1, NULL, (void*)proc1, (void*) &arg);
pthread_join( thread1, void *status);
thread1
Main program
pthread_create( &thread1, NULL, (void*)proc1, (void*) &arg);
pthread_join( thread1, void *status);
proc1(&arg)
{
….
return(*status);
}
Pthread
#include <pthread.h>
pthread_cancel(&thread1)
for (j=0;j<NUM_THREADS;j++)
Detached
thread: threads que se crean y se terminan sin la necesidad de
usarifun(threads[j]
join se llaman!=
thread
tid)detached
pthread_cancel(threads[j]);
pthread_self
pthread_mutex_t mutex1;
void
print_it(void *arg)
pthread_mutex_init(&mutex1,NULL);
{
pthread_mutex_destroy(&mutex1);
pthread_t tid; /* get the calling thread's ID */
tid = pthread_self();
pthread_mutex_lock(
mutex1 );
printf("Thread %d \n", tid);
pthread_mutex_unlock( mutex1 );
}
Pthread
Destroying Mutexes
struct obj
thread_mutex_t
foo_mutex;
{
void foo()
pthread_mutex_t om;
{
int refcnt; ...
pthread_mutex_init(&foo_mutex,NULL);
};
obj_done(struct obj *op)
pthread_mutex_lock(&foo_mutex);
/* Do{work. */
pthread_mutex_lock(&op->om);
x = x+1;
if (--op->refcnt == 0)
pthread_mutex_unlock(&foo_mutex);
{
}
pthread_mutex_unlock(&op->om);
pthread_mutex_destroy(&op->om);
free(op);
}
else
pthread_mutex_unlock(&op->om);
}
Hardware?
Todas las computadoras modernas
tienen cache
Hyperthreading. Cada núcleo
dispone ahora de dos hilos de
procesamiento, con lo que el
sistema ve el microprocesador
como si tuviera ocho núcleos en
vez de cuatro
L2: 8Mb
Hardware
• Si un therad en un core requiere un dato se trasfiere
desde la memoria hasta la cache del core (se hace una
copia).
• Posteriormente cuando el thread quiere obtener el
dato accede a su cache.
• Si otro thread ubicado en otro core quiere el mismo
dato, se hace una nueva copia del dato en la cache del
nuevo core que lo requiere. (hay 2 copias).
• El problema surge cuando un thread modifica el
contenido del dato. Luego se debe usar un protocolo
de coherencia para asegurar la correctitud de los
datos.
Hardware
Protocolo de coherencia de cache
Política de actualización: se actualiza todas
las copias del dato en todas las cachés
Política de invalidar (más común): cuando
se modifica una copia en una caché, las
otras copias son invalidadas utilizando un bit
de validación.
Hardware
La caché se organiza en bloques de
direcciones continuas
caché
Code:
a+=2;
b+=2;
c+=a+b;
bloques
ab
c
RAM
False sharing: un bloque puede ser pedido por varios threads, pero
cada thread accede a datos diferentes. Cuando se actualiza un dato
partes de las copias del bloque en otros cores deben ser actualizados
o invalidados
False-sharing
RAM
bloque
Address
tag
7
6
5
4
3
2
1
0
cache
cache
Core 1
Bloque en cache
Core 2
Ejemplo
sum
int sum, a[1000];
sum = 0;
for( i=0;i<1000; i++)
sum += a[i];
a
------------
Solución 1
Proceso 1
sum1 = 0;
for( i=0; i<1000; i+=2 )
sum1 += a[i];
sum += sum1
Proceso 2
sum2 = 0;
for( i=1; i<1000; i+=2 )
sum2 += a[i];
sum += sum2
Ejemplo
sum
N procesos tomando
números de a[]
a
------------
global_index
int a[array_size];
int global_index;
int sum = 0;
pthread_mutex_t mutex1;
Int nth = 10;
main()
{
int i;
pthread_t thread[nth];
for( i=0; i<array_size; i++ )
a[i] = i+1;
for(i=0;i< nth; i++ )
pthread_create(&thread[i],NULL,
slave, NULL);
for(i=0; i<nth; i++ )
pthread_join(thread[i],NULL);
}
Void *slave( void *ignorado)
{
int local_index, partial_sum = 0;
do {
pthread_mutex_lock(&mutex1);
local_index = global_index;
global_index++;
pthread_mutex_unlock(&mutex1);
if (local_index < array_size)
partial_sum += a[local_index];
}while(local_index < array_size )
pthread_mutex_lock(&mutex1);
sum += partial_sum;
pthread_mutex_unlock(&mutex1);
}
OpenMP
#include <omp.h>
g++-4.2 main.cc -o main.out –fopenmp
Las directivas se especifican con #pragma
#pragma omp directive-name[clause[,] clause]...
Al final de una región paralela hay una
sincronización implícita. Solo el thread master
continúa la ejecución.
Cuando un thread encuentra un constructor
paralelo, un grupo de threads es creado
OpenMP: clausuras
Private (lista de variables) En esta la lista de variables puede ser
separada por ",“ y para cada una de ellas se genera una copia en
cada thread, esta copia no tiene relación con la original y no es
inicializada a menos que se utilice firstprivate.
Shared (lista de variables) En esta las variables de la lista son
comunes a todos los threads y cada uno de ellos puede modificarla
afectándola en forma global.
Threadprivate (lista de variables) Hace que la lista sea privada a
cada thread pero globales dentro de un thread.
Reduction (operador:lista de variables) Realiza una operación de
reducción sobre las variables que aparecen en la lista utilizando el
operador/intrínseco especificado. El operador puede ser: +, *, -,
&(and), |(or), ^(eqv), &&(neqv). El intrínseco puede ser: || (max),
(min), (and), (or).
if(expresión escalar): los threads se crean si al evaluar la expresión
es verdadera.
OpenMP
int omp_get_threads_num(void) Devuelve el
identificador del thread.
int omp_get_num_threads(void) Devuelve cuántos
threads se están utilizando
int omp_get_num_procs(void) Devuelve el número
de procesadores accesibles
void omp_set_num_threads(int) Indica el número
de threads a utilizar
int omp_get_max_threads(void) Devuelve el
máximo posible de threads
OpenMP: Variables de entorno
OMP_NUM_THREADS Indica el
número de threads a usar.
export OMP_NUM_THREADS=4
setenv OMP_NUM_THREADS 4
set OMP_NUM_THREADS=4
OpenMP: Ejemplo
Si no quieren usar variables de
entorno pueden tener el mismo
efecto usando
omp_set_num_threads(NT);
OpenMP: Tipos de constructores
DO / for – Comparten las
iteraciones de un loop.
Representa el “paralelismo
de datos"
SECTIONS – Divide el trabajo
en secciones discretas. Cada
sección se ejecuta por un thread.
Paralelismo de tareas
Ejemplo
#pragma omp for[clause[,] clause]...
{
ciclo for
}
FOR
SCHEDULE(type, chunck): Describe cómo se dividen las iteraciones
de un loop entre los threads.
STATIC: Las iteraciones se dividen en chunks y asignados
estáticamente a los threads
DYNAMIC: Las iteraciones se dividen en chunks y asignados
dinámicamente a los threads. Cuando un thread termina un chunk
se le asigna otro
Ejemplo static
#include <opm.h>
#define SIZE 4
#define N 8
int main( )
{
int i,chunk;
float a[N], b[N], c[N];
for( i=0;i<N ;i++)
a[i] = b[i] = i*1.0;
chunck = SIZE;
#pragma opm parallel shared(a,b,c) private(i)
{
#pragma opm schedule( static, chunk )
for( i=0;i<N;i++)
c[i] = a[i]+ b[i];
}
}
Ejemplo
SECTIONS
SECTIONS / END SECTIONS
Debe incluirse en una región paralela.
Las secciones se dividen entre los “threads”.
Cada “thread” ejecuta una sección diferente.
Es posible realizar paralelismo a nivel de tarea.
SECTION define cada una de las secciones.
OpenMP
SECTION
OpenMP: Directivas
#pragma omp single: sólo un thread
ejecuta el código
#pragma opm parallel shared(a,b,c) private(i)
{
BLOCK1
#pragma opm single
{
BLOCK2
}
BLOCK3
}
OpenMP: Directivas
#pragma omp master: el código a
continuación lo ejecuta solo el
thread master
#pragma opm parallel shared(a,b,c)
private(i)
{
BLOCK1
#pragma opm master
{
BLOCK2
}
BLOCK3
}
OpenMP: Directivas
#pragma omp barrier: barrera de
sync.
#pragma opm parallel shared(a,b,c)
private(i)
{
BLOCK1
#pragma opm barrier
BLOCK3
}
OpenMP: Directivas
#pragma omp critical: regiones
críticas
#pragma opm parallel shared(a,b,c)
private(i)
{
BLOCK1
#pragma opm critical (zona1)
{
x = x+1;
}
BLOCK2
}