Académique Documents
Professionnel Documents
Culture Documents
Paralela, Concurrente y
Distribuida
Bibliografa
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.
M. Quinn - Parallel Computing. Theory and Practice. Second Edition. McGraw-Hill. Inc. 1994.
CPU
Memoria de
Programa
..
Mi
..
M1
M0
ALU
Registros
Contador de Programa
Qu es la computacin paralela?
Lnea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
ARPANET
1969
1976 1987
1990
1993
1995
1999
2005
2007
tiempo
ARPANET
Experimento militar
Comienzo de la Internet
Lnea Temporal
Sist. Paralelos
Sist. Distribuidos
Sist. Hibridos
ARPANET
Cray-1
1969
1976 1987
1990
1993
1995
1999
2005
2007
tiempo
Cray-1
Lnea 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
Computacin Paralela
Lnea 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
Lnea 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
tiempo
Lnea 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
Lnea Temporal
Lnea Temporal
Noviembre 2010
Lnea 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
Lnea 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
Computacin Paralela
Aplicaciones
Computacin Paralela:
Caractersticas del problema
Aplicaciones
Aplicaciones
Explotacin de petrleo
Razones principales:
Ahorrar tiempo
Resolver grandes problemas
OtrasParalela
razones:
LaComp.
es la evolucin de la computacin
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 simultneamente
econmicas
Evitar problemas de memoria
Paradigmas de Computacin
Paralela, Concurrente y
Distribuida
Introduccin a los Sistemas Paralelos
Terminologa
Multiprogramacin:
Multiprocesamiento:
Procesamiento distribuido:
Coherencia y seguridad
Tu
3:00
Llegas a casa
3:05
Miras en la heladera
no hay leche
Vas al mercado
3:10
3:15
compaero 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!!!
Computacin Paralela
vs.
Computacin Distribuida
diferentes
recursos
Divide una aplicacin en tareas Utiliza
fsicamente separados
que se ejecutan simultneamente
(fuertemente acoplado)
Se consideran varias aplicaciones
Se considera una aplicacin por a la vez (pueden pertenecer a
diferentes usuarios).
vez.
Objetivo: acelerar la ejecucin de Objetivo: permitir que varios
usuarios
trabajen
en
forma
una aplicacin
cooperativa
Se ejecutan sobre arquitecturas Se ejecutan sobre arquitecturas
abiertas
y
homogneas
con
memoria heterogneas,
dinmicas
compartida
Sistema Distribuido
Sistema Distribuido
Ventajas:
Desventajas:
El programador es responsable de la
comunicacin
Difcil mapear datos basados en memoria
global
Mltiples procesadores
1
2
3
2
4
5
6
5
7
8
9
8
Total 15 t. en 1 procesador
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
Terminologa
Terminologa
Comunicacin:
Sincronizacin:
Terminologa
El tamao de un proceso puede ser
descrito por su granularidad
Terminologa
Granularidad gruesa:
Comunicacin y sincronizacin
Cmputo
Comunicacin y sincronizacin
Mucho computo. Mas oportunidad para mejorar la performance.
Terminologa
Granularidad fina:
Comunicacin y sincronizacin
Cmputo
Comunicacin y sincronizacin
Cmputo
Comunicacin y sincronizacin
Cmputo
Comunicacin y sincronizacin
Ms overhead de comunicacin.
Menos oportunidad para mejorar la performance.
Granularidad
Aumentar la granularidad:
Reduce los costos de creacin de procesos y
comunicacin entre procesos
Reduce el nmero de procesos concurrentes y la
cantidad de paralelismo
Terminologa
Super-lineal
Speed-up lineal
Speed-up tpico
Numero de procesadores P
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 Amadahls
Todo cmputo posee una porcin
serial s que no puede ser
paralelizable. Sin importar la
cantidad de procesadores P que se
utilicen, el tiempo de ejecucin no
puede ser menor que s.
Tpo secuencial
f
No se puede paralelizar:
Lmite de la mejora que se
puede obtener
Ley Amadahls
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
Administracin de tareas
Tiempo de Start-up
Sincronizacin
Comunicacin de datos
Software overhead, threads,
Tiempo de finalizacin de las tareas
Balance de carga
Cmputo - Comunicacin
Balance de Carga
Tiempo ocioso
Menor utilizacin
No funciona bien
en sistemas
distribuidos
Terminologa
Escalabilidad: Habilidad de demostrar
un incremento en el speed-up
paralelo
Escalabilidad
Hardware
Al incrementar el nmero mquinas
mejora la performance del sistema
Escalabilidad con tamao de problema fijo
Analizar cmo vara el tiempo paralelo y la eficiencia al aumentar P
Escalabilidad
Software
Al aumentar el tamao del
problema no decrece la
performance del sistema
Terminologa
Costo de comunicacin =
Latencia + Bandwith
Terminologa
Portabilidad
Clasificacin de las
Computadoras Paralelas
SISD
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
Memoria Compartida
Memoria Distribuida
Mecanismos de locks y
Sincronizacin.
Responsabilidad del
programador
Mecanismos de
comunicacin
Cada procesador ve
datos diferentes
Distribucin de datos
M.Distribuida
Escalable
No
MIMD- Hardware
Topologas de M. Compartida
Arquitectura basada en BUS
MIMD- Hardware
Topologas de M. Distribuida
Redes basadas en BUS
Muy sencillas
No escalables
Redes basadas en SW
Rpidas
Jerarqua de SW: Fat-tree
Fat-Tree
Condiciones de competencia:
Pasaje de Mensajes
Y
Creacin de Procesos
Creacin de procesos
Esttica:
Creacin de procesos
Dinmica:
tiempo
spawn()
Proceso 1
Proceso 2
Pasaje de mensajes
Ejemplo
Ejemplo
Podemos dividir el
Trabajo entre dos
procesadores
P1 enva datos a P2
P1 y P2 computan
P2 enva datos a P1
Ejemplo
Patrones de comunicacin
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
Datos
Longitud del mensaje
Direccin destino y posiblemente un tag
No utiliza buffers
tiempo
tiempo
send()
Solicita envo
Acknowledgement
send()
Mensaje
recv()
recv()
tiempo
send()
recv()
Depende del
tamao del
buffer
Soluciones
Broadcast
Un
Broadcast
Si queremos paralelizar:
Scatter
Process 1
dato
dato
Process N
dato
Accin
buf
Cdigo
scatter
scatter
scatter
Gather
Process 1
dato
dato
Process N
dato
Accin
buf
Cdigo
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
19
30
11
K= 433
27
P5
3
Reduction
Ejemplo
Ejemplo en Paralelo
Paralelismo de datos
Paralelismo de tareas
y
Diseo de software paralelo
Paralelismo de Datos
Se caracteriza por la ejecucin 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
ejecucin
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
P1
P2
Paralelismo de datos
16 14 2
10 6
16 2
12 20 30 16 2
Suma = 0.
18 16 14 24 18
Paralelismo de datos
secuencial
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
Divide y Vencers
suma
x(m-1)n/m-1.. Xn-1
Divide y Vencers
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 );
//enva s nmeros al slave Pi
result = 0;
for( i=0;i<m; i++ )
recv( &part_sum, Pany);
sum += part_sum;
SLAVE
recv( numbers, s, Pmaster );
part_sum = numbers[0];
for( i=0; i< s; i++ )
part_sum += numbers[i];
send( &part_sum, Pmaster );
Con broadcast?
Etapa 2: Cmputo:
Etapa 3: Comunicacin:
Etapa 4: Cmputo:
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
Tareas finales
estar activo
en un nivel del rbol
P3
2m sub-tareas
2m+1-1 procesos
P2
P4
P5
P6
P4
P0
P0
P2
P1
P2
P4
P3
P4
P6
P5
P6
P7
Es un algoritmo de particin
Funciona bien si los nmeros se distribuyen
uniformemente en un intervalo [0..a-1]
El intervalo se divide en m regiones denominadas
buckets
Para ubicar un nmero en un bucket, i/m y usar el
resultados para identificar el bucket
--------------------------------------------
buckets
sort
merge
Algoritmo secuencial:
Se divide el nmero i por el nmero de buckets y me
da el identificador del bucket donde lo debera ubicar.
Es decir los nmeros se distribuyen uniformemente en
buckets. Si los nmeros estn uniformemente
distribuidos, en cada bucket hay n/m nmeros.
Eso permite balancear la carga de trabajo asignada a
cada bucket.
luego se ordenan en forma secuencial los nmeros de
cada buckets y finalmente se aplica una funcin de
merge
--------------------------------------------
buckets
sort
merge
Buckets
grandes
sort
merge
Alternativa 2:
Se divide la secuencia en m regiones, una para cada procesador.
Cada procesador genera buckets ms pequeos y distribuye los
nmeros en esos buckets.
Estos buckets pequeos se vacan en P buckets mas grandes para
ser ordenados.
Para ello c/procesador enva un bucket chico a c/u de los otros
procesadores (bucket i al procesador i)
Nmeros desordenados
-------------------------------------------procesadores
sort
merge
D&V Paralelo
Tipos de Algoritmos (Input-Output)
Los problemas se pueden clasificar segn sus
datos de entrada y salida
Comn-Comn (CC): las variables paralelas de
entrada y salida son comunes (replicadas) a todos
los procesadores del grupo
Comn-Privado (CP): las variables paralelas de
entrada son comunes (replicadas) pero las
variables resultado quedan privadas en cada
procesador
Privada-Comn (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
Caso de estudio:
Algoritmo shortest path
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 vrtices
vj
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)
}
Computacin
Pipelined
Pipelined
T0
T1
T2
T3
Pipelined
2.
3.
Pipelined
Si se ejecuta mas de una instancia
del problema
procesos
1.
P4
Inst.1 Inst.2
P3
P2
Pipelined
1.
2.
d4
P0
P1
P0
P1
P2
P1
P2
P3
P1
P2
tiempo
P3
P4
d3
d2
d1
P0
P0
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
P1
P2
P3
P4
P5
Tipos de Paralelismos
Threads
JOIN
JOIN
JOIN
Threads
IP
code
Heap
IP
code
Heap
stack
threads
Rutinas de
Interrupcin
stack
IP
Files
Files
stack
Proceso
Rutinas de
Interrupcin
Threads
Threads: Ejemplo
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 Crticas
- Locks
Locks
Pthread
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);
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?
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
Hardware
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
------------
Solucin 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
nmeros 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);
}
OpenMP
#include <omp.h>
OpenMP: clausuras
OpenMP
OMP_NUM_THREADS Indica el
nmero 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);
Ejemplo
#pragma omp for[clause[,] clause]...
{
ciclo for
}
FOR
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
OpenMP
SECTION
OpenMP: Directivas
#pragma omp single: slo un thread
ejecuta el cdigo
OpenMP: Directivas
#pragma omp master: el cdigo a
continuacin 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