sistemas de ecuaciones lineales glen d. rodríguez r. algoritmos paralelos basado en material de j....
TRANSCRIPT
Sistemas de Ecuaciones Lineales
Glen D. Rodríguez R.
Algoritmos Paralelos
Basado en material de J. Demmel
Eliminación Gaussiana y matrices densas
Algebra lineal densa “Gaussian Elimination” (GE) para resolver Ax=b Optimizar GE para máquinas secuenciales con
caché Usando multiplicación matriz x matriz (BLAS)
LAPACK Partición de la Data en comp.paralelas GE paralelo ScaLAPACK Problemas de Eigenvalue
Sca/LAPACK Overview
Exitos usando Sca/LAPACK
Cosmic Microwave Background Analysis, BOOMERanG collaboration,
MADCAP code (Apr. 27, 2000).
ScaLAPACK
Muy usado: Adoptado por Mathworks, Cray,
Fujitsu, HP, IBM, IMSL, NAG, NEC, SGI, …
>56M visitas en la web de Netlib (incl. CLAPACK, LAPACK95)
Descubrimientos hechos a través de la solución de sistemas de ec. densos Artículo en Nature sobre el
universo plano usó ScaLAPACK Otros en Physics Review B
también lo usaron 1998 Premio Gordon Bell www.nersc.gov/news/reports/
newNERSCresults050703.pdf
Usos de Solución de sistemas de ecuaciones lineales
Resistencia de estructuras (ing. civil) Stress, tensiones en piezas mecánicas Electromagnetismo, electrodinámica Circuitos eléctricos Ing. de tráfico. DSP, óptica (de-convolución) Economía y finanzas.
Motivación (1)3 problemas básicos de Alg. Lineal
1. Ecuaciones Lineales: Resolver x en Ax=b
2. Mínimos cuadrados: Hallar x que minimiza
||r||2 ri2 donde r=Ax-b
Estadística: Ajustar datos a funciones simples
3a. Eigenvalues: Hallar , x tal que Ax = x Análisis de vibraciones (terremotos, circuitos)
3b. Singular Value Decomposition: ATAx=2x Ajuste de data, Obtención de información
Muchas variaciones para diferentes estructuras de A Simétrica, definida positiva, en bandas, …
Motivación (2) Por qué A densa, en vez de A dispersa?
Muchas matrices grandes son dispersas, pero …
Alg. Densos son más fáciles de entender Algunas aplicaciones producen matrices densas
grandes LINPACK Benchmark (www.top500.org)
“Qué tan rápida es tu computadora?” = “Qué tan rápido resuelves Ax=b denso?”
Alg. de matriz dispersa grande con frecuencia producen menores (pero aún grandes) problemas densos.
Records en la solución de Sist. Densos (2006)
GigaflopsMáquina n=100 n=1000 Any n Pico
IBM BlueGene/L 281K 367K (131K procs) (281 Teraflops) (n=1.8M)NEC SX 8 (8 proc, 2 GHz) 75.1 128 (1 proc, 2 GHz) 2.2 15.0 16
…
www.netlib.org
Palm Pilot III .00000169 (1.69 Kiloflops)
Records en la solución de Sist. Densos (2011/2)www.netlib.org
4 AMD Athlon K7 500 Mhz (256 Mb) – (2x) 100 Mbs Switched – 2 NICs per node (channel bonding)
8 Duals Intel PIII 550 Mhz (512 Mb) - Myrinet
Compaq 64 nodes (4 ev67 667 Mhz processors / node) AlphaServer SC
Performance (Gflops) , Problem size on 4 nodes.
GRID 2000 5000 8000 10000
1 x 4 1.28 1.73 1.89 1.95
2 x 2 1.17 1.68 1.88 1.93
4 x 1 0.81 1.43 1.70 1.80
Performance (Gflops), Problem size on 8- and 16-processors grids.
GRID 2000 5000 8000 10000 15000 20000
2 x 4 1.76 2.32 2.51 2.58 2.72 2.73
4 x 4 2.27 3.94 4.46 4.68 5.00 5.16
GRID N 1/2 Nmax Rmax (Gflops) Efficiency
1 x 1 150 6625 1.136 1.000
2 x 2 800 13250 4.360 0.960
4 x 4 2300 26500 17.00 0.935
8 x 8 5700 53000 67.50 0.928
16 x 16 14000 106000 263.6 0.906
Eliminación Gaussiana (GE) en Ax=b Añadir múltiplos de cada fila a las demás para volver A en
triangular sup. Resolver el sist.triang. resultante Ux = c por sustitución
… para cada columna i… “cerear” debajo de la diagonal añadiendo múltiplos de la fila i a las de abajofor i = 1 to n-1 … para cada fila j debajo de la fila i for j = i+1 to n … añadir un multiplo de la fila i a la fila j tmp = A(j,i); for k = i to n A(j,k) = A(j,k) - (tmp/A(i,i)) * A(i,k)
0...0
0...0
0.0
000
0...0
0...0
0.0
0...0
0...0
0...0
After i=1 After i=2 After i=3 After i=n-1
…
Refinando el algoritmo GE (1) Versión inicial
Elimina computación de constante tmp/A(i,i) de loop interno
… para cada columna i… “cerear” debajo de la diagonal añadiendo múltiplos de fila i a las de abajofor i = 1 to n-1 … para cada fila j debajo de fila i for j = i+1 to n … añadir un múltiplo de la fila i a la fila j tmp = A(j,i); for k = i to n A(j,k) = A(j,k) - (tmp/A(i,i)) * A(i,k)
for i = 1 to n-1 for j = i+1 to n m = A(j,i)/A(i,i) for k = i to n A(j,k) = A(j,k) - m * A(i,k)
m
Refinando el algoritmo GE (2) Última versión
No computa lo que ya se conoce: ceros bajo la diagonal en la columna i
for i = 1 to n-1 for j = i+1 to n m = A(j,i)/A(i,i) for k = i+1 to n A(j,k) = A(j,k) - m * A(i,k)
for i = 1 to n-1 for j = i+1 to n m = A(j,i)/A(i,i) for k = i to n A(j,k) = A(j,k) - m * A(i,k)
No calcula los ceros
m
Refinando el algoritmo GE (3) Última versión
Guarda los factores m bajo la diagonal en el espacio donde irían los ceros para uso posterior
for i = 1 to n-1 for j = i+1 to n m = A(j,i)/A(i,i) for k = i+1 to n A(j,k) = A(j,k) - m * A(i,k)
for i = 1 to n-1 for j = i+1 to n A(j,i) = A(j,i)/A(i,i) for k = i+1 to n A(j,k) = A(j,k) - A(j,i) * A(i,k)
Guarda m aquí
m
Refinando el algoritmo GE (4) Última versión
for i = 1 to n-1 for j = i+1 to n A(j,i) = A(j,i)/A(i,i) for k = i+1 to n A(j,k) = A(j,k) - A(j,i) * A(i,k)
• Partir el loop
for i = 1 to n-1 for j = i+1 to n A(j,i) = A(j,i)/A(i,i) for j = i+1 to n for k = i+1 to n A(j,k) = A(j,k) - A(j,i) * A(i,k)
Guardar todos los m aquí antes de modificar el resto de la matriz
Refinando el algoritmo GE (5) Última versión
Rápido usando operaciones de matrices (BLAS)
for i = 1 to n-1 A(i+1:n,i) = A(i+1:n,i) * ( 1 / A(i,i) ) A(i+1:n,i+1:n) = A(i+1:n , i+1:n ) - A(i+1:n , i) * A(i , i+1:n)
for i = 1 to n-1 for j = i+1 to n A(j,i) = A(j,i)/A(i,i) for j = i+1 to n for k = i+1 to n A(j,k) = A(j,k) - A(j,i) * A(i,k)
Qué computa en realidad la GE?
Llamemos a la matriz triangular inferior de multiplicadores m como M, y hagamos L = I+M
Llamemos al triangulo superior de la matriz final como U Lema (Factorización LU): Si el algoritmo anterior termina (no
hay división por cero) entonces A = L*U Solución de A*x=b usando GE
Factorizar A = L*U usando GE (costo = 2/3 n3 flops) Resolver L*y = b para y, usando substitución (costo = n2 flops) Resolver U*x = y para x, usando substitución (costo = n2 flops)
Por lo tanto A*x = (L*U)*x = L*(U*x) = L*y = b como se desea
for i = 1 to n-1 A(i+1:n,i) = A(i+1:n,i) / A(i,i) A(i+1:n,i+1:n) = A(i+1:n , i+1:n ) - A(i+1:n , i) * A(i , i+1:n)
Problemas con el alg. GE básico Qué pasa si algún A(i,i) es cero? O es muy pequeño?
Resultado inválido (div.por cero), o “inestable”, se necesita pivotear
Se computan operaciones BLAS 1 o BLAS 2, pero sabemos que las BLAS 3 (mult. de matrices) es más rápida (clase anterior…)
for i = 1 to n-1 A(i+1:n,i) = A(i+1:n,i) / A(i,i) … BLAS 1 (escala un vector) A(i+1:n,i+1:n) = A(i+1:n , i+1:n ) … BLAS 2 (update en rango 1) - A(i+1:n , i) * A(i , i+1:n)
PicoBLAS 3
BLAS 2
BLAS 1
Pivotear en GE
• A = [ 0 1 ] falla por que no se puede dividir entre A(1,1)=0 [ 1 0 ]
• Pero resolver Ax=b es facilísimo! • Cuando elemento diagonal A(i,i) es diminuto (no sólo cero),
el algoritmo puede terminar pero dar una respuesta completamente errada
• Inestabilidad numérica• La causa es el error de redondeo a punto flotante
• Cura: usar Pivot (intercambiar filas de A) tal que A(i,i) sea grande
GE con Pivot Parcial (GEPP)• Pivoteo Parcial: intercambiar filas tal que A(i,i) es la mayor en su columna
for i = 1 to n-1
Hallar y guardar k donde |A(k,i)| = max{i <= j <= n} |A(j,i)| … o sea, el mayor element en el resto de la columna i if |A(k,i)| = 0 exit con advertencia que A es singular, o casi singular elseif k != i intercambiar filas i , k de A end if A(i+1:n,i) = A(i+1:n,i) / A(i,i) … cada cociente cae en [-1,1] A(i+1:n,i+1:n) = A(i+1:n , i+1:n ) - A(i+1:n , i) * A(i , i+1:n)
• Lema: este algoritmo computa A = P*L*U, donde P es una matriz de permutación.
• Es numéricamente estable en la práctica• Para más detalles ver código LAPACK en
http://www.netlib.org/lapack/single/sgetf2.f
Problemas con el alg. GE básico Qué pasa si A(i,i) es cero? O es muy pequeño?
Resultado inválido, o “inestable”, así que se debe pivotear Se computan operaciones BLAS 1 o BLAS 2, pero sabemos que
las BLAS 3 (mult. de matrices) es más rápida (clase anterior…)for i = 1 to n-1 A(i+1:n,i) = A(i+1:n,i) / A(i,i) … BLAS 1 (escala un vector) A(i+1:n,i+1:n) = A(i+1:n , i+1:n ) … BLAS 2 (update en rango 1) - A(i+1:n , i) * A(i , i+1:n)
PicoBLAS 3
BLAS 2
BLAS 1
Convirtiendo BLAS2 a BLAS3 en GEPP Bloques
Usado para optimizar mult.matrices Más difícil en GE por las dependencias de data en GEPP
GRAN IDEA: Updates retrasados Salvar varios updates consecutivos BLAS2 a una “matriz relegada” Aplicar muchos updates simultáneamente en una operación
BLAS2
La misma idea funciona en otras partes del alg. lineal Quedan preguntas por resolver….
Primer enfoque: necesito escoger un tamaño de bloque b Algoritmo guarda y aplica b updates b debe ser suficientemente pequeño de tal forma que la sub matriz
activa consistente en b columnas de A quepa en el cache b debe ser suficientemente grande para que BLAS3 sea rápido
GEPP en bloques (www.netlib.org/lapack/single/sgetrf.f)
for ib = 1 to n-1 step b … Procesa b columnas end = ib + b-1 … Apunta al final del bloque de b columns aplica versión BLAS2 de GEPP para obtener A(ib:n , ib:end) = P’ * L’ * U’ … LL denota la parte triangular inferior de A(ib:end , ib:end) + I
A(ib:end , end+1:n) = LL-1 * A(ib:end , end+1:n) … update siguientes b filas de U A(end+1:n , end+1:n ) = A(end+1:n , end+1:n ) - A(end+1:n , ib:end) * A(ib:end , end+1:n) … aplica updates retrasados con una mult.matrices … de dimensiones w x b , b x w
Eficiencia del GEPP en bloques
0
0.2
0.4
0.6
0.8
1
1.2
Cnvx C4(1 p)
Cnvx C4(4 p)
Cray C90(1 p)
Cray C90(16 p)
Alpha RS6000 SGI PC
Eff
icie
ncy
Speed (LAPACK/LU) / Speed(best effort)Speed(Matmul) / HW PeakSpeed(LAPACK LU) / Speed(MatMul)
Vista general de LAPACK y ScaLAPACK
Librería estándar para algebra lineal densa y en bandas Sistemas lineales: A*x=b Problemas de mínimos cuadrados: minx || A*x-b ||2 Problemas de Eigenvalues: Ax =x, Ax = Bx Descomposición en valores singulares (SVD): A = UVT
Alg. reorganizados para usar lo más posible BLAS3 Base de librerías matemáticas en muchos sistemas,
Matlab, etc … Aún faltan más mejoras por implementar
Proyectos para maestrías, doctorados?
Performance de LAPACK (n=1000)
Performance de Eigen-values, SVD, etc.
Performance de LAPACK (n=100)
Eficiencia es mucho menor para matrices más chicas
Paralelizando la GE Pasos de la paralelización
Descomposición: identificar suficiente trabajo paralelo, pero no demasiado Asignación: balance de carga entre procesos Coordinación: comunicación y sincronización Mapeo: qué procesadores ejecutan qué tareas?
Descomposición En la parte BLAS 2, casi cada flop en el loop interno puede hacerse en
paralelo, así que con n2 procs., necesito 3n pasos paralelos
Esto es grano muy fino, mejor es llamar a mult.matrices locales Necesario usar mult.matrices paralelo
Asignación Que procesadores son responsables de qué submatrices?
for i = 1 to n-1 A(i+1:n,i) = A(i+1:n,i) / A(i,i) … BLAS 1 (escala un vector) A(i+1:n,i+1:n) = A(i+1:n , i+1:n ) … BLAS 2 (update rango 1) - A(i+1:n , i) * A(i , i+1:n)
Diferentes particiones de data para GE paralelo
Mal balance de carga:P0 ocioso luego den/4 pasos
Mejor balance, pero difícil usar BLAS2 o BLAS3
Se puede negociar balance de carga y performance BLAS2/3 cambiando b, pero la factorización del bloque de columnas es el cuello de botella
Difícil de direccionar
0123012301230123
0 1 2 3 0 1 2 3
0 1 2 3
3 0 1 2
2 3 0 1
1 2 3 0
1) Bloque de columnas 1D 2) Columnas 1D cíclicas
3) Bloques cíclicos de columnas 1D 4) Bloques de diagonales
El mejor!
0 1 0 1 0 1 0 12 3 2 3 2 3 2 30 1 0 1 0 1 0 12 3 2 3 2 3 2 30 1 0 1 0 1 0 12 3 2 3 2 3 2 30 1 0 1 0 1 0 12 3 2 3 2 3 2 3
6) Bloques cíclicos de filas y columnas 2D
0 1 2 3
Mal balance de carga:P0 ocioso luego den/2 pasos
0 1
2 35) Bloques de filas y columnas 2D
b
Revisión: GEPP con BLAS 3 (con bloques)
for ib = 1 to n-1 step b … Procesa matriz de b columnas end = ib + b-1 … Apunta alfinal del bloque de b columnas aplica ver.BLAS2 de GEPP para onbtener A(ib:n , ib:end) = P’ * L’ * U’ … LL denota parte triangular inferior de A(ib:end , ib:end) + I
A(ib:end , end+1:n) = LL-1 * A(ib:end , end+1:n) … update sgtes.b filas de U A(end+1:n , end+1:n ) = A(end+1:n , end+1:n ) - A(end+1:n , ib:end) * A(ib:end , end+1:n) … aplicar updates retrasados con una mult.matrices … de dimensiones w x b, x w
BLAS 3
Bloque cíclico de Filas y Columnas
• Procesadores y bloques de matrices están distribuidos en un array 2d
•Array de procesadores prow x pcol•Bloques de matrices brow x bcol
• Paralelismo “pcol” veces en cualquier columna, y llamadas a BLAS2 y BLAS3 en matrices de tamaño brow x bcol
• Cuello de botella serial es menos problemático
• prow pcol y brow bcol posible, es más deseable
0 1 0 1 0 1 0 1
2 3 2 3 2 3 2 3
0 1 0 1 0 1 0 1
2 3 2 3 2 3 2 3
0 1 0 1 0 1 0 1
2 3 2 3 2 3 2 3
0 1 0 1 0 1 0 1
2 3 2 3 2 3 2 3
bcol
brow
GE distribuido con Bloques cíclicos 2D
• Tamaño de bloque b en el algoritmo y los tamaños de bloque brow y bcol en la partición satisfacen b=bcol.
• Regiones sombreadas indican procesadores ocupados con computación o comunicación.
• No es necesario tener barrera entre pasos sucesivos del algoritmo, ej: pasos 9, 10, y 11 se pueden hacer en “paralelo”
Distributed GE with a 2D Block Cyclic LayoutContador de columnas
Contador de filas
Mu
lt. m
atri
ces
de
ver
de
= v
erd
e -a
zul *
ro
sa
–1
PDGEMM = PBLAS mat.mul.
Observaciones:• Para N fijo, si P crece, Mflops
crece pero menos que 100% de eficiencia
• Si P es fijo, si N crece, Mflops (eficiencia) crece
DGEMM = rutina BLAS para mat.mul.Máxima velocidad para PDGEMM = # Procs * velocidad DGEMM
Observaciones:• Eficiencia siempre es por lo
menos 48%• Para N fijo, si P crece, eficiencia
disminuye • Para P fijo, si N crece, eficiencia
crece
Revisión de MatMul paralela
• Se quiere problemas grandes por procesador
Como no puede correr más rápido que el loop interno (PDGEMM), hacemos:
Eficiencia = Veloc(PDGESV)/Veloc(PDGEMM)
Observaciones:• Eficiencia muy por encima de 50% para
problemas suficientemente grandes• Para N fijo, si P crece, eficiencia
disminuye (igual que en PDGEMM)• Para P fijo, si N crece, eficiencia crece
(igual que en PDGEMM)• Según la tabla inferior, el coso de
resolver• Ax=b es aprox. la mitad del mat.mul.
para matrices suficientemente grandes.
• Del contador de flops se deduce que
debería ser (2*n3)/(2/3*n3) = 3 veces más rápida, pero la comunicación lo hace algo más lento.
PDGESV = LU paralelo de ScaLAPACK
Modelos de performance ScaLAPACK (1)
Contador de operaciones de ScaLAPACKtf = 1
tm =
tv = brow=bcolP = prow = pcol
Modelos de performance ScaLAPACK (2)
(LU)
(Cholesky)
Comparar Predicciones y Mediciones
Escalabilidad de LAPACK y ScaLAPACK
Problemas “unilaterales” son escalables En GE, A factorizada como el producto de 2 matrices A = LU por medio
de pre-multiplicar A por una secuencia de matrices más simples Asintóticamente es 100% BLAS3 LU (“Linpack Benchmark”) Cholesky, QR
Problemas “Bilaterales” som menos escalables A factorizada como producto de 3 matrices por medio de pre y post
multiplicación 50% BLAS2, no llega a 100% BLAS3 Eigenproblemas, SVD descomposición de valor singular
Eigenproblemas asimétricos son peores
Problemas de banda estrecha son los peores (para llevarlo a BLAS3 o paralelizar)
Ecuaciones lineales y eigenproblemas www.netlib.org/{lapack,scalapack}
Algoritmos Recursivos También usa updates retrasados, pero organizados en
forma diferente Puede explotar particiones de data recursiva
3x speedups en mínimos cuadrados para matrices altas y delgadas
En teoría, la performance de la jerarquía de memoria es óptima
Referencias “Recursive Block Algorithms and Hybrid Data Structures,” Elmroth,
Gustavson, Jonsson, Kagstrom, SIAM Review, 2004 http://www.cs.umu.se/research/parallel/recursion/
Algoritmo LU : 1: Partir la matriz en 2 rectangulos (m x n/2) si solo queda 1 columna, escale por el reciproco del pivot y “return”
2: Aplicar el algoritmo LU a la parte izquierda
3: Aplique transformaciones a la parte derecha (solución triangular A12 = L-1A12 y mult. matrices A22=A22 -A21*A12 )
4: Aplicar algoritmo LU a la parte derecha
GE usando un Algoritmo Recursivo
L A12
A21 A22
F. Gustavson y S. Toledo
La mayor parte del computo es multiplicarmatrices de tamaño n/2, n/4, n/8, …
Source: Jack Dongarra
Factorizaciones recursivas Tan precisas como los métodos convencionales Mismo número de operaciones Se forman bloques de tamaño variable en forma
automática Sólo operaciones BLAS nivel 1 y 3!
Simplicidad de expresión Potencialmente eficientes pero a la vez “indiferente” al
caché Pero no se debería llevar la recursión hasta el extremo de 1
columna!
La formulación recursiva es sólo un reajuste de algoritmos más viejos del LINPACK
DGEMM ATLAS & DGETRF Recursive
AMD Athlon 1GHz (~$1100 system)
0
100
200
300
400
500 1000 1500 2000 2500 3000
Order
MFl
op/s
Pentium III 550 MHz Dual Processor LU Factorization
0
200
400
600
800
500 1000 1500 2000 2500 3000 3500 4000 4500 5000
Order
Mflo
p/s
LAPACK
Recursive LU
Recursive LU
LAPACK
Dual-processor
Uniprocessor
Source: Jack Dongarra
Limites de los algortimos recursivos Dos clases de descomposiciones de matrices densas “Unilaterales”
Secuencia de operaciones sencillas aplicadas en la izquierda de la matriz
GE: A = L*U o A = P*L*U GE simétrica: A = L*D*LT
Cholesky, sólo matrices simétricas: A = L*LT
Descomposición QR para mínimos cuadrados: A = Q*R Puede acercarse a 100% BLAS 3 Susceptible de recursión
“Bilaterales” Secuencia de operaciones sencillas aplicadas en ambos lados,
alternadamente Algoritmos de Eigenvalores, SVD Por lo menos ~25% BLAS 2 Enfoque recursivo imposible, difícil? Algunos progresos la última decada: SVD (25% vs 50%
BLAS2)
Out-of-core significa que la matriz reside en disco; muy grande para entrar completa en la RAM
Mucho más difícil evitar efecto de latencia del disco
QR más fácil que LU por que no hace falta pivotear para QR
Algoritmos “Out of Core”
Source: Jack Dongarra
Resolviendo Sist.Ec.Linealesprovenientes de Ec.Dif.Parc.
Repaso de “Fuentes de paralelismo” Sistemas de eventos discretos:
Ejs: “Game of Life,” simulación de circuitos lógicos.
Sistemas de partículas: Ejs: bolas de billar, simulación de dispositivos
semiconductores, galaxias. Variables agregadas dependientes de parámetros continuos:
EDOs, ejs: simulación de circuitos (Spice), mecánica estructral, cinética química.
Variables contínuas dependientes de parámetros continuos: EDPs, ejs: calor, elasticidad, electrostática.
Un fenómeno dado puede ser modelado en múltiples niveles.
Muchas simulaciones combinan más de una técnica.
Repaso: Resolviendo EDPs° Problemas hiperbólicos (ondas):
Onda sonora (posición, time) Usan iteración en el tiempo en forma explícita Solución en cada punto depende de los vecinos en Δt
anterior Problemas elípticos (estado estable):
Potencial electrostático (posición) Todo valor depende de todos lo demás valores Localidad es más difícil de hallar que en los problemas
hiperbólicos Problemas parabólicos (dependientes del tiempo):
Temperatura (posición, tiempo) Involucra una solución elíptica cada Δt
Nos enfocaremos en los elípticos Ejemplo canónico es la ec. Poisson
2u/x2 + 2u/y2 + 2u/z2 = f(x,y,z)
Ec. Poisson aparece en muchos lados
Potencial electrostático o gravitacional: Potencial (posición) Flujo de calor: Temperatura (posición, tiempo) Difusión: Concentración (posición, tiempo) Flujo de fluidos: Velocidad, Presión ,Densidad (posición,
tiempo) Elasticidad: Tensión, estiramiento (posición, tiempo) Variaciones de Poisson tienen coeficientes variables
3D: 2u/x2 + 2u/y2 + 2u/z2 = f(x,y,z)
2D: 2u/x2 + 2u/y2 = f(x,y)
1D: d2u/dx2 = f(x)
f representa las fuentes; además se necesita condiciones de frontera
Relación de ec. Poisson con la Gravedad, Electrostática
Fuerza en la partícula en (x,y,z) debido a una partícula en (0,0,0) 3D: -(x,y,z)/r3, where r = (x2 +y2 +z2 ) 2D: -(x,y)/r2, where r = (x2 + y2 )
Fuerza es gradiente del potencial V (con signo opuesto) 3D: V = -1/r, V = (V/x, V/y, V/z) 2D: V = log r, V = (V/x, V/y)
V satisface la ec. de Poisson (tarea)
Ec. Poisson en 1D: 2u/x2 = f(x)
2 -1
-1 2 -1
-1 2 -1
-1 2 -1
-1 2
T =2-1 -1
Grafo y “estencil”
Discretizar d2u/dx2 = f(x) en la malla regular
ui = u(i*h)
Para conseguir
[ u i+1 – 2*u i + u i-1 ] / h2 = f(x)
Se resuelve como Tu = -h2 * f Para array desconocido u donde
Ec. Poisson en 2D Similar al caso 1D, pero la matriz T se vuelve:
3D es análogo
4 -1 -1
-1 4 -1 -1
-1 4 -1
-1 4 -1 -1
-1 -1 4 -1 -1
-1 -1 4 -1
-1 4 -1
-1 -1 4 -1
-1 -1 4
T =
4
-1
-1
-1
-1
Grafo y “estencil”
6-1 -1
-1
-1-1
-1
Algoritmos para Poisson 2D (3D) (N = n2 (n3) vars)
Algoritmo Serial PRAM Memoria #Procs LU denso N3 N N2 N2
LU bandas N2 (N7/3) N N3/2 (N5/3) N (N4/3)
Jacobi N2 (N5/3) N (N2/3) N N Inv.Explicit N2 log N N2 N2
Gradiente Conj. N3/2 (N4/3) N1/2(1/3) *log N N N SOR r/n N3/2 (N4/3) N1/2 (N1/3) N N LU dispersa N3/2 (N2) N1/2 N*log N (N4/3) N FFT N*log N log N N N Multigrid N log2 N N N MINIMO N log N N
PRAM es un modelo de paralelismo ideal con costo de comunicación despreciable
Referencia: James Demmel, Applied Numerical Linear Algebra, SIAM, 1997.
Resumen de Algoritmos en malla n x n grid (n x n x n) (1)
El orden de presentación es así (aprox.):Del más lento al más rápido en máquinas secuenciales.Del más general (trabaja en cualquier matriz) al más especializado
(trabaj en matrices “parecidas” a T).LU denso: GE; trabaja en cualquier matriz N-by-N.LU en bandas: aprovecha el hecho que T es ≠ de cero solo en las N1/2
(N2/3) diagonales más cercanas a la diagonal principal.Jacobi: básicamente hace mult. matriz vector por T en el loop interno de un algoritmo iterativo.
Inverso explícito: Asume que queremos resolver muchos problemas con la misma T, así que se precalcula y guarda inv(T) “gratis”, y se multiplica por ella (pero todavía caro!).
Gradiente conjugada: usa mult. matriz vector, como Jacobi, pero aprovecha propiedades matemáticas de T que Jacobi no aprovecha.
SOR (successive over-relaxation) rojo/negro: Variación de Jacobi que explota otras propiedades de T. Usado en multigrid.
LU disperso: GE explotando la estructura particular de ceros de T.FFT (fast Fourier transform): Trabaja sólo en matrices muy similares a T.Multigrid: trabaja en matrices similares a T, que vienen de ec. elípticas.MINIMO: estadística del mejor Serial (tiempo para tener la respuesta en output); del mejor paralelo (tiempo para combinar los N outputs).
Resumen de Algoritmos en malla n x n grid (n x n x n) (2)
Dimensión = N = n2 en 2D (=n3 en 3D)Ancho de banda = BW = n en 2D (=n2 en 3D)Número de Condición= k = n2 en 2D ó 3D#its = número de iteracionesSpMV = Sparse-matrix-vector-multiply
LU densa: costo = N3 (serial) ó N (paralelo, con N2 procs)
LU en bandas: costo = N * BW2 (serial) ó N (paralelo con BW2 procs)
Jacobi: costo = costo(SpMV) * #its, #its = k.
Gradiente conjugada: costo = (costo(SpMV) + costo(prod vectorial))* #its, #its = sqrt(k)
SOR roja/negra: costo = costo(SpMV) * #its, #its = sqrt(k)
Algoritmos Iterativos necesitan diversos supuestos para análisis de convergencia
Comentarios en mallas en la práctica
Mallas regulares 1D, 2D, 3D Importantes como bloques básicos para fromar mallas más
complicadas Se discutirán primero
Mallas en la prácticas son irregular con frecuencia Mallas compuestas, consistentes de vrias mallas regulares
“torcidas” unidas en los bordes Mallas no estructuradas, Con puntos de malla y coneccones
arbitrarias Mallas adaptativas, cambian en resolución (tamaño, finura) a
lo largo del proceso de solución para computar más donde se necesita más precisión
Malla compuesta en una estructura mecánica
Malla no estructurada: Perfil de ala 2D (NASA)
Refinamiento de malla adaptativa (AMR)
°Malla adaptativa alrededor de una explosión°Fuente: John Bell y Phil Colella en LBL
Malla irregular : tubo que se estrecha (multigrid)
Método de Jacobi Para derivar este método, escribir Poisson como:
u(i,j) = (u(i-1,j) + u(i+1,j) + u(i,j-1) + u(i,j+1) + b(i,j))/4 Hacer u(i,j,m) la aproximación de u(i,j) después de m
pasos
u(i,j,m+1) = (u(i-1,j,m) + u(i+1,j,m) + u(i,j-1,m) +
u(i,j+1,m) + b(i,j)) / 4 O sea, u(i,j,m+1) es un promedio ponderado de vecinos Motivación: u(i,j,m+1) escogido para satisfacer
exactamente la ecuación en el punto (i,j) Pasos para converger proporcional al tamaño del
problema, N=n2
Ver Lección 24 de www.cs.berkeley.edu/~demmel/cs267_Spr99
Por lo tanto, complejidad serial es de O(N2)
Convergencia de los métodos de vecinos Jacobi involucra la computación de los vecinos más
próximos en una malla nxn (N = n2) Así que toma O(n) = O(sqrt(N)) iteraciones para que la
información se propague
Ej., considerar un vector b = 0, excepto en el centro =1 La solución exacta es más o menos así:
Aún en el mejor caso, cualquier computación de vecinos más próximos toma n/2 pasos para propagarse en una malla nxn
Convergencia de los métodos de vecinos
Paralelizando el método de Jacobi Se reduce a una mult. matriz dispersa T (o casi) x vector
U(m+1) = (T/4 - I) * U(m) + B/4 Cada valor de U(m+1) puede ser calculado por separado
mantener 2 copias para las iteraciones m y m+1
Requiere que los valores en los límites se comuniquen Si cada procesador posee n2/p elementos para update Cantidad de data comunicada, n/p por vecino, es relativamente
poco si n>>p
Optimización de Localidad en Jacobi Update de vecinos más próximos en Jacobi tiene:
Buena localidad espacial (en mallas regulares): fila / columna Mala localidad temporal: pocos flops por punto
Ej: en mallas 2D: 4 sumas y 1 mult. vs. 5 lecturas y 1 escritura
Para proc. Paralelo o secuencial, se puede reducir ops. memoria por un aumento de cómputos Idea: para cada submalla, hacer varias iteraciones de Jacobi Tamaño de submalla se achica con cada iteración, así que
comenzar con la mayor Usado en uniprocesadores:
Rescheduling para Localidad, Michelle Mills Strout: www-unix.mcs.anl.gov/~mstrout
Algoritmos multigrid eficientes en uso de cache, Sid Chatterjee Y comput.paralelas, incluyendo “ajustes” de mallas
Ian Foster et al, SC2001
Nodos fantasmas redundantes en Jacobi
Resumen de optimización de jerarquía de memoria
Puede ser usado en mallas no estructuradas Tamaño de región fantasma (y cómputo redundante)
depende en velocidad de red o memoria vs. computación
Para computar verde
Copiar amarillo
Computar azul
Sobre-Relajación Sucesiva (SOR) Similar a Jacobi: u(i,j,m+1) se calcula como una
combinación lineal de los vecinos Coefic. numéricos y orden de updates son diferentes Basado en 2 mejoras respecto a Jacobi
Usa los “valores más recientes” disponible para u, por que estos valores posiblemente son más precisos Gauss Seidel
Actualizar el valor de u(m+1) “más agresivamente” a cada paso
Primero, note que cuando evaluamos secuencialmente u(i,j,m+1) = (u(i-1,j,m) + u(i+1,j,m) …
algunos de los valores para m+1 ya están disponibles u(i,j,m+1) = (u(i-1,j,latest) + u(i+1,j,latest) …
donde “latest” es ya sea m ó m+1
Gauss-Seidel Actualizar de izq.-a-der. en orden por filas, es el algoritmo
de Gauss-Seidelfor i = 1 to n
for j = 1 to n
u(i,j,m+1) = (u(i-1,j,m+1) + u(i+1,j,m) + u(i,j-1,m+1) + u(i,j+1,m)
+ b(i,j)) / 4
No puede paralelizarse, debido a las dependencias, así que mejor se usa el orden “rojo-negro”forall puntos negros u(i,j)
u(i,j,m+1) = (u(i-1,j,m) + …
forall puntos rojos u(i,j)
u(i,j,m+1) = (u(i-1,j,m+1) + …° Para un gráfico general, usar coloreo de grafos
° Se puede usar conjuntos independ. máximos repetidos para colorear° Grafo(T) es bipartito => 2 colores (rojo y negro)° Nodos para cada color pueden ser actualizados simultáneamente° Sigue siendo multip. vector matriz dispersa, usando submatrices
Sobre-Relajación Sucesiva (SOR) Este Gauss-Seidel rojo-negro converge dos veces más rápido que
Jacobi, pero hay el doble de pasos paralelos, así que es lo mismo en la práctica.
Para motivar la siguiente mejora, que el paso básico sea:
u(i,j,m+1) = u(i,j,m) + corrección(i,j,m) Si la “corrección” es una buena dirección a donde moverse, entonces
uno debería moverse aún más lejos en esa diección por un factor w>1
u(i,j,m+1) = u(i,j,m) + w * correction(i,j,m)
Se le llama “successive overrelaxation” (SOR) Paraleliza como Jacobi (Multip. vector matriz dispersa…) Se puede probar que w = 2/(1+sin(/(n+1)) ) da mejor convergencia
Número de pasos para converger = complejidad paralela = O(n), en vez del O(n2) de Jacobi
Complejidad Serial O(n3) = O(N3/2), en vez del O(n4) = O(N2) de Jacobi
Gradiente Conjugada (CG) para resolver A*x = b Este método puede usarse cuando la matriz A es
simétrica, o sea, A = AT
positiva definida, o sea cualquiera de estas 3 definiciones equivalentes: Todos los eigenvalores son positivos xT * A * x > 0 para todo vector x diferente de 0 Tiene una factorización Cholesky A = L*LT
El algoritmo mantiene 3 vectores x = la solución aproximada, mejorada tras cada iteración r = el residual, r = A*x - b p = dirección de búsqueda, o la gradiente conjugada
Costo de una iteración Mult. vector x matriz dispersa A (costo más importante) 3 productos vectoriales, 3 saxpy (escala*vector + vector)
Converge en O(n) = O(N1/2) pasos, como SOR Complejidad serial = O(N3/2) Complejidad paralela = O(N1/2 log N), factor log N del producto vectorial
Gradiente Conjugada (CG) para resolver A*x = b
Aproximación inicial x (“initial guess”,adivinada) r = b – A*x, j=1 Repetir
rho = rT*r … producto vectorial If j=1, p = r, else beta = rho/viejo_rho, p = r + beta*p, endif …
saxpy q = A*p … MatMul dispersa alpha = rho / pT * q … producto vectorial x = x + alpha * p … saxpy r = r – alpha * q … saxpy viejo_rho = rho; j=j+1
Hasta que rho sea lo suficientemente pequeño
Cómo escoger el algoitmo iterativo para Ax=b
Usar sólo mult.matriz-vector, prod.vect., saxpy, … Ver www.netlib.org/templates
Simétrica?
Definida?AT disponible?
Eigenvaloresconocidos?
trata CG trata CG oChebyshev
trata Minreso CG
trata QMRAlmacenam.es “caro”?
trata CGS oBi-CGSTAB
trata GMRES
N S
N
N
N
N
S
S
S
S
Sumario de Jacobi, SOR y CG Todos (Jacobi, SOR, y CG) hacen mult. Matriz dispersa x
vector Para Poisson, esto significa comunicación entre vecinos
más próximos en una malla n-by-n grid Toma n = N1/2 pasos para que la información viaje a lo
largo de una malla n-por-n Como la solución en un lado de la malla depende de la
data en el otro lado de la malla, se necesitan métodos que muevan la información más rápidos FFT Multigrid
Resolviendo la Ec.Poisson con FFT Motivación: expresar la solución continua como serie de Fourier
u(x,y) = i k uik sen( ix) sen( ky)
uik es el coeficiente de Fourier de u(x,y)
La ecuación de Poisson 2u/x2 + 2u/y2 = b se convierte en:
i k (-i2 - k2) uik sen( ix) sen( ky)
i k bik sen( ix) sen( ky)
° donde bik son los coefic. de Fourier de b(x,y)
Unicidad: como la serie de Fourier es única, uik = bik / (-i2 - k2)
Algoritmo continuo (Algoritmo discreto)° Computa coefic.Fourier bik del lado derecho de la ecuación
° Aplicar FFT 2D a los valores b(i,k) en la malla
° Computa coefic.Fourier uik de la solución° Divida cada transformada b(i,k) entre la función(i,k)
° Computa la solución u(x,y) usando los coef.Fourier° Aplicar la FFT inversa 2D a los valores de b(i,k) divididos
FFT Serial Hacer i=sqrt(-1) y que los índices de matrices y
vectores empiezen en 0. La Transformada discreta de Fourier de un vector v de
m elementos es: F*v Donde F es la matriz m*m definida como: F[j,k] = (j*k)
Donde es: = e (2i/m) = cos(2/m) + i*sen(2/m)
es un número complejo cuyo m-esima potencia m =1 y por ello es una raiz m-esima de la unidad
Ej., for m = 4: = i, = -1, = -i, = 1,
Usando la FFT 1D para filtrar Señal = sen(7t) + .5 sen(5t) en 128 puntos Ruido = número aleatorio no mayor que 0.75 Filtrar cereando los componentes FFT < 0.25
Usando la FFT 2D para compresión de imágenes Imagen = matriz 200x320 pixels (valores) Comprimido manteniendo el 2.5% más significativo de los
componente del FFT, descarta el resto. Similar idea usada en formato jpeg (transf. del coseno)
Transformadas relacionadas La mayor parte de aplicaciones necesitan multiplicar
por F y por la inversa de F.
Multiplicando por F y inversa(F) es esencialmente lo mismo (inversa(F) es la conjugada compleja de F dividida por n)
Para resolver la ec. Poisson y varias otras, usaremos las variaciones de la FFT La transformada del seno – parte imaginaria de F La transformada del coseno – parte real de F
Algoritmos similares, así que nos enfocaremos en la “forward FFT”
Algoritmo serial para la FFT
Computar la FFT de un vector v con m elementos, F*v
(F*v)[j] = F(j,k) * v(k)
= (j*k) * v(k)
= ( j)k * v(k)
= V(j) Donde V es el polinomio
V(x) = xk * v(k)
m-1
k = 0
m-1
k = 0m-1
k = 0
m-1
k = 0
Motivación del Multigrid Recordemos que Jacobi, SOR, CG, y cualquier otro
algoritmo basado en multiplicación de vector por matriz dispersa puede mover información sólo en una celda a la vez (por iteración) Mover la información a lo largo de una malla n x n toma por
lo menos n pasos
Se puede mostrar que disminuir el error por un factor fijo c<1 toma mínimo unos (log n) pasos límite asintótico mínimo Convergencia a un error fijo < 1 toma (log n ) pasos
Por lo tanto, converger en O(1) pasos (número constante de pasos para cualquier n) implica mover información a lo largo de la malla o grilla más rápido que una celda por paso
Motivación de Multigrid
Bases de Multigrid Algoritmo básico:
Reemplazar problema en una grilla o malla fina por una aproximación en una malla más gruesa (o malla burda)
Resolver aproximadamente el problema en la grilla gruesa, y usar la solución como una “starting guess” para el problema en malla fina, el cual es luego resuelto iterativamente
Resolver el problema en malla gruesa recursivamente, o sea, usando una aproximación más burda todavía, etc.
El éxito depende de que la solución en malla burda sea una buena aproximación a la solución de malla fina
Esa misma Gran Idea se usa en otros lados Reemplazar el problema fino por una aproximación burda
en forma recursiva. Multilevel Graph Partitioning (METIS):
Reemplazar el grafo a ser particionado por un grafo más burdo, obtenido por el “Maximal Independent Set”
Dada la partición de la grilla burda, refinar usando Kernighan-Lin
Barnes-Hut (y el método de Multipolo Rápido) para computar las fuerzas gravitacionales de n partículas en tiempo O(n log n): Aproximar partículas encajas por masa total, centro de gravedad Suficientemente bueno para partículas lejanas; para las cercanas,
dividir la caja en forma recursiva.
Todos estos ejemplos dependen de que la aproximación burda sea suficientemente buena (por lo menos si estamos lejos en la recursión)
Multigrid usa “Divide y Vencerás” en 2 formas
1ra forma: Resolver el problema en una malla dada invocando al Multigrid en
una aproximación burda para conseguir una buena “initial guess” a ser refinada después.
2da forma: Piense que el error es la suma de senos de diferente frecuencias. La misma idea que con el método de las FFT, pero no en forma
explícita. Cada llamada al Multgrid es responsable de suprimir los
coeficientes de los senos en el 50% de las frecuencias más bajas en el error (gráficos después)
Multigrid en 1D a grosso modo Considere una grilla 1D de tamaño 2m+1 por simplicidad Sea P(i) el problema de resolver la ec. discreta de Poisson
en una grilla 2i+1 en 1D. La ec.linear sería T(i) * x(i) = b(i) P(m) , P(m-1) , … , P(1) es la secuencia de problemas del más
fino al más burdo
Multigrid en 1D y 2D a grosso modo Considere la grilla 2m+1 en 1D (2m+1 x 2m+1 en 2D) por simplicidad Sea P(i) el problema de resolver Poisson discreto en una grilla 2i+1 en
1D (2i+1 by 2i+1 en 2D) El sistema linear sería T(i) * x(i) = b(i)
P(m) , P(m-1) , … , P(1) es la secuencia de problemas del más fino al más burdo
Operadores Multigrid Para el problema P(i) :
b(i) es el vector del lado derecho de la ecuación lineal y x(i) es la solución estimada actualmente
Todos los sgtes. operadores solo promedian valores en puntos aledaños en la grilla (así la info se mueve más rápido en mallas burdas)
El operador restricción R<i> mapea P(i) a P(i-1)
Redefine el problema en la grilla fina P(i) a la grilla burda P(i-1) Usa muestreo o promedios b(i-1)= R<i> (b(i))
El operador interpolación In<i-1> mapea la solución aprox. x(i-1) a x(i) Interpola la solución en la malla burda P(i-1) a la fina P(i)
x(i) = In<i-1>(x(i-1)) El operador solución S(i) toma P(i) y mejora la solución x(i)
Usa Jacobi “ponderado” o SOR en un solo nivel de la malla x mejorado (i) = S<i> (b(i), x(i))
Ambos en la grillade tamaño 2i-1
Algoritmo Multigrid de ciclo VFunction MGV ( b(i), x(i) )
… Resuelve T(i)*x(i) = b(i) dado un b(i) y un “initial guess” para x(i)
… retorna un x(i) mejorado
if (i = 1)
computar solución exacta de x(1) of P(1) solo 1 incógnita
return x(1)
else
x(i) = S<i> (b(i), x(i)) mejorar la solución
atenuando el error de alta frecuencia
r(i) = T(i)*x(i) - b(i) computar el residual
d(i) = In<i-1> ( MGV( R<i> (r(i)), 0 ) ) resolver T(i)*d(i) = r(i) recursivamente
x(i) = x(i) - d(i) corregir solución en grilla fina
x(i) = S<i> ( b(i), x(i) ) mejorar solución de nuevo
return x(i)
¿Por qué es llamado ciclo V? Miren el dibujo del orden de las llamadas Después de un tiempo, el ciclo V luce así:
Complejidad de un Ciclo V En una computadora serial
En cada punto del Ciclo V, el cómputo es del orden O(número de incógnitas)
Costo del nivel i-esimo es (2i-1)2 = O(4 i) Si el nivel más fino es el m, el tiempo total es: O(4 i) = O( 4 m) = O(# incógnitas)
En un sistema paralelo (PRAM) Con un procesador por cada punto de la grilla y
comunicación con costo despreciable, cada paso del ciclo V tarda un tiempo constante
Tiempo Total del ciclo V es O(m) = O(log #incógnitas)
m
i=1
Full Multigrid (FMG) Intuición:
Mejorar la solución haciendo varios ciclos V Evitar los costosos ciclos en grilla fina (alta frecuencia) El por qué funciona es para otro curso
Function FMG (b(m), x(m))
… retorna un x(m) mejorado dado un “initial guess”
computa la solución exacta x(1) del P(1)
for i=2 to m
x(i) = MGV ( b(i), In<i-1> (x(i-1) ) )
En otras palabras: Resolver el problema con 1 incógnita Dada la solución de un problema burdo P(i-1) , mapear los valores de
la solución como el guess inicial del problema P(i)
Resolver el problema más fino usando el ciclo V
Análisis del costo del Full Multigrid
Una V para cada llamada al Full MultiGrid Algunos usan Ws y otras formas
Tiempo serial: O(4 i) = O( 4 m) = O(# incógn.)
Tiempo PRAM: O(i) = O( m 2) = O( log2 # incógn.)
m
i=1
m
i=1
Complejidad de resolver la Ec.Poisson
Teorema: error después de una llamada al Full Multigrid<= c* error antes, donde c < 1/2, independentemente del # incógnitas
Corolario: se puede hacer que el error se vuelva < que cualquier tolerancia fija arbitraria en n número fijo de pasos, independentemente del tamaño de la grilla fina
Esta es la más importante propiedad de convergencia del MultiGrid, que lo diferencia de otros métodos, que convergen más lento en grillas grandes (finas)
Complejidad total es proporcional al costo de una llamada al FMG
El operador Solución S<i> - Detalles El operador Solución, S<i>, es un Jacobi
ponderado Considere este problema 1D
En el nivel i, el Jacobi puro hace:
x(j) := 1/2 (x(j-1) + x(j+1) + b(j) ) En su lugar, Jacobi ponderado hace:
x(j) := 1/3 (x(j-1) + x(j) + x(j+1) + b(j) )
En 2D, de forma similar se promedia la variable con sus vecinos.
Jacobi ponderado para amortiguar error de alta frecuencia
Error inicial “Áspero” Componentes de alta frec. son fuertes Norma = 1.65
Error después de 1 Jacobi “Suave” Comp. de alta frec. menos fuertes Norma = 1.06
Error después de 2 Jacobi “Más Suave” Débil comp. de alta frec. Norma = .92, No disminuirá mucho más
Multigrid como algoritmo Divide y Vencerás
Cada nivel en un ciclo V reduce el error en una parte del dominio de la frecuencia
El Operador Restricción R<i> - Detalles El operador restricción, R<i>, toma
un problema P(i) con vector del lado derecho b(i) y lo mapea en un problema más burdo P(i-1) con vector b(i-1)
En 1D, se promedia los valores de los vecinos xburdo(i) = 1/4 * xfino(i-1) + 1/2 * xfino(i) + 1/4 * xfino(i+1)
En 2D, se promedia con los 8 vecinos (N,S,E,W,NE,NW,SE,SW)
El operador Interpolación In<i-1>, toma una función en una malla burda P(i-1) , y produce una función en una malla fina P(i)
En 1D, se hace interpolación lineal a los vecinos burdos más próximos xfino(i) = xburdo(i) si el punto i de la grilla fina está también en la burda, si no: xfino(i) = 1/2 * xburdo(izquierda de i) + 1/2 * xburdo(derecha de i)
En 2D, la interpolación debe promediar los 4 vecinos (NW,SW,NE,SE)
Operador Interpolación In<i-1>: detalles
Convergencia del Multigrid en 1D
Convergencia del Multigrid en 2D
Multigrid paralela en 2D
Multigrid en 2D necesita computar con los vecinos más próximos (hasta 8) en cada nivel de la grilla
Empieza con una grilla de n=2m+1 x 2m+1 (aquí m=5)
Se usa una malla de procesadores de s x s (aquí s=4)
Modelo de performance del Multigrid 2D paralelo (ciclo V)
Asumir grilla de 2m+1 x 2m+1 puntos, n= 2m-1, N=n2
Asumir p = 4k procesadores, en una malla de 2k x 2k Procesadores comienzan con una sub grilla de 2m-k x 2m-k variables
Considerar que el Ciclo V empieza en el nivel m En los niveles del m al k del ciclo V, cada procesador trabaja. En los noveles k-1 al 1, algunos procesadores están ociosos, por que una
malla de 2k-1 x 2k-1 variables (o menos) no puede ocupar cada procesador Costo de un nivel en el ciclo V
If nivel j >= k, then costo =
O(4j-k ) …. Flops, proporcional al número de puntos/procesador
+ O( 1 ) …. Envía un número constante de mensajes a los procs. vecinos
+ O( 2j-k) …. Número de words (doubles o floats) enviados If nivel j < k, then costo =
O(1) …. Flops, proporcional al número de puntos/procesador
+ O(1) …. Envía un número constante de mensajes a los procs. vecinos
+ O(1) .… Número de words enviados
Sume para todos los niveles 1,2,… y todos los ciclos V en FMG!!!
Comparición de Métodos (en O(.)) # Flops # Mensajes # Words enviadas
MG N/p + (log N)2 (N/p)1/2 +
log p * log N log p * log N
FFT N log N / p p1/2 N/p
SOR N3/2 /p N1/2 N/p
SOR es más lento en todo Flops para el MG y FFT dependen de la precisión del
MG MG comunica menos data (ancho de banda) El total de mensajes (latencia) depende …
Este análisis simplista no nos dice si MG o FFT es mejor cuando >>
Consideraciones prácticas En la práctica, no tenemos que iterar hasta P(1)
En programa secuencial, las grillas más burdas son rápidas, pero en un prog.paralelo no. Considere 1000 puntos por procesador En 2D, las vars. a comunicar es 4xsqrt(1000) ~= 128, o 13% En 3D, sería 1000-83 ~= 500, o 50%
Ver Tuminaro y Womble, SIAM J. Sci. Comp., v14, n5, 1993 para el análisis de MG en nCUBE2 de 1024 procs. En grilla 64x64 vars., solo 4 por procesador
eficiencia de 1 ciclo V fue 0.02, y en FMG 0.008 En grilla 1024x1024
eficiencias fueron 0.7 (MG ciclo V) y 0.42 (FMG) Aunque su eficiencia paralela es peor, FMG es 2.6 veces más
rápido que sólo los ciclos V nCUBE tenía comunicación rápida, procesadores lentos
Multigrid en un Mesh adaptativo Para problemas con un
rango dinámico muy grande, se necesita otro nivel de refinamiento
Se construye un mesh adaptativo y se resuelve el multigrid (típicamente) en cada nivel
No se puede costear el uso de mesh fino en todo el problema
Aplicaciones multibloque Resolver el sistema de ecuaciones en una unión de
rectángulos subproblema de AMR
Ej:
Refinando el Mesh Adaptativo (AMR)
Usar estructuras de datos en el AMR El paralelismo usual es asignar grillas en cada nivel
a los procesadores Balance de carga
es problemático
Soporte para AMR Dominios en ciertos sistemas (Titanium, etc.) diseñados
para este problema Librerías: Kelp, Boxlib, y AMR++ Primitivas para ayudar con los updates en las fronteras
entre procesadores, etc.
Multigrid en un Mesh no estructurado Otro enfoque para
manejar trabajos variables es usar un mesh no estructurado que se refina más en las áreas de interes
Rectangular adaptivo o no estructurado? Fórmulas más simples
en el rectangular Supuestamente más
fácil de implementar (arrays) pero las fronteras tienden a dominar el código.
Hasta 39M variables en 960 procesadores,Con 50% eficiencia (Fuente: M. Adams)
Multigrid en una Mesh no estructurada Se necesita particionar el gráfico para paralelizar Recordar: Cuál es el propósito del Multigrid? Debe poderse crear grillas burdas (problema “duro”)
No se puede “saltearse los puntos uno si otro no” como antes Usar de nuevo “maximal independent sets” Como hacer que un grafo burdo aproxime bien al fino???
Se debe redefinir R<> y In<> Cómo convertir de grilla burda a fina y viceversa?
Definir S<> Cómo se computa la matriz? (fórmulas varían)
Procesar meshes burdas eficientemente Sería mejor limitarse a usar pocos procesadores en meshes
burdas? Debería cambiarse el “solver” en meshes burdas?
Fuente de Mesh no estructurada (elem.finito): Vertebra
Fuente: M. Adams, H. Bayraktar, T. Keaveny, P. Papadopoulos, A. Gupta
Multigrid para análisis elástico no lineal de hueso
Test mecánico depropiedades del material
Tomografía por computadora @ resolución 22 m
Imagen 3d FE mesh2.5 mm3
elementos 44 m
Hasta537M variables4088 Procesadores (ASCI White)70% eficiencia en paralelo
Fuente: M. Adams et al