Paralela3

2,342 views

Published on

Clase 3

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
2,342
On SlideShare
0
From Embeds
0
Number of Embeds
702
Actions
Shares
0
Downloads
72
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Paralela3

  1. 1. Programación y Computación paralela (3) Dependencia, Paralelismo y Localidad Glen D. Rodríguez R. Basado en material de J. Demmel 1
  2. 2. Qué se puede y qué no se puede paralelizar? • La suma de dos matrices es fácilmente paralelizable + • Pero se puede paralelizar esto? A=B+C A=B+C D=A+E D=A+E A=B+C D=A+E 2
  3. 3. Dependencia de data • Relación de dependencia: read after write • X=…….. • Y=X+-*………… • La operación j+1 no puede realizarse correctamente hasta que la operación j se realice. • Más formalmente, si hay 2 operaciones de orden i, j con i>j, hay relación de dependencia si alguno de los INPUTS de la oper.j es el OUTPUT de la oper.i • Se puede achicar sus efectos: • A=B+C • D=A+E • A=G+H A=B+C • Se puede reordenar D=A+E A=G+H 3
  4. 4. Dependencia de data y de flujo • Relación de bloqueo: write after read • F=G+D • G=H+I • Si i>j, el output de la oper.j es el input de la oper.i • Se puede solucionar usando variables auxiliares: • AUX=G • F=AUX+D • G=H+I • Dependencia de flujo: if A>B then C=D+E. Primero hay que hacer la comparación antes de tocar C. Si antes alguna operación modificaba A ó B, debe ser antes tocar C. • SI NO hay ninguna de estas dependencias, se puede paralelizar “a lo bestia” y funcionará bien. Por que entonces no hay carreras por la data localidad 4
  5. 5. Paralelismo y Localidad en Simulación • Problemas físicos tienen paralelismo y localidad: • Muchos objetos operan independientemente unos de otros. • Los objetos generalmente dependen más de otros objetos cercanos que de los lejanos. • Dependencia en objetos lejanos se puede simplificar. • Algunos modelos científicos pueden crear paralelismo: • Cuando un problema continuo se discretiza, la dependencia en el tiempo se limita a time steps cercanos. • Efectos lejanos se pueden ignorar o aproximar. • Puede haber paralelismo en varios niveles • Ej.: varios circuitos se pueden simular a diferentes niveles, desde el de todo un aparato, hasta los componentes básicos individuales. 5
  6. 6. Algunas clases básicas de simulación • Sistemas de eventos discretos: • Ejs: “Game of Life,” circuitos lógicos. • Sistemas de partículas: • Ejs: bolas de billar, dispositivos semiconductores, galaxias. • Variables agregadas que dependen de param. continuos: • EDOs, ej: simulación de circuitos (Spice), estructuras mecánicas, cinética química. • Variables continuas que dependen de param. continuos: • EDPs, ej: calor, elasticidad, electrostática. • Muchas simulaciones combinan varias técnicas. 6
  7. 7. Resumen • Eventos discretos discreto • Tiempo y espacio discretos • Partículas • Caso especial de sistema agregado • Ec. Diferenciales ordinarias (EDOs) • Sistemas agregados • Entidades o posiciones discretas, tiempo continuo • Ec. Diferenciales parciales (EDPs) • Tiempo y espacio es continuo • SE VERA EN OTRO CAPITULO continuo • Identificar problemas comunes y sus soluciones 7
  8. 8. Sistemas de eventos discretos 8
  9. 9. Sistema de eventos discretos • Sistemas se representan como: • Conjunto finito de variables. • El conjunto de todos los valores de las variables en cierto momento es un “estado”. • Cada variable se actualiza computando una función de transición dependiendo de otras variables. • Pueden ser: • sincrónicos: en cada time step discreto, se evalúan las funciones de transición; “state machine”. • asincrónicos: las funciones se evalúan sólo si los inputs cambian, basados en un “evento” en alguna parte del sistema; “event driven simulation”. • Ej: “game of life:” • Autómatas Celulares • Espacio se divide en celdas, hay reglas que gobiernan el contenido de cada celda en cada time step. 9
  10. 10. Paralelismo en el “Game of Life” • Simulación sincrónica • Usa dos copias de la matriz (vieja y nueva). • El valor en cada celda depende sólo de las 9 celdas (ella misma más los 8 vecinos) en la vieja matriz. • Simulación en time steps– cada celda se actualiza en cada time step. • Fácil de paralelizar dividiendo el dominio físico: Domain Decomposition P1 P2 P3 Repetir compute localmente para actualizar celdas P4 P5 P6 barrier() intercambiar info e estado con los vecinos P7 P8 P9 Hasta terminar último time step • Localidad se logra usando grandes matrices divididas entre procesadores • Solo los valores fronterizos entre procesadores se intercambian. • Qué forma dar a los dominios? 10
  11. 11. Mallas regulares • Suponer que el grafo es una malla nxn • Que partición tiene menos comunicación? • Minimizar comunicación en la malla ≡ minimizar ratio “superficie a volúmen” de la partición n*(p-1) 2*n*(p1/2 –1) cruces de borde cruces de borde 11
  12. 12. Simulación sincrónica de circuitos • Circuito es un grafo hecho de subcircuitos unidos por cables • Simulación de componentes necesaria para interacciones por cable. • Estructura de datos es irregular (grafo). • Algoritmo paralelo es manejado por tiempo o síncrono: • Evaluar todos los componentes cada time step • Partición del grafo asigna subgrafos a procesadores • Determina paralelismo y localidad. • Intenta distribuir equitativamente subgrafos a procesadores (balance de carga). • Intenta minimizar cruces de borde (menos comunicación). Cruces de borde = 6 Cruces de borde= 10 12
  13. 13. Simulación asincrónica • Las sincrónicas pueden desperdiciar tiempo: • Simulan y computan incluso cuando no hay cambios. • Las asincrónicas simulan solo cuando un evento llega de algún componente: • No hay time steps, sino eventos individuales con time stamp. • Ej: “Game of life” en estanqus poco conectados. • Ej: circuitos con delays (eventos: puerta que cambian de valor). • Ej: tráfico en la calle (eventos: carros cambiando carriles, etc.). • Es más eficiente, pero más difícil de paralelizar • En MPI, los eventos serían mensajes, Pero como se sabe cuando ejecutar un “receive”? 13
  14. 14. Sistema de Partículas 14
  15. 15. Sistema de partículas • Un sistema de partículas tiene: • Un número finito de partículas • Moviéndose en el espacio según las leyes de Newton • Tiempo es continuo • Ejemplos • Estrellas en el espacio • Haz de electrones • Átomos en una molécula sufriendo fuerzas electrostáticas • Neutrones en un reactor de fisión • Carros en una autopista 15
  16. 16. Fuerzas en el Sistema • La fuerza actuando en una partícula se puede subdividir F = F_externa + F_cercana + F_lejana • Externa • Corrientes oceánicas en los peces • Campo eléctrico externo en haz de electrones • Cercana • Predadores atraídos por los peces • Bolas de billar chocando entre si • Fuerzas de Van der Wals en fluidos (1/r^6) • Lejana • Peces se acercan al cardumen (1/r^2 ) • Gravedad, electrostática • Fuerzas gobernadas por EDP elípticas 16
  17. 17. Paralelismo en F_externa • El más simple • Las fuerzas externas son independientes • “trivialmente paralelo” • Distribuir las partículas equitativamente entre procesadores • Cualquier forma es buena • Localidad perfecta, no necesitamos comunicación • Para cada partícula en un pocesador, aplicar la fuerza externa 17
  18. 18. Paralelismo en F_cercana • Hay interacción y por lo tanto se necesita comunicación. • La fuerza puede epender de partículas dercanas: • Ej: colisiones. • Algoritmos simples son O(n2): chequear todos los pares para ver si colisionan. • Modelo paralelo usual es descomposición del dominio físico: • O(n/p) partículas por procesador si es equitativo. 18
  19. 19. Paralelismo en F_cercana • Desafio 1: interacciones de partículas cerca de los bordesde un procesador: • Debe comunicarse esas variables a los procesadores vecinos. • Bajo ratio volumen a superficie = poca comunicación. • Usar cuadrados, no tiras Comunicar partículas en el borde Necesita chequear colisiones en los bordes 19
  20. 20. Paralelismo en F_cercana • Desafio 2: balance de carga, si las partículas se juntan: • Estrellas, electrones. • Dividir el espacio en formas no regulares. • Que cada región tenga más o menos el mismo número de part. • Quad-tree en 2D, oct-tree en 3D. Ej: cada cuadrado tiene a lo más 3 partículas Ver: http://donar.umiacs.umd.edu/quadtree/points/prquad.html 20
  21. 21. Paralelismo en F_lejanas • Involucrarían interacción todos contra todos = mucha comunicación. • Furza depende de otras partículas: • Ejs: gravedad, proteínas • Algoritmos simples son O(n2) • Descomposición espacial por si sola no ayuda pues cada partícula necesita “visitar” a las demás. Rotar conjuntos de partículas. • Mantiene los proc. ocupados • Todos los procesadores ven a todas las partículas • Mejores algoritmos superan O(n2). 21
  22. 22. Métodos de Partícula-Malla • Basados en aproximación: • Sobreponer una malla regular. • “Mover” partículas al punto de malla más cercano. • Aprovechar el hecho que las f.lejanas satisfacen una EDP fácil de resolver en una malla regular: • FFT, multigrid • Exactitud depende de la finura de la malla y la uniformidad de la distribución de partículas. 1) Partículas se mueven a la malla (scatter) 2) Se resuelva la malla 3) Fuerzas se interpolan a las partículas (gather) 22
  23. 23. Descomposición de árboles • Basados en aproximación • Fuerzas lejanas simplificadas – como una sola partícula grande. • Usar árbol; cada nodo contiene una aproximación de sus hojas. • O(n log n) ó O(n) en vez de O(n2). • Varios algoritmos • Barnes-Hut. • Fast multipole method (FMM) de Greengard/Rohklin. • Método de Anderson 23
  24. 24. Sistemas agregados: EDOs 24
  25. 25. Sistemas de Variables agregadas • Muchos sistemas se pueden aproximar por: • Sistema de vars. “agregadas” o macro variables. • Dependen de un parámetro continuo (tiempo). • Ej -- circuito: • Se aproxima como grafo. • Cables son las aristas. • Nodos son las conexiones entre 2 o más cables. • Cada arista tiene resistencia, capacitancia, inductancia y/o fuente de voltaje. • Sistema es “agregado” por que no se computa V o I en cada punto del espacio, sino en la arista, o en los nodos. • Ley de Ohm, de Kirchoff, etc. • Forma un sistema de Ec. Diferenciales ordinarias (EDOs). • Diferenciales con respecto a tiempo 25
  26. 26. Ejemplo de Circuito • Estado de sistema representado por • vn(t) Voltaje de los nodos • ib(t) corriente de las aristas en el tiempo t • vb(t) voltaje de las aristas • Ecuaciones: • Corriente de Kirchoff 0 A 0 vn 0 • Voltaje de Kirchoff A’ 0 -I * ib = S • Ohm 0 R -I vb 0 • Capacitancia 0 -I C*d/dt 0 • Inductancia 0 L*d/dt I 0 • A es matriz dispersa, representa las coenxiones del circuito • Un gran sistema de EDOs (tal vez con restricciones extra). 26
  27. 27. Ej.: análisis de estructuras • Análisis de estructuras en ing. civil: • Variables: desplazamiento de puntos en un edificio, columna. • Leyes de Newton y de Hook (“resortes”). • Modelo estático: ejercer fuerza y determinar desplazamiento. • Modelo dinámico: aplicar fuerza continua (terremoto). • Problema de Eigenvalue: modos resonantes del edificio vs el terremoto 27
  28. 28. Resolviendo EDOs • En estos ejemplos, las matrices son dispersas: • O sea, la mayor parte de elementos son cero. • Esos 0’s no se deben guardar ni computar. • Disperso, por que cada componente solo depende de algunos otros • Dado un conjunto de EDOs, hay dos preguntas: • Computar los valores de variables en un tiempo t • Métodos explícitos • Métodos implícitos • Computar modos de vibración • Problemas de Eigenvalue 28
  29. 29. Resolviendo EDOs : Métodos explícitos • Asumir x’(t) = f(x) = A*x(t), donde A es una matriz dispersa • Computar x(i*dt) = x[i] para i=0,1,2,… • EDO da x’(i*dt) = pendiente x[i+1]=x[i] + dt*pendiente Usar pendiente en x[i] t (i) t+dt (i+1) • Métodos explícitos, (Forward) Euler. • Aproximar x’(t)=A*x(t) con (x[i+1] - x[i] )/dt = A*x[i]. • x[i+1] = x[i]+dt*A*x[i], o sea. Multp. matriz dispersa x vector . • Sus más y sus menos: • Algoritmo sencillo y paralelizable: multp. matriz vector. • Problemas de estabilidad: se necesitar a veces dt muy pequeño, sobre todo si el sistema es rígido (i.e. A tiene elementos grandes x puede variar muy rápido). 29
  30. 30. Resolviendo EDOs: Métodos implícitos • Asumir x’(t) = f(x) = A*x(t) , con A matriz dispersa • Computar x(i*dt) = x[i] para i=0,1,2,… • EDOda x’((i+1)*dt) = pendiente x[i+1]=x[i] + dt*pendiente Usar pendiente en x[i+1] t t+dt • Método implícito, Backward Euler: • Aproximar x’(t)=A*x(t) con (x[i+1] - x[i] )/dt = A*x[i+1]. • (I - dt*A)*x[i+1] = x[i], o sea se necesita resolver un sistema de ecuaciones disperso. • Sus más y sus menos: • “dt” puede ser mayor: sobretodo para problemas rígidos • Algoritmo más difícil: solución de ecuaciones dispersa 30
  31. 31. Resolviendo EDOs : Eigensolvers • Computar modos de vibración: encontrar los eigenvalues y eigenvectors. • Buscar solución de x’’(t) = A*x(t) de forma x(t) = sin(ω*t) * x0, donde x0 es un vector constante. • Reemplazando, -ω2 *x0 = A*x0, así que –ω2 es un eigenvalue y x0 es un eigenvector de A. • Métodos de solución se reducen a multiplicación d matrices dispersas, o a resolver sistemas de ecuaciones dispersas. 31
  32. 32. EDOs y matrices dispersas • Todos los problemas se reducen a operaciones con dispersas: • Explícito: multipl. Matriz dispersa x vector (SpMV). • Implícito: sistema lineal disperso • Soluciones directas (Eliminación Gaussiana). • Soluciones iterativas (usan SpMV). • Eigenvalues. 32
  33. 33. Hechos claves sobre SpMV • y = y + A*x con A dispersa • Escoger estructura de datos para A • Compressed sparse row (CSR): popular para As genéricas en procesadores con cache • CSR: 3 arrays: • col_index: ïndex de la columna de los valores no-zeros • values: valores No-zero • row_ptr: para cada fila, el index en el array col_index/values for i = 1:m start = row_ptr(i); end = row_ptr(i + 1); for j = start : end - 1 y(i) = y(i) + values(j) * x(col_index(j)); 33
  34. 34. SpMV paralelo • y = A*x, con A dispersa de tamaño n x n x P1 y P2 • Preguntas i: [j1,v1], [j2,v2],… • En qué procesador guardar P3 • y[i], x[i], A[i,j] • Donde computar P4 • y[i] = sum (from 1 to n) A[i,j] * x[j] = (row i of A) * x … producto escalar disperso • Particionar: Puede necesitar • Cjto.de index de Partición {1,…,n} = N1 ∪ N2 ∪ … ∪ Np. comunicación • For all i en Nk, proc. k guarda y[i], x[i], fila i de A • For all i en Nk, proc. k computa y[i] = (row i of A) * x • Regla “el dueño computa” : Proc. k computa las y[i] que posee. 34
  35. 35. “Los 7 enanos” • “Problemas tipo” en cuanto a la computación y comunicación necesaria 1. Álgebra lineal densa 2. Álgebra linear dispersa 3. Métodos espectrales, FFT 4. Métodos de N-cuerpos 5. Mallas estructuradas 6. Mallas no estructuradas 7. Montecarlo 35
  36. 36. Programación y Computación paralela (4) MPI Glen D. Rodríguez R. 36
  37. 37. MPI (Message Passing Interface) • Es una interfaz estándar (1993) para la programación usando el paradigma de paso de mensajes. • Sirve tanto para grandes computadores de memoria compartida, como para clusters o redes de ordenadores heterogéneos (incluido el grid computing). • Definida para C, C++ y FORTRAN. • Comprende una gran cantidad de funciones (128), macros, etc. • Pero con 6 funciones básicas se puede empezar a programar usando MPI. 37
  38. 38. Implementaciones de MPI • Existen bastantes implementaciones del estándar MPI. Algunas son debidas a proveedores de hardware que las proporcionan (optimizadas) paras sus máquinas (IBM, HP, SGI…), otras son desarrolladas en el ámbito académico. • Algunas implementaciones son: • MPICH (MPICH 2 implementa MPI2) • Disponible para múltiples devices incluido globus2. • LAM/MPI • OpenMPI unión de varios proyectos (FT-MPI, LA-MPI, LAM/MPI, y PACX-MPI) . 38
  39. 39. Uso de MPI • Se puede usar MPI para: • Programas paralelos “portables”. • Librerías paralelas. • Programas con relaciones entre datos irregulares o dinámicas que no se ajusten a un modelo de paralelismo en los datos. • Cuando no usar MPI: • Si se puede usar HPF o un programa paralelo Fortran 90. • Si se pueden usar librerías de más alto nivel (que pueden haber sido escritas usando MPI). • Si no se necesita realmente el paralelismo ☺ 39
  40. 40. MPI tipos de datos • Se definen los siguientes tipos de datos MPI: • MPI_CHAR • MPI_SHORT • MPI_INT • MPI_LONG • MPI_UNSIGNED_CHAR • MPI_UNSIGNED_SHORT • MPI_UNSIGNED • MPI_UNSIGNED_LONG • MPI_FLOAT • MPI_DOUBLE • MPI_LONG_DOUBLE • MPI_BYTE • MPI_PACKED • Corresponde a los de C, pero se añaden el tipo byte, y el empaquetado, que permite enviar simultáneamente datos de distintos tipos. 40
  41. 41. MPI Funciones básicas • Funciones básicas: • MPI_Init => Inicialización de MPI. • MPI_Finalize => Termina MPI. • MPI_Comm_size => Para averiguar el número de procesos. • MPI_Comm_rank => Identifica el proceso. • MPI_Send => Envía un mensaje. • MPI_Recv => Recibe un mensaje. • Referencia del estándar en • http://www-unix.mcs.anl.gov/mpi/ 41
  42. 42. MPICH • MPICH es una implementación gratuita de MPI 1.2 • Implementa parte del nuevo estándar MPI-2 • MPICH 2 implementa MPI-2 • Es una implementación muy “portable”: • Supercomputadores de memoria distribuida • Sistemas de memoria compartida • Clusters • Grid • Esta se puede compilar para distintos “devices” de comunicación. Consideraremos dos: • MPICH-P4 • Device ch-p4 dirigido a redes de ordenadores. • MPICH-G2 • Es una implementación “grid” de MPICH mediante el device globus2 • Completamente rediseñada desde la anterior versión MPICH-G • http://www3.niu.edu/mpi/ 42
  43. 43. Escribiendo programas MPI • De las seis funciones básicas que mencionamos antes MPI_Init y MPI_Finalize son imprescindibles para que haya un programa MPI. • Veamos un ejemplo trivial #include "mpi.h" #include <stdio.h> int main( int argc, char **argv ) { MPI_Init( &argc, &argv ); printf( "Hola Mundon" ); MPI_Finalize(); return 0; } 43
  44. 44. Programas MPI (compilación) • El programa anterior solo inicializa y termina el entorno MPI. Entre tanto cada proceso imprime un mensaje por pantalla. • Para un programa pequeño como este podemos hacer una llamada directamente al comando de compilación: • mpicc (para programas C) • mpif77 (Fortran 77). • mpif90 (Fortran 90) • mpiCC (C++) • Para aplicaciones más complicadas conviene usar un Makefile. • En nuestro caso anterior (fichero hello.c): mpicc –o hello hello.c 44
  45. 45. Ejecución de un programa MPI con MPICH • El comando mpirun se usa para ejecutar los programas MPI en MPICH. (esto no es parte del estándar) • mpirun admite diversas opciones. Destacaremos las siguientes: • -np N: N indica el número de procesos que se quiere en la ejecución del programa. • -p4pg pgfile: indica explícitamente las máquinas en las que se quiere correr y el path del programa y usuario que se usará en cada una de ellas. • -machinesfile mfile: fichero de máquinas para correr en lugar del estándar (se usa en combinación con –np). • Digamos que queremos correr nuestro programa en dos máquinas de la lista estándar: mpirun -np 2 hello 45
  46. 46. Ejemplo pgfile y machinefile grid079 0 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpi grid079 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpi grid006 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpi grid007 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpi grid008 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpi grid073.ifca.unican.es:2 grid074.ifca.unican.es:2 grid075.ifca.unican.es:2 grid076.ifca.unican.es:2 grid077.ifca.unican.es:2 grid078.ifca.unican.es:2 46
  47. 47. Delimitación del alcance de la comunicación • Grupos separados de subprocesos trabajando en diferentes subprogramas. • Invocación paralela de librerías paralelas: • Los mensajes propios de la aplicación deben mantenerse separados de los de la librería. • MPI proporciona grupos de procesos • Inicialmente el grupo “all”. • Se proporcionan rutinas para la administración de los grupos. • Todas las comunicaciones, no solo las colectivas, tienen lugar en grupos. • Un grupo (group) y un contexto (context) se combinan en un comunicador (communicator). • Fuente y destino en una operación send o receive se refieren al rank en el grupo asociado con un comunicador dado. Se puede usar MPI_ANY_SOURCE en una operación receive. 47
  48. 48. MPI tipos de comunicación • La comunicación MPI entre procesos puede ser de dos tipos: • Punto a punto: el proceso “origen” conoce el identificador del proceso “destino” y envía un mensaje dirigido solo a él. Se usan las funciones MPI_Send y MPI_Recv. • Colectiva: Operaciones en las que participan todos los procesos de un operador. Ejemplo: • “Broadcast”: El proceso origen manda el mensaje a todos los demas (que pertenezcan al mismo comunicador). Esto es típico de un esquema “master-slave”. Se usa la función MPI_Bcast. • Las funciones MPI de recepción de datos son por lo general “bloqueantes”, es decir, un proceso que debe recibir un mensaje espera hasta que de hecho lo ha recibido completo. 48
  49. 49. Obteniendo información de MPI • Usaremos ahora dos más de las seis funciones básicas: MPI_Comm_size y MPI_Comm_rank. • Así averiguaremos desde el programa el número de procesos que participan y la identificación de cada uno. int main( argc, argv ) { int rank, size; MPI_Init( &argc, &argv ); MPI_Comm_rank( MPI_COMM_WORLD, &rank ); MPI_Comm_size( MPI_COMM_WORLD, &size ); printf( “Hola Mundo! Soy el proceso %d de %dn", rank, size ); MPI_Finalize(); return 0; } 49
  50. 50. Funciones de comunicación MPI • A continuación veremos un poco más en detalle las funciones básicas de envío y recepción de mensajes punto a punto y broadcast. • MPI_Send • MPI_Recv • MPI_Bcast • MPI_Reduce 50
  51. 51. Sintaxis de MPI_Send y MPI_Recv • La operación básica de envío (bloqueante) es: MPI_Send( start, count, datatype, dest, tag, comm ) 1. start: puntero a los datos a enviar 2. count: número de elementos a enviar 3. datatype: tipo de dato 4. dest: Identificación del proceso destino 5. tag: etiqueta de la comunicación 6. comm: Identificación del comunicador • La operación básica de recepción correspondiente: MPI_Recv(start, count, datatype, source, tag, comm, status) 1. start: puntero para la recepción de los datos 2. count: número de elementos 3. datatype: tipo de dato 4. source: Identificación del proceso origen 5. tag: etiqueta de la comunicación 6. comm: Identificación del comunicador 7. status: puntero para acceso a información sobre mensaje 51
  52. 52. Ejemplo MPI_Send/MPI_Recv char msg[100]; if(my_rank==0) { sprintf(msg,"nnt Esto es un mensaje del proceso %d al proceso %d",source,dest); MPI_Send(msg,100,MPI_CHAR,dest,TAG,MPI_COMM_WORLD); printf("n Mensaje enviado a %d",dest); } else if(my_rank==1) { MPI_Recv(msg,100,MPI_CHAR,source,TAG,MPI_COMM_WORLD,&status); printf("n Mensaje recibido en %d",dest); printf(msg); } 52
  53. 53. Adquiriendo información sobre un mensaje • MPI_TAG y MPI_SOURCE son usados principalmente cuando hay MPI_ANY_TAG y/o MPI_ANY_SOURCE en la llamada MPI_Recv. • MPI_Get_count se usa para determinar la cantidad de datos de un tipo dado que se han recibido. MPI_Status status; MPI_Recv( ..., &status ); ... status.MPI_TAG; ... status.MPI_SOURCE; MPI_Get_count( &status, datatype, &count ); 53
  54. 54. Operaciones colectivas • Comunicación colectiva: envío de un mensaje de uno a muchos. Se hace con MPI_Bcast (Broadcast) • Típicamente un master envía los mismos datos a sus esclavos. • Por ejemplo, en la paralelización del entrenamiento de una red neuronal enviamos a todos los esclavos los nuevos pesos al final de cada época de entrenamiento. • Operaciones colectivas: se realiza una operación matemática distribuida y se devuelve el resultado al root de la operación • También es típico en un esquema master-slave. • En la neura se utiliza por ejemplo en la suma de los errores de todos los esclavos. • Operaciones definidas: • Aritméticas: suma, multiplicación… • Lógicas: AND, OR… 54
  55. 55. Operaciones colectivas 55
  56. 56. Reduce • MPI_MAX maximum integer, float integer, real, complex • MPI_MIN minimum integer, float integer, real, complex MPI_SUM sum integer, float integer, real, complex • MPI_PROD product integer, float integer, real, complex • MPI_LAND logical AND integer logical • MPI_BAND bit-wise AND integer, MPI_BYTE integer, MPI_BYTE • MPI_LOR logical OR integer logical • MPI_BOR bit-wise OR integer, MPI_BYTE integer, MPI_BYTE • MPI_LXOR logical XOR integer logical • MPI_BXOR bit-wise XOR integer, MPI_BYTE integer, MPI_BYTE • MPI_MAXLOC max value and location float, double and long double real, complex,double precision • MPI_MINLOC min value and location float, double and long double real, complex, double precision 56
  57. 57. Sintaxis de Broadcast y Reduce • Broadcast: MPI_Bcast(start, count, datatype, root, comm) 1. start: puntero a los datos a enviar 2. count: número de elementos a enviar 3. datatype: tipo de dato 4. root: identificación del proceso origen 5. comm: Identificación del comunicador • Reduce: MPI_Reduce(start, result, count, datatype, operation, root, comm) 1. start: puntero a los datos a enviar 2. result: puntero para almacenar el resultado 3. count: número de elementos a enviar 4. datatype: tipo de dato 5. operation: identificación de la operación colectiva 6. root: identificación del proceso origen 7. comm: Identificación del comunicador 57
  58. 58. Reduce • Operaciones predefinidas para MPI_Reduce: • MPI_MAX máximo • MPI_MIN mínimo • MPI_SUM suma • MPI_PROD producto • MPI_LAND “and” lógico • MPI_LOR “or” lógico • MPI_LXOR “xor” lógico • MPI_BAND “bitwise and” • MPI_BOR “bitwise or” • MPI_BXOR “bitwise xor” • MPI_MAXLOC máximo e índice del máximo • MPI_MINLOC mínimo e índice del mínimo • Además existe un mecanismo para que el usuario cree sus propias funciones para el “Reduce”. 58
  59. 59. Ejemplo BroadCast Char msg[100]; if(my_rank==source) { sprintf(msg,"n Esto es un mensaje del proceso %d a todos los demás",sourc e); MPI_Bcast(msg,100,MPI_CHAR,source,MPI_COMM_WORLD); printf("n Mensaje enviado a todos desde %d",source); } else { MPI_Bcast(msg,100,MPI_CHAR,source,MPI_COMM_WORLD); printf("n Mensaje recibido en %d desde %d",my_rank,source); printf(msg); } 59
  60. 60. Ejemplo Reduce int value; int result; value = my_rank; MPI_Reduce(&value,&result,1,MPI_INT,MPI_SUM,source,MPI_COMM_WORLD); if(my_rank==source) { printf("n Resultado de la suma colectiva %d", result); } 60
  61. 61. Integración en paralelo #include <stdio.h> #include <math.h> #include "mpi.h" int main(int argc, char *argv[]) { int nprocs, myproc; int i, n; double pi_25= 3.141592653589793238462643; double pi, w, x, y, error; double t0, t1; /* MPI initialization */ MPI_Init( &argc, &argv ); MPI_Comm_size( MPI_COMM_WORLD, &nprocs ); MPI_Comm_rank( MPI_COMM_WORLD, &myproc ); /* Determine the number of divisions to use */ if( argc == 2 ) { /* Take n from the command line argument */ sscanf( argv[1], "%d", &n ); } else { n = 1000; /* Otherwise use 1000 divisions */ } if( myproc == 0 ) printf("Calculating pi using %d divisionsn", n); 61 /* Broadcast the number of divisions to all nodes */
  62. 62. Sigue el programa MPI_Bcast( &n, 1, MPI_INT, 0, MPI_COMM_WORLD); /* ??? Is this needed ??? */ /* Start the timer after a barrier command */ MPI_Barrier( MPI_COMM_WORLD ); t0 = MPI_Wtime(); pi = 0.0; w = 1.0 / n; /* Each processor starts at a different value and computes its * own contributions to pi. */ for( i=myproc; i<n; i+=nprocs ) { x = (double) i / n; y = sqrt( 1.0 - x*x ); pi += y * w; } MPI_Allreduce( &pi, &pi, 1, MPI_DOUBLE, MPI_SUM, MPI_COMM_WORLD ); pi = pi*4; error = fabs( pi - pi_25 ); t1 = MPI_Wtime(); if( myproc == 0 ) { printf("The calculated pi = %f (error = %f)n", pi, error); printf("The calculation took %f seconds on %d nodesn", t1-t0, nprocs); } MPI_Finalize(); 62 }

×