TÉCNICAS DE CÁLCULO EN PARALELO: Directivas OpenMP y MPI (Message Passing Interface)

Transcripción

1 TÉCNICAS DE CÁLCULO EN PARALELO: Directivas OpenMP y MPI (Message Passing Interface) J. París, H. Gómez, X. Nogueira,F. Navarrina, I. Colominas, M. Casteleiro GMNI GRUPO DE MÉTODOS NUMÉRICOS EN INGENIERÍA Departmento de Métodos Matemáticos y de Representación E. T. S. de Ingeniería de Caminos, Canales y Puertos Universidade da Coruña, España jparis@udc.es página web:

2 ÍNDICE Introducción al cálculo en paralelo Arquitecturas de memoria compartida y distribuida Cálculo en paralelo mediante directivas OpenMP Cálculo en paralelo mediante Message Passing Interface (MPI)

3 ÍNDICE Introducción al cálculo en paralelo Arquitecturas de memoria compartida y distribuida Cálculo en paralelo mediante directivas OpenMP Cálculo en paralelo mediante Message Passing Interface (MPI)

4 Introducción al cálculo en paralelo (I) Introducción Cálculo estándar secuencial: Instrucciones por orden (no en paralelo) Cálculo distribuído: Instrucciones se ejecutan en varios procesadores sin interacción entre los mismos. Cálculo en paralelo: instrucciones se calculan simultáneamente en varios procesadores Objetivo: Realizar el mismo cálculo en un menor tiempo de ejecución. Niveles de paralelismo: Nivel de programa dentro de una aplicación Nivel de procedimiento dentro de un programa (entre subrutinas de código) Nivel de bucle dentro de un procedimiento (entre iteraciones de un mismo bucle)

5 Introducción al cálculo en paralelo (II) Medidas de rendimiento del cálculo en paralelo: Aceleración (Speed-up): S(p) = T cpu(1) T cpu (p), p = 2,..., n Eficiencia: E(p) = S(p) p 100 %, p = 2,..., n Ejemplo: Tiempo con 1 CPU = 120 s Tiempo con 32 CPU = 6 s S(32) = T cpu(1) T cpu (32) = = 20 Eficiencia: E(32) = = 62.5 %

6 Introducción al cálculo en paralelo (III) Rendimiento del cálculo en paralelo: Ley de Amdahl: La parte secuencial de un cálculo en paralelo limita su eficiencia Ejemplo: Código 5 % secuencial: Utilizando p procesadores: T cpu (1) = T paralelo cpu T cpu (p) = 95 p + 5 > 5 + T secuencial cpu = S(p) = T cpu(1) T cpu (p) = /p + 5 < 20 E(p) = S(p) p = p p 0 Si p aumenta, S(p) está acotado (p.ej. p = 256 S(256) Si p aumenta, E(p) tiende a 0 (p. ej. p = 256 E(256) 7.27 % Solución: Reducir la parte secuencial de los códigos

7 ÍNDICE Introducción al cálculo en paralelo Arquitecturas de memoria compartida y distribuida Cálculo en paralelo mediante directivas OpenMP Cálculo en paralelo mediante Message Passing Interface (MPI)

8 Arquitecturas de memoria compartida y distribuida (I) Tipos de arquitecturas para cálculo en paralelo: Memoria compartida (UMA,NUMA): Memoria distribuida: Una memoria única para todos los procesadores Accesible desde todos los procesadores Facilidad de implementación Escalabilidad más reducida (Hasta p 128 en 2012) (Hasta aprox. 512 Gb en 2012) Tantas memorias locales como procesadores Cada procesador sólo tiene acceso a su memoria local Facilidad de implementación Escalabilidad muy elevada (Hasta p = en ) (Hasta Gb en ) 1 Fuente: TOP500 (

9 Arquitecturas de memoria compartida y distribuida (II) Memoria compartida: Memoria distribuida: PLACA MADRE (MotherBoard) CLUSTER DE COMPUTACION P1 PM1 M1 P1 P2 PM2 M2 P2 P3 BUS DE CONEXIÓN MEMORIA PM3 M3 P3 RED DE CONEXIÓN Pp-1 PMp-1 Mp-1 Pp-1 Pp PMp Mp Pp

10 Arquitecturas de memoria compartida y distribuida (II) Memoria compartida-distribuída: CLUSTER DE COMPUTACION PLACA MADRE (MotherBoard) PLACA MADRE (MotherBoard) PLACA MADRE (MotherBoard) P1,1 P1,2 P1,m P2,1 BUS DE CONEXIÓN MEMORIA P2,2 BUS DE CONEXIÓN MEMORIA P2,m BUS DE CONEXIÓN MEMORIA Pp,1 Pp,2 Pp,m RED DE CONEXIÓN

11 Arquitecturas de memoria compartida y distribuida (IIa) Memoria compartida: Memoria distribuida: Placa base con 2 CPUs Placa base con 4 CPUs Red de comunicaciones entre equipos U NIVERSIDADE DA C ORU N A G RUPO DE M E TODOS N UM E RICOS EN I NGENIER I A

12 Arquitecturas de memoria compartida y distribuida (IIb) Memoria compartida: Memoria distribuida: Placa base con 2 CPUs Placa base con 4 CPUs Red de comunicaciones entre equipos U NIVERSIDADE DA C ORU N A G RUPO DE M E TODOS N UM E RICOS EN I NGENIER I A

13 Arquitecturas de memoria compartida y distribuida (IIc) Memoria compartida: Memoria distribuida: Placa base con 2 CPUs Red de comunicaciones entre equipos Placa base con 4 CPUs U NIVERSIDADE DA C ORU N A G RUPO DE M E TODOS N UM E RICOS EN I NGENIER I A

14 Arquitecturas de memoria compartida y distribuida (III) Memoria compartida (UMA,NUMA): Programación mediante directivas OpenMP Necesario añadir líneas de directivas No altera el código secuencial original Implementación más rápida y portable Menos eficiente Lenguajes de programación: Fortran, C, C++,... Memoria distribuida: Programación mediante Message Passing Interface (MPI) Necesario añadir comandos de sincronización y comunicación Reestructuración completa del código original Implementación compleja y rígida. Más eficiente Lenguajes de programación: Fortran, C, C++,...

15 ÍNDICE Introducción al cálculo en paralelo Arquitecturas de memoria compartida y distribuida Cálculo en paralelo mediante directivas OpenMP Cálculo en paralelo mediante Message Passing Interface (MPI)

16 Cálculo en paralelo mediante directivas OpenMP (I) OpenMP: OpenMP es un conjunto de directivas, librerías y variables de entorno para programas en Fortran, C y C++, por ejemplo. Es en la actualidad el estándar para programación en paralelo en sistemas de memoria compartida Las directivas son sentencias de programación que sólo se activan al utilizar una opción de compilación específica Proporcionan instrucciones para ejecución en paralelo Funcionamiento: La ejecución comienza en modo secuencial con un thread 1 maestro Al llegar a una región paralela se activan los restantes threads El trabajo se reparte entre todos los threads, incluido el maestro Cuando finaliza la región paralela, continúa la ejecución el thread maestro 1 Aunque su traducción literal es hilo, se suele asociar con un núcleo de cálculo

17 Cálculo en paralelo mediante directivas OpenMP (II) Directivas OpenMP Se utilizan normalmente para paralelización a nivel de bucle Se buscan los bucles más costosos y se reparten sus iteraciones entre los procesadores La comunicación de información entre threads se realiza a través de variables compartidas Las variables compartidas pueden crear conflictos debido al acceso simultáneo por varios procesadores Para evitarlo hay que utilizar directivas de sincronización La creación de regiones paralelas y las directivas de sincronización son muy costosas Recomendación: reducir el número de regiones paralelas creadas y el número de directivas de sincronización.

18 Cálculo en paralelo mediante directivas OpenMP (III) Directivas de paralelización: Sintaxis general (en Fortran) Centinela nombre directiva (cláusulas)!$omp PARALLEL DEFAULT(SHARED) Las directivas comienzan en la columna 1 (formato fijo) Las cláusulas se pueden separar por espacios o comas La columna 6 debe ser un espacio salvo que la línea sea continuación de la anterior, en cuyo caso será un &!$OMP PARALLEL!$OMP&SHARED(A, B, C) Columna 6 Si la línea comienza con!$ sólo se ejecuta con OpenMP activado.!$ write(6,*) Calculando en paralelo

19 Cálculo en paralelo mediante directivas OpenMP (IV) Directiva PARALLEL!$OMP PARALLEL (cláusulas) Sentencias de ejecución!$omp END PARALLEL Crea una región paralela que se ejecutará por todos los threads Uno de ellos se convierte en master thread con identificador 0 Las sentencias de ejecución no pueden desviar la ejecución a otras líneas de código fuera de la región paralela Las subrutinas pueden formar parte de las sentencias y se ejecutarán en paralelo Hay una barrera implícita (sincronización de threads) al final de la región paralela Cláusulas más habituales: PRIVATE(lista de variables privadas) SHARED(lista de variables compartidas) DEFAULT (SHARED) por defecto todas las variables compartidas, (NONE) nada por defecto FIRSTPRIVATE(lista de variables privadas). Mantienen su valor anterior

20 Cálculo en paralelo mediante directivas OpenMP (V) PRIVATE(lista) Declara privadas para cada thread las variables de la lista Cada thread genera una copia local de la variable Esta variable local es invisible para los restantes threads Las variables son locales de la región paralela, se crean al principio y se eliminan al finalizar ésta SHARED(lista) Declara compartidas para todos los threads las variables de la lista Sólo existe una variable compartida por todos los threads Todos los threads acceden a la misma posición de memoria cuando la modifican No evita la posibilidad de acceso simultáneo (lo tiene que evitar el programador) Uso de variables compartidas: Acceso a las mismas para sólo lectura Acceso a diferentes localizaciones (componentes) de la variable Comunicar información entre diferentes threads

21 Cálculo en paralelo mediante directivas OpenMP (VIa) Distribución de trabajo (Paralelización a nivel de bucle):!$omp DO[ cláusulas ] Bucle do secuencial!$omp END DO Distribuye el número de repeticiones de las instrucciones entre los threads Introduce una barrera de sincronización al final de forma automática La mayor parte de las variables son compartidas (por defecto) salvo: El índice del bucle (que siempre es privada) Las variables definidas como privadas

22 Cálculo en paralelo mediante directivas OpenMP (VIb) Distribución de trabajo (Paralelización a nivel de bucle): Cláusulas adicionales (optativas): REDUCTION( operador(+,-,*,/,max): lista de variables) Aplica el operador sobre variables compartidas evitando accesos simultáneos (pero perdiendo eficiencia) SCHEDULE(clase, tamaño del bloque) (STATIC,3) Indica asignación estática de 3 pasos del bucle para cada thread de forma recursiva Lo más recomendable normalmente es (STATIC,n/p) si n es el número de iteraciones (DYNAMIC,3) Indica asignación dinámica de pasos del bucle de 3 en 3 a medida que finalizan (GUIDED,3) asigna n/(2p) a cada thread y luego por orden de finalización asigna 3 iteraciones como mínimo

23 Cálculo en paralelo mediante directivas OpenMP (VIIa) Directivas de secuencialización: Directiva SINGLE!$OMP SINGLE Sentencias a desarrollar de modo secuencial!$omp END SINGLE El bloque de código es ejecutado por un único thread del equipo Introduce una barrera de sincronización al final Directiva MASTER!$OMP MASTER Sentencias a desarrollar de modo secuencial!$omp END MASTER El bloque de código es ejecutado únicamente por el master thread No hay barreras implícitas ni al principio ni al final

24 Cálculo en paralelo mediante directivas OpenMP (VIIb) Directivas de secuencialización: Directiva CRITICAL!$OMP CRITICAL Sentencias a desarrollar sin accesos simultáneos!$omp END CRITICAL Crea un bloque de código que sólo puede ser ejecutado por un thread simultáneamente Se crea una cola de acceso para la realización de este bloque!$omp BARRIER Introduce una barrera de sincronización

25 Cálculo en paralelo mediante directivas OpenMP (VIII) Si se añade además la librería omp_lib como:!$ use omp_lib Se pueden utilizar además las siguientes instrucciones:!$ OMP_SET_NUM_THREADS( n threads) Indica el número de threads (n threads) de la siguiente región paralela Tiene prioridad sobre la variable del sistema OMP_NUM_THREADS si se habilita el ajuste dinámico!$ n_threads = OMP_GET_NUM_THREADS() Devuelve el número de threads utilizados en la región paralela en ejecución!$ nthread = OMP_GET_THREAD_NUM() Devuelve el número que identifica a cada thread en el rango [0, OMP GET NUM THREADS()-1]

26 Cálculo en paralelo mediante directivas OpenMP (IX) Ejemplo: Cálculo de b a f(x)dx mediante el método del Trapecio Compuesto (Serie) program trapecio serie IMPLICIT NONE real*8 a, b, h, x, parcial, integral, f! h = ancho de trapecios integer*4 i, n! n = número de trapecios print*, Indique los valores de a, b, n read(5,*)a,b,n h = (b - a) / dfloat(n) integral = ( f(a) + f(b) ) / 2.0 parcial = 0. do i =1, n-1! Numeramos los puntos desde 0 a n x = a + dfloat(i) * h parcial = parcial + f(x) enddo integral = integral + parcial integral = integral * h print*, El area calculada con,n, intervalos es:,integral end!******************************* real*8 function f(x) IMPLICIT NONE real*8 x f = x*x return end

27 Cálculo en paralelo mediante directivas OpenMP (IX) Ejemplo: Cálculo de b a f(x)dx mediante el método del Trapecio Compuesto (OpenMP) program trapecio OpenMP!$ use omp lib IMPLICIT NONE real*8 a, b, h, x, parcial, integral, f! h = ancho de trapecios integer*4 i, n! n = número de trapecios print*, Indique los valores de a, b, n read(5,*)a,b,n h = (b - a) / dfloat(n) integral = ( f(a) + f(b) ) / 2.0!$OMP PARALLEL DEFAULT (SHARED), PRIVATE(parcial, x) parcial = 0.!$OMP DO do i =1, n-1! Numeramos los puntos desde 0 a n x = a + dfloat(i) * h parcial = parcial + f(x) enddo!$omp END DO!$OMP CRITICAL integral = integral + parcial!$omp END CRITICAL!$OMP END PARALLEL integral = integral * h print*, El area calculada con,n, intervalos es:,integral end!******************************* real*8 function f(x) IMPLICIT NONE real*8 x f = x*x return end

28 Cálculo en paralelo mediante directivas OpenMP (IX) Ejemplo: Cálculo de b a program trapecio serie IMPLICIT NONE real*8 a, b, h, x, parcial, integral, f! h = ancho de trapecios integer*4 i, n! n = número de trapecios print*, Indique los valores de a, b, n read(5,*)a,b,n h = (b - a) / dfloat(n) integral = ( f(a) + f(b) ) / 2.0 parcial = 0. do i =1, n-1! Numeramos los puntos desde 0 a n x = a + dfloat(i) *h parcial = parcial + f(x) enddo integral = integral + parcial integral = integral * h print*, El area calculada con,n, intervalos es:,integral end!******************************* real*8 function f(x) IMPLICIT NONE real*8 x f = x*x return end f(x)dx mediante el método del Trapecio Compuesto (OpenMP) program trapecio OpenMP!$ use omp lib IMPLICIT NONE real*8 a, b, h, x, parcial, integral, f! h = ancho de trapecios integer*4 i, n! n = número de trapecios print*, Indique los valores de a, b, n read(5,*)a,b,n h = (b - a) / dfloat(n) integral = ( f(a) + f(b) ) / 2.0 parcial = 0.!$OMP PARALLEL DEFAULT (SHARED), PRIVATE(parcial, x)!$omp DO do i =1, n-1! Numeramos los puntos desde 0 a n x = a + dfloat(i) *h parcial = parcial + f(x) enddo!$omp END DO!$OMP CRITICAL integral = integral + parcial!$omp END CRITICAL!$OMP END PARALLEL integral = integral * h print*, El area calculada con,n, intervalos es:,integral end!******************************* real*8 function f(x) IMPLICIT NONE real*8 x f = x*x return end

29 Cálculo en paralelo mediante directivas OpenMP (X) Compilado: Se compila normalmente con la opción que activa las directivas OpenMP Compilador Gfortran (GNU): Opción -fopenmp Compilador Intel Fortran: Opción -openmp Para algunas funciones puede ser necesario incluir al principio del código fuente:!$ use omp_lib! librerías específicas de OpenMP Ejecución en paralelo: Basta con indicar el número de threads a utilizar y lanzar la ejecución Unix/Linux (sh, bash): export OMP_NUM_THREADS=16 Windows: set OMP_NUM_THREADS=16 Más información en:

30 ÍNDICE Introducción al cálculo en paralelo Arquitecturas de memoria compartida y distribuida Cálculo en paralelo mediante directivas OpenMP Cálculo en paralelo mediante Message Passing Interface (MPI)

31 Cálculo en paralelo mediante MPI (I) Paradigma SPMD (Single Program Multiple Data): Se ejecuta el mismo programa en diferentes procesadores con distintos datos de partida. Para diferenciar los datos que ejecuta cada programa se utiliza el identificador de cada thread (rank) durante el cálculo. i thread [0,..., n threads 1] La memoria está físicamente distribuída y todas las variables son locales a cada thread. Si es necesario compartir valores de variables se envían mensajes de comunicación a todos los threads y se actualizan las variables locales. Es recomendable evitar en la medida de lo posible el envío de mensajes porque ralentizan el cálculo.

32 Cálculo en paralelo mediante MPI (II) Creación de un programa con MPI: Todo programa en mpi debe comenzar con la directiva de preproceso: include mpif.h Esta directiva contiene definiciones, macros y prototipos de funciones de MPI. El cálculo en paralelo comienza con: call MPI INIT ( ierr ) Y finaliza con : call MPI FINALIZE(ierr)

33 Cálculo en paralelo mediante MPI (III) CALL MPI COMM RANK ( COMM, RANK, IERR ) INTEGER COMM, RANK, IERR Envía un mensaje a los procesadores para que indiquen el número de proceso que se les ha asignado y comprueba su funcionamiento antes de comenzar la ejecución. El comando COMM más habitual es MPI COMM WORLD, que envía mensajes de comprobación del funcionamiento de todos los procesadores antes de comenzar la ejecución en paralelo. La variable entera RANK indica el índice del procesador que ha realizado la comunicación IERR es una variable que indica que esta subrutina ha funcionado correctamente CALL MPI COMM SIZE ( COMM, P, IERR ) INTEGER COMM, P, IERR P es una variable que indica cuantos threads están ejecutando el comunicador indicado IERR es una variable que indica que esta subrutina ha funcionado correctamente

34 Cálculo en paralelo mediante MPI (IV) Coordinación entre procesos: MPI Send: Envía un mensaje a un proceso predeterminado MPI Recv: Recibe un mensaje de un proceso determinado Estas instrucciones requieren además la información: 1. Rango del proceso que recibe el mensaje 2. Rango del proceso que envía el mensaje 3. Una etiqueta (tag) que identifica la variable enviada (en el caso de múltiples envíos simultáneos). Es un entero en el intervalo [0, 32767]. 4. Un comunicador

35 Cálculo en paralelo mediante MPI (V) Ejemplos: MPI SEND ( MESSAGE, COUNT, DATATYPE, DEST, TAG, COMM, IERROR ) MPI RECV ( MESSAGE, COUNT, DATATYPE, SOURCE, TAG, COMM, STATUS, IERROR ) El contenido del mensaje se almacena en el bloque de memoria referenciado por el argumento message. A priori el tamaño del mensaje se desconoce cuando se recibe. El bloque message debe tener espacio suficiente para almacenarlo. De lo contrario, overflow COUNT indica el número de argumentos enviados/recibidos

36 Cálculo en paralelo mediante MPI (VI) DATATYPE indica el tipo de argumentos de MPI enviados/recibidos (junto con COUNT determina la longitud del mensaje) Tipo de datos MPI MPI INTEGER4 MPI REAL4 MPI REAL8 MPI DOUBLE PRECISION MPI COMPLEX MPI LOGICAL MPI CHARACTER MPI BYTE Equivalente en Fortran INTEGER*4 REAL*4 REAL*8 DOUBLE PRECISION COMPLEX LOGICAL CHARACTER(1) MPI BYTE: es un tipo de variable que envía la codificación binaria sin alterar. (Se utiliza cuando los mensajes se envían entre diferentes tipos de equipos con diferentes codificaciones de las variables) DEST y SOURCE son respectivamente los identificadores de los procesos de envío y de recepción del mensaje. El valor de SOURCE puede ser un comodín (wildcard). En MPI el habitual es MPI ANY SOURCE El valor de DEST tiene que ser especificado. No se pueden utilizar comodines.

37 Cálculo en paralelo mediante MPI (VII) TAG es una variable entera. En el caso de MPI RECV también se puede utilizar el comodín MPI ANY TAG COMM es el comunicador. Al igual que al inicio el más habitual es MPI COMM WORLD. En este caso no se pueden utilizar comodines. En el envío de un mensaje el comunicador del MPI SEND debe coincidir con el comunicador del MPI RECV STATUS devuelve información sobre el mensaje recibido.

38 Cálculo en paralelo mediante MPI (VIII) Ejemplo: Cálculo de b a f(x)dx mediante el método del Trapecio Compuesto program trapecio serie IMPLICIT NONE real*8 a, b, h, x, integral, f! h es el ancho de los trapecios integer*4 i, n! número de trapecios data a, b, n / 0.0, 1.0, 1024 /! Se fijan por simplicidad h = (b - a) / dfloat(n) integral = ( f(a) + f(b) ) / 2.0 do i =1, n-1! Numeramos los puntos desde 0 a n x = a + dfloat(i) *h integral = integral + f(x) enddo integral = integral * h print*, El area calculada con,n, intervalos es:,integral end!******************************* real*8 function f(x) IMPLICIT NONE real*8 x f = x*x return end

39 Ejemplo: Cálculo de b a Cálculo en paralelo mediante MPI (IX) f(x)dx mediante el método del Trapecio Compuesto (MPI) program trapecio mpi IMPLICIT NONE include mpif.h integer*4 my rank, p, n! p=2 k procesadores, n trapecios real*8 a, b, h! h es el ancho de los trapecios integer*4 local n! variables locales de cada proceso real*8 local a, local b real*8 integral, total! Resultados finales integer*4 source, dest! Proceso que envía/recibe integer*8 tag, status(mpi STATUS SIZE), ierr data a, b, n, dest, tag / 0.0, 1.0, 1024, 0, 50 / real*8 Trapecio! Función que calcula cada subintegral call MPI INIT(ierr)! Iniciamos el entorno MPI! Obtenemos el índice de cada proceso en my rank call MPI COMM RANK( MPI COMM WORLD, my rank, ierr )! Obtenemos el número de procesos en paralelo en p call MPI COMM SIZE( MPI COMM WORLD, p, ierr ) h = (b - a) / dfloat(n)! Todos los procesos lo calculan local n = dfloat(n) / dfloat(p)! Numero trapecios por proceso local a = a + dfloat(my rank * local n) * h local b = local a + dfloat(local n) * h integral = Trapecio ( local a, local b, local n, h ) if ( my rank.eq. 0 ) then! El proceso 0 suma todos total = integral! los resultados parciales do source = 1, p-1 call MPI RECV(integral, 1, MPI REAL8, source, tag, & MPI COMM WORLD, status, ierr) total = total + integral enddo print*, El area calculada con,n, intervalos es:,total else! El resto de procesos envían sus resultados al 0 call MPI SEND ( integral, 1, MPI REAL8, dest, & tag, MPI COMM WORLD, ierr ) endif call MPI FINALIZE( ierr )! Finalizamos MPI end!******************************* real*8 function Trapecio ( l a, l b, l n, h ) IMPLICIT NONE real*8 l a, l b, h, integral, x, f integer*4 l n, i integral = ( f(l a) + f(l b) ) / 2.0 do i =1, l n - 1! Numeramos los puntos desde 0 a l n x = l a + dfloat(i) *h integral = integral + f(x) enddo integral = integral * h Trapecio = integral return end!******************************* real*8 function f(x) IMPLICIT NONE real*8 x f = x*x return end

40 Cálculo en paralelo mediante MPI (X) Lectura y escritura de datos (I/O) en paralelo Cada instrucción la realizan todos los procesos salvo especificación contraria No se establece ningún criterio automático sobre este aspecto El orden de lectura/escritura en paralelo no está definido Para evitar un mal funcionamiento se impone de forma rigurosa: Se indicará qué proceso lee/escribe la información y en qué orden En el caso de variables comunes a todos los procesos, uno se encarga de la lectura y posteriormente lo distribuye a todos los demás procesos... if ( my rank.eq. 0 ) then print*, Enter a, b, n read *, a, b, n! Leemos los datos & & &! Elegimos el proceso do dest = 1, p-1! Los enviamos al resto de procesos tag = 0! Envío a call MPI SEND(a, 1, MPI REAL, dest, tag, MPI COMM WORLD, ierr) tag = 1! Envío b call MPI SEND(b, 1, MPI REAL, dest, tag, MPI COMM WORLD, ierr) tag = 2! Envío n call MPI SEND(n, 1, MPI INTEGER, dest, tag, MPI COMM WORLD, ierr) else! El resto de procesos reciben la información tag = 0 call MPI RECV(a, 1, MPI REAL, source, tag,! Recibo a & MPI COMM WORLD, status, ierr) tag = 1 call MPI RECV(b, 1, MPI REAL, source, tag,! Recibo b & MPI COMM WORLD, status, ierr) tag = 2 call MPI RECV(n, 1, MPI INTEGER, source, tag,! Recibo n & MPI COMM WORLD, status, ierr) endif... Se puede utilizar para que cada proceso lea o escriba un fichero de datos distinto

41 Cálculo en paralelo mediante MPI (XI) Otras instrucciones: Broadcast: Un único proceso envíe el mismo mensaje a todos los procesos. MPI BCAST ( BUFFER, COUNT, DATATYPE, ROOT, COMM, IERROR ) Ej.: call MPI BCAST ( a, 1, MPI REAL, 0, MPI COMM WORLD, ierr ) Reduce: Permite que operaciones que afectan a variables locales se traten conjuntamente en un sólo proceso MPI Reduce ( PARTIAL RES, TOTAL RES, COUNT, DATATYPE, OPERATION, ROOT, COMM, IERROR) Ej: MPI Reduce ( integral, total, 1,MPI REAL, MPI SUM, 0, MPI COMM WORLD, ierr ) Realiza de forma automática la suma (MPI SUM) de las variables locales integral en la variable total del proceso ROOT

42 Cálculo en paralelo mediante MPI (XII) Otras instrucciones: AllReduce: Permite que operaciones que afectan a variables locales se realicen en un único proceso y se actualice el resultado en todos los procesos MPI AllReduce(PARTIAL RES, TOTAL RES, COUNT, DATATYPE, OPERATION, COMM, IERROR) Ej: MPI AllReduce ( integral, total, 1,MPI REAL, MPI SUM, MPI COMM WORLD, ierr ) Realiza de forma automática la suma (MPI SUM) de las variables locales integral en la variable total y actualiza su valor a todas las variables total locales Barrier: Establece barreras de sincronización de todos los procesos MPI BARRIER ( COMM, IERROR ) Los procesos se detienen hasta que todos han alcanzado esta instrucción.

43 Cálculo en paralelo mediante MPI (XIII) Compilado: Se requiere un compilador (GNU, Intel, Pathscale,...) y librerías y aplicaciones MPI (OPENMPI, MPICH,...). Ejecución: GNU+OPENMPI: mpif77 ó mpif90 Ej.: mpif90 -O3 programa_mpi.f -o programa_mpi.exe Más información: man mpif90 en sistemas Linux Cada compilador suele tener su herramienta de ejecución en MPI. GNU+OPENMPI: mpirun Ej.: mpirun -np 16 programa_mpi.exe Más información: man mpirun en sistemas Linux Más info en: