1

Programación y Computación paralela (3)

Dependencia, Paralelismo y Localidad

Glen D. Rodríguez R.Basado en material de J. Demmel

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+CD=A+E

+

A=B+C

D=A+E

A=B+C D=A+E

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• Se puede reordenar A=B+C

A=G+HD=A+E

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

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.

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.

7

Resumen

• Eventos discretos• 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

• Identificar problemas comunes y sus soluciones

discreto

continuo

8

Sistemas de eventos discretos

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.

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

• Localidad se logra usando grandes matrices divididas entre procesadores

• Solo los valores fronterizos entre procesadores se intercambian.

• Qué forma dar a los dominios?

P4

P1 P2 P3

P5 P6

P7 P8 P9

Repetircompute localmente para actualizar celdasbarrier()intercambiar info e estado con los vecinos

Hasta terminar último time step

11

Mallas regulares

• Suponer que el grafo es una malla nxn• Que partición tiene menos comunicación?

n*(p-1)cruces de borde

2*n*(p1/2 –1)cruces de borde

• Minimizar comunicación en la malla ≡ minimizar ratio “superficie a volúmen” de la partición

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

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”?

14

Sistema de Partículas

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

16

Fuerzas en el Sistema

• La fuerza actuando en una partícula se puede subdividir

• 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

F = F_externa + F_cercana + F_lejana

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

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.

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 chequearcolisiones en losbordes

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

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.

• Mejores algoritmos superan O(n2).

Rotar conjuntos de partículas.

• Mantiene los proc. ocupados

• Todos los procesadores ven a todas las partículas

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)

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

24

Sistemas agregados:

EDOs

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

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• Voltaje de Kirchoff• Ohm• Capacitancia• Inductancia

• A es matriz dispersa, representa las coenxiones del circuito

• Un gran sistema de EDOs (tal vez con restricciones extra).

0 A 0 vn 0

A’ 0 -I * ib = S

0 R -I vb 0

0 -I C*d/dt 0

0 L*d/dt I 0

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

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

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

• 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).

t (i) t+dt (i+1)

Usar pendiente en x[i]

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

• 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

t t+dtUsar pendiente en x[i+1]

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.

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.

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:mstart = row_ptr(i);end = row_ptr(i + 1);for j = start : end - 1

y(i) = y(i) + values(j) * x(col_index(j));

34

SpMV paralelo

• y = A*x, con A dispersa de tamaño n x n

• Preguntas• En qué procesador guardar

• y[i], x[i], A[i,j]

• Donde computar• y[i] = sum (from 1 to n) A[i,j] * x[j]

= (row i of A) * x … producto escalar disperso

• Particionar:• Cjto.de index de Partición {1,…,n} = N1 ∪ N2 ∪ … ∪ Np.• 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.

i: [j1,v1], [j2,v2],…

x

y

P1

P2

P3

P4

Puede necesitarcomunicación

35

“Los 7 enanos”

• “Problemas tipo” en cuanto a la computación y comunicación necesaria1. Álgebra lineal densa2. Álgebra linear dispersa3. Métodos espectrales, FFT4. Métodos de N-cuerpos5. Mallas estructuradas6. Mallas no estructuradas7. Montecarlo

36

Programación y Computación paralela (4)

MPI

Glen D. Rodríguez R.

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.

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) .

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 ☺

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.

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/

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/

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 Mundo\n" ); MPI_Finalize(); return 0;

}

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

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

46

Ejemplo pgfile y machinefile

grid079 0 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpigrid079 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpigrid006 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpigrid007 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpigrid008 1 /grid/mpi/marco/Portal/NeuralNetwork/test-nn/ExampleApplication.exe mpi

grid073.ifca.unican.es:2grid074.ifca.unican.es:2grid075.ifca.unican.es:2grid076.ifca.unican.es:2grid077.ifca.unican.es:2grid078.ifca.unican.es:2

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.

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.

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 %d\n", rank, size ); MPI_Finalize(); return 0;

}

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

51

Sintaxis de MPI_Send y MPI_Recv

• La operación básica de envío (bloqueante) es:

• La operación básica de recepción correspondiente:

MPI_Recv(start, count, datatype, source, tag, comm, status)

MPI_Send( start, count, datatype, dest, tag, comm )

1. start: puntero a los datos a enviar2. count: número de elementos a enviar3. datatype: tipo de dato4. dest: Identificación del proceso destino5. tag: etiqueta de la comunicación6. comm: Identificación del comunicador

1. start: puntero para la recepción de los datos2. count: número de elementos3. datatype: tipo de dato4. source: Identificación del proceso origen5. tag: etiqueta de la comunicación6. comm: Identificación del comunicador7. status: puntero para acceso a información sobre mensaje

52

Ejemplo MPI_Send/MPI_Recv

char msg[100];

if(my_rank==0){sprintf(msg,"\n\n\t 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);

}

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 );

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…

55

Operaciones colectivas

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

57

Sintaxis de Broadcast y Reduce

• Broadcast:

• Reduce:

MPI_Bcast(start, count, datatype, root, comm)

MPI_Reduce(start, result, count, datatype, operation, root, comm)

1. start: puntero a los datos a enviar2. count: número de elementos a enviar3. datatype: tipo de dato4. root: identificación del proceso origen5. comm: Identificación del comunicador

1. start: puntero a los datos a enviar2. result: puntero para almacenar el resultado3. count: número de elementos a enviar4. datatype: tipo de dato5. operation: identificación de la operación colectiva6. root: identificación del proceso origen7. comm: Identificación del comunicador

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”.

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",source);

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);

}

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);}

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 divisions\n", n);

/* Broadcast the number of divisions to all nodes */

62

Sigue el programaMPI_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 nodes\n", t1-t0, nprocs);

}MPI_Finalize();

}