Post on 02-Aug-2015
Laboratorio de ParalelismoIF - EHU
. 3 .
PROGRAMACIÓN DE SISTEMAS
DE MEMORIA DISTRIBUIDA:
MPI
Laboratorio de ParalelismoIF - EHU
1. Introducción.2. Funciones MPI básicas.3. Otros modos de envío y recepción.4. Comunicación en grupo.5. Tipos de datos derivados.6. Comunicadores y topologías.7. Entrada/salida paralela (introd.).8. Performance, debugging,
profiling...
Índice
Laboratorio de ParalelismoIF - EHU
MPI 33
Paralelizar una aplicación para que se ejecute en un sistema de memoria compartida SMP “no es muy complejo”.El uso de variables compartidas facilita la comunicación entre procesos, aunque implica:
– analizar detalladamente el tipo de variables.
– sincronizar correctamente el acceso a las variables compartidas. Sin embargo, el número de procesadores de un sistema SMP no suele ser muy grande, por lo que no es fácil conseguir altos niveles de paralelismo.
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 43
Es relativamente sencillo conseguir una máquina paralela tipo cluster con muchos procesadores, uniendo P máquinas independientes mediante una red de conexión estándar.
Por ejemplo, nosotros vamos a utilizar una máquina de 32 + 3 nodos (32 + 3x4 = 44 pr.), unidos mediante una red gigabit ethernet.
No es una máquina de alto rendimiento, pero es “barata” y sencilla de ampliar (en nodos de cálculo y en comunicación).
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 53
Sin embargo, programar aplicaciones para sistemas de memoria distribuida es más complejo.
Recuerda:• la memoria de cada procesador es de uso
privado, por lo que todas las variables son, por definición, privadas.
• la comunicación entre procesos debe hacerse a través de paso explícito de mensajes.
• la red de comunicación juega un papel importante en el rendimiento del sistema.
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 63
Diferentes alternativas para programar aplicaciones:• utilizar lenguajes diseñados específicamente para sistemas paralelos (OCCAM).
• ampliar la sintaxis de un lenguaje estándar para gestionar el paso de mensajes (Fortran M).
• utilizar un lenguaje estándar y una librería de funciones de comunicación.
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 73
El estándar actual de programación de los sistemas de memoria distribuida, mediante paso de mensajes, es MPI (message-passing interface).
PVM → MPI 1.0 (94) → MPI 2.0 (97)
Necesitamos:- un método para crear procesos: estático / dinámico.- un método para enviar y recibir mensajes, punto a punto y de manera global.
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 83
MPI es, básicamente, una librería (grande) de funciones de comunicación para el envío y recepción de mensajes entre procesos.Para Fortran y C. Se busca: portabilidad, eficiencia...
El objetivo de MPI es explicitar la comunicación entre procesos, es decir:
> el movimiento de datos entre procesadores
> la sincronización de procesos
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 93
El modelo de paralelismo que implementa MPI es SPMD (Single Program Multiple Data).
if (pid==1) ENVIAR_a_pid2
else if (pid==2) RECIBIR_de_pid1
Recuerda que cada proceso dispone de su propio espacio de direcciones.
También se puede trabajar con un modelo MPMD (Multiple Program Multiple Data): se ejecutan programas diferentes en los nodos.
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 103
MPI gestiona los procesos (número y asignación) de manera estática (MPI2 permite gestión dinámica de procesos).
La comunicación entre procesos puede hacerse de formas muy diferentes. Elegiremos una determinada estrategia en función de la longitud de los mensajes, de la estructura del programa...
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 113
En todo caso, ten en cuenta que la eficiencia en la comunicación va a ser determinante en el rendimiento del sistema paralelo, sobre todo en aquellas aplicaciones en las que la comunicación juega un papel importante (paralelismo de grano medio / fino).
Además de implementaciones específicas, dos imple-mentaciones libres de uso muy extendido: LAM y MPICH. Nosotros vamos a usar MPICH.
Introducción
Laboratorio de ParalelismoIF - EHU
MPI 123
gigabit ethernet
g000002.gi.ehu.esnodo00 nodoxx
Recuerda: ethernet- switch / conmutación de paquetes- formato de paquetes
- direcciones IP: 32 bits (4 × 8)- direcciones del NIC (MAC, 48 bits)
check datos tipo @orig @dest cabecera
4 bytes < 1,5 Kbytes
2 bytes 6 bytes 6 bytes 8 bytes
Introducción: el cluster
Laboratorio de ParalelismoIF - EHU
MPI 133
Para poder ejecutar MPI en el cluster:
1. Generar fichero de claves para ssh> ssh-keygen –t rsa(pasar al directorio .ssh)
> cp id_rsa.pub authorized_keys> chmod go-rw authorized_keys(salir del directorio .ssh)Entrar la primera vez en cada máquina:
> ssh nodo01 ..... yes .... exit
2. Crear en el directorio principal el fichero .mpd.conf con una línea que ponga: secretword=xxxxx> chmod 600 .mpd.conf
Introducción: el cluster
Laboratorio de ParalelismoIF - EHU
MPI 143
El proceso de compilación/ejecución de programas MPI depende de la implementación concreta. En el caso de MPICH2:
1. Lanzar daemons en cada procesador:> mpdboot –v –n zz –f fichero_maquinas
2. Tras compilar (mpicc …), ejecutar el programa (spmd):> mpiexec –n xx programa
2’. En su caso (mpmd), indicar qué ejecutar en cada nodo:> mpiexec –n 1 –host nodo00 p1 : -n 1 –host nodo01 p2(o en un fichero)
Introducción: el cluster
Laboratorio de ParalelismoIF - EHU
MPI 153
Algunas herramientas para gestionar el cluster como si fuera una máquina única. Una muy sencilla es C3 (Cluster Command and Control suite).http://www.csm.ornl.gov/torc/C3Fichero de configuración
cluster cluster32 { g000002:nodo00 #head node dead 0 nodo0[1-9] nodo[10-31] acpt48 acpt49 acpt51}
Algunos comandos cshutdown clist, cname, cnum cget, cpush, cpushimage crm ckill, cexec
Introducción: el cluster
Laboratorio de ParalelismoIF - EHU
1. Introducción.
2. Funciones MPI básicas
inicio y control de procesosenvío y recepción de
mensajes
3. Otros modos de envío y recepción.4. Comunicación en grupo.5. Tipos de datos derivados.6. Comunicadores y topologías.7. Entrada/salida paralela (introd.).8. Performance, debugging,
profiling...
Índice
Laboratorio de ParalelismoIF - EHU
MPI 173
Aunque MPI consta de más de 320 funciones, el núcleo básico lo forman sólo 6:
2 de inicio y finalización del programa. 2 de control del número de procesos.2 de comunicación.
Sintaxis: MPI_Funcion(…)
#include <mpi.h>
Funciones básicas
Laboratorio de ParalelismoIF - EHU
MPI 183
Los parámetros de las funciones MPI son de tres tipos:
IN: la función lee el argumento
OUT: la función modifica el argumento
IN/OUT: la función lee y modifica el argumento
Las funciones MPI (casi todas) devuelven un entero como código de error.
error = MPI_Funcion(...)
Si no ha habido problemas, MPI_SUCCESS (0 en esta implementación); en caso de errores, el valor que indica el tipo de error depende de la implementación.
Funciones básicas
Laboratorio de ParalelismoIF - EHU
MPI 193
1. Comienzo y final del programa:
> MPI_Init(&argc, &argv);
> MPI_Finalize();
Estas dos funciones son la primera y última función MPI que deben ejecutarse en un programa.
No se pueden utilizar funciones MPI antes de _Init, y si un proceso no ejecuta _Finalize el programa queda como “colgado”.
F. básicas: Init / Finalize
Laboratorio de ParalelismoIF - EHU
MPI 203
Los procesos que se van a ejecutar se agrupan en conjuntos denominados comunicadores.Cada proceso tiene un identificador o pid en cada comunicador.
El comunicador MPI_COMM_WORLD (un objeto de tipo MPI_COMM) se crea por defecto y engloba a todos los procesos.
Funciones básicas
Laboratorio de ParalelismoIF - EHU
MPI 213
2. Identificación de procesos
> MPI_Comm_rank(comm, &pid);
Devuelve en pid (int) el identificador del proceso dentro del grupo de procesos, comunicador comm, especificado.Recuerda que un proceso se identifica mediante dos parámetros: identificador (pid) y grupo (comm).
> MPI_Comm_size(comm, &npr);
Devuelve en npr (int) el número de procesos del comunicador especificado.
F. básicas: Comm_rank / _size
Laboratorio de ParalelismoIF - EHU
MPI 223
Un ejemplo simple
#include <stdio.h>#include <mpi.h>
main (int argc, char *argv[]){
int pid, npr, A = 2;
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &pid);MPI_Comm_size(MPI_COMM_WORLD, &npr);
A = A + 1;
printf(“Proceso %d de %d activado. A = %d \n”, pid, npr, A);
MPI_Finalize();}
Funciones básicas
Laboratorio de ParalelismoIF - EHU
MPI 233
Otro ejemplo: planificación de un bucle
...main (int argc, char *argv[]){
...MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &pid);MPI_Comm_size(MPI_COMM_WORLD, &npr);
for (i=pid; i<N; i=i+npr) func(i);
MPI_Finalize();}
Funciones básicas
Laboratorio de ParalelismoIF - EHU
MPI 243
3. Envío y recepción de mensajes
MPI ofrece dos (tres) tipos de comunicación:
punto a punto, del proceso i al j (participan ambos).
en grupo (colectiva): entre un grupo de procesos, de uno a todos, de todos a uno, o de todos a todos.
one-sided: del proceso i al j (participa uno solo).
F. básicas: comunicación
Además, básicamente en el caso de comunicación entre dos procesos, hay múltiples variantes en función de cómo se implementa el proceso de envío y de espera.
Laboratorio de ParalelismoIF - EHU
MPI 253
3. Envío y recepción de mensajes entre dos procesos
La comunicación entre procesos requiere (al menos) de dos participantes: emisor y receptor.
El emisor ejecuta una función de envío y el receptor otra de recepción.
A Benviar recibir
La comunicación es un proceso cooperativo: si una de las dos funciones no se ejecuta, no se produce la comunicación (y podría generarse un deadlock).
F. básicas: comunicación
Laboratorio de ParalelismoIF - EHU
MPI 263
MPI ofrece diferentes modo de comunicación. Veamos un resumen.
F. básicas: comunicación
EMI REC• síncrona: la comunicación no se produce hasta que emisor y receptor se ponen de acuerdo (sin búfer intermedio).
RTS
- petición de transmisión (espera)
RTR
- aceptación de transmisión
D
- envío de datos (de usuario a usuario)
Modos de comunicación (1)
Laboratorio de ParalelismoIF - EHU
MPI 273
Modos de comunicación (1)
• con búfer (buffered): el emisor deja el mensaje en un búfer y retorna. La comunicación se produce cuando el receptor está dispuesto a ello. El búfer no se puede reutilizar hasta que se vacíe.
EMI REC
usuario s.o.s.o. usuario
¡Ojo con el tamaño del búfer!
F. básicas: comunicación
Laboratorio de ParalelismoIF - EHU
MPI 283
Modos de comunicación (2)
• bloqueanteSe espera a que la “comunicación” se produzca,
antes de continuar con la ejecución del programa.La comunicación síncrona es bloqueante. La
comunica- ción con búfer también, si el mensaje no cabe en el búfer.• no bloqueante
Se retorna “inmediatamente” de la función de comunica- ción, y se continúa con la ejecución.
Se comprueba más tarde si la comunicación se ha efectuado.
F. básicas: comunicación
Laboratorio de ParalelismoIF - EHU
MPI 293
Cada estrategia tiene sus ventajas e inconvenien-tes:
> síncrona: es más rápida si el receptor está dispuesto a recibir; nos ahorramos la copia en el búfer. Además del intercambio de datos, sirve para sincronizar los procesos.Ojo: al ser bloqueante es posible un deadlock!
> con búfer: el emisor no se bloquea si el receptor no está disponible, pero hay que hacer copia(s) del mensaje (más lento).
F. básicas: comunicación
Laboratorio de ParalelismoIF - EHU
MPI 303
Para enviar o recibir un mensaje es necesario especificar:
• a quién se envía (o de quién se recibe)• los datos a enviar (dirección de comienzo y
cantidad)• el tipo de los datos• la clase de mensaje (tag)
F. básicas: comunicación
Las dos funciones estándar para enviar y recibir mensajes son:
Todo lo que no son los datos forma el “sobre” del mensaje (que se puede “procesar”).
Laboratorio de ParalelismoIF - EHU
MPI 313
> MPI_Send(&mess, count, type, dest,tag, comm);
- mensaje a enviar: [mess (@comienzo), count (tamaño), type]
- receptor: [dest (@destino), comm (comunicador)]
- tag: 0..32767 (clase de mensajes, orden...)
Función estándar para enviar un mensaje:
Tipos : MPI_CHAR, INT, LONG, FLOAT, DOUBLE, BYTE...
Send utiliza la capacidad de buffering del sistema; es decir, retorna una vez copiado en el búfer el mensaje a enviar… ¡siempre que quepa!
F. básicas: Send y Recv
Laboratorio de ParalelismoIF - EHU
MPI 323
> MPI_Recv(&mess, count, type, source, tag, comm, &status);
- mensaje a recibir:[mess, count, type]
- emisor: [source, comm]
- tag: clase de mensaje
- status: devuelve información sobre el mensaje recibido
Función básica para recibir un mensaje:
Recv se bloquea hasta que se efectúa la recepción.
F. básicas: Send y Recv
Laboratorio de ParalelismoIF - EHU
MPI 333
Algunas precisiones:
• source, dest, count y tag son enteros (int); comm y status son de tipo MPI_Comm y MPI_Status.
• para que la comunicación se efectúe tienen que coincidir las direcciones de emisor y receptor, y el tag del mensaje.
• el tamaño del mensaje (count) definido en la función Recv debe ser igual o mayor al definido en Send.
• el origen de un mensaje en la función Recv puede ser MPI_ANY_SOURCE, y el tipo de mensaje puede ser MPI_ANY_TAG.
F. básicas: Send y Recv
Laboratorio de ParalelismoIF - EHU
MPI 343
• status es un struct con tres campos, en el que se devuelve información sobre el mensaje recibido:
status.MPI_SOURCE: indica el emisor del mensaje
status.MPI_TAG: devuelve el tag del mensaje recibido
status.MPI_ERROR: devuelve un código de error
(aunque lo más habitual es abortar en caso de error)
• también puede obtenerse el tamaño del mensaje recibido ejecutando:
> MPI_Get_count(&status, type,
&count);
Algunas precisiones:
F. básicas: Send y Recv
Laboratorio de ParalelismoIF - EHU
MPI 353
• si un proceso tiene varios mensajes pendientes de recibir, no se reciben en el orden en que se enviaron sino en el que se indica en la recepción mediante los parámetros de origen y tag del mensaje.
• si el tag del mensaje que se recibe puede ser cualquiera, los mensajes que provienen del mismo origen se reciben en el orden en que se enviaron.
Algunas precisiones:
F. básicas: Send y Recv
Laboratorio de ParalelismoIF - EHU
MPI 363
...#define N 10int main (int argc, char **argv){int pid, npr, orig, dest, ndat, tag;int i, VA[N];MPI_Status info;
MPI_Init(&argc, &argv);MPI_Comm_rank(MPI_COMM_WORLD,&pid);
for (i=0;i<N;i++) VA[i] = 0;
if (pid == 0) {
for (i=0;i<N;i++) VA[i] = i;
dest = 1; tag = 0;MPI_Send(&VA[0], N, MPI_INT, dest,
tag, MPI_COMM_WORLD);}
else if (pid == 1) {
for (i=0;i<N;i++) printf(“%4d”,VA[i]);
orig = 0; tag = 0;MPI_Recv(&VA[0], N, MPI_INT, orig,
tag, MPI_COMM_WORLD, &info);
MPI_Get_count(&info, MPI_INT, &ndat);
printf(“Datos desde pr %d; tag = %d, ndat = %d \n”, info.MPI_SOURCE, info.MPI_TAG, ndat);
for (i=0;i<ndat;i++) printf(“%4d”,VA[i]);
}
MPI_Finalize();
}
Ejemplo
Laboratorio de ParalelismoIF - EHU
MPI 373
• Lo más sencillo, mandar primero un mensaje con la longitud del segundo mensaje.Tras ello, puede asignarse la memoria correspondiente para el mensaje que se va a recibir.
¿Y si se desconoce el tamaño del mensaje que hay que recibir (p.e., se calcula dinámicamente)?
• MPI_Probe(source, tag, comm, &status) permite obtener información (fuente, tamaño y tag) de un mensaje que esté a la espera de ser recibido. Podemos así reservar espacio en memoria, decidir cómo recibir el mensaje en función de quién lo envía, o incluso no recibirlo si nos basta con el tag (p.e., es un mensaje vacío, un aviso).
F. básicas: Probe
Laboratorio de ParalelismoIF - EHU
MPI 383
Un par de funciones MPI para obtener tiempos de ejecución:
double MPI_Wtime();tiempo (s) transcurrido desde algún instante
anterior
double MPI_Wtick();devuelve la precisión de la medida de tiempo
t1 = MPI_Wtime();
...
t2 = MPI_Wtime();
printf(“T = %f\n”, t2-t1);
F. básicas: temporización
Laboratorio de ParalelismoIF - EHU
MPI 393
Una cuestión previa sobre las operaciones de entrada/salida.
Lo habitual es que sólo un proceso tenga acceso a teclado y pantalla; ese proceso se encargará de leer los datos y distribuirlos, así como de recoger resultados e imprimirlos.
if (pid==0) { leer_datos(); distribuir_datos();}else
recibir_datos();
Un procedimiento simple para hacerlo podría ser:
F. básicas: entrada/salida
Laboratorio de ParalelismoIF - EHU
1. Introducción.2. Funciones MPI básicas.
3. Otros modos de envío/recepción
comunicación síncrona, inmediata...
4. Comunicación en grupo.5. Tipos de datos derivados.6. Comunicadores y topologías.7. Entrada/salida paralela (introd.).8. Performance, debugging, profiling...
Índice
Laboratorio de ParalelismoIF - EHU
MPI 413
Aparte de las funciones estándar de envío y recepción, MPI ofrece varias alternativas con el objetivo de lograr el máximo rendimiento.Aunque bastaría con un solo modo, cada alternativa está pensada para determinado tipo de situación.
Las principales alternativas al modo estándar son:
- comunicación síncrona- comunicación inmediata
Otros modos de comunicación
Laboratorio de ParalelismoIF - EHU
MPI 423
1. Comunicación síncrona
En modo síncrono, la función de envío no retorna hasta que se produce la comunicación.En principio, no se necesita un búfer intermedio.
> MPI_Ssend (mismos parámetros que Send);
La función síncrona es bloqueante; si no se produce el correspondiente matching, habrá un deadlock.
Comunicación síncrona
Laboratorio de ParalelismoIF - EHU
MPI 433
Obviamente, hay que cambiar el orden.
Deadlock
P1 P2 Ssend_to_2; Ssend_to_1; Recv_from_2; Recv_from_1;
¿Y con el Send estándar?
P1 P2 Send_to_2; Send_to_1; Recv_from_2; Recv_from_1;
Comunicación síncrona
Laboratorio de ParalelismoIF - EHU
MPI 443
2. Comunicación inmediataLa función de comunicación retorna sin esperar a que se produzca una determinada acción (es una especie de post/signal). Es, por definición, no bloqueante y se busca solapar las latencias de cálculo y comunicación.
La comunicación se divide en dos fases: un aviso de envío/recepción, y una verificación de que se ha producido. Se utiliza un handle para obtener información sobre el estado de la comunicación.
Comunicación síncrona
Laboratorio de ParalelismoIF - EHU
MPI 453
Funciones de envío y recepción
> MPI_Isend(..., &request);> MPI_Irecv(..., &request);
request debe ser una variable de tipo MPI_Request, y se utiliza para preguntar sobre el estado de la función.El búfer no se puede acceder hasta que la comunicación se produce.
Funciones de test (status debe ser de tipo MPI_Status)
> MPI_Test(&request, &flag, &status);devuelve en flag un 0 si la operación no se ha
completado
> MPI_Wait(&request, &status);espera hasta que la comunicación se haya
efectuado
Comunicación inmediata
Laboratorio de ParalelismoIF - EHU
MPI 463
Ejemplo
int flag = 0; // sólo parte del códigoMPI_Status status;int bufer[grande];MPI_Request info;...
MPI_Isend(bufer, grande, MPI_INT, dest, tag, MPI_COMM_WORLD, &info);
while(!flag && hay_tareas)
{ ... /* realizar una tarea */
MPI_Test(&info, &flag, &status);}if (!flag) MPI_Wait(&info, &status);...
Comunicación inmediata
Laboratorio de ParalelismoIF - EHU
MPI 473
Hay más opciones (muchas):
- MPI_Sendrecv(…); Por ejemplo, en una comunicación en anillo,
recibe del anterior y envía al siguiente, asegurando que no se produce deadlock.
- Comunicación con bufferingObligamos a que la comunicación se haga
mediante un búfer definido por el usuario. Hay un conjunto de funciones con esas
características (Bsend, …), más otras funciones para gestionar los búferes.
Otros modos de comunicación
Laboratorio de ParalelismoIF - EHU
MPI 483
- Comunicación persistenteSi se van a enviar repetidamente mensajes con los mismos argumentos (por ejemplo, dentro de un bucle), dividimos la comunicación en dos partes: (1) crear el contexto, una sola vez, y (2) enviar el mensaje (las veces que haga falta).
> MPI_Send_init(…, &request);> MPI_Recv_init(…, &request);
> MPI_Start(&request); (Isend = Send_init +
Start)- Mezclas de todas ellas
Otros modos de comunicación
Hay más opciones (muchas):
Laboratorio de ParalelismoIF - EHU
MPI 493
La comunicación es uno de los puntos clave en el rendimiento de un sistema paralelo de memoria distribuida. Por ello, MPI ofrece una gran variedad de estrategias de comunicación.
Resumen de modos de envío / recepción
Modo Fun. bloq. Func. no bloq.
estándar MPI_Send MPI_Isendsíncrono MPI_Ssend MPI_Issendbuffered MPI_Bsend MPI_Ibsend(ready MPI_Rsend MPI_Irsend)
Resumen
En todos los casos: Recv / Probe Irecv / Iprobe
Laboratorio de ParalelismoIF - EHU
MPI 503
El uso recomendado sería el siguiente:
MPI_Ssend: cuando es posible, ofrece los mejores resultados, puesto que no se utilizan búferes intermedios (ojo con los deadlocks).
MPI_Send: la alternativa más habitual.
MPI_Isend: si, por cuestiones de rendimiento, se necesitan rutinas no bloqueantes.
(p.e., en clusters en los que la comunicación sea “cara”, para solapar cálculo y comunicación).
El resto de opciones, para casos especiales.
Resumen
Laboratorio de ParalelismoIF - EHU
1. Introducción.2. Funciones MPI básicas.3. Otros modos de envío/recepción.
4. Comunicación en grupo: broadcast, gather, scatter / reduce / barrier
5. Tipos de datos derivados.6. Comunicadores y topologías.7. Entrada/salida paralela (introd.).8. Performance, debugging, profiling...
Índice
Laboratorio de ParalelismoIF - EHU
MPI 523
Muchas aplicaciones requieren de operaciones de comunicación en las que participan muchos procesos. La comunicación es en grupo o colectiva si partici-pan en ella todos los procesos del comunicador.
Ejemplo: un broadcast, envío de datos desde un proceso a todos los demás. En general, podría ejecutarse mediante un bucle de funciones tipo send/receive, pero no sería muy eficiente.
Comunicación en grupo
Laboratorio de ParalelismoIF - EHU
MPI 533
Todos los procesos del comunicador deben ejecutar la función. Las funciones de comunicación en grupo son bloqueantes en el mismo sentido que la función Send.
Tres tipos: 1 Movimiento de datos
2 Cálculo en grupo
3 Sincronización
Las principales funciones de comunicación en grupo que ofrece MPI son las siguientes:
Comunicación en grupo
Laboratorio de ParalelismoIF - EHU
MPI 543
1a BROADCAST: envío de datos desde un proceso (root) a todos los demás.
AP0
P2 P3
P1
A A
A
(La implementación suele ser en árbol)
AP0
P2 P3
P1
> MPI_Bcast(&mess, count, type, root, comm);
Mov. de datos: broadcast
Laboratorio de ParalelismoIF - EHU
MPI 553
ABCDP0
P2 P3
P1A B C
DP0
P2 P3
P1
1b SCATTER: reparto de datos desde un proceso al resto de procesos del comunicador.
C
B
D
A
CG: mov. de datos, scatter
Laboratorio de ParalelismoIF - EHU
MPI 563
> MPI_Scatter(&send_data, send_count, send_type,
&recv_data, recv_count, recv_type,
root, comm);
- el proceso root distribuye send_data en P trozos, uno por procesador, de tamaño send_count.
- los datos se reciben en recv_data (también en root).
- lo lógico es que el tamaño y tipo de los datos que se envían y se reciben sean iguales.Ejemplo: A = (0, 1, 2, 3, 4, 5, 6, 7) en P0
MPI_Scatter(A, 2, MPI_INT, B, 2, MPI_INT, 0, comm);
(P0) B = 0, 1 (P1) B = 2, 3 (P2) B = 4, 5 (P3) B = 6, 7
CG: mov. de datos, scatter
Laboratorio de ParalelismoIF - EHU
MPI 573
AP0
P2 P3
P1
C D
B AP0
P2 P3
P1
C D
B ABCD
1c GATHER: recolección de datos de todos los procesos en uno de ellos (orden estricto de pid).
CG: mov. de datos, gather
Laboratorio de ParalelismoIF - EHU
MPI 583
> MPI_Gather(&send_data, send_count, send_type,
&recv_data, recv_count, recv_type, root, comm);
- el proceso root recolecta en recv_data los datos enviados en send_data por cada proceso del comunicador.
- los datos se guardan en el orden marcado por el pid.- recv_count indica el tamaño de los datos
recibidos de cada proceso, no el total; lo lógico es que tamaño y tipo de los datos que se envían y se reciben sean iguales.Ejemplo: (P0) B = 0, 1 (P1) B = 2, 3 (P2) B = 4, 5 (P3) B =
6, 7
MPI_Gather(B, 2, MPI_INT, C, 2, MPI_INT, 0, comm);
→ en P0: C = 0, 1, 2, 3, 4, 5, 6, 7
CG: mov. de datos, gather
Laboratorio de ParalelismoIF - EHU
MPI 593
Otras versiones de estas funciones
> MPI_Allgather(…); al final, todos los procesos disponen de todos los datos.
> MPI_Gatherv(…); la información que se recolecta es de tamaño variable.
> MPI_Allgatherv(…); “suma” de las dos anteriores.
> MPI_Alltoall(…); todos los procesos distribuyen datos a todos los procesos.
> MPI_Scatterv(…); la información que se distribuye es de tamaño variable.
> MPI_Alltoallv(…); “suma” de las dos anteriores.
CG: movimiento de datos
Laboratorio de ParalelismoIF - EHU
MPI 603
Ejemplo: reparto de trozos de un vector A, de tamaños diferentes y no consecutivos:
- Tam: vector (int) que contiene un elemento por proceso, e indica el número de datos del trozo a enviar a cada uno.
- Desp: vector (int) que contiene un elemento por proceso, e indica la distancia desde el comienzo de A al comienzo de cada trozo que hay que repartir.
- Tamrec: entero que indica el número de elementos a recibir en buf en el procesador local.
No se admite solapamiento “fisico” de los trozos a enviar.
> MPI_Scatterv(A, tam, desp, tipo,buf, tamrec, tipo, root, comm);
CG: movimiento de datos
Laboratorio de ParalelismoIF - EHU
MPI 613
2 REDUCE: una operación de reducción con los datos de cada procesador, dejando el resultado en uno de ellos (root).
> MPI_Reduce(&operand, &result, count, datatype, operator, root, comm);
AP0
P2 P3
P1
C D
B AP0
P2 P3
P1
C D
BA+B+C+D
CG: cálculo en grupo, reduce
Laboratorio de ParalelismoIF - EHU
MPI 623
Algunos comentarios
• Operación: result = result operator operand
• result es una variable del proceso destino, de nombre diferente a operand (no aliasing).
• Funciones típicas de reducción: MPI_MAX, _MIN,
_SUM, _PROD, _BAND, _BOR, _BXOR, _LAND, _LOR, _LXOR, _MAXLOC, _MINLOC
• Pueden definirse otras operaciones de reducción:
MPI_Op_create(…); MPI_Op_free(…);
CG: cálculo en grupo, reduce
Laboratorio de ParalelismoIF - EHU
MPI 633
Otras funciones del mismo tipo:
> MPI_Allreduce(…); > MPI_Reduce_scatter(…); > MPI_Scan(…);
ALLREDUCE
3 pasos (log P)
CG: cálculo en grupo, reduce
Laboratorio de ParalelismoIF - EHU
MPI 643
3 BARRIER: sincronización global entre los procesos del comunicador.
> MPI_Barrier(comm);
La función se bloquea hasta que todos los procesos del comunicador la ejecutan.
CG: sincronización
Laboratorio de ParalelismoIF - EHU
MPI 653
Ejemplo: V(i) = V(i) * V(j)
(Leer N; sum = 0);for (j=0; j<N; j++) sum = sum + V[j];for (i=0; i<N; i++) V[i] = V[i] *
sum;
1. Leer N (el pid = 0)2. Broadcast de N/npr (tamaño del vector local)3. Scatter del vector V (trozo correspondiente)4. Cálculo local de la suma parcial5. Allreduce de sumas parciales (todos obtienen suma total)6. Cálculo local de V(i)*sum7. Gather de resultados8. Imprimir el resultado (el pid = 0)
Comunicación en grupo
Laboratorio de ParalelismoIF - EHU
1. Introducción.2. Funciones MPI básicas.3. Otros modos de envío/recepción.4. Comunicación en grupo.
5. Tipos de datos derivadosvector, indexed, struct / packed
6. Comunicadores y topologías.7. Entrada/salida paralela (introd.).8. Performance, debugging, profiling...
Índice
Laboratorio de ParalelismoIF - EHU
MPI 673
La comunicación entre procesos es costosa (en función de la red). Por ello, es mejor enviar un paquete con 3 datos que 3 paquetes con un dato cada uno.
Las funciones Send y Recv indican explícitamente la dirección de comienzo del mensaje y el número de elementos que lo componen, pero hay una restricción: deben ser elementos consecutivos y del mismo tipo.
Tipos de datos derivados
Laboratorio de ParalelismoIF - EHU
MPI 683
Ejemplo: enviar la fila 2 de la matriz A, de P0 a P1
Pero, ¿cómo se envía una columna en un solo mensaje? ¿cómo se envían en un mensaje datos de tipos diferentes?
int A[N][M];...
orig = 0; dest = 1;
if (pid == orig)MPI_Send(&A[2][0], M, MPI_INT, dest, 0,
MPI_COMM_WORLD);else if (pid == dest)
MPI_Recv(&A[2][0], M, MPI_INT, orig, 0, MPI_COMM_WORLD, &info);
Tipos de datos derivados
Laboratorio de ParalelismoIF - EHU
MPI 693
Tenemos dos soluciones:
1. Definir nuevos tipos de datos, en los que se permita agrupar datos de diferente tipo, tamaño... para formar un mensaje con cierta “estructura”.
2. “Empaquetar” los datos que hay enviar (que en general serán de diferente tipo, tamaño y estructura) en un único paquete, que el receptor deberá desempaquetar de manera adecuada.
Tipos de datos derivados
Laboratorio de ParalelismoIF - EHU
MPI 703
1. Definición de tipos derivados
La generación de tipos de datos derivados se efectúa mediante dos funciones:
1. definición del tipo de datos derivado2. creación del tipo (commit)
Los nuevos tipos de datos que se crean se declaran como MPI_Datatype. Veamos la opciones que disponemos.
Tipos de datos derivados
Laboratorio de ParalelismoIF - EHU
MPI 713
1a. Tipo “vector”Se define un vector de n elementos, del mismo tipo y tamaño, a distancia (stride) constante.(normalmente un subconjunto de un array mayor).
> MPI_Type_vector(num_elem, tam, stride, tipo, &nuevo_tipo);
El nuevo tipo contiene num_elem elementos de tamaño tam, a distancia stride uno de otro.
[ - MPI_Type_contiguous(num_elem, tipo, &nuevo_tipo); ]
TDD: vector
Laboratorio de ParalelismoIF - EHU
MPI 723
Ejemplo: enviar la columna 2 de la matriz A, de P0 a P1.
int A[N][M];MPI_Datatype Columna;...MPI_Type_vector(N, 1, M, MPI_INT, &Columna);MPI_Type_commit(&Columna);
orig = 0; dest = 1;
if (pid == orig)MPI_Send(&A[0][2], 1, Columna, dest, 0, MPI_COMM_WORLD);
else if (pid == dest)MPI_Recv(&A[0][2], 1, Columna, orig, 0, MPI_COMM_WORLD, &info);
TDD: vector
OJO: 1 columna
Laboratorio de ParalelismoIF - EHU
MPI 733
1b. Tipo “indexed”Se define un vector de n elementos, del mismo tipo, con tamaño y stride variable.
> MPI_Type_indexed(num_elem, tam, desp, tipo, &nuevo_tipo);
tam[]: array que contiene el número de componentes de cada elemento que forma el nuevo tipo.
desp[]: array que contiene el desplazamiento necesario para acceder desde el comienzo del nuevo tipo a cada elemento (de tipo MPI_Aint).
TDD: indexed
Laboratorio de ParalelismoIF - EHU
MPI 743
Ejemplo: enviar de P0 a P1 el triángulo superior de la matriz A.
int A[N][M], T[N][M];MPI_Datatype Mtri;...
for(i=0; i<N; i++) {long_bl[i] = M - i;desp[i] = (M+1) * i;
}
MPI_Type_indexed (N, long_bl, desp, MPI_INT, &Mtri);MPI_Type_commit (&Mtri);
if (pid == 0) MPI_Send(A, 1, Mtri, 1, 0, MPI_COMM_WORLD);else if (pid == 1) MPI_Recv(T, 1, Mtri, 0, 0, MPI_COMM_WORLD, &info);
N
M
TDD: indexed
Laboratorio de ParalelismoIF - EHU
MPI 753
1c. Tipo “struct”Es un caso más general, en el que se agrupan n elementos de tamaño y tipo diferente.Por ejemplo, P0 tiene que enviar a todos los procesadores tres parámetros: A y B, flotantes, y C, entero. Podemos formar un “paquete” con los tres parámetros y efectuar un único envío (BC).
Para ello construimos un struct con:
- número de elementos- tipo de cada elemento- desplazamiento de cada elemento
desde el origen
62
ff i
A B C
TDD: struct
Laboratorio de ParalelismoIF - EHU
MPI 763
1c. Tipo “struct”
La función para definir el tipo es:
> MPI_Type_create_struct(num_elem, tam, desp, tipo, &nuevo_tipo);
tam[]: número de componentes de cada elemento que forma el nuevo tipo.
desp[]: desplazamiento necesario para acceder desde el comienzo del nuevo tipo a cada elemento (MPI_Aint).
tipo[]: tipo de cada elemento (MPI_Datatype).
TDD: struct
> MPI_Get_address (&A, &dirA)Devuelve la dirección de A en dirA (de
tipo MPI_Aint)
Laboratorio de ParalelismoIF - EHU
MPI 773
void Crear_Tipo (float* A, B; int* C; MPI_Datatype* Mensaje) {int tam[3];MPI_Aint desp[3], dir1, dir2; // address intMPI_Dataype tipo[3];
tam[0] = tam[1] = tam[2] = 1;tipo[0] = tipo[1] = MPI_FLOAT;tipo[2] = MPI_INT;
despl[0] = 0;MPI_Get_address (A, &dir1);MPI_Get_address (B, &dir2);despl[1] = dir2 - dir1;MPI_Get_address (C, &dir2);despl[2] = dir2 - dir1;
MPI_Type_create_struct(3, tam, desp, tipo, Mensaje);MPI_Type_commit(Mensaje);
}
... (A, B, C, punteros a las variables)
Crear_Tipo(A, B, C, &Mensaje);
MPI_Bcast(A, 1, Mensaje, 0, MPI_COMM_WORLD);...
TDD: struct
Laboratorio de ParalelismoIF - EHU
MPI 783
1d. Subarrays
Una submatriz de N dimensiones a partir de una de N dimensiones. Por ejemplo, un bloque 2D de una matriz 2D:
TDD: subarrays
> MPI_Type_create_subarray(...);> MPI_Type_create_darray(...);
Laboratorio de ParalelismoIF - EHU
MPI 793
1d. Subarrays
Una submatriz de N dimensiones a partir de una de N dimensiones. Por ejemplo, un bloque 2D de una matriz 2D;
TDD: subarrays
> MPI_Type_create_subarray(ndims, tam_a, tam_sa, dir_sa, orden, tipo,
&nuevo_tipo);
ndims: dimensiones del array originaltam_a[], tam_sa[]: elementos en cada dimensióndir_sa[]: comienzo del subarrayorden: MPI_ORDER_C, _FORTRAN
Laboratorio de ParalelismoIF - EHU
MPI 803TDD: subarrays
Tamaño y extensión del tipo:
1. Tamaño: número de bytes que se transmiten (sin incluir huecos).
2. Extensión: Distancia entre el primer y el último byte (incluyendo huecos).
Un par de funciones MPI devuelven estos parámetros del tipo de datos.
Laboratorio de ParalelismoIF - EHU
MPI 813
2. Empaquetamiento
Alternativa a la definición de tipos: “empaquetar” los datos que hay que enviar en posiciones consecutivas de memoria.
La comunicación se efectúa en tres fases:
• Antes de enviar el mensaje, se van añadiendo los datos a un búfer (vector) mediante la función MPI de empaquetamiento.
• Se envía el vector, que es de tipo MPI_PACKED.
• El receptor desempaqueta los datos recibidos mediante la función MPI de desempaquetamiento.
TDD: packed
Laboratorio de ParalelismoIF - EHU
MPI 823
2. Empaquetamiento
La función para empaquetar datos es:
> MPI_Pack(&dat, tam, tipo, bufer, tambuf, &pos, comm);
Añade a bufer (char, de tamaño tambuf) la variable dat, a partir de la posición marcada por el puntero pos. El puntero queda apuntando a la primera posición libre de bufer. Al final de las operaciones de empaquetamiento, indica el tamaño del paquete.
La función MPI_Pack_size (ver manual) devuelve el tamaño mínimo necesario para empaquetar un objeto. Se puede usar para calcular el tamaño final del paquete y reservar memoria para el mismo.
TDD: packed
Laboratorio de ParalelismoIF - EHU
MPI 833
2. Empaquetamiento
La función para desempaquetar datos es:
> MPI_Unpack(bufer, tambuf, &pos, &dat, tam, tipo, comm);
Recupera de bufer (apuntado por pos) la variable dat del tamaño y tipo indicado (pos queda apuntando a la siguiente variable).
Tambuf debe ser suficiente para que quepa el mensaje recibido.
TDD: packed
Laboratorio de ParalelismoIF - EHU
MPI 843
void Leer_Datos (float* A, B; int* C; int pid) {char bufer[100]; int pos;
if (pid == 0) {printf(“-> A, B y C\n”);scanf(“%f %f %d”, A, B, C); // A, B, C, punteros a las vbles.pos = 0;
MPI_Pack(A, 1, MPI_FLOAT, bufer, 100, &pos, MPI_COMM_WORLD);MPI_Pack(B, 1, MPI_FLOAT, bufer, 100, &pos, MPI_COMM_WORLD);MPI_Pack(C, 1, MPI_INT, bufer, 100, &pos, MPI_COMM_WORLD); MPI_Bcast(bufer, pos, MPI_PACKED, 0, MPI_COMM_WORLD);
} else {
MPI_Bcast(bufer, 100, MPI_PACKED, 0, MPI_COMM_WORLD);pos = 0;
MPI_Unpack(bufer, 100, &pos, A, 1, MPI_FLOAT, MPI_COMM_WORLD);MPI_Unpack(bufer, 100, &pos, B, 1, MPI_FLOAT, MPI_COMM_WORLD);MPI_Unpack(bufer, 100, &pos, C, 1, MPI_INT, MPI_COMM_WORLD);
}}
TDD: packed
Laboratorio de ParalelismoIF - EHU
MPI 853
Para reducir el overhead de la comunicación se pueden definir “tipos de datos” que agrupen los datos a enviar en posiciones consecutivas de memoria.Especialmente útil cuando se repite el mismo tipo de comunicación una y otra vez.
Un tipo derivado es básicamente un struct que se crea en ejecución y que puede pasarse como argumento a una función de comunicación.
Tipos: MPI_Type_vector, _indexed, _struct
Otra alternativa es empaquetar datos y desempaque-tarlos tras recibirlos (MPI_PACKED).
TDD: resumen
Laboratorio de ParalelismoIF - EHU
MPI 863
Lo más habitual es utilizar el mecanismo estándar de transmisión: datos consecutivos de un array.
Si los datos a enviar son muchos y no consecutivos, y se envían repetidamente, lo mejor sería definir un tipo específico:- datos homogéneos: contiguous, vector, indexed- datos heterogéneos: struct
Si se envían datos heterogéneos una sola vez (o pocas), lo más adecuado sería empaquetar.
TDD: resumen
Laboratorio de ParalelismoIF - EHU
MPI 873
Matching de tipos
Send y Recv especifican el tipo de los datos que se envían y reciben. Se llama firma (signature) de tipos a la secuencia {t0, t1..., tn-1}, donde ti es el tipo del elemento i.
El tipo no tiene por qué ser el mismo en ambas funciones, pero la firma de tipos del tipo de datos especificado en Recv tiene que tener al menos tantos elementos como la de Send, y los tipos han de ser iguales: es decir, se deben recibir al menos tantos datos como se envían y del mismo tipo.
Ojo: en las funciones colectivas el tipo debe ser el mismo!
TDD: resumen
Laboratorio de ParalelismoIF - EHU
MPI 883
Matching de tipos
El paquete de datos lleva los datos sin “estructura”. La estructura se “recompone”, si se desea, al recibirlos.
Por ejemplo, enviamos N elementos de una columna de una matriz utilizando el tipo columna. Si recibimos los datos con el tipo columna, se cargarán en la columna de la matriz que indiquemos. Si los recibimos como N enteros, se cargarán uno tras otro a partir de la dirección que indiquemos; si los recibimos con tipo “diagonal”, se cargarán en la diagonal; etc.
TDD: resumen
Laboratorio de ParalelismoIF - EHU
1. Introducción.2. Funciones MPI básicas.3. Otros modos de envío/recepción.4. Comunicación en grupo.5. Tipos de datos derivados.
6. Comunicadores y topologías.7. Entrada/salida paralela (introd.).8. Performance, debugging, profiling...
Índice
Laboratorio de ParalelismoIF - EHU
MPI 903
Un comunicador MPI define un grupo de procesos entre los cuales es posible el intercambio de mensajes. Cada proceso se identifica en el comunicador mediante su pid.El comunicador predefinido MPI_COMM_WORLD engloba a todos los procesos de la aplicación paralela.
En muchos casos es útil definir otros grupos de procesos o comunicadores para hacer más simple la comunicación. Así, un proceso puede tener más de un pid: uno por cada grupo del que forme parte.
Comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 913
Un comunicador está formado, al menos, por un grupo de procesos y un contexto.El contexto define un espacio propio e identificado de comunicación.
Un comunicador puede incluir más datos asociados, tales como una topología, características específicas de los procesadores que lo componen, entrada/salida, etc.
Para ver la utilidad de definir grupos de procesos, analicemos un ejemplo sencillo: producto de dos matrices.
Comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 923
Ejemplo: C = A × B
En el caso de una matriz “densa”, hay que efectuar O(N3) operaciones. ¿Cómo paralelizar el cálculo de manera eficiente entre P procesadores? ¿Cuál es la mejor manera de distribuir los datos entre los procesos?
Objetivo: minimizar el tiempo asociado a la comunicación.
Cij = Ai,0 B0,j + Ai,1 B1,j + ... + Ai,i Bi,j + ... + Ai,n-1 Bn-1,j
x =
BA C
Motivación
Laboratorio de ParalelismoIF - EHU
MPI 933
x =
BA CP0
1. Descomposición unidimensional (filas) (P procesadores, N/P filas por procesador)
• Computación por procesador (* y +) : O(N3/P)
• Pero hay que añadir comunicación: N2/P datos desde cada uno de los P-1 procesadores restantes → O(N2).
Podría ser un allgather de N2/P datos, que se ejecuta en log P pasos.
Motivación (A × B)
Laboratorio de ParalelismoIF - EHU
MPI 943
P
PNtPtt
P
Nwiop
loglog
2 23
• Tejec = Tcalc + Tcom
Eficiente sólo si: top >> tw oP es pequeño (<<N)
P
PNtPt
P
NttPT wiwicom
logloglog
22
• Si Tcom = ti + tw N ti tiempo de inicio tw tiempo por palabra
Motivación (A × B)
Laboratorio de ParalelismoIF - EHU
MPI 953
N = 100 ti = 100 tw tw = 100 top
P
speed-up = Ts / Tp
0
20
40
60
80
100
20 40 60 80 100
efi
cie
ncia
= T
s /
(Tp*P
)
0
0.2
0.4
0.6
0.8
1
Motivación
Laboratorio de ParalelismoIF - EHU
MPI 963
2. Descomposición bidimensional:
• Computación por procesador: O(N3/P)
x =
BA CP0
• Pero ahora la necesidad de comunicación es menor. Cada procesador necesita los datos de “los bloques de su fila y su columna”.Se necesita recibir 2(P1/2-1)(N2/P) datos.
¿Cuál es la manera más eficiente de procesar/enviar esos datos?
Motivación (A × B)
Laboratorio de ParalelismoIF - EHU
MPI 973
A00B00+ A01B10+ A02B20 A00B01+ A01B11+ A02B21 A00B02+ A01B12+ A02B22
A20B00+ A21B10+ A22B20 A20B01+ A21B11+ A22B21 A20B02+ A21B12+ A22B22
A10B00+ A11B10+ A12B20 A10B01+ A11B11+ A12B21 A10B02+ A11B12+ A12B22
bc
bc
bc
bc
bc
bc
Motivación (A × B)
Algoritmo de multiplicación (Fox):
Laboratorio de ParalelismoIF - EHU
MPI 983
Algoritmo de multiplicación (Fox):
for k = 0 to P – 1• en cada fila i, el proceso (i+k) mod N hace un
broadcast de A (su trozo) al resto de procesos de la fila
• operaciones locales de cálculo: Ci,j += Ai,i+k Bi+k,j
• envío del trozo procesado de B al vecino de arriba Comunicación por procesador:
P veces• broadcast de N2/P datos a P - 1 procesos (se
puede optimizar en log P pasos)• send de N2/P datos
Motivación (A × B)
Laboratorio de ParalelismoIF - EHU
MPI 993
Coste global (cálculo + comunicación)
wiop
wiopejec
tNP
Pt
PPt
P
N
P
NttPPt
P
NT
23
23
2
log
2
log2
1log2
[ ¿y el coste de reorganizar las matrices? ]
Motivación (A × B)
Laboratorio de ParalelismoIF - EHU
MPI 1003
N = 100 ti = 100 tw tw = 100 top
efi
cie
ncia
= T
s /
(Tp*P
)
0
0.2
0.4
0.6
0.8
1
0
20
40
60
80
100
20 40 60 80 100
P
speed-up = Ts / Tp
Motivación
Laboratorio de ParalelismoIF - EHU
MPI 1013
Conclusión: división 2D es más “escalable”, pero requiere comunicaciones entre subconjuntos de procesos.
N
N
N2/P
Com.: N2 - N2/P =
N2(P-1)/P
P1/2
bloquesCom.: 2 N2/P (P1/2-1) =
N2 2(P1/2-1)/P
Resumen (NxN datos, P procesadores)
0
0.2
0.4
0.6
0.8
1
1 10 100 1000
CO
M
P
Motivación
Laboratorio de ParalelismoIF - EHU
MPI 1023
Para crear grupos de procesos entre los que poder intercambiar información, hay que seguir los siguientes pasos:
1. Extraer de un comunicador inicial, com1, el grupo de procesos asociados, gr1:
> MPI_Comm_group(com1, &gr1);
Si com1 es MPI_COMM_WORLD, gr1 contendrá a todos los procesos.
Creación de comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 1033
3. Finalmente, se crea el comunicador com2 con los procesos del grupo gr2 extraídos del comunicador com1:
> MPI_Comm_create(com1, gr2, &com2);
2. Crear un nuevo grupo de procesos, gr2, eligiendo del grupo gr1 aquellos que queremos que formen parte del nuevo comunicador:
> MPI_Group_incl(gr1, npr_gr2, pid_gr1,
&gr2);
pid_gr1 es un array de npr_gr2 elementos que indica el pid de los procesos que se eligen para formar el nuevo grupo.(también se puede hacer por exclusión, con la función MPI_Group_excl)
Creación de comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 1043
Ejemplo: una matriz está repartida por bloques en n × n procesos. Así definiríamos el grupo “fila 0” de procesos y haríamos un broadcast en esa fila:
MPI_Group gr1, grf0;MPI_Comm CF0;
for(i=0; i<n; i++) pids[i] = i; /* lista de proc. */
MPI_Comm_group (MPI_COMM_WORLD, &gr1);MPI_Group_incl (gr1, n, pids, &grf0);MPI_Comm_create(MPI_COMM_WORLD, grf0, &CF0);...
if (pid < n) { MPI_Comm_rank(CF0, &pid_f0); MPI_Broadcast(&A[0][0], tam, MPI_FLOAT, 0, CF0);}
Creación de comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 1053
Algunas precisiones:
• Los grupos de procesos son variables de tipo MPI_Group y los comunicadores son de tipo MPI_Comm.
• MPI_Comm_create es una operación colectiva, que debe ser llamada por todos los procesos del comunicador original (aunque no vayan a formar parte del nuevo comunicador; se les devuelve el valor MPI_COMM_NULL).
• Al finalizar su uso hay que “deshacer” el comunicador, ejecutando MPI_Comm_free.
• Otras funciones para trabajar con grupos: MPI_Group_rank, size, free, union, intersection...
Creación de comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 1063
Si hay que crear comunicadores “similares” a partir de uno determinado (por ejemplo filas o columnas de una estructura 2D), podemos generarlos todos a la vez, mediante la función:
> MPI_Comm_split(com1,split_key,pid_com1,&com2);
Los procesos de com1 se van a agrupar en nuevos comunicadores en función de la clave con la que llamen a la función.Se crean tantos comunicadores como claves diferentes se utilicen, todos con el mismo nombre com2.
Creación de comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 1073
Ejemplo: crear comunicadores para todas las filas de un grupo de n × n procesos:
// pid = identificador en el comunicador global
mi_fila = pid / n;MPI_Comm_split(MPI_COMM_WORLD, mi_fila, pid, &CFILA);
Si había 3×3 procesos, ahora tendremos un nuevo comunicador en el que el grupo de procesos es diferente en función de quién lo use: {0,1,2} en P0,P1,P2 / {3,4,5} en P3,P4,P5 / {6,7,8} en P6,P7,P8Se trata de una función colectiva; todos los procesos del comuni-cador original tienen que ejecutarla. Si un proceso no va a formar parte de los nuevos comunicadores, llama a la función con la clave MPI_UNDEFINED (formará parte del comunicador MPI_COMM_NULL).
Creación de comunicadores
Laboratorio de ParalelismoIF - EHU
MPI 1083
Un comunicador puede incluir, además del grupo y el contexto, otro tipo de información o atributos; por ejemplo, una topología (virtual).
No se refiere a la red de comunicación, sino a una manera alternativa de identificar a los procesos de un comunicador. Se genera un nuevo comunicador.
Dos tipos: cartesian y graph.
Topologías
Laboratorio de ParalelismoIF - EHU
MPI 1093
Por ejemplo, si queremos trabajar con una distribución 2D de datos, podemos definir una “retícula” de procesos (p.e., de 4x4 si tenemos 16 procesadores).
Para definir un comunicador con una “malla” global tenemos que indicar:
• número de dimensiones (2)• elementos por dimensión (4)• ¿cadenas (0) o anillos (1)?• optimización (ajuste a la red física)
Topologías
Laboratorio de ParalelismoIF - EHU
MPI 1103
Ejemplo: definir un comunicador con topología toro
MPI_Comm CTORO...
opt = 1; ndim = 2;kdim[0] = kdim[1] = 4;c_a[0] = c_a[1] = 1;
MPI_Cart_create (MPI_COMM_WORLD, ndim, kdim, c_a, opt, &CTORO);
kdim: número de procesos en cada dimensión.c_a: 0 → malla; 1 → toro;CTORO es un nuevo comunicador que engloba a los mismos procesos que MPI_COMM_WORLD, pero que añade coordenadas cartesianas a los procesos.
Topologías
Laboratorio de ParalelismoIF - EHU
MPI 1113
Ahora podemos trabajar con una identificación doble de los procesos: el pid en el nuevo comunicador y las coordenadas cartesianas de la topología asociada.Dos funciones permiten pasar de una a otra:
> MPI_Cart_coords(com2, pid2, dim, coord);
com2: nuevo comunicador con topologíapid2: identificador del proceso en el nuevo comunicadordim: número de dimensionescoord: array donde se devuelven las coordenadas
> MPI_Cart_rank(com2, coord, pid);
Topologías
Laboratorio de ParalelismoIF - EHU
MPI 1123
Se pueden obtener las direcciones de los “vecinos” en la topología:
> MPI_Cart_shift(com, direc, desp, &orig, &dest);
dir: dimensión en la que queremos buscar los vecinosdesp: distancia del vecino&orig,&dest: vecinos segun el despl (orig, yo, dest)
Topologías
Laboratorio de ParalelismoIF - EHU
MPI 1133
Se puede dividir (split) una retícula en otras de menos dimensiones (p.e., una malla de dos dimensiones en sus columnas o filas), y crear así nuevos comunicadores:> MPI_Cart_sub(cart_comm, free_coords, new_comm);
A partir del comunicador que tiene asociada la topología, se crean comunicadores en función del array booleano free_coords:
0 → se considera esa coordenada1 → no se tiene en cuenta (free)
Por ejemplo, de una malla de n × n procesos se pueden crear los comunicadores “fila” haciendo: free_coord[0] = 0; free_coord[1] = 1; (al revés, las columnas).
Topologías
Laboratorio de ParalelismoIF - EHU
MPI 1143
Un conjunto de funciones similares permite añadir un “grafo” subyacente a un determinado grupo de procesos.
En resumen.Un comunicador representa a un grupos de procesos que se reconocen entre sí como posible origen y destino de sus comunicaciones. Una topología es un mecanismo alternativo de identificación “lógica” de procesos dentro de un grupo, que genera un nuevo comunicador y, en su caso, subgrupos.
Topologías
Laboratorio de ParalelismoIF - EHU
MPI 1153
Resumen de las funciones prinicipales (hay más funciones, mirar manual) que permiten crear comunicadores y topologías:
> MPI_Comm_group/create/split/free
> MPI_Group_incl/excl/rank/free
> MPI_Cart_create/rank/coords/shift/sub
Topologías
Laboratorio de ParalelismoIF - EHU
1. Introducción.2. Funciones MPI básicas.3. Otros modos de envío/recepción.4. Comunicación en grupo.5. Tipos de datos derivados.6. Comunicadores y topologías.
7. Entrada/salida paralela (introd.).
8. Performance, debugging, profiling...
Índice
Laboratorio de ParalelismoIF - EHU
MPI 1173
Algunas aplicaciones utilizan y generan una gran cantidad de datos, por lo que el tiempo necesario para las operaciones de I/O puede ser muy elevado (comparable o mayor que el tiempo estricto de ejecución).
Algunos campos en los que se procesan datos de manera intensiva:
> minería de datos: grano fino / patrones de acceso no predecibles> multimedia: grano grueso / predecibles > cálculo científico: grano fino - grueso / predecibles o no
Entrada/salida paralela
Laboratorio de ParalelismoIF - EHU
MPI 1183
Estructura típica serie: • un disco conectado al procesador (servidores, sistema RAID) • datos en diferentes formatos • acceso secuencial / aleatorio • llamadas estándar (fprintf, fscanf...) • sistema de ficheros NFS
El número de datos procesados por unidad de tiempo es mayor en los sistemas paralelos. Si el sistema de almacenamiento de datos (discos) no responde adecuadamente, el rendimiento del sistema global decaerá (Amdahl de nuevo).
Entrada/salida paralela
Laboratorio de ParalelismoIF - EHU
MPI 1193
Resumen RAID (redundant array independent disks)
• objetivos: capacidad (+ disc.), rendimiento (entrelaz.), fiabilidad (paridad, hamming...)
RAID0: entrelazado de los datos (nivel de subbloque) entre un conjunto de discos (igual que en la MP)
+ capacidad / + rendimiento / no fiabilidadRAID1/10 (mirroring): replicación de datos /
entrelazado
- capacidad / rendimiento / fiabilidadRAID5: entrelazado de los datos / paridad+ capacidad / + rendimiento / tolerancia a
fallos
• estructura:
Entrada/salida paralela
Laboratorio de ParalelismoIF - EHU
MPI 1203
La entrada/salida en paralelo hace referencia a dos cuestiones:
• estructura “física” de los ficheros
> un disco local en cada nodoI/O local -- almacenamiento
temporallos datos se pueden juntar al finalfunciones estándar de I/O en C
> nodos específicos de I/Omejor rendimientofunciones paralelas de I/O
Entrada/salida paralela
Laboratorio de ParalelismoIF - EHU
MPI 1213
• estructura “lógica” de los ficheros
> procesadores escribiendo en el mismo fichero
- los datos de cada proceso se intercalan en el fichero
- MPI-2 parallel I/O> en ficheros diferentes, que se pueden juntar al final-- en general, un sistema de ficheros tipo PVFS
Entrada/salida paralela
La entrada/salida en paralelo hace referencia a dos cuestiones:
Laboratorio de ParalelismoIF - EHU
MPI 1223
MPI-2 añade un interfaz para el uso compartido de ficheros en operaciones de entrada/salida.
La lectura y escritura de datos se realiza de forma similar al envío y recepción de datos.
Los modos de acceso pueden ser bloqueantes (lo más habitual) y no bloqueantes, así como individuales (lo más habitual) y colectivos.
Entrada/salida paralela
Laboratorio de ParalelismoIF - EHU
MPI 1233
Cada proceso tiene una “vista” del fichero, compuesta por tres elementos:
- desplazamiento: punto base de los accesos.
- tipo elemental (e-type): tipo de las unidades que forman el fichero, y que representa la unidad de acceso y desplazamiento, normalmente un byte.
- filetype: una plantilla de repeticiones del “e-type” que indica los datos que pueden ser accedidos por cada proceso (p.e., los elementos pares/impares de un vector).
La “vista” por defecto tiene desplazamiento 0, y tipo elemental y filetype MPI_BYTE.
Entrada/salida paralela
Laboratorio de ParalelismoIF - EHU
MPI 1243
> MPI_File_open(comm, &filename, amode, info, &fh);
comm: comunicador
filename: nombre del fichero (char)
amode: modo de acceso (int)
info: información sobre el fichero (MPI_Info)(MPI_INFO_NULL)
fh: handle para trabajar con el fichero (MPI_File)
Operaciones básicas con ficheros: 1. Apertura y cierre del fichero
> MPI_File_close(&fh);
Entrada/salida paralela
Laboratorio de ParalelismoIF - EHU
MPI 1253
> MPI_File_open(comm, &filename, amode, info, &fh);
> MPI_File_close(&fh);
Modos de acceso: MPI_MODE_RDONLY; _RDWR; _WRONLY;
Se pueden añadir (OR, |) otras opciones: MPI_MODE_CREATE; _EXCL; _DELETE_ON_CLOSE; UNIQUE_OPEN; _SEQUENTIAL; _APPEND;
Entrada/salida paralela
Operaciones básicas con ficheros: 1. Apertura y cierre del fichero
Laboratorio de ParalelismoIF - EHU
MPI 1263
> MPI_File_open(comm, &filename, amode, info, &fh);
> MPI_File_close(&fh);
Son funciones colectivas; para acceso a ficheros locales (un solo proceso) se usa el comunicador MPI_COMM_SELF.
Entrada/salida paralela
Operaciones básicas con ficheros: 1. Apertura y cierre del fichero
> MPI_File_delete(&filename, info);
Permite borrar un fichero que no esté abierto (sólo un proceso).
Laboratorio de ParalelismoIF - EHU
MPI 1273
> MPI_File_read(fh, &buf, count, datatype, &status);
Lee de fh count elementos de tipo datatype y los deja en buf. Utiliza el puntero privado de acceso al fichero (que se actualiza automáticamente).
> MPI_File_read_at(fh, offset, &buf, count, datatype, &status);
Lee comenzando en la dirección marcada por offset, sin utilizar ni modificar ningún puntero privado.
Entrada/salida paralela
Operaciones básicas con ficheros: 2. Lectura de datos
Laboratorio de ParalelismoIF - EHU
MPI 1283
> MPI_File_seek(fh, offset, whence);
Desplaza el puntero offset unidades (bytes) en relación a la posición actual en el fichero (whence = MPI_SEEK_CUR), al comienzo del fichero (MPI_SEEK_SET), o al final (MPI_SEEK_END).
> MPI_File_set_view(fh, disp, etype, filetype, drepr, info);
Crea una “vista” del fichero fh para cada proceso (operación colec-tiva); posiciona los punteros particulares de cada proceso en disp (p.e., función del pid). drepr indica el modo de representación de datos (ver manual).
Entrada/salida paralela
Operaciones básicas con ficheros: 2. Manejo de punteros
Laboratorio de ParalelismoIF - EHU
MPI 1293
> MPI_File_get_position(fh, offset);
Devuelve en offset la posición actual del puntero privado.
Entrada/salida paralela
Operaciones básicas con ficheros: 2. Manejo de punteros
Laboratorio de ParalelismoIF - EHU
MPI 1303
> MPI_File_write(fh, &buf, count, datatype, &status);
> MPI_File_write_at(fh, offset, &buf, count,
datatype, &status);
Escribe en fh count elementos de buf de tipo datatype. Utiliza el puntero privado de acceso al fichero (que se actualiza automáticamente).
Escribe en fh a partir de la dirección marcada por offset, sin utilizar ni modificar ningún puntero privado.
Entrada/salida paralela
Operaciones básicas con ficheros: 3. Escritura de datos
Laboratorio de ParalelismoIF - EHU
MPI 1313
> MPI_File_sync(fh);
Obliga a escribir en fh datos que todavía puedan estar sin escribir.Es una operación colectiva que deben realizar todos los procesos del comunicador.
Existen muchas más funciones para trabajar con ficheros (ver manual MPI-2), con el objetivo de conseguir el mayor rendi-miento posible en aplicaciones en las que el punto clave sean las operaciones de entrada/salida.
Entrada/salida paralela
Operaciones básicas con ficheros: 4. Flush de datos
Laboratorio de ParalelismoIF - EHU
1. Introducción.2. Funciones MPI básicas.3. Otros modos de envío/recepción.4. Comunicación en grupo.5. Tipos de datos derivados.6. Comunicadores y topologías.7. Entrada/salida paralela (introd.).
8. Performance, debugging, profiling
Índice
Laboratorio de ParalelismoIF - EHU
MPI 1333
El objetivo de un programa paralelo es resolver problemas más grandes y/o en menor tiempo.
Los parámetros típicos que miden el rendimiento de una determinada ejecución en paralelo son (N = tam. probl., P = núm. proc.):
speed-up S(N,P) = Ts(N) / Tp(N,P)
eficiencia E(N,P) = S(N,P) / PLa comparación de tiempos hay que hacerla con el mejor programa serie, y no con el programa paralelo ejecutado sobre un procesador.
Performance
Laboratorio de ParalelismoIF - EHU
MPI 1343
Factores que limitan el rendimiento> parte del código se ejecutará en serie (Amdahl)
- a tamaño constante S 1 / (1-f)
- a tiempo constante S f * p
S debería estar entre 0 y P (E, entre 0 y 1)
S = P es el caso ideal. En todo caso, lo mejor es que S sea una función lineal de P (escalabilidad).¡pero puede ser que S < 1! (peor que el caso serie)S > P?? Influyen otros factores; por ejemplo, el hecho de que el sistema de P procesadores tenga P veces más memoria que un solo procesador.
Performance
Laboratorio de ParalelismoIF - EHU
MPI 1353
ts + N/B ts = latencia (start-up)B = ancho de bandaN = datos a transmitir
Factores que limitan el rendimiento
Cuando se ejecuta el código en paralelo, hay que hacer más cosas que simplemente ejecutar cálculo. Lo principal, la comunicación entre procesos (y las operaciones de entrada/salida).
Tp(N,P) = T_calc(N,P) + T_com(N,P) + (T_io)
Performance
Laboratorio de ParalelismoIF - EHU
MPI 1363
Comunicación
Tc = ts + N/B
0
1000
2000
3000
4000
5000
0 1000 2000 3000 4000 5000
Tc
N
ABreal = N / Tc = = B / (1 + B*ts/N)
(x 1/B)
0
0.2
0.4
0.6
0.8
1
1 10 100 1000 104 105
ABreal
N
Performance
Laboratorio de ParalelismoIF - EHU
MPI 1373
Factores que limitan el rendimiento
> cálculo extra (replicado)> tiempos muertos (load balancing) (+
Tidle)
Tp(N,P) = Tcal(N,P) + Tcom(N,P) + Tidle + (Tio)
Es útil/necesario solapar cálculo y comunicación en cada proceso:
(a) comunicaciones no bloqueantes.(b) procesadores específicos de
comunicación.
Performance
Laboratorio de ParalelismoIF - EHU
MPI 1383
Hay que elegir el algoritmo adecuado al problema, teniendo en cuenta el tiempo de respuesta.
Error: cambiar un buen algoritmo secuencial por un algoritmo paralelo... ¡desastroso!
Hay que analizar con cuidado el reparto de datos a los procesadores (localidad).
Error: suponer que las operaciones de coma flotante son asociativas (reducciones).
Performance
Laboratorio de ParalelismoIF - EHU
MPI 1393
Intentar reducir el efecto de la latencia en la comunicación:
• Agrupar datos en los envíos.• Aumentar el tamaño de grano de las tareas.
• Utilizar las diferentes estrategias de gestión de los mensajes para reducir los tiempos muertos en la comunicación (handshake).Error: no tomar en consideración las limitaciones de buffering del sistema (dep. de la máquina!).
Performance
Laboratorio de ParalelismoIF - EHU
MPI 1403
Algunas ideas sobre debugging de programas paralelos:
• es más difícil; un error puede no corresponder a un proceso, sino a una secuencia de acciones en diferentes procesos.
• es imposible predecir el comportamiento de un programa erróneo, ya que los resultados cambian de ejecución a ejecución y de sistema a sistema.
• la gran mayoría de los errores no tienen nada que ver con el paralelismo.
Debugging
Laboratorio de ParalelismoIF - EHU
MPI 1413
Procedimiento a seguir:
1. Hacer una versión serie del programa.Diseñar previamente el programa antes de escribir código, seguir un proceso incremental de pruebas, mejor ser claro que “original”...Utilizar las herramientas de depuración de programas serie (por ejemplo, gdb).
2. Tras diseñar el programa paralelo, probarlo en un solo procesador.
3. Si es correcto, probarlo con más procesadores.
Debugging
Laboratorio de ParalelismoIF - EHU
MPI 1423
Los problemas específicos están relacionados casi siempre con la “sincronización” de los procesos:• Carreras (races)
Los programas paralelos pueden ofrecer resultados no deterministas, que cambian de ejecución a ejecución.
• Bloqueos (deadlocks)Los procesos se bloquean en operaciones de comunicación que no se completan. Por ejemplo:
+ intentar recibir datos con Recv pero no enviarlos.
+ parámetros no correctos en las funciones de comunicación: direcciones de origen/destino, tags...
Debugging
Laboratorio de ParalelismoIF - EHU
MPI 1433
Ante un determinado problema, tres líneas a seguir:1. Leer el código detenidamente, e intentar
deducir cómo se comporta el programa paralelo (si es sencillo y sabemos más o menos dónde puede estar el error).
2. Tracear el programa mediante (printf); etiquetar los mensajes con el nodo y hacer flush(stdout);... Ojo: la introducción de trazas puede modificar el comportamiento del programa.Es útil imprimir los parámetros de comunicación antes de enviar los mensajes y cuando se reciben.
Debugging
Laboratorio de ParalelismoIF - EHU
MPI 1443
3. Usar un debbuger simbólico: TotalView, gdb...
Casi todas las funciones MPI devuelven un código que puede ayudar a identificar problemas.Manejadores de errores (error handler, EH)- MPI_ERRORS_ARE_FATAL: el programa aborta.- MPI_ERRORS_RETURN: devuelve un código de error.
Los EH están asociados a los comunicadores (recuerda que un comunicador puede llevar parámetros “cacheados”, como, por ejemplo, una topología). Un ejemplo:
Debugging
Ante un determinado problema, tres líneas a seguir:
Laboratorio de ParalelismoIF - EHU
MPI 1453
int cod_err;cod_err = MPI_Errhandler_set (MPI_COMM_WORLD,
MPI_ERRORS_RETURN);
char mens_err[MPI_MAX_ERROR_STRING];int long_mens;
cod_err = MPI_Broadcast (&x, 1, MPI_INT, 0, comm);if (cod_err != MPI_SUCCESS) {MPI_Error_string (cod_err, mens_err, &long_mens);fprintf (stderr, “Error BC = %s\n”, mens_err);
fprintf (stderr, “Agur Benhur\n”);MPI_Abort (MPI_COMM_WORLD, -1); // -1: error_code
}
Debugging
Laboratorio de ParalelismoIF - EHU
MPI 1463
De cara a mejorar el rendimiento del programa, tenemos que identificar qué partes del mismo son las responsables de la mayor parte del tiempo de ejecución: hay que obtener un “perfil”.
Obviamente, para obtener un buen rendimiento debemos de partir de un buen algoritmo.
Hay que medir tiempos:- gettimeofday, MPI_Wtime…- barreras (?)- modificar las funciones MPI, para incluir toma de
tiempos (PMPI)
Profiling
Laboratorio de ParalelismoIF - EHU
MPI 1473
Usar alguna herramienta específica de profiling:
• gprof (serie)
• TotalView, Paragraph, Pablo, Vampir, Paradyne…
(INTEL, KAI, Porland, PALLAS…)
• jumpshot(xmpi / lam)
Se puede analizar el tiempo de ejecución de cada función MPI, los patrones de comunicación...
Profiling
Laboratorio de ParalelismoIF - EHU
MPI 1483
Jumpshot es una aplicación que permite analizar “gráficamente” el comportamiento de programas paralelos (MPICH / MPE) que se han ejecutado previamente y de los que se ha obtenido un fichero tipo “log”.
Para generar el fichero log podemos añadir puntos de muestreo en lugares concretos (añadiendo funciones de MPE), o, en casos sencillos, tomar datos de todas las funciones MPI:
> mpicc –mpe=mpilog –o p1 p1.c
> mpiexec –n num_proc p1
Jumpshot
Laboratorio de ParalelismoIF - EHU
MPI 1493
Al ejecutar el programa se genera el fichero p1.clog2, que, transformado a formato slog2, puede analizarse mediante jumpshot4
> clog2TOslog2 p1.clog2
> jumpshot
Veamos unos ejemplos de uso de jumpshot.
Jumpshot
Laboratorio de ParalelismoIF - EHU
Hemos analizado las funciones principales de MPI, pero hay más.
Por ejemplo, MPI-2 permite generar procesos de manera dinámica, y no solamente de manera estática, tal como hemos hecho a lo largo del curso.
También existen operaciones de comunicación one-sided (put, get) que permiten a un proceso acceder a la memoria local de otro (con lo que podríamos utilizar un modelo de memoria compartida!).
Comunicación one-sided
Laboratorio de ParalelismoIF - EHU
En la mayoría de los clusters, cada nodo es un pequeño multiprocesador (4-8 procesadores), o un procesador de cuatro a ocho núcleos con multithreading.
En esos casos es interesante utilizar simultáneamente los dos modelos: MPI (paso de mensajes entre nodos de memoria privada) y OpenMP (hilos de memoria compartida).
Basta con añadir a los procesos MPI las correspondientes directivas OpenMP, de tal manera que la tarea asignada a cada nodo se reparta entre los procesadores locales. Atención al modelo de memoria (variables privadas y compartidas), que es diferente en cada caso.
MPI-OpenMP
Laboratorio de ParalelismoIF - EHU
> MPI
• P. S. Pacheco: Parallel Programming with MPI. Morgan Kaufmann, 1997.
• W. Gropp et al.: Using MPI. Portable Parallel Programming with the Message Passing Interface.Using MPI-2. Advanced Features of the Message Passing Interface. The MIT Press, 1999.
• M. Snir et al.: MPI - The complete reference (vol. 1 /2).The MIT Press, 1998.
• mpich: www-unix.mcs.anl.gov/mpi/ lam: www.lam-mpi.org
Referencias
Laboratorio de ParalelismoIF - EHU
> Gestión de un cluster
• T. Sterling: Beowulf Cluster Computing with Linux.The MIT Press, 2002
• J.D. Sloan: High Performance Linux Clusters with OSCAR, Rocks, openMosix & MPI.O’Reilly, 2005
Referencias