Este documento presenta varios métodos para resolver sistemas de ecuaciones diferenciales parciales, como la ecuación de Poisson. Revisa el método de Jacobi, el método SOR rojo y negro, el gradiente conjugado y la transformada rápida de Fourier. Luego explica cómo estos métodos pueden ser paralelizados para resolver sistemas de ecuaciones a gran escala de manera más eficiente.

1. Programación y Computación
paralela (7)
Resolviendo Sist.Ec.Lineales
provenientes de Ec.Dif.Parc.
Glen D. Rodríguez R.
Basado en material de J. Demmel
1

2. Temario
• Revisar Ec. Poisson
• Resumen de métodos para resolver Ec. Poisson
• Método de Jacobi
• Método SOR Rojas y Negras Reducen a mat.mul de
matrices dispersas.
• Gradiente conjugada Pre-requisitos para
• FFT (transformada rápida de Fourier) entender Multigrid
02/02/2006 CS267 Lecture 6

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

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

5. Ec. Poisson aparece en muchos lados
∂
3D: ∂2u/∂x2 + ∂2u/∂y2 + ∂2u/∂z2 = f(x,y,z)
∂ ∂
2D: ∂2u/∂x2 + ∂2u/∂y2 = f(x,y)
∂ ∂ f representa las
fuentes; además
1D: d2u/dx2 = f(x) se necesita
condiciones de
frontera
• 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
5

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

7. Ec. Poisson en 1D: ∂2u/∂x2 = f(x)
∂
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
2 -1 Grafo y “estencil”
-1 2 -1
-1 2 -1
-1 2 -1
T= -1 2 -1
-1 2
7

8. Ec. Poisson en 2D
• Similar al caso 1D, pero la matriz T se vuelve:
Grafo y “estencil”
4 -1 -1
-1 4 -1 -1
-1
-1 4 -1
-1 4 -1
-1 4 -1 -1
T= -1 -1 4 -1 -1
-1
-1 -1 4 -1
-1 4 -1
-1 -1 4 -1
-1 -1 4
-1
• 3D es análogo -1
-1 6 -1
-1
-1 8

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

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

11. 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 iteraciones
• SpMV = 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 11

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

13. Malla compuesta en una estructura mecánica
13

14. Malla no estructurada: Perfil de ala 2D (NASA)
14

15. Refinamiento de malla adaptativa (AMR)
°Malla adaptativa alrededor de una explosión
°Fuente: John Bell y Phil Colella en LBL
15

16. Malla irregular : tubo que se estrecha (multigrid)
16

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

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

19. Convergencia de los métodos de vecinos
Right Hand Side True Solution
1 1
0.5 0.5
0 0
20 20
20 20
0 0 0 0
5 steps of Jacobi Best 5 step solution
1 1
0.5 0.5
0 0
20 20
20 20
0 0 0 0
19

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

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

22. Nodos fantasmas redundantes en Jacobi
• Resumen de optimización de jerarquía de memoria
Para computar
verde
Copiar amarillo
Computar azul
• 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
22

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

24. Gauss-Seidel
• Actualizar de izq.-a-der. en orden por filas, es el algoritmo
de Gauss-Seidel
for 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
24
°Sigue siendo multip. vector matriz dispersa, usando submatrices

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

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

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

28. 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?
N S
AT disponible? Definida?
N S N S
Almacenam. trata Minres Eigenvalores
trata QMR
es “caro”? o CG conocidos?
N S N S
trata CGS o trata CG trata CG o
trata GMRES
Bi-CGSTAB Chebyshev
28

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

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

31. 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 (2πi/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, ϖ2 = -1, ϖ3 = -i, ϖ4 = 1,
31

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

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

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

35. Algoritmo serial para la FFT
• Computar la FFT de un vector v con m elementos, F*v
m-1
(F*v)[j] = Σ k=0
F(j,k) * v(k)
m-1
= Σ k = 0 ϖ (j*k) * v(k)
= Σ k = 0 (ϖ j)k * v(k)
m-1
= V(ϖ j)
• Donde V es el polinomio
V(x) = Σ k = 0 xk * v(k)
m-1
35

36. FFT usando “divide y vencerás”
• V puede ser evaluado usando el “divide y vencerás”
m-1
V(x) = Σk = 0 (x)k * v(k)
= v[0] + x2*v[2] + x4*v[4] + …
+ x*(v[1] + x2*v[3] + x4*v[5] + … )
= Vpar(x2) + x*Vimpar(x2)
• V tiene grado m-1, así que Vpar y Vimpar son polinomios
de grado m/2-1
• Los evaluamos en los puntos (ϖ j)2 para 0<=j<=m-1
• Pero esto relamente es sólo m/2 puntos diferentes, pues
(ϖ (j+m/2) )2 = (ϖ j *ϖ m/2) )2 = ϖ 2j *ϖ m = (ϖ j)2
• Así que FFT en m puntos se reduce a 2 FFTs en m/2
puntos
• Divide y vencerás!
36

37. FFT usando “divide y vencerás”
FFT(v, ϖ, m)
if m = 1 retornar v[0]
else
veven = FFT(v[0:2:m-2], ϖ 2, m/2)
vodd = FFT(v[1:2:m-1], ϖ 2, m/2)
precomputed
ϖ-vec = [ϖ0, ϖ1, … ϖ (m/2-1) ]
retornar [vpar + (ϖ-vec .* vimpar),
vpar - (ϖ-vec .* vimpar) ]
• La operación .* es multiplicación componente a componente, no es
prod. vectorial.
• El […,…] es la construcción de vector de m elementos de 2 vecores
con m/2 elementos
El algoritmo es de complejidad O(m log m).
37

38. Un Algoritmo iterativo
• El árbol de llamadas de algoritmo divide y vencerás FFT
es un árbol binario completo de log m niveles
FFT(0,1,2,3,…,15) = FFT(xxxx)
par impar
FFT(0,2,…,14) = FFT(xxx0) FFT(1,3,…,15) = FFT(xxx1)
FFT(xx00) FFT(xx10) FFT(xx01) FFT(xx11)
FFT(x000) FFT(x100) FFT(x010) FFT(x110) FFT(x001) FFT(x101) FFT(x011) FFT(x111)
FFT(0) FFT(8) FFT(4) FFT(12) FFT(2) FFT(10) FFT(6) FFT(14) FFT(1) FFT(9) FFT(5) FFT(13) FFT(3) FFT(11) FFT(7) FFT(15)
• Los algoritmos prácticos son iterativos, van a lo largo de
cada nivel del árbol comenzando de abajo
• El algoritmo sobre escribe v[i] con (F*v)[bitreverse(i)]
38

39. FFT 1D paralelo
• Dependencias de data en
el FFT 1D
• Patrón de “mariposa”
• Un algoritmo PRAM toma
un tiempo O(log m)
• Cada paso a la derecha
es paralelo
• Hay log m pasos
• Y qué pasa con el costo
de comunicación?
• Ver paper LogP
• Culler, Karp, Patterson,
“LogP: Towards a
Realistic Model of
Parallel Computation” 39

40. Partición en bloques FFT 1D
• Usando una partición en
bloques (m/p elts
contiguos por procesador)
• No hay comunicación en
los últimos log m/p pasos
• Cada paso necesita
comunicación de grano
fino en los primeros log p
pasos
40

41. Partición cíclica FFT 1D
• Partición cíclica (sólo 1
elemento por
procesador, circular o
“wrapped”)
• No hay comunicación
en los primeros
log(m/p) pasos
• Comunicación en los
últimos log(p) pasos
41

42. Complejidad Paralela
• m = tamaño del vector, p = número de procesadores
• f = tiempo por flop = 1
• α = latencia por mensaje (en unidades f)
• β = tiempo por palabra “word” en el mensaje (en
unidades f)
• Tiempo(FFT_bloques) = Tiempo(FFT_cíclico) =
2*m*log(m)/p
+ log(p) * α
+ m*log(p)/p * β
42

43. FFT con “Transposición”
• Si empezamos con
partición cíclica para los
primeros log(p) pasos,
no hay comunicación
• Luego transponemos el
vector para los últimos
log(m/p) pasos
• Sólo hay comunicación
en la transposición
43

44. ¿Porqué se le llama transposición?
• Análogo a la transpuesta de una matriz
• Ver como una matriz 2D de n/p por p
• Nota: la misma idea es útil en uniprocesadores con
cache.
44

45. Complejidad de la FFT con Transposición
• Si la comunicación no es simultánea (suposición!)
• Tiempo(FFT_transp) =
2*m*log(m)/p igual que antes
+ (p-1) * α era log(p) * α
+ m*(p-1)/p2 * β era m* log(p)/p ∗ β
• Si la comunicación es simultánea, no se cuenta el
tiempo de p-1 mensajes si no de uno, el segundo
término se convierte en α, en vez de (p-1)α.
• Es casi lo óptimo. Ver paper LogP.
• Ver estos otros papers
• A. Sahai, “Hiding Communication Costs in Bandwidth Limited FFT”
• R. Nishtala et al, “Optimizing bandwidth limited problems using one-
sided communication”
45

46. Comentario al FFT 1D paralelo
• Este algoritmo deja la data en orden bit-reversed
• Algunas aplicaciones la pueden usar así no más, como Poisson
• Otras necesitan una transposición adicional
• Hay otros algoritmos paralelos para FFT
• Uno es de Edelman (ver http://www-math.mit.edu/~edelman)
• Basado en el algoritmo rápido de Multipolos
• Menos comunicación para un algoritmo que no deja los
elementos en orden bit reversed
46

47. FFTs en 2D, 3D
• FFTs en 2 o 3 dimensiones son FFTs 1D en vectores en
todas las dimensiones.
• Ej. un FFT 2D hace varios FFTs 1D en todas las filas y
luego en todas las columnas
• Hay 3 posibilidades obvias para un FFT 2D:
• (1) Partición bloques 2D para la matriz, usar algoritmos 1D para
cada fila y columna
• (2) Partición de bloques de filas para la matriz, usar FFTs 1D
seriales en las filas, seguidos de una transposición, luego más
FFTs 1D seriales
• (3) Partición de bloques de filas para la matriz, usar FFTs 1D
seriales en las filas, luego FFTs 1D paralelos en las columnas
• Opción 2 es mejor, si hacemos coincidir la comunicación y la
computación
• Para un FFT 3D las opciones son similares
• 2 phases done with serial FFTs, followed by a transpose for 3rd
47
• can overlap communication with 2nd phase in practice

48. FFTW – Fastest Fourier Transform in the West
• Mismo “la pistola más rápida del oeste”
• www.fftw.org
• Producen una implementación de la FFT optimizada
para:
• El tipo de FFT (compleja, real,…)
• Cualquier valor de n (arbitrario, primo)
• Varias arquitecturas
• Casi optimo para serial, se debe mejorar al paralelizar
• Ganó el Premio Wilkinson 1999 para Software numérico
• Muy usada.
48