3. Unidades de medida en HPC
• High Performance Computing (HPC) se mide en:
- Flop: floating point operation
- Flops/s: floating point operations per second
- Bytes: para el tamaño de datos en memoria (una variable flotante de
double precision ocupa 8 bytes)
• Generalmente hablamos de millones, billones, …
Mega Mflop/s = 106 flop/sec Mbyte = 220 = 1048576 ~ 106 bytes
Giga Gflop/s = 109 flop/sec Gbyte = 230 ~ 109 bytes
Tera Tflop/s = 1012 flop/sec Tbyte = 240 ~ 1012 bytes
Peta Pflop/s = 1015 flop/sec Pbyte = 250 ~ 1015 bytes
Exa Eflop/s = 1018 flop/sec Ebyte = 260 ~ 1018 bytes
Zetta Zflop/s = 1021 flop/sec Zbyte = 270 ~ 1021 bytes
Yotta Yflop/s = 1024 flop/sec Ybyte = 280 ~ 1024 bytes
• Ver en www.top500.org la lista de supercomputadoras
más veloces
3
4. Simulación: tercer pilar de la ciencia
• Paradigma tradicional en Ciencia e Ingeniería:
1) Elaborar la teoría o crear un paper.
2) Hacer experimentos o construir un sistema.
• Limitaciones:
- Muy difícil – ej: grandes estructuras para experimentos.
- Muy caro – construir un auto o avión de pueba.
- Muy lento –verificar efecto de medicinas en animales.
- Muy peligroso -- armas, experimentos climáticos.
• Paradigma de la ciencia computacional:
3) Usar sistemas HPC para simular el fenómeno
- Basandose en leyes físicas y en métodos numéricos.
4
5. Algunos Computos difíciles
• Ciencia
- Modelo del clima global
- Biología: genómica; “protein folding”; diseño de medicinas
- Modelos astrofísicos
- Química computacional
- Ciencia de los materiales por computadora
• Ingeniería
- Diseño de semiconductores
- Terremotos y modelos de edificaciones
- Dinámica de fluidos por computadora (diseño de aviones)
- Combustión (diseño de motores)
- Simulación de choques de autos
• Negocios
- Modelos económicos y financieros
- Proceso de transacciones, servicios web y motores de búsqueda
• Defensa
- Test por simulación de armas nucleares
- Criptografía
5
6. Impacto económico de la HPC
• Aerolíneas:
- Optimización de logística a escala mundial en sistemas paralelos.
- Ahorros: aprox. $100 millones anuales por aerolínea.
• Diseño de autos:
- Las grandes compañías usan HPC (500 o más CPUs) para:
- CAD-CAM, test de choques, integridad estructural y
aerodinámica.
- Ahorros: aprox. $1000 millones al año.
• Industria de Semiconductores:
- Usan HPC grandes (500 o más CPUs) para
- Simulación de dispositivos electrónicos y validación lógica.
- Ahorros: aprox. $1000 millones al año.
• Finanzas:
- Ahorros: aprox. $15000 millones al año en hipotecas en USA.
6
7. Modelo global del clima
• Problema a computar:
f(latitud, longitud, elevación, tiempo)
temperatura, presión, humedad, velocidad del viento
• Enfoque:
- Discretizar el dominio, ej:, un punto cada 10 km
- Diseñar el algoritmo que prediga el clima en t+δt dado el clima
en el tiempo t
• Usos:
- Predecir eventos
importante como el Niño
- Estudiar políticas de
estándares ambientales
fuente: http://www.epm.ornl.gov/chammp/chammp.html
7
8. Computación del clima
• Una parte es modelar el flujo de fluidos en la atmósfera
- Resolver las ecuaciones de Navier-Stokes
- Aprox. 100 Flops por punto en la malla con δt de 1 minuto
• Requisitos de computo:
- Para tiempo real, 5 x 1011 flops en 60 seconds = 8 Gflop/s
- Predecir el clima para la TV (7 días en 24 horas) 56 Gflop/s
- Predecir el clima para papers (50 años en 30 días) 4.8 Tflop/s
- Para usar en negociaciones (50 años en 12 horas) 288 Tflop/s
• Si se dobla la resolución de la malla, el computo
aumenta por un factor de 8x u 16x
• Modelos “de estado del arte” necesitan más partes:
oceanos, hielos polares, elevación del terreno, ciclo del
carbono, geoquímica, contaminantes, etc.
• Modelos actuales no llegan a tanto.
8
10. Simulación para 100 años
• Demostración del
Community Climate Model
(CCSM2)
• Una simulación a 1000
años muestra una
tendencia estable y de
largo plazo.
• Se usaron 760,000 horas
de CPU
• Se ve el cambio de la
temperatura.
• Warren Washington and Jerry Meehl, National Center for
Atmospheric Research; Bert Semtner, Naval Postgraduate
School; John Weatherly, U.S. Army Cold Regions Research and
Engineering Lab Laboratory et al.
• http://www.nersc.gov/news/science/bigsplash2002.pdf
10
11. Modelo del clima en el Earth Simulator System
El ESS se empezó a crear en 1997 para estudiar el cambio
de clima global y el calentamiento global.
Su construcción se completó en Febreo del 2002 y
empezó a trabajar desde el 1ro de Marzo del 2002
35.86Tflops (87.5% de la performance pico) obtenida en el
benchmark Linpack (máquina más rápida del mundo del 2002 al
2004).
26.58Tflops obtenidos con los simuladores del clima global.
11
12. Dinámica de agujeros negros binarios
• Núcleo de grades supernovas colapsan en agujeros negros.
• En el centro de los agujeros negros el tiempo espacio se altera.
• Son un test crucial para teorías de gravedad –
de la relatividad gral. a gravedad cuántica.
• Observación indirecta – muchas galaxias
tiene un agujero negro en su centro.
• Ondas gravitacionales muestras al agujero
negro y sus parámetros.
• Agujeros negros binarios son una gra
fuente de ondas gravitacionales.
• Su simulación es muy compleja –
el espacio tiempo se altera !
12
13. Paralelismo en Análisis de datos
• Hallar información entre grandes cantidades de datos.
• Para qué husmear en grandes cantidades de datos?:
- Hay alguna dolencia inusual en una ciudad?
- Qué clientes son más propensos a tratar de hacer fraude
al seguro de salud?
- Cuándo conviene poner en oferta la cerveza?
- Qué tipo de publicidad mandarte a la casa?
• Hay data que se recolecta y guarda a gran velocidad
(Gbyte/hour)
- Sensores remotos en un satélite
- Telescopios
- Microarrays generando data de genes
- Simulaciones generando terabytes de datos
- Espionaje (NSA)
13
15. Tendencia tecnológica: Capac. del microproc.
Moore’s Law
2X transistores/Chip cada 1.5 años
Es la “Ley de Moore” Gordon Moore (co-fundador de
Intel) predijo en 1965 la densidad
de transistores en chips de
Microprocesadores son semiconductores se duplicaría
cada vez más chicos, más o menos cada 18 meses.
densos y poderosos. fuente: Jack Dongarra
15
16. Impacto de la miniaturización de dispositivos
• Qué pasa cuando el tamaño del transistor dçse achica en
un factor de x ?
• El reloj de la CPU aumenta en x porque los cables entre
transistores son más cortos
- Realmente es menos que x, debido a la disipación de
energía
• Nro. De Transistores/area sube en x2
• Tamaño del “dado” crece
- Generalmente en un factor cercano a x
• Poder de proceso del chip sube cerca de x4 !
- Del cuál x3 se dedica al paralelismo o localidad
16
17. Transistores por Chip
• Mejora en Transistores por chip • Mejora en reloj de CPU
100,000,000 1000
10,000,000
R10000 100
Pentium
Clock Rate (M Hz)
1,000,000
Transistors
i80386
10
i80286 R3000
100,000 R2000
i8086 1
10,000
i8080
i4004
0.1
1,000
1970 1980 1990 2000
1970 1975 1980 1985 1990 1995 2000 2005
Year
Year
17
18. Pero hay límites: Creciente costo y
dificultad de fabricación
• 2da ley de Moore (ley
de Rock)
Demo de
CMOS de
0.06
micrones
18
19. Más Limites: Qué tan rápida puede ser una comput. serial?
CPU secuencial
r = 0.3
de 1 Tflop/s, 1 mm
Tbyte
• Considerar un CPU secuencial de 1 Tflop/s :
- Data debe viajar cierta distancia r, para ir de la
memoria a la CPU.
- Para conseguir 1 elemento de data por ciclo, o sea
1012 veces por segundo, a la velocidad de la luz c =
3x108 m/s. Tenemos que r < c/1012 = 0.3 mm.
• Como poner 1 Tbyte en un área de 0.3 mm x 0.3 mm:
- Cada bit ocupa 1 Angstrom2, o el tamaño de un
átomo.
• No se puede. Sólo queda usar paralelismo.
19
23. Principios de Computación paralela
• Encontrar suficiente paralelismo (Ley de Amdahl)
• Granularidad
• Localidad
• Balance de carga
• Coordinación y sincronización
• Modelamiento de la performance
Estos detalles hacen que la BUENA programación
paralela sea más difícil que la secuencial.
23
24. Paralelismo automático en computadoras modernas
• A nivel de bit
- Dentro de operaciones de punto flotante, etc.
• A nivel de instrucción (ILP)
- Ejecutar múltiples instrucciones en un solo ciclo de reloj
• A nivel de memoria del sistema
- Computar y leer/escribir en memoria a la vez
• A nivel del Sistema Operativo
- Muchos jobs corriendo en paralelo en SMPs
Todos tienen un límite – para excelente perfomance, el
humano debe identificar, calendarizar y coordinar tareas
paralelas. 24
25. Encontrar suficiente Paralelismo
• Suponer que solo una parte de un programa se puede
paralelizar.
• Ley de Amdahl
- Si s es la fracción de trabajo no paralelizable (secuencial), entonces
(1-s) es la fracción paralelizable
- P = número de procesos
Speedup(P) = Tiempo(1)/Tiempo(P)
<= 1/(s + (1-s)/P)
<= 1/s
• Aún si la parte paralela se acelera (speeds up) a la
perfección, la performance está limitada por la parte
secuencial.
25
26. Costos del Paralelismo
• Si hay bastante parte paralelizable, la mayor barrera
para lograr buen speedup es el costo del paralelismo.
• Ese costo incluye:
- Costo de empezar un hilo o un proceso
- Costo de comunicar data compartida
- Costo de sincronización
- Computación extra o redundante
• Cada uno de ellos pueden estar en el rango de ms (=
millones de flops) en algunos sistemas.
• Solución de Compromiso: los algoritmos necesitan
unidades de trabajo suficientemente grandes para correr
rápido en paralelo (o sea, grano grueso), pero no tan
grandes que no hay suficiente trabajo paralelo o trabajo
para menos procesadores.
26
27. Localidad y Paralelismo
Jerarquía del almacenamiento en memoria
Proc Proc Proc
Cache Cache Cache
L2 Cache L2 Cache L2 Cache
interconexiones
Posibles
L3 Cache L3 Cache L3 Cache
Memoria Memoria Memoria
• Las memorias grandes son lentas, las rápidas son las chicas
• La memoria es rápida y grande en promedio
• Los procesadores paralelos, colectivamente, tienen mayor caché y memoria
- El acceso lento a data “remota” se llama “comunicación”
• Los algoritmos deben tratar de trabajar mayormente en data local.
27
28. Gap entre Procesador-DRAM (latencia)
1000 CPU
µProc
60%/año
“Ley de Moore”
Performance
100 Gap de performance
entre CPU y DRAM:
(crece 50% / año)
10
DRAM
DRAM
7%/año
1
1987
1988
1989
1990
1993
1994
1995
1996
1997
1980
1981
1983
1991
1992
1998
2000
1982
1984
1985
1986
1999
Año
28
29. Desbalance de carga
• El desbalance de carga es el tiempo que algunos CPUs
en el sistema están ociosos debido a:
- Insuficiente paralelismo (durante esa fase)
- Trabajos de tamaño desigual
• Ejemplos de trabajos desiguales
- Adaptarse a “partes interesantes del dominio”
- Cómputos con estructuras de árbol (ej: ajedrez)
- Problemas no estructurados.
• Se necesita algoritmos para balancear la carga.
29
30. Mejorando la Performance real
Performance pico crece exponencialmente,
como dice la ley de Moore
En los 90s, creció 100x; en esta década,
crecerá 1000x 1,000
Pero la eficiencia (performance relativa al Performance pico
pico de hardware) ha caído 100
Era 40-50% en las supercomputadoras
Teraflops
vectoriales de los 90s
Ahora entre 5-10% en muchas 10 Gap de
Performance
supercomputadoras paralelas
El gap se cierra vía ...
1
Métodos matemáticos y algoritmos que logran
mejor performance en un solo CPU y escalan Performance real
a miles de CPUs
0.1
Modelos de programación más eficientes y 1996 2000 2004
mejores herramientas (compiladores, etc.)
30
31. Midiendo la Performance
• Peak advertised performance (PAP)
- La que dice el fabricante. Máximo teórico.
• LINPACK Benchmark
- El programa “hello world” en computación paralela
- Resolver Ax=b por Eliminación Gaussiana.
• Gordon Bell Prize winning applications performance
- La mejor combinación de aplicación/algoritmo/plataforma
• Performance sostenida promedio
- Lo que se puede esperar razonablemente en el caso de aplicaciones
comunes.
Ojo, muchas veces se confunden unas evaluaciones por
otras, incluso en libros y revistas
31
32. Qué deberíamos sacar de este curso?
• Cuándo es útil el cómputo paralelo?
• Saber las diferentes opciones de hardware en
computación paralela.
• Modelos de programación (software) y herramientas.
• Algunas aplicaciones y algoritmos paralelos
• Análisis y mejora de Performance (si alcanza tiempo)
Ver: http://www-unix.mcs.anl.gov/dbpp/
32
33. Optimizando multiplicación de matrices
• Es una operación importante en la ciencia
- Aparece en muchos algoritmos de álgebra lineal
• Si se optimiza, los métodos se pueden copiar en otros
problemas.
• Si se optimiza, sería muy útil
• Problema muy estudiado
• POR AHORA, estudiemos el caso en una computadora
secuencial
33
34. Notas en almacenamiento de la matriz
• Una matriz es un array 2-D de elementos, pero en la
memoria todo es “1-D”
• Convenciones para almacenamiento de matrices
- por columna (tipo Fortran); A(i,j) en posición A + i + j*n
- por fila (tipo C); A(i,j) en posición A + i*n + j
- recursivo Matriz por columna en memoria
Por Columna Por fila
0 5 10 15 0 1 2 3
1 6 11 16 4 5 6 7
2 7 12 17 8 9 10 11
3 8 13 18 12 13 14 15
4 9 14 19 16 17 18 19
La fila azul en la matriz
Cache lines
• Usaremos por columna está guardada en las
líneas rojas 34
Fuente: Larry Carter, UCSD
35. Modelo simple de memoria a usar
• Asumir que hay solo 2 niveles de memoria, rápida y lenta
• Toda la data está al inicio en la memoria lenta
- m = número de elemento de memoria (words) movidos entre la memoria
rápida y la lenta. Intensidad
- tm = tiempo por operación en memoria lenta computacional:
- f = número de operaciones aritméticas eficiencia de algor.
- tf = tiempo por operación aritmética (memoria rápida) << tm
- q = f / m número promedio de flops por acceso a memoria lenta
• Tiempo mínimo= f* tf, si toda la data está en mem. rápida.
• Tiempo real
Balance de
- f * tf + m * tm = f * tf * (1 + tm/tf * 1/q) máquina:
eficiencia
de máquina
• Mayor q es tpo. más cercano al mínimo f * tf
- q ≥ tm/tf necesario para obtener al menos 50% de velocidad pico
35
36. Multiplicando Matriz y vector
{implementa y = y + A*x}
for i = 1:n
for j = 1:n
y(i) = y(i) + A(i,j)*x(j)
A(i,:)
= + *
y(i) y(i) x(:)
36
37. Multiplicando Matriz y vector
{read x(1:n) de memoria lenta en memoria rápida}
{read y(1:n) de memoria lenta en memoria rápida}
for i = 1:n
{read fila i de A de memoria lenta en memoria rápida}
for j = 1:n
y(i) = y(i) + A(i,j)*x(j)
{write y(1:n) de memoria rápida a memoria lenta}
• m = número de ops. en memoria lenta = 3n + n2
• f = número de ops. aritméticas = 2n2
• q = f / m ~= 2
• Esta multiplicación esta limitada por la velocidad de la
memoria lenta
37
38. Multiplicando Matriz y vector
• Para matriz de tamaño nxn = 1000x1000
• Tiempo
- f * tf + m * tm = f * tf * (1 + tm/tf * 1/q)
- = 2*n2 * tf * (1 + tm/tf * 1/2)
• Para tf y tm, según data de R. Vuduc (tesis)
- http://bebop.cs.berkeley.edu/pubs/vuduc2003-dissertation.pdf
- tm = mínima latencia de memoria / words por cache-line
Clock Peak Mem Lat (Min,Max) Linesize t_m/t_f
MHz Mflop/s cycles Bytes Balance
Ultra 2i 333 667 38 66 16 24.8 de máq.
Ultra 3 900 1800 28 200 32 14.0 (q debe
Pentium 3 500 500 25 60 32 6.3 ser mínimo
Pentium3M 800 800 40 60 32 10.0 esto para
Power3 375 1500 35 139 128 8.8 obtener
Power4 1300 5200 60 10000 128 15.0 50% del
Itanium1 800 3200 36 85 32 36.0 pico)
Itanium2 900 3600 11 60 64 5.5
38
39. Multiplicación de matrices por método trivial
{implementa C = C + A*B}
for i = 1 to n
for j = 1 to n
for k = 1 to n
C(i,j) = C(i,j) + A(i,k) * B(k,j)
Algoritmo tiene 2*n3 = O(n3) Flops y opera
en 3*n2 words de memoria
q puede llegar hasta 2*n3 / 3*n2 = O(n)
C(i,j) C(i,j) A(i,:)
B(:,j)
= + *
39
40. Multiplicación de matrices por método trivial
{implementa C = C + A*B}
for i = 1 to n
{read fila i de A en memoria rápida}
for j = 1 to n
{read C(i,j) en memoria rápida}
{read columna j de B en memoria rápida}
for k = 1 to n
C(i,j) = C(i,j) + A(i,k) * B(k,j)
{write C(i,j) a memoria lenta}
C(i,j) C(i,j) A(i,:)
B(:,j)
= + *
40
41. Multiplicación de matrices por método trivial
Número de accesos a memoria lenta:
m = n3 para leer cada columna de B n veces
+ n2 para leer cada fila de A una vez
+ 2n2 para leer y escribir cada elemento de C una vez
= n3 + 3n2
Así, q = f / m = 2n3 / (n3 + 3n2)
~= 2 para n grande, no hay mejora respecto a mult. matriz por
vector
C(i,j) C(i,j) A(i,:)
B(:,j)
= + *
41
42. Ejemplo en una RS/6000 de IBM
n=12000 tomaría
1095 años
6
T = N4.7
log cycles/flop 5
4
3
2 n= 2000 tomó 5 días
1
0
-1 0 1 2 3 4 5
log Problem Size
O(N3) sería una recta horizontal
Performance se ajusta experimentalmente a O(N4.7)
Fuente: Larry Carter, UCSD 42
43. Ejemplo en una RS/6000 de IBM
Fallo de página cada iteración
6
5
log cycles/flop
Fallo de TLB cada
4
iteración
3
2 Fallo de Cache cada
16 iteraciones Fallo de página cada 512 iteraciones
1
0
0 1 2 3 4 5
log Problem Size
Fuente: Larry Carter, UCSD 43
44. Multiplicación de matrices por bloques
Sean A,B,C matrices de N-por-N de b-por-b sub-bloques donde
b=n / N es el tamaño de bloque
for i = 1 to N
for j = 1 to N
{read block C(i,j) en memoria rápida}
for k = 1 to N
{read block A(i,k) en memoria rápida}
{read block B(k,j) en memoria rápida}
C(i,j) = C(i,j) + A(i,k) * B(k,j) {multiplicar un bloque}
{write block C(i,j) a memoria lenta}
C(i,j) C(i,j) A(i,k)
= + * B(k,j)
44
45. Multiplicación de matrices por bloques
m es cantidad de elementos que viajan entre las memorias
la matriz tiene nxn elementos, y NxN bloques de tamaño bxb
f es el número de ops. punto flotante, 2n3 en este caso
q = f / m mide la eficiencia del algoritmo en la memoria
LUEGO:
m = N*n2 lee cada bloque de B N3 veces (N3 * b2 = N3 * (n/N)2 = N*n2)
+ N*n2 lee cada bloque de A N3 veces
+ 2n2 lee y escribe cada bloque de C una vez
= (2N + 2) * n2
Entonces q = f / m = 2n3 / ((2N + 2) * n2)
~= n / N = b para n grande
Se puede mejorar la performance aumentando el tamaño de bloque b
45
Puede ser más rápido que la mult. matriz por vector (q=2)
46. Analizando lo anterior…
El algoritmo con bloques tiene intensidad computacional q ~= b
• A mayor b, más eficiencia del algoritmo
• Límite: los 3 bloques de A,B,C deben caber en memoria rápida
(cache), así que no pueden ser demasiado grandes
• Si la memoria rápida tiene tamaño Mfast
3b2 <= Mfast, so q ~= b <= sqrt(Mfast/3)
• Para construir una máquina que
multiplique matrices a 1/2 de la required
velocidad pico del hardware, t_m/t_f KB
necesitamos una memoria rápida: Ultra 2i 24.8 14.8
Mfast >= 3b2 ~= 3q2 = 3(tm/tf)2 Ultra 3 14 4.7
• Tamaño razonable para cache, pero Pentium 3 6.25 0.9
no para los registros. Pentium3M 10 2.4
Power3 8.75 1.8
Power4 15 5.4
Itanium1 36 31.1
Itanium2 5.5 0.7
46
47. Basic Linear Algebra Subroutines (BLAS)
• Interface estándar en el mundillo de HPC (en evolución)
- www.netlib.org/blas, www.netlib.org/blas/blast--forum
• Fabricantes proporcionan versiones optimizadas para su hardware
• Historia
- BLAS1 (1970s):
- Operaciones de vectores: producto dot, saxpy (y=α*x+y), etc
- m=2*n, f=2*n, q ~1 or less
- BLAS2 (mediados 1980s)
- Operaciones matriz con vector: multiplicación, etc
- m=n^2, f=2*n^2, q~2, menos costo
- Un poco más rápido que BLAS1
- BLAS3 (finales 1980s)
- Operaciones matriz matriz: multiplicación, etc
- m <= 3n^2, f=O(n^3), o sea que q=f/m puede ser tan grande como n, por lo
que BLAS3 es potencialmente mucho más rápido que BLAS2
• Buenos algoritmos usan BLAS3 si se puede (LAPACK & ScaLAPACK)
- Ver www.netlib.org/{lapack,scalapack}
47
