1 / 42

MPI (Message Passing Interface)

بـس ـ م الله الرحــمــن الرحـــيــم. 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…

rhett
Download Presentation

MPI (Message Passing Interface)

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. بـسـم الله الرحــمــن الرحـــيــم MPI (Message Passing Interface)

  2. 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… • 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.

  3. Architectures visées • Machine parallèles à mémoire distribuée • Grappes de stations (clusters) • Réseaux hétérogènes de stations

  4. Format des fonctions • err = MPI_Xxxx(paramètre,...); • MPI_Xxxx(paramètre,...);

  5. Initialisation • 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.

  6. Quitter 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.

  7. Bonjour! (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 */

  8. Compilation et exécution • La compilation et l'exécution dépendent de l’environnement et de l’implémentation : • MPICH • CHIMP • LAM

  9. Compilation et exécution (salle de TP) • Nous disposons de la version MPI-LAM. • Compilation : • mpicc bonjour.c –o boujour • Exécution • Avant l'exécution il faut lancer le démon MPI avec la commande lamboot (une seule fois). • Pour lancer 4 processus : • mpirun –np 4 bonjour • Avant de quitter votre session, il faut lancer la commande lamhalt pour arrêter le démon MPI.

  10. Communicateur MPI_COMM_WORLD • Un 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.

  11. Communicateur MPI_COMM_WORLD

  12. Rang d'un processus • MPI_Rank(MPI_Comm comm, int *rang) • retourne le rang d'un processus dans un communicateur (rang est un entier).

  13. Taille • MPI_Comm_size(MPI_Comm comm, int *taille) • donne le nombre de processus dans le communicateur "comm'' (taille est un entier).

  14. 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(); • }

  15. Communications point à point (point-to-point)

  16. Envoi 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.

  17. MPI_Send (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).

  18. Ré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).

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

  20. Ordre 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.

  21. Exemple P0 Affichage bonjour de 1! bonjour de 2! bonjour de 7! P1 P2 P7 …

  22. #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);

  23. 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 */

  24. Exercices • 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 • 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.

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

  26. Envoi/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)

  27. Communications collectives

  28. Synchronisation • 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

  29. Diffusion • Un même processus envoie une même valeur à tous les autres processus (d'un communicateur). Données processus

  30. Diffusion • 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.

  31. Diffusion • 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); • }

  32. Réduction • Collecte et réduction par un processus d'un ensemble de valeurs détenues par tous les processus. Données processus

  33. Ré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.

  34. Exemple • 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);

  35. Ré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.

  36. Exemple • 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);

  37. Rassemblement • int 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). Données processus

  38. 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. Données processus

  39. Distribution personnalisée • int 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) Données processus

  40. Compactage/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)

  41. Exemple • #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); • }

  42. 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); • }

More Related