MPI (Message Passing Interface)

transcript

الرحــمــن ـبـس الله مالرحـــيــم

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

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

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+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 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

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

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

MPI (Message Passing Interface)

Documents