El documento describe técnicas para mejorar el algoritmo de eliminación gaussiana (GE) para resolver sistemas de ecuaciones lineales densos. Explica cómo optimizar GE mediante el uso de operaciones de matrices (BLAS) en lugar de bucles anidados, almacenando factores de multiplicación en lugar de recalcularlos, y aplicando pivotaje parcial para mejorar la estabilidad numérica. También describe cómo GE en realidad calcula una factorización LU de la matriz y cómo esta factorización puede usarse para resolver el sistema de ecuaciones.

1. Programación y Computación
paralela (6)
Sistemas de Ec. lineales
Glen D. Rodríguez R.
Basado en material de J. Demmel
1

2. Tipos de datos de usuario en MPI
• En el programa de metropolis por ejemplo, queríamos
pasar 4 numeros (xmax, xmin, ymax, ymin) y tuvimos
que hacer 4 broadcast. Mejor mandarlo todos como 1
solo broadcast, pero esos números no son array.
• Creo un tipo de datos propio:
• int long_bloque[4]; /*en este caso, todos los elementos =1*/
• MPI_Aint desplaz[4]; /*elements: 0, direc.xmin-direc.xmax,
• Diecc.ymax-direc.xmax,direc.ymin-direc.xmax*/
• MPI_Datatype tipos[4]; /*todos son MPI_DOUBLE*/
• MPI_Datatype nuevotipo;
• MPI_Type_struct(4, long_bloque, desplaz, tipos, &nuevotipo);
• MPI_Type_commit(&nuevotipo);
• MPI_Bcast(variable,1,nuevotipo,…….)
2

3. Comunicadores en MPI
• Comunicador: colección de procesos que se pueden
mandar mensajes entre sí (“universo de comunicación”).
• Topologías: estructura que direcciona las
comunicaciones en un comunicador.
• Se usaron en el ejemplo del alg. de Fox
• En vez de Bcast(…,MPI_COMM_WORLD), hacer un
Bcast(…,Fila3). En el comunicador Fila3 hay q procesos
con rank del 0 al q-1. MPI_COMM_WORLD es un grupo
con comunicador de todos los procesos p>=q, con
rangos de 0 al p-1. Para un procesador generalemente
p!=q
• Cada comunicador tiene un identificador diferente.
• MPI_Group mundo;
• MPI_Group Fila1;
• MPI_Comm Comun_Fila1; 3

4. Sigue…
• q=sqrt(p)
• int rango[q];
• rango[0]=0; rango[1]=1; ….; rango[q-1]=q-1;
• MPI_Comm_group(MPI_COMM_WORLD, &mundo);
• MPI_Group_incl(mundo, q, rango, &Fila1);
• MPI_Comm_Create(MPI_COMM_WORLD, Fila1,
&Comun_Fila1);
• …..
• MPI_Bcast(….., Comun_Fila1);
• Se pueden crear varios comunicadores a la vez:
• MPI_Comm comun_mi_fila;
• int mi_fila;
• MPI_Comm_rank(MPI_COMM_WORLD, &mi_rango)
• mi_fila= mi_rango/q; /*division entera, no decimales*/
• MPI_Comm_split(MPI_COMM_WORLD, mi_fila, mi_rango,
&comun_mi_fila); 4

5. Sigue…
• Topologías: permiten enumerar los procesos de un
comunicador en formas nuevas, por ejemplo con do
índices en vez de uno.
• MPI_Comm comun_malla;
• int tamano_dim[2], wraping[2], reorden=1;
• tamano_dim[0]= tamano_dim[1]= q;
• wraping[0]= wraping[1]= 1;
• MPI_Cart_create(MPI_COMM_WORLD, 2, tamano_dim,
wraping, reorden, &comun_malla)
• El comunicador comun_malla tiene a todos los procesos
originales de MPI_COMM_WORLD pero reordenados, y
una numeración 2D cartesiana asociada.
• Para que un proceso sepa sus coordenadas:
• int coord[2]; int mi_rango_en_malla;
• MPI_Comm_rank(comun_malla, &mi_rango_en_malla);
5
• MPI_Cart_coords(comun_malla, mi_rango_en_malla, 2, coord);

6. Sigue…
• Para pasar de coordenadas a rango, usar
MPI_Cart_rank
• Para dividir esta malla en mallas más pequeñas, se usa
MPI_Cart_sub
• Ver ejemplo de Fox y como se usan estas funciones
6

7. 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
7

8. Sca/LAPACK Overview
8

9. Exitos usando Sca/LAPACK
• 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ó Cosmic Microwave Background
ScaLAPACK Analysis, BOOMERanG collaboration,
MADCAP code (Apr. 27, 2000).
• Otros en Physics Review B
también lo usaron
ScaLAPACK
• 1998 Premio Gordon Bell
• www.nersc.gov/news/reports/ne
wNERSCresults050703.pdf 9

10. 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, …
10

11. 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.
11

12. Records en la solución de Sist. Densos (2006)
www.netlib.org, click en Performance Database Server
Gigaflops
Má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
…
Palm Pilot III .00000169
(1.69 Kiloflops)
12

13. 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 abajo
for 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
. 0
. . . . . . .
. . .
. . . 0
. . . . 0
. . 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
13

14. Refinando el algoritmo GE (1)
• Versión inicial
… para cada columna i
… “cerear” debajo de la diagonal añadiendo múltiplos de fila i a las de abajo
for 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)
• Elimina computación de constante tmp/A(i,i) de loop
interno
for i = 1 to n-1
for j = i+1 to n
m = A(j,i)/A(i,i)
for k = i to n m
A(j,k) = A(j,k) - m * A(i,k)
14

15. Refinando el algoritmo GE (2)
• Última versión
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 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 m
A(j,k) = A(j,k) - m * A(i,k)
No calcula los ceros
15

16. Refinando el algoritmo GE (3)
• Última versión
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)
• 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
A(j,i) = A(j,i)/A(i,i)
for k = i+1 to n m
A(j,k) = A(j,k) - A(j,i) * A(i,k)
Guarda m aquí
16

17. 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 17

18. Refinando el algoritmo GE (5)
for i = 1 to n-1
• Última versión 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)
• 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)
18

19. Qué computa en realidad la GE?
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)
• 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
19

20. 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)
Pico
BLAS 3
BLAS 2
BLAS 1
20

21. 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
21

22. 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
22

23. 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)
Pico
BLAS 3
BLAS 2
BLAS 1
23

24. 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
24

25. 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
(For a correctness proof,
see on-line notes from
CS267 / 1996.)
25

26. Eficiencia del GEPP en bloques
Speed (LAPACK/LU) / Speed(best effort)
1.2 Speed(Matmul) / HW Peak
Speed(LAPACK LU) / Speed(MatMul)
1
0.8
Efficiency
0.6
0.4
0.2
0
Cnvx C4 Cnvx C4 Cray C90 Cray C90 Alpha RS6000 SGI PC
(1 p) (4 p) (1 p) (16 p)
26

27. 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 = UΣVT
• 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?
27

28. Performance de LAPACK (n=1000)
Performance
de Eigen-
values, SVD,
etc.
28

29. Performance de LAPACK (n=100)
Eficiencia es
mucho
menor para
matrices
más chicas
29

30. 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
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)
• 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?
30

31. Diferentes particiones de data para GE paralelo
Mal balance de carga: Mejor balance, pero
P0 ocioso luego de 0123012301230123
0 1 2 3 difícil usar BLAS2 o
n/4 pasos BLAS3
1) Bloque de columnas 1D 2) Columnas 1D cíclicas
Se puede negociar
balance de carga y 0 1 2 3
Difícil de
performance BLAS2/3 3 0 1 2 direccionar
cambiando b, pero la 0 1 2 3 0 1 2 3
factorización del 2 3 0 1
bloque de columnas es 1 2 3 0
el cuello de botella b
3) Bloques cíclicos de columnas 1D 4) Bloques de diagonales
0 1 0 1 0 1 0 1
Mal balance de carga: 0 1 2
0
3
1
2
0
3
1
2
0
3
1
2
0
3
1
P0 ocioso luego de 2 3 2 3 2 3 2 3 El mejor!
0 1 0 1 0 1 0 1
n/2 pasos 2 3 2 3 2 3 2 3 2 3
0 1 0 1 0 1 0 1
2 3 2 3 2 3 2 3 6) Bloques cíclicos de filas
5) Bloques de filas y columnas 2D y columnas 2D
31

32. 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
BLAS 3 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
32

33. Bloque cíclico de Filas y Columnas
• Procesadores y bloques de matrices
bcol
están distribuidos en un array 2d
brow 0
2
1
3
0
2
1
3
0
2
1
3
0
2
1
3
•Array de procesadores prow x pcol
0 1 0 1 0 1 0 1 •Bloques de matrices brow x bcol
2 3 2 3 2 3 2 3
• Paralelismo “pcol” veces en cualquier
0 1 0 1 0 1 0 1
2 3 2 3 2 3 2 3
0 1 0 1 0 1 0 1 columna, y llamadas a BLAS2 y
2 3 2 3 2 3 2 3
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 33

34. 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”
34

35. Distributed GE with a 2D Block Cyclic Layout
Contador de columnas
Contador de filas
35

36. –1
Mult. matrices de
36
verde = verde -azul * rosa

37. Revisión de MatMul paralela
• Se quiere problemas grandes
por procesador
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 37

38. PDGESV = LU paralelo de ScaLAPACK
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.
38

39. Modelos de performance ScaLAPACK (1)
Contador de operaciones de ScaLAPACK tf = 1
tm = α
tv = β
ΝΒ = brow=bcol
√P = prow = pcol
39

40. Modelos de performance ScaLAPACK (2)
Comparar Predicciones y Mediciones
(LU)
(Cholesky)
40

41. 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}
41

42. 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/ 42

43. GE usando un Algoritmo Recursivo
F. Gustavson y S. Toledo
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
L A12
A21 A22
La mayor parte del computo es multiplicar
matrices de tamaño n/2, n/4, n/8, …
43
Source: Jack Dongarra

44. 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
44

45. DGEMM ATLAS MHz Dual Processor
Pentium III 550 & DGETRF Recursive
LU Factorization
AMD Athlon 1GHz (~$1100 system)
800 Recursive LU
400 Dual-processor
600 LAPACK
M FM flo/s /s
300
lo p p
400 Recursive LU
200
200 LAPACK
100 Uniprocessor
00
500 1000 1000
500 1500 2000 1500
2500 3000 3500
2000 4000
2500 4500 3000
5000
Order
Order
45
Source: Jack Dongarra

46. 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)
46

47. Algoritmos “Out of Core”
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
47
Source: Jack Dongarra

48. Slides
extra
48

49. QR (Mínimos cuadrados)
Escala bien,
casi velocidad total
de la computadora
49

50. Algoritmo actual:
Más rápido que el inicial
A veces hay inestabilidad
numérica
Algoritmos más rápidos y
estables se siguen investigando
Algoritmo inicial:
Numericamente estable
Fácil de paralelizar
Pero es lento, esta en
obsolescencia
50

51. Eigensolver simétrico escalable y SVD
El “Santo Grial” (Parlett, Dhillon, Marques)
Complejidad perfecta (O(n * #vectores)), Trivialmente paralelo, Preciso
A ser incluido en LAPACK y ScaLAPACK
51

52. Eigensolver asimétrico escalable
• Axi = λi xi , Forma de Schur A = QTQT
• HQR paralelo
• Henry, Watkins, Dongarra, Van de Geijn
• Ahora en ScaLAPACK
• No tan escalable como LU: N veces más mensajes
• Partición de datos Block-Hankel es mejor en teoría, pero no en
ScaLAPACK
• Función de Signo
• Beavers, Denman, Lin, Zmijewski, Bai, Demmel, Gu, Godunov, Bulgakov,
Malyshev
• Ai+1 = (Ai + Ai-1)/2 → proyección desplazada en Re λ > 0
• Repetir en A transformada para el espectro del “divide y venceras”
• Sólo usa inversión, por ello es escalable
• Existe versión que no usa inversión (usa QRD)
• Alto contador de flops comparado al HQR, menos estable
52

53. Asignación de trabajo paralelo en GE
• Piense en asignar submatrices a hilos o procesos,
donde cada hilo es responsible de updatear la submatriz
que le fue asignada
• “Que el dueño compute” es la regla natural de localidad
• Cómo deberían ser esas submatrices para lograr
balance de carga?
53

54. Electromagnetismo computacional (MOM)
METODO DE MOMENTOS (una especia de método de
elementos de frontera)
Los principales pasos en el proceso de solución son:
• Fill: calcular los elementos de la matriz A
• Factor: factorizar la matriz densa A
• Solve: solucionar para uno o más vectores de
excitación b
• Field Calc: computar los campos difundidos
(reflejados, scattered) desde el objeto
54

55. Análisis del MOM en paralelo
Tarea Trabajo Paralelismo Veloc.paralela
Fill O(n**2) trivial baja
Factor O(n**3) + ó - difícil muy alta
Solve O(n**2) + ó - difícil alta
Field Calc. O(n) trivial alta
55

56. Versión BLAS2 de GE con pivoteo parcial (GEPP)
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 elemento del resto de la columna i
if |A(k,i)| = 0
Abortar con un aviso 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 esta en el intervalo [-1,1]
… BLAS 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)
… BLAS 2, mayor parte del trabajo es aquí
56

57. Electromagnetismo computacional – Solucionar Ax=b
•Desarrollado en los 80s, para aplicaciones militares
•Determinar el RCS (radar cross section) de aviones
•Reducir la imagen o eco de radar del avión (tecnología stealth
o furtiva, F-117, B-2, etc.)
•Otras aplicaciones: diseño de antenas, de equipo médico.
•Dos enfoques numéricos más fundamentales:
•MOM , ó método de momentos, ó “methods of moments”,
relacionado a BEM (dominio de la frecuencia)
•Matrices densas grandes
•Diferencias finitas (dominio del tiempo)
•Matrices dispersas enormes
57

58. Electromagnetismo computacional
- Discretizar la superficie del objeto en caras
triangulares usando herramientas de modelado.
- Amplitud de la corriente en cada careta son las
incognitas
- Ecuación integral se discretiza en un conjunto de
ecuaciones lineales
58

59. Electromagnetismo computacional (MOM)
Después de la discretización, la ecuación integral
tiene la forma
A x = b
donde
A es la matriz de impedancia (densa),
x es el vector desconocido de amplitudes, y
b es el vector de excitación.
(see Cwik, Patterson, and Scott, Electromagnetic Scattering on the Intel Touchstone Delta,
IEEE Supercomputing ‘92, pp 538 - 542) 59

60. Resultados paralelos en la Intel Delta
Tarea Tiempo (horas)
Fill (computar n2 elementos de la matriz) 9.20
(trivialmente paralelo pero lento)
Factor (GE, O(n3) ) 8.25
(buen paralelismo con el algoritmo adecuado)
Solve (O(n2)) 2 .17
(decente paralelismo con el algortimo adecuado)
Field Calc. (O(n)) 0.12
(trivialmente paralelo y rápido)
El problema era de una matriz de tamaño 48,672.
2.6 Gflops para Factor - Record mundial el 1991.60