• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Paralela1
 

Paralela1

on

  • 1,303 views

Clase 1

Clase 1

Statistics

Views

Total Views
1,303
Views on SlideShare
813
Embed Views
490

Actions

Likes
0
Downloads
27
Comments
0

1 Embed 490

http://compinformatidf.wordpress.com 490

Accessibility

Upload Details

Uploaded via as Adobe PDF

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Paralela1 Paralela1 Presentation Transcript

    • Programación y Computación paralela Cap. 1: Introducción Glen Rodríguez glen.rodriguez@gmail.com Tomado de clases de Rajesh Nishtala (U.Berkeley) 1
    • Por qué se necesita gran poder de cómputo? 2
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • Modelo climático de alta resolución NERSC-3 – P. Duffy, et al., LLNL
    • 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
    • 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
    • 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
    • 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
    • Por qué las computadoras poderosas son paralelas? 14
    • 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
    • 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
    • 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
    • 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
    • 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
    • Performance en el test LINPACK 20
    • 21
    • Por qué escribir programas paralelos rápidos es difícil? 22
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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
    • 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)
    • 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
    • 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