Paralela7

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.