Paralela7

1,572 views
1,501 views

Published on

Clase 7

Published in: Education, Travel, Business
0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total views
1,572
On SlideShare
0
From Embeds
0
Number of Embeds
621
Actions
Shares
0
Downloads
27
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Paralela7

  1. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 13. Malla compuesta en una estructura mecánica 13
  14. 14. Malla no estructurada: Perfil de ala 2D (NASA) 14
  15. 15. Refinamiento de malla adaptativa (AMR) °Malla adaptativa alrededor de una explosión °Fuente: John Bell y Phil Colella en LBL 15
  16. 16. Malla irregular : tubo que se estrecha (multigrid) 16
  17. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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

×