1
Programación y Computación paralela (7)
Resolviendo Sist.Ec.Linealesprovenientes de Ec.Dif.Parc.
Glen D. Rodríguez R.
Basado en material de J. Demmel
02/02/2006 CS267 Lecture 6
Temario
• Revisar Ec. Poisson
• Resumen de métodos para resolver Ec. Poisson
• Método de Jacobi
• Método SOR Rojas y Negras
• Gradiente conjugada
• FFT (transformada rápida de Fourier)
Reducen a mat.mul de
matrices dispersas.
Pre-requisitos para
entender Multigrid
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.
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)
5
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
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)
7
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”
Discretizard2u/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
8
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
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.
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).
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
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 conecconesarbitrarias
• 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
13
Malla compuesta en una estructura mecánica
14
Malla no estructurada: Perfil de ala 2D (NASA)
15
Refinamiento de malla adaptativa (AMR)
°Malla adaptativa alrededor de una explosión°Fuente: John Bell y Phil Colella en LBL
16
Malla irregular : tubo que se estrecha (multigrid)
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)
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
19
Convergencia de los métodos de vecinos
0
20
0
20
0
0.5
1
Right Hand Side
0
20
0
20
0
0.5
1
True Solution
0
20
0
20
0
0.5
1
5 steps of Jacobi
0
20
0
20
0
0.5
1
Best 5 step solution
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
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
22
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
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
24
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
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
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
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
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?
Definida?AT disponible?
Eigenvalores
conocidos?
trata CG trata CG o
Chebyshev
trata Minres
o CGtrata QMR
Almacenam.
es “caro”?
trata CGS o
Bi-CGSTABtrata GMRES
N S
N
N
N
N
S
S
S
S
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
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
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,
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
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)
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”
35
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
36
FFT usando “divide y vencerás”
• V puede ser evaluado usando el “divide y vencerás”
V(x) = Σ (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(x
2)
• 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!
m-1
k = 0
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)
ϖ-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).
precomputed
38
Un Algoritmo iterativo
• El árbol de llamadas de algoritmo divide y vencerás FFT
es un árbol binario completo de log m niveles
• 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)]
FFT(0,1,2,3,…,15) = FFT(xxxx)
FFT(1,3,…,15) = FFT(xxx1)FFT(0,2,…,14) = FFT(xxx0)
FFT(xx10) FFT(xx01) FFT(xx11)FFT(xx00)
FFT(x100) FFT(x010) FFT(x110) FFT(x001) FFT(x101) FFT(x011) FFT(x111)FFT(x000)
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)
par impar
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”
40
Partición en bloques FFT 1D
• Usando una partición en
bloques (m/p eltscontiguos 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
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
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 * β
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
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.
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”
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
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
• 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.