ProParCurso 14/15 1Computadores Paralelos 2Programación basada en paso de mensajes 3Técnicas básicas de programación paralela Compulsiva, Divide y Vencerás,

Presentación del tema: "ProParCurso 14/15 1Computadores Paralelos 2Programación basada en paso de mensajes 3Técnicas básicas de programación paralela Compulsiva, Divide y Vencerás,"— Transcripción de la presentación:

1 proParCurso 14/15 1Computadores Paralelos 2Programación basada en paso de mensajes 3Técnicas básicas de programación paralela Compulsiva, Divide y Vencerás, Pipeline, Síncrona, Equilibrado de carga y Terminación 4Programación basada en memoria común 5Algoritmos y aplicaciones Ordenación, … 5 5 2, 2, 2 2, 2 5 4

2 proPar TemariodiviVence-2 4Particionamiento y Divide y Vencerás 1Particionamiento 2Divide y Vencerás 3Ordenación mediante cubetas 4Integración numérica 5Problema de los N-cuerpos

3 proParParticionamientodiviVence-3 Particionar: Dividir el problema en partes (Ej: Fractal Mandelbrot) datos cuentaM cuentaE1cuentaEn Componer resultado final: scatter + reduce funcional f1 f2 fn Mucho menos frecuente Huffman Quantizar IDCT P  B YCbCr  RGB MPEG

4 proParDivide y VencerásdiviVence-4 Divide y Vencerás: Particionar de forma recursiva, combinando resultados (Ej: QuickSort, SumarNúmeros) int sumar(int *s) { if (card(s) <= 2) return (n1 + n2); else { dividir (s, s1, s2); suma1 = sumar(s1); suma2 = sumar(s2); return (suma1 + suma2); } ++++ ++ + ¿ Paralelización ?

5 proParDivide y Vencerás (paralelización)diviVence-5 P7P7 P8P8 P9P9 P 10 P 11 P 12 P 13 P 14 P3P3 P4P4 P5P5 P6P6 P1P1 P2P2 P0P0 Dividir Recolectar sumas No trabajan todos los procesos todo el tiempo

6 proParDivide y Vencerás (paralelización)diviVence-6 P0P0 P1P1 P2P2 P3P3 P4P4 P5P5 P6P6 P7P7 P0P0 P2P2 P4P4 P6P6 P0P0 P4P4 P0P0 ¿ Cómo programarlo ? Recibir_Mi_Trozo Distribuir_A_Descendientes Procesar_Mi_Trozo Recolectar_Sumas_De_Mis_Descendientes Enviar_Mi_Suma_Total_A_Mi_Ancestro ¿Cuáles? P 0 => 4, 2, 1 P 4 => 6, 5 P 2 => 3 P 6 => 7 Nivel 4 2 1 0

7 proParDivide y Vencerás (paralelización)diviVence-7 //Recibir_Mi_Trozo if (yo == 0) nivel = numProcesos / 2; else recibir (-1, {&padre, &nivel, &miTrozo}); //Distribuir_A_Descendientes for (i=nivel; i>0; i=i/2) enviar(yo+i, {yo, i/2, trozo(i)}); //Procesar_Mi_Trozo //Recolectar_Sumas_De_Mis_Descendientes //Enviar_Mi_Suma_Total_A_Mi_Ancestro if (yo == 0) printf(“Total = %d\n”, Total); else enviar(padre, Total);

8 proParDivide y Vencerás (paralelización)diviVence-8 //Recibir_Mi_Trozo if (yo == 0) { for (i=0; i<N; i++) v[i] = random(); nivel = numProcesos / 2; longRodaja = N; } else { MPI_Recv (v, N/2, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &estado); padre = estado.MPI_SOURCE; nivel = estado.MPI_TAG; MPI_Get_count (&estado, MPI_INT, longRodaja); } //Distribuir_A_Descendientes for (i=nivel; i>0; i=i/2) { longRodaja = longRodaja / 2; MPI_Send (&v[longRodaja], longRodaja, MPI_INT, yo+i, i/2, MPI_COMM_WORLD); }

9 proParDivide y Vencerás (paralelización)diviVence-9 //Procesar_Mi_Trozo suma = 0; for (i=0; i<longRodaja; i++) suma += v[i]; //Recolectar_Sumas_De_Mis_Descendientes for (i=nivel; i>0; i=i/2) { MPI_Recv (&sumaBis, 1, MPI_INT, MPI_ANY_SOURCE, 1, MPI_COMM_WORLD, &estado); suma += sumaBis } // Enviar_Mi_Suma_Total_A_Mi_Ancestro if (yo>0) MPI_Send (&sumaBis, 1, MPI_INT, padre, 1, …); else printf (“Suma = %d\n”, suma);

10 proParDivide y Vencerás (paralelización)diviVence-10 32.000.000 números int  sumaSec => 0,033 ProcesossumaPar 20,152 40,222 80,996 161,382 321,626 sumaParBis 0,161 0,234 1,006 1,385 1,632 Scatter + Reduce ? *500 17,021 0,75 0,41 0,34 0,27 0,20 211,388 410,279 86,320 163,985 322,675

11 proParOrdenación mediante cubetasdiviVence-11 ¿Ordenar exámenes? ¿Cuánto tardará en ordenar 600 exámenes? De uno en uno ¡ Lentísimo ! A BZ Un montón por letra juntar ¡ Más rápido ! ¿ Paralelo ? ordenar

12 proParOrdenación mediante cubetasdiviVence-12 M números (10.000.000) en un rango (sea: 0..99.999) Uniformemente distribuidos en N intervalos regulares (sean: 10)  1.000.000  [0..9.999],  1.000.000  [10.000..19.999],............. 0 10.000 19.999 0 9.999 90.000 99.999 M-1 Distribuir en cubetas Ordenar cubetas ¿Programa paralelo? Juntar ¡ No todas iguales !

13 0 10.000 19.999 0 9.999 90.000 99.999 M-1 P0P0 P1P1 P9P9 proParOrdenación mediante cubetasdiviVence-13 Versión 1: Asociar una cubeta por proceso Ordenar mi cubeta Recolectar en mi cubeta Para todo Pi Todos los Pi necesitan el array completo

14 proPar Ordenación mediante cubetas diviVence-14 static int *vector, elemCubeta; vector = malloc (CARDINALIDAD * 4); enterosCubeta = MAX_ENTERO / numCubetas; if (yo == 0) // Inicializar vector MPI_Bcast (vector, CARDINALIDAD, MPI_INT, 0, MPI_COMM_WORLD); // Coger los de mi cubeta elemCubeta = 0; for (i=0; i<CARDINALIDAD; i++) if ((vector[i] / enterosCubeta) == yo) vector[elemCubeta++] = vector[i]; ordenarCubeta ( ); // Enviar y Recoger cubetas if (yo == 0) { j = elemCubeta; for (i=1; i<numCubetas; i++) { MPI_Recv (&vector[j], CARDINALIDAD, MPI_INT, i, 1, MPI_COMM_WORLD, &estado); MPI_Get_count (&estado, MPI_INT, &elemCubeta); j+=elemCubeta; } } else MPI_Send (vector, elemCubeta, MPI_INT, 0, 1, MPI_COMM_WORLD);

15 10.000 19.999 0 9.999 90.000 99.999 proParOrdenación mediante cubetasdiviVence-15 Versión 2: Asignar un trozo del array original a cada proceso 0 M-1 P0P0 P1P1 P9P9 Recolectar en miniCubetas Para todo Pi Env/Rec miniCubetas Ordenar mi cubeta MPI_Alltoall

16 proParOrdenación mediante cubetasdiviVence-16 MPI_Alltoall (BufferEnvio, BufferRecepcion, MPI_Comm) buffer enviar buffer recibir P0P0 buffer enviar 0n-1 P1P1 0 P n-1 0n-1 P0P0 0 P n-2 ¿Todas las minicubetas iguales? gather (receptorP 0 ) gather (receptorP n-1 )

17 proParTiempos ordenar CubetasdiviVence-17 480.000 números, 2..16 cubetas/Pi y Selección Directa 97,208 puro

18 Precisión I =   F(x) x=a b-  proParIntegración numéricadiviVence-18  a F(x) dx b a b   = (b – a) / N a b  ¿Cómo puede ser el programa paralelo? ¿Mejor trapecios?

19 proParIntegración numéricadiviVence-19 a b  = (b – a) / N (N=1.000.000) a)Particionamiento y Asignación Estática (4Pi) a b Cada Pi calculará su trozo: 250.000 rectángulos (  ) ¿Esbozo del programa paralelo?  = (b – a) / P (P=4) P0P0 P1P1 P2P2 P3P3 Conocimiento previo del N razonable

20 proParIntegración numéricadiviVence-20 a b  = (b – a) / N (N=¿?) nAnAn 2nA 2n |A 2n -A n | < cotaError ¿Esbozo del programa paralelo? NArea 2A2A2 4A4A4 b)Divide y Vencerás y Asignación Estática (4Pi) a b P0P0 P1P1 P2P2 P3P3 Reparto no equilibrado de trabajo

21 proParProblema de los N-cuerposdiviVence-21 “N-body” Interacción de astros en el espacio (galaxia) m1 m2 m3 m4 t m2 (x i,y i ) V i  i titi ii G m p m q F = F = m a r 2 q p (x i+1,y i+1 ) V i+1  i+1 t i+1 tt composición  i+1 m (V i+1 -V i ) F =  t V i+1 = V i + (F  t / m) dist = V i  t (x i+1,y i+1 ) = f (dist,  i, X i, Y i )

22 proParProblema de los N-cuerposdiviVence-22 for (t=0; t<tMax; t++) /* Para cada periodo */ for (i=0; i<N; i++) { /* Para cada cuerpo */ FNew[i] = NuevaFuerza(i); VNew[i] = NuevaVelocidad(i); PNew[i] = NuevaPosicion(i); } for (i=0; i<N; i++){ /*Actualizar estado global*/ F[i] = Fnew[i] V[i] = VNew[i]; P[i] = PNew[i]; } ¿Esbozo del programa paralelo? No computable eficientemente O(N 2 )

23 proParAlgoritmo de Burnes-HutdiviVence-23 Idea: Disminuir N agrupando cuerpos próximos r Centro de masa ¿ Cómo determinar las agrupaciones ?

24 proParAlgoritmo de Burnes-HutdiviVence-24 Idea: Dividir el espacio en (8 ó 4) regiones (cubos o cuadrados) que contengan un único cuerpo y luego......... QuadTree: Árbol cuaternario En cada nodo: Masa total Centro de masa

25 proParAlgoritmo de Burnes-HutdiviVence-25 Idea:..... y luego calcular (F,V,X,Y) recorriendo árbol Para Sigue ¿ Parar ? r >= d /  tal que  = 1.0 o menor r d

26 proParAlgoritmo de Burnes-HutdiviVence-26

27 for (t=0; t<tMax; t++) { /* Para cada periodo */ formarArbol; CalcularMasasYCentros; CalcularNuevasFuerzas; Actualizar; } Complejidad = O(NlogN) proPar Algoritmo de Burnes-Hut diviVence-27 ¿Programa paralelo? ??? Asignar nodos a procesos Árbol muy poco equilibrado Bisección recursiva ortogonal

28 proPar Algoritmo de Burnes-Hut diviVence-28 9 21 101 Media = 10,25

29 proParAlgoritmo de Burnes-HutdiviVence-29 Bisección recursiva ortogonal FIN