mpi (message passing interface)
DESCRIPTION
بـس ـ م الله الرحــمــن الرحـــيــم. MPI (Message Passing Interface). Introduction. MPI est un environnement de programmation par passage de message qui fournit une large variété de primitives qui peuvent être appelées à partir de programmes C, C++, Fortran… - PowerPoint PPT PresentationTRANSCRIPT
MPI (Message Passing Interface)
الرحــمــن ـبـس الله مالرحـــيــم
IntroductionIntroduction
MPI est un environnement de programmation par passage de message qui fournit une large variété de primitives qui peuvent être appelées à partir de programmes C, C++, Fortran…
Dans ce cours, nous allons voir la version 1, qui est basée sur un modèle de programmation statique : un nombre fixe de processus est créé au début de l'exécution du programme.
La version MPI-2, permet la création dynamique de processus.
Architectures viséesArchitectures visées
Machine parallèles à mémoire distribuéeGrappes de stations (clusters)Réseaux hétérogènes de stations
Format des fonctionsFormat des fonctions
err = MPI_Xxxx(paramètre,...);
MPI_Xxxx(paramètre,...);
InitialisationInitialisation
Chaque programme MPI doit contenir la directive :
#include "mpi.h"
Avant l'appel de toute fonction MPI, la fonction MPI_Init doit être appelée:
int MPI_Init(int argc, char **argv)
Cette fonction permet d'initialiser MPI.
Quitter MPIQuitter MPI
int MPI_Finalize()
Permet de sortir de MPI et doit être appelée par tous les processus.
Aucune fonction MPI ne doit être appelée après cette fonction.
Bonjour! Bonjour! (bonjour.c)(bonjour.c)
#include <stdio.h>
#include "mpi.h"
main(int argc, char* argv[]) {
MPI_Init(&argc, &argv); /* Démarrer MPI */
printf("Bonjour !\n");
MPI_Finalize(); /* Quitter MPI */
} /* main */
Compilation et exécutionCompilation et exécution
La compilation et l'exécution dépendent de l’environnement et de l’implémentation :
MPICHCHIMPLAM
Compilation et exécution (salle de Compilation et exécution (salle de TP)TP)Nous disposons de la version MPI-LAM.
Compilation :Compilation :mpicc bonjour.c –o boujour
ExécutionExécutionAvant l'exécution il faut lancer le démon MPI avec la
commande lamboot (une seule fois).Pour lancer 4 processus :mpirun –np 4 bonjourAvant de quitter votre session, il faut lancer la
commande lamhalt pour arrêter le démon MPI.
Communicateur Communicateur MPI_COMM_WORLDMPI_COMM_WORLDUn communicateur est un ensemble de processus
qui peuvent échanger des messages entre eux. MPI_COMM_WORLD est un communicateur prédéfini qui regroupe tous les processus.
On peut définir d'autres communicateurs.
Communicateur Communicateur MPI_COMM_WORLDMPI_COMM_WORLD
Rang d'un processusRang d'un processus
MPI_Rank(MPI_Comm comm, int *rang)
retourne le rang d'un processus dans un communicateur (rang est un entier).
TailleTaille
MPI_Comm_size(MPI_Comm comm, int *taille)
donne le nombre de processus dans le communicateur "comm'' (taille est un entier).
Exemple Exemple #include <stdio.h>
#include "mpi.h"
main(int argc, char* argv[]) {
int rang; /* rang du processus */
int p; /* nombre de processus */
MPI_Init(&argc, &argv);
MPI_Comm_rank(MPI_COMM_WORLD, &rang);
MPI_Comm_size(MPI_COMM_WORLD, &p);
printf("Mon numéro est : %d et le nombre de processus est :%d \n",rang,p);
MPI_Finalize();
}
Communications point Communications point à point à point
(point-to-point)(point-to-point)
Envoi de messagesEnvoi de messages
MPI_Send(void* message, int count, MPI_Datatype datatype,
int dest, int etiquette,
MPI_Comm comm)
Envoie un message à "dest''. Elle est bloquante.
MPI_Send (MPI_Send (description):description):
message : tableau de type ``datatype''.
count : taille du message.
datatype : type des données. Les types prédéfinies sont :MPI_CHAR MPI_SHORT
MPI_INT MPI_UNSIGNED_CHAR
MPI_LONG MPI_UNSIGNED_SHORT
MPI_FLOAT MPI_UNSIGNED_LONG
MPI_DOUBLE MPI_LONG_DOUBLE
MPI_UNSIGNED MPI_PACKED
MPI_BYTE
etiquette : étiquette (pour différencier les messages d’un même couple émetteur/receveur).
RéceptionRéception
MPI_Recv(void* buf, int count, MPI_Datatype
datatype, int source, int etiquette,
MPI_Comm comm, MPI_Status *status)
Permet de recevoir un message de "source''. Elle est bloquante.
"source'' peut avoir la valeur MPI_ANY_SOURCE (n'improte quelle source).
"etiquette'' peut avoir la valeur MPI_ANY_TAG (n'importe quelle étiquette).
Réception (description)Réception (description)
status : identificateur de l'émetteur et du message reçu.status.MPI_SOURCE : source
status.MPI_TAG : tag
status.ERROR : erreur
"status'' contient l'information sur la taille du message.
Pour cela, on appelle la fonction :
int MPI_Get_count(MPI_Status *status, MPI_Datatype datatype, int *nbre)
Ordre de réception des messagesOrdre de réception des messages
Si deux processus A et B envoient un message à un autre processus C, l'ordre d'arrivé des messages n'est pas déterminé.
Si un processus envoie un message m1 à C ensuite envoie un message m2 à C, alors m1 sera reçu avant m2.
Exemple Exemple
…bonjour de 1!P1
bonjour de 2!P2
bonjour de 7!P7
P0
Affichage
#include <stdio.h>#include <string.h>#include "mpi.h"main(int argc, char* argv[]) { int my_rank; /* rang du processus */ int p; /* nombre de processus */ int source; /* rang de l'émetteur */ int dest; /* rang du récepteur */ int tag = 0; /* étiquette */ char message[100]; /*pour stocker le message*/ MPI_Status status; /* status du message */
MPI_Init(&argc, &argv); /* Démarrer MPI */MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);MPI_Comm_size(MPI_COMM_WORLD, &p);
if (my_rank != 0) { /* si je ne suis pas le processus racine*/ sprintf(message, "Bonjour de %d!", my_rank); dest = 0; /* Utiliser strlen+1 pour que '\0' soit transmis! */ MPI_Send(message, strlen(message)+1, MPI_CHAR,
dest, tag, MPI_COMM_WORLD); } else { /* my_rank == 0 */ for (source = 1; source < p; source++) { MPI_Recv(message, 100, MPI_CHAR, source, tag,
MPI_COMM_WORLD, &status); printf("%s\n", message); } } MPI_Finalize(); /* Quitter MPI */} /* fin de la fonction main */
ExercicesExercices
1. Utiliser MPI_ANY_SOURCE et MPI_ANY_TAG pour écrire le programme suivant :
– chaque processus envoi son rang au processus 0
– le processus 0 reçoit le numéro et l'affiche
2. Ecrire un programme qui permet de réaliser:
le processus 0 envoi un vecteur au processus 1, le processus 1 envoie le vecteur reçu au processus 2 et ainsi de suite, jusqu'à réception du vecteur par le dernier processus.
3. Ecrire un programme qui fait la même chose que l'exercice 2, mais cette fois le message est envoyé en pipeline (découpé en plusieurs morceaux).
Envoi/réception non bloquantEnvoi/réception non bloquant
int MPI_Isend(void* buf, int count, MPI_Datatype
datatype, int dest, int tag, MPI_Comm comm,
MPI_Request *request)
int MPI_Irecv(void* buf, int count, MPI_Datatype
datatype, int source, int tag,
MPI_Comm comm, MPI_Request *request)
Communications Communications collectivescollectives
SynchronisationSynchronisation
int MPI_Barrier(MPI_Comm comm)
Synchronisation ou rendez-vous
Pas d'échange d'informations
Tous les processus sont assurés que tous ont ralliés le point de synchronisation
DiffusionDiffusion
Un même processus envoie une même valeur à tous les autres processus (d'un communicateur).
A0 A0
A0
A0
A0
A0
processus
Données
DiffusionDiffusion
int MPI_Bcast(void *buff, int count, MPI_Datatype datatype, int root, MPI_Comm comm)
Appel par tous les processus du communicateur comm avec la même valeur de root, count, datatype.
La valeur détenue par le processus root sera émise et rangée chez chacun des autres processus.
DiffusionDiffusion
void Get_data(int my_ rank, float *a_ ptr){
int root = 0; int count = 1; if (my_ rank == root) { printf(" Donner a\ n"); scanf("%f", a_ ptr); } MPI_Bcast(a_ptr, 1, MPI_FLOAT, root,
MPI_COMM_WORLD); }
RéductionRéduction
Collecte et réduction par un processus d'un ensemble de valeurs détenues par tous les processus.
A0
B0
C0
D0
E0
A0+B0+C0+D0+E0processus
Données
RéductionRéduction
MPI_Reduce(void *sbuf, void* rbuf, int count, MPI_Datatype dtype, MPI_Op op, int root, MPI_Comm comm)
Appel par tous les processus du communicateur comm avec une même valeur de count, datatype, op.
Les Opérations binaires prédéfinies par MPI sont (MPI_ MAX , MPI_ SUM ...), avec possibilité de définir de nouvelles opérations.
Seul le processus root détient le résultat.
ExempleExemple
ps_local = ps(x,y,n); /* produit scalaire de deux vecteurs */
MPI_Reduce(&ps_local, &ps_global, 1, MPI_FLOAT, MPI_SUM, 0, MPI_COMM_WORLD);
Réduction généraliséeRéduction généralisée
int MPI_Allreduce(void *sbuf, void *rbuf, int count, MPI_Datatype dtype, MPI_Op op, MPI_Comm comm)
C'est une réduction avec résultat dans chacun des processus.
ExempleExemple
ps_local = ps(x,y,n); /* produit scalaire de deux vecteurs */
MPI_Allreduce(&ps_local, &ps_global, 1, MPI_FLOAT, MPI_SUM, MPI_COMM_WORLD);
RassemblementRassemblementint MPI_Gather(void *sbuf, int scount,
MPI_Datatype sdtype, void *rbuf, int rcount, MPI_Datatype rdtype, int root, MPI_Comm comm)
Mise bout à bout des messages de chacun des processus (All-to-One).
A0
B0
C0
D0
E0
A0 B0 C0 D0 E0processus
Données
Commérage (All-to-All)Commérage (All-to-All)int MPI_Allgather(void *sbuf, int scount, MPI_Datatype
sdtype, void *rbuf, int rcount, MPI_Datatype rdtype, MPI_Comm comm)
Même chose que MPI_Gather, avec résultat dans chacun des processus.
A0
B0
C0
D0
E0
A0 B0 C0 D0 E0
A0 B0 C0 D0 E0
A0 B0 C0 D0 E0
A0 B0 C0 D0 E0
A0 B0 C0 D0 E0
processus
Données
Distribution personnaliséeDistribution personnaliséeint MPI_Scatter(void *sbuf, int scount,MPI_Datatype
sdtype, void *rbuf, int rcount, MPI_Datatype rdtype, int root, MPI_Comm comm)
Distribution d'un message personnalisé aux autres processus (One-to-All)
A0 B0 C0 D0 E0processus
Données
A0
B0
C0
D0
E0
Compactage/décompactageCompactage/décompactage
Les fonctions MPI_Pack et MPI_Unpack, compactent et décompactent différents données destinées à être envoyées.
int MPI_Pack(void *buf, int count, MPI_Datatype dtype, void *packbuf, int packsize, int *packpos, MPI_Comm comm)
int MPI_Unpack(void* inbuf, int insize, int *position, void *outbuf, int outcount, MPI_Datatype datatype, MPI_Comm comm)
ExempleExemple#define COM MPI_COMM_WORLD
if (my_rank == root){
printf("Donner a, b, et n\ n");
scanf("% f %f %d", a, b, n);
/* compactage des données dans le buffer */
position = 0;
/* On commence au début du buffer */
MPI_ Pack( a, 1, MPI_ FLOAT, buffer, 100, &position, COM);
/* position a été incrémenté de sizeof(float) bytes */
MPI_ Pack( b, 1, MPI_ FLOAT, buffer, 100, &position,);
MPI_ Pack( n, 1, MPI_ INT, buffer, 100, &position, COM);
/* Diffusion du contenu du buffer */
MPI_Bcast( buffer, 100, MPI_PACKED, root, COM);
}
exemple (suite)exemple (suite)
else {
MPI_Bcast( buffer, 100, MPI_PACKED, root, COM);
/* Unpack des données depuis le buffer */
position = 0;
MPI_ Unpack( buffer, 100, &position, a, 1, MPI_FLOAT, COM);
/* De même, position a été incrémenté de sizeof( float) bytes */
MPI_Unpack( buffer, 100, &position, b, 1, MPI_FLOAT, COM);
MPI_Unpack( buffer, 100, &position, n, 1, MPI_INT, COM);
}