Message Passing Interface (MPI)

Transcription

1 Message Passing Interface (MPI) Isabelle Dupays Marie Flé Jérémie Gaidamour Dimitri Lecas

2 MPI Plan I 1 Introduction Introduction Concepts de l échange de messages Mémoire distribuée Historique Bibliographie Environnement Communications point à point Notions générales Opérations d envoi et de réception bloquantes Types de données de base Autres possibilités Communications collectives Notions générales Synchronisation globale : MPI_BARRIER() Diffusion générale : MPI_BCAST() Diffusion sélective : MPI_SCATTER() Collecte : MPI_GATHER() Collecte générale : MPI_ALLGATHER() Collecte : MPI_GATHERV() Échanges croisés : MPI_ALLTOALL() Réductions réparties... 70

3 MPI Plan II 4.10 Compléments Types de données dérivés Introduction Types contigus Types avec un pas constant Validation des types de données dérivés Exemples Types homogènes à pas variable Construction de sous-tableaux Types hétérogènes Taille des types de données Conclusion Modèles de communication Modes d envoi point à point Appel bloquant Appel non bloquant Communicateurs Introduction Exemple Communicateur par défaut Groupes et communicateurs Partitionnement d un communicateur...144

4 MPI Plan III 7.6 Communicateur construit à partir d un groupe Topologies MPI-IO Introduction Ouverture et fermeture d un fichier Lectures/écritures : généralités Lectures/écritures individuelles Lectures/écritures collectives Positionnement explicite des pointeurs dans un fichier Vues sur les fichiers Lectures/écritures non bloquantes Conseils Definitions Conclusion Annexes Communications collectives Types de données dérivés Optimisations Communicateurs Gestion de processus RMA MPI-IO

5 MPI Plan IV 11 Index Index des constantes MPI Index des sous-programmes MPI...337

6 6/343 1 Introduction 1 Introduction 1.1 Introduction Concepts de l échange de messages Mémoire distribuée Historique Bibliographie Environnement 3 Communications point à point 4 Communications collectives 5 Types de données dérivés 6 Modèles de communication 7 Communicateurs 8 MPI-IO 9 Conclusion 10 Annexes 11 Index

7 7/343 1 Introduction 1.1 Introduction 1 Introduction 1.1 Introduction Parallélisme L intérêt de faire de la programmation parallèle est : De réduire le temps de restitution ; D effectuer de plus gros calculs ; D exploiter le parallélisme des processeurs modernes (multi-coeurs, multithreading). Mais pour travailler à plusieurs, la coordination est nécessaire. MPI est une bibliothèque permettant de coordonner des processus en utilisant le paradigme de l échange de messages.

8 8/343 1 Introduction 1.2 Concepts de l échange de messages 1 Introduction 1.2 Concepts de l échange de messages Modèle de programmation séquentiel le programme est exécuté par un et un seul processus ; toutes les variables et constantes du programme sont allouées dans la mémoire allouée au processus ; un processus s exécute sur un processeur physique de la machine. Mémoire Programme P Figure 1 Modèle de programmation séquentiel

9 9/343 1 Introduction 1.2 Concepts de l échange de messages Modèle de programmation par échange de messages le programme est écrit dans un langage classique (Fortran, C, C++, etc.) ; toutes les variables du programme sont privées et résident dans la mémoire locale allouée à chaque processus; chaque processus exécute éventuellement des parties différentes d un programme ; une donnée est échangée entre deux ou plusieurs processus via un appel, dans le programme, à des sous-programmes particuliers. Mémoires Processus Réseau Programmes Figure 2 Modèle de programmation par échange de messages

10 10/343 1 Introduction 1.2 Concepts de l échange de messages Concepts de l échange de messages Si un message est envoyé à un processus, celui-ci doit ensuite le recevoir 0 1 source cible J envoie source Je reçois dans cible Figure 3 Échange d un message

11 11/343 1 Introduction 1.2 Concepts de l échange de messages Constitution d un message Un message est constitué de paquets de données transitant du processus émetteur au(x) processus récepteur(s) En plus des données (variables scalaires, tableaux, etc.) à transmettre, un message doit contenir les informations suivantes : l identificateur du processus émetteur; le type de la donnée; sa longueur; l identificateur du processus récepteur. Mémoires Processus Réseau d1 1 message d2 2 message emetteur récepteur type longueur Figure 4 Constitution d un message DONNEE d1

12 12/343 1 Introduction 1.2 Concepts de l échange de messages Environnement Les messages échangés sont interprétés et gérés par un environnement qui peut être comparé à la téléphonie, à la télécopie, au courrier postal, à la messagerie électronique, etc. Le message est envoyé à une adresse déterminée Le processus récepteur doit pouvoir classer et interpréter les messages qui lui ont été adressés L environnement en question est MPI (Message Passing Interface). Une application MPI est un ensemble de processus autonomes exécutant chacun leur propre code et communiquant via des appels à des sous-programmes de la bibliothèque MPI

13 13/343 1 Introduction 1.3 Mémoire distribuée 1 Introduction 1.3 Mémoire distribuée Architecture des supercalculateurs La plupart des supercalculateurs sont des machines à mémoire distribuée. Ils sont composés d un ensemble de nœud, à l intérieur d un nœud la mémoire est partagée. Noeud 0 Noeud n... Réseau Figure 5 Architecture des supercalculateurs

14 14/343 1 Introduction 1.3 Mémoire distribuée Ada 332 nœuds de calcul 4 processeurs Intel SandyBridge (8-cœurs) à 2,7 GHz par nœud cœurs 46 To ( 304 nœuds à 128Go et 28 nœuds à 256 Go ) 230 Tflop/s crête 192 Tflop/s (linpack) 244 kwatt 786 MFLOPS/watt

15 15/343 1 Introduction 1.3 Mémoire distribuée Turing nœuds 16 processeurs POWER A2 à 1,6 GHz par nœud cœurs threads 64 Tio ( 16 Go par nœud) 839 Tflop/s crête 716 Tflop/s (linpack) 329 kwatt MFLOPS/watt

16 16/343 1 Introduction 1.3 Mémoire distribuée MPI vs OpenMP OpenMP utilise un schéma à mémoire partagée, tandis que pour MPI la mémoire est distribuée. Figure 6 Schéma MPI Figure 7 Schéma OpenMP

17 17/343 1 Introduction 1.3 Mémoire distribuée Décomposition de domaine Un schéma que l on rencontre très souvent avec MPI est la décomposition de domaine. Chaque processus possède une partie du domaine global, et effectue principalement des échanges avec ses processus voisins * * * * * * Figure 8 Découpage en sous-domaines

18 18/343 1 Introduction 1.4 Historique 1 Introduction 1.4 Historique Historique Version 1.0 : en juin 1994, le forum MPI (Message Passing Interface Forum), avec la participation d une quarantaine d organisations, abouti à la définition d un ensemble de sous-programmes concernant la bibliothèque d échanges de messages MPI Version 1.1 : juin 1995, avec seulement des changements mineurs Version 1.2 : en 1997, avec des changements mineurs pour une meilleure cohérence des dénominations de certains sous-programmes Version 1.3 : septembre 2008, avec des clarifications dans MPI 1.2, en fonction des clarifications elles-mêmes apportées par MPI-2.1 Version 2.0 : apparue en juillet 1997, cette version apportait des compléments essentiels volontairement non intégrés dans MPI 1.0 (gestion dynamique de processus, copies mémoire à mémoire, entrées-sorties parallèles, etc.) Version 2.1 : juin 2008, avec seulement des clarifications dans MPI 2.0 mais aucun changement Version 2.2 : septembre 2009, avec seulement de «petites» additions

19 19/343 1 Introduction 1.4 Historique MPI 3.0 Version 3.0 : septembre 2012 changements et ajouts importants par rapport à la version 2.2 ; principaux changements : communications collectives non bloquantes; révision de l implémentation des copies mémoire à mémoire; Fortran ( ) bindings; suppression de l interface C++; interfaçage d outils externes (pour le débogage et les mesures de performance); etc. voir

20 20/343 1 Introduction 1.5 Bibliographie 1 Introduction 1.5 Bibliographie Bibliographie Message Passing Interface Forum, MPI : A Message-Passing Interface Standard, Version 3.0, High Performance Computing Center Stuttgart (HLRS), Message Passing Interface Forum, MPI : A Message-Passing Interface Standard, Version 2.2, High Performance Computing Center Stuttgart (HLRS), William Gropp, Ewing Lusk et Anthony Skjellum : Using MPI : Portable Parallel Programming with the Message Passing Interface, second edition, MIT Press, 1999 William Gropp, Ewing Lusk et Rajeev Thakur : Using MPI-2, MIT Press, 1999 Peter S. Pacheco : Parallel Programming with MPI, Morgan Kaufman Ed., 1997 Documentations complémentaires :

21 21/343 1 Introduction 1.5 Bibliographie Implémentations MPI open source Elles peuvent être installées sur un grand nombre d architectures mais leurs performances sont en général en dessous de celles des implémentations constructeurs MPICH2 : Open MPI :

22 22/343 1 Introduction 1.5 Bibliographie Outils Débogueurs Totalview DDT Outils de mesure de performances MPE : MPI Parallel Environment Scalasca : Scalable Performance Analysis of Large-Scale Applications Vampir

23 23/343 1 Introduction 1.5 Bibliographie Bibliothèques scientifiques parallèles open source ScaLAPACK : résolution de problèmes d algèbre linéaire par des méthodes directes. Les sources sont téléchargeables sur le site PETSc : résolution de problèmes d algèbre linéaire et non-linéaire par des méthodes itératives. Les sources sont téléchargeables sur le site MUMPS : résolution de grands systèmes linéaires creux par méthode directe multifrontale parallèle. Les sources sont téléchargeables sur le site FFTW : transformées de Fourier rapides. Les sources sont téléchargeables sur le site

24 24/343 2 Environnement 1 Introduction 2 Environnement 3 Communications point à point 4 Communications collectives 5 Types de données dérivés 6 Modèles de communication 7 Communicateurs 8 MPI-IO 9 Conclusion 10 Annexes 11 Index

25 25/343 2 Environnement Description Toute unité de programme appelant des sous-programmes MPI doit inclure un fichier d en-têtes. En Fortran, il faut utiliser le module mpi introduit dans MPI-2 (dans MPI-1, il s agissait du fichier mpif.h), et en C/C++ le fichier mpi.h. Le sous-programme MPI_INIT() permet d initialiser l environnement nécessaire : integer, intent(out) :: code call MPI_INIT(code) Réciproquement, le sous-programme MPI_FINALIZE() désactive cet environnement : integer, intent(out) :: code call MPI_FINALIZE(code)

26 26/343 2 Environnement Communicateurs Toutes les opérations effectuées par MPI portent sur des communicateurs. Le communicateur par défaut est MPI_COMM_WORLD qui comprend tous les processus actifs Figure 9 Communicateur MPI_COMM_WORLD

27 27/343 2 Environnement Arrêt d un programme Parfois un programme se trouve dans une situation où il doit s arrêter sans attendre la fin normale. C est typiquement le cas si un des processus ne peut pas allouer la mémoire nécessaire à son calcul. Dans ce cas il faut utiliser le sous-programme MPI_ABORT() et non l instruction Fortran stop. integer, intent(in) :: comm, erreur integer, intent(out) :: code call MPI_ABORT(comm, erreur, code) comm : tous les processus appartenant à ce communicateur seront stoppés, il est conseillé d utiliser MPI_COMM_WORLD ; erreur : numéro d erreur retourné à l environnement UNIX. Code Il n est pas nécessaire de tester la valeur de code après des appels aux routines MPI. Par défaut, lorsque MPI rencontre un problème, le programme s arrête comme lors d un appel à MPI_ABORT().

28 28/343 2 Environnement Rang et nombre de processus À tout instant, on peut connaître le nombre de processus gérés par un communicateur donné par le sous-programme MPI_COMM_SIZE() : integer, intent(out) :: nb_procs,code call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) De même, le sous-programme MPI_COMM_RANK() permet d obtenir le rang d un processus (i.e. son numéro d instance, qui est un nombre compris entre 0 et la valeur renvoyée par MPI_COMM_SIZE() 1) : integer, intent(out) :: rang,code call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code)

29 29/343 2 Environnement 1 program qui_je_suis 2 use mpi 3 implicit none 4 integer :: nb_procs,rang,code 5 6 call MPI_INIT(code) 7 8 call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 9 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) print *, Je suis le processus,rang, parmi,nb_procs call MPI_FINALIZE(code) 14 end program qui_je_suis > mpiexec -n 7 qui_je_suis Je suis le processus 3 parmi 7 Je suis le processus 0 parmi 7 Je suis le processus 4 parmi 7 Je suis le processus 1 parmi 7 Je suis le processus 5 parmi 7 Je suis le processus 2 parmi 7 Je suis le processus 6 parmi 7

30 30/343 3 Communications point à point 1 Introduction 2 Environnement 3 Communications point à point 3.1 Notions générales Opérations d envoi et de réception bloquantes Types de données de base Autres possibilités Communications collectives 5 Types de données dérivés 6 Modèles de communication 7 Communicateurs 8 MPI-IO 9 Conclusion 10 Annexes 11 Index

31 31/343 3 Communications point à point 3.1 Notions générales 3 Communications point à point 3.1 Notions générales Notions générales Une communication dite point à point a lieu entre deux processus, l un appelé processus émetteur et l autre processus récepteur (ou destinataire) Émetteur Récepteur 5 6 Figure 10 Communication point à point

32 32/343 3 Communications point à point 3.1 Notions générales Notions générales L émetteur et le récepteur sont identifiés par leur rang dans le communicateur. Ce que l on appelle l enveloppe d un message est constituée : du rang du processus émetteur; du rang du processus récepteur; de l étiquette (tag) du message ; du communicateur qui définit le groupe de processus et le contexte de communication. Les données échangées sont typées (entiers, réels, etc ou types dérivés personnels). Il existe dans chaque cas plusieurs modes de transfert, faisant appel à des protocoles différents.

33 33/343 3 Communications point à point 3.2 Opérations d envoi et de réception bloquantes 3 Communications point à point 3.2 Opérations d envoi et de réception bloquantes Opération d envoi MPI_SEND <type et attribut>:: message integer :: longueur, type integer :: rang_dest, etiquette, comm, code call MPI_SEND(message,longueur,type,rang_dest,etiquette,comm,code) Envoi, à partir de l adresse message, d un message de taille longueur, de type type, étiqueté etiquette, au processus rang_dest dans le communicateur comm. Remarque : Cette opération est bloquante : l exécution reste bloquée jusqu à ce que le contenu de message puisse être réécrit sans risque d écraser la valeur qui devait être envoyée.

34 34/343 3 Communications point à point 3.2 Opérations d envoi et de réception bloquantes Opération de réception MPI_RECV <type et attribut>:: message integer :: longueur, type integer :: rang_source, etiquette, comm, code integer, dimension( MPI_STATUS_SIZE) :: statut call MPI_RECV(message,longueur,type,rang_source,etiquette,comm,statut,code) Réception, à partir de l adresse message, d un message de taille longueur, de type type, étiqueté etiquette, du processus rang_source. Remarques : statut reçoit des informations sur la communication : rang_source, etiquette, code,.... L appel MPI_RECV ne pourra fonctionner avec une opération MPI_SEND que si ces deux appels ont la même enveloppe (rang_source, rang_dest, etiquette, comm). Cette opération est bloquante : l exécution reste bloquée jusqu à ce que le contenu de message corresponde au message reçu.

35 35/343 3 Communications point à point 3.2 Opérations d envoi et de réception bloquantes 1 program point_a_point 2 use mpi 3 implicit none 4 5 integer, dimension( MPI_STATUS_SIZE) :: statut 6 integer, parameter :: etiquette=100 7 integer :: rang,valeur,code 8 9 call MPI_INIT(code) call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) if (rang == 2) then 14 valeur= call MPI_SEND(valeur,1, MPI_INTEGER,5,etiquette, MPI_COMM_WORLD,code) 16 elseif (rang == 5) then 17 call MPI_RECV(valeur,1, MPI_INTEGER,2,etiquette, MPI_COMM_WORLD,statut,code) 18 print *, Moi, processus 5, j ai reçu,valeur, du processus end if call MPI_FINALIZE(code) end program point_a_point > mpiexec -n 7 point_a_point Moi, processus 5, j ai reçu 1000 du processus 2

36 36/343 3 Communications point à point 3.3 Types de données de base 3 Communications point à point 3.3 Types de données de base Types de données de base Fortran Table 1 Principaux types de données de base (Fortran) Type MPI MPI_INTEGER MPI_REAL MPI_DOUBLE_PRECISION MPI_COMPLEX MPI_LOGICAL MPI_CHARACTER Type Fortran INTEGER REAL DOUBLE PRECISION COMPLEX LOGICAL CHARACTER

37 37/343 3 Communications point à point 3.3 Types de données de base Types de données de base C Table 2 Principaux types de données de base (C) Type MPI MPI_CHAR MPI_SHORT MPI_INT MPI_LONG MPI_UNSIGNED_CHAR MPI_UNSIGNED_SHORT MPI_UNSIGNED MPI_UNSIGNED_LONG MPI_FLOAT MPI_DOUBLE MPI_LONG_DOUBLE Type C signed char signed short signed int signed long int unsigned char unsigned short unsigned int unsigned long int float double long double

38 38/343 3 Communications point à point 3.4 Autres possibilités 3 Communications point à point 3.4 Autres possibilités Autres possibilités À la réception d un message, le rang du processus et l étiquette peuvent être des «jokers», respectivement MPI_ANY_SOURCE et MPI_ANY_TAG. Une communication avec le processus «fictif» de rang MPI_PROC_NULL n a aucun effet. MPI_STATUS_IGNORE est une constante prédéfinie qui peut être utilisée à la place de la variable prévue pour récupérer en réception le statut. Il existe des variantes syntaxiques, MPI_SENDRECV() et MPI_SENDRECV_REPLACE(), qui effectuent un envoi et une réception (dans le premier cas, la zone de réception doit être forcément différente de la zone d émission). On peut créer des structures de données plus complexes grâce à ses propres types dérivés (voir le chapitre 5).

39 39/343 3 Communications point à point 3.4 Autres possibilités Opération d envoi et de réception simultanés MPI_SENDRECV <type et attribut>:: message_emis, message_recu integer :: longueur_message_emis, longueur_message_recu integer :: type_message_emis, type_message_recu integer :: rang_source, rang_dest, etiq_source, etiq_dest, comm, code integer, dimension( MPI_STATUS_SIZE) :: statut call MPI_SENDRECV(message_emis,longueur_message_emis,type_message_emis, rang_dest,etiq_source, message_recu, longueur_message_recu, type_message_recu, rang_source, etiq_dest, comm, statut, code) Envoi, à partir de l adresse message_emis, d un message de taille longueur_message_emis, de type type_message_emis, étiquetté etiq_source, au processus rang_dest dans le communicateur comm; réception, à partir de l adresse message_recu, d un message de taille longueur_message_recu, de type type_message_recu, étiquetté etiq_dest, du processus rang_source dans le communicateur comm.

40 40/343 3 Communications point à point 3.4 Autres possibilités Opération d envoi et de réception simultanés MPI_SENDRECV Figure 11 Communication sendrecv entre les processus 0 et 1

41 41/343 3 Communications point à point 3.4 Autres possibilités 1 program sendrecv 2 use mpi 3 implicit none 4 integer :: rang,valeur,num_proc,code 5 integer,parameter :: etiquette= call MPI_INIT(code) 8 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 9 10! On suppose avoir exactement 2 processus 11 num_proc=mod(rang+1,2) call MPI_SENDRECV(rang+1000,1, MPI_INTEGER,num_proc,etiquette,valeur,1, MPI_INTEGER, & 14 num_proc,etiquette, MPI_COMM_WORLD, MPI_STATUS_IGNORE,code) print *, Moi, processus,rang,, j ai reçu,valeur, du processus,num_proc call MPI_FINALIZE(code) 19 end program sendrecv > mpiexec -n 2 sendrecv Moi, processus 1, j ai reçu 1000 du processus 0 Moi, processus 0, j ai reçu 1001 du processus 1

42 42/343 3 Communications point à point 3.4 Autres possibilités Attention! Il convient de noter que dans le cas d une implémentation synchrone du MPI_SEND() (voir le chapitre 6), le code précédent serait en situation de verrouillage si à la place de l appel MPI_SENDRECV() on utilisait un MPI_SEND() suivi d un MPI_RECV(). En effet, chacun des deux processus attendrait un ordre de réception qui ne viendrait jamais, puisque les deux envois resteraient en suspens. call MPI_SEND(rang+1000,1, MPI_INTEGER,num_proc,etiquette, MPI_COMM_WORLD,code) call MPI_RECV(valeur,1, MPI_INTEGER,num_proc,etiquette, MPI_COMM_WORLD,statut,code)

43 43/343 3 Communications point à point 3.4 Autres possibilités Opération d envoi et de réception simultanés MPI_SENDRECV_REPLACE <type et attribut>:: message integer :: longueur integer :: type integer :: rang_source, rang_dest, etiq_source, etiq_dest, comm, code integer, dimension( MPI_STATUS_SIZE) :: statut call MPI_SENDRECV_REPLACE(message,longueur,type, rang_dest,etiq_source, rang_source, etiq_dest, comm, statut, code) Envoi, à partir de l adresse message, d un message de taille longueur, de type type, d étiquette etiq_source, au processus rang_dest dans le communicateur comm ; réception d un message à la même adresse, d une taille et d un type identique, d étiquette etiq_dest, du processus rang_source dans le communicateur comm.

44 44/343 3 Communications point à point 3.4 Autres possibilités 1 program joker 2 use mpi 3 implicit none 4 integer, parameter :: m=4,etiquette=11 5 integer, dimension(m,m) :: A 6 integer :: nb_procs,rang,code,i 7 integer, dimension( MPI_STATUS_SIZE ):: statut 8 9 call MPI_INIT (code) 10 call MPI_COMM_SIZE ( MPI_COMM_WORLD,nb_procs,code) 11 call MPI_COMM_RANK ( MPI_COMM_WORLD,rang,code) 12 A(:,:) = if (rang == 0) then 15! Initialisation de la matrice A sur le processus 0 16 A(:,:) = reshape((/ (i,i=1,m*m) /), (/ m,m /)) 17! Envoi de 3 éléments de la matrice A au processus 1 18 call MPI_SEND (A(1,1),3, MPI_INTEGER,1,etiquette, MPI_COMM_WORLD,code) 19 else 20! On reçoit le message 21 call MPI_RECV (A(1,2),3, MPI_INTEGER, MPI_ANY_SOURCE, MPI_ANY_TAG, & 22 MPI_COMM_WORLD,statut,code) 23 print *, Moi processus,rang, je recois 3 elements du processus, & 24 statut( MPI_SOURCE ), "avec l etiquette", statut( MPI_TAG ), & 25 " les elements sont ", A(1:3,2) 26 end if 27 call MPI_FINALIZE (code) 28 end program joker

45 45/343 3 Communications point à point 3.4 Autres possibilités > mpiexec -n 2 joker Moi processus 1 je recois 3 elements du processus 0 avec l etiquette 11 les elements sont 1 2 3

46 46/343 4 Communications collectives 1 Introduction 2 Environnement 3 Communications point à point 4 Communications collectives 4.1 Notions générales Synchronisation globale : MPI_BARRIER() Diffusion générale : MPI_BCAST() Diffusion sélective : MPI_SCATTER() Collecte : MPI_GATHER() Collecte générale : MPI_ALLGATHER() Collecte : MPI_GATHERV() Échanges croisés : MPI_ALLTOALL() Réductions réparties Compléments Types de données dérivés 6 Modèles de communication 7 Communicateurs 8 MPI-IO 9 Conclusion 10 Annexes 11 Index

47 47/343 4 Communications collectives 4.1 Notions générales 4 Communications collectives 4.1 Notions générales Notions générales Les communications collectives permettent de faire en une seule opération une série de communications point à point. Une communication collective concerne toujours tous les processus du communicateur indiqué. Pour chacun des processus, l appel se termine lorsque la participation de celui-ci à l opération collective est achevée, au sens des communications point-à-point (donc quand la zone mémoire concernée peut être modifiée). Il est inutile d ajouter une synchronisation globale (barrière) après une opération collective. La gestion des étiquettes dans ces communications est transparente et à la charge du système. Elles ne sont donc jamais définies explicitement lors de l appel à ces sous-programmes. Cela a entre autres pour avantage que les communications collectives n interfèrent jamais avec les communications point à point.

48 48/343 4 Communications collectives 4.1 Notions générales Types de communications collectives Il y a trois types de sous-programmes : 1 celui qui assure les synchronisations globales : MPI_BARRIER(). 2 ceux qui ne font que transférer des données : diffusion globale de données : MPI_BCAST() ; diffusion sélective de données : MPI_SCATTER() ; collecte de données réparties : MPI_GATHER() ; collecte par tous les processus de données réparties : MPI_ALLGATHER() ; diffusion sélective, par tous les processus, de données réparties : MPI_ALLTOALL(). 3 ceux qui, en plus de la gestion des communications, effectuent des opérations sur les données transférées : opérations de réduction (somme, produit, maximum, minimum, etc.), qu elles soient d un type prédéfini ou d un type personnel : MPI_REDUCE() ; opérations de réduction avec diffusion du résultat (équivalent à un MPI_REDUCE() suivi d un MPI_BCAST()) : MPI_ALLREDUCE().

49 49/343 4 Communications collectives 4.2 Synchronisation globale : MPI_BARRIER() 4 Communications collectives 4.2 Synchronisation globale : MPI_BARRIER() Synchronisation globale : MPI_BARRIER() P0 P1 P2 P3 P0 P1 P2 P3 P0 P1 P2 P3 Barrière Figure 12 Synchronisation globale : MPI_BARRIER() integer, intent(out) :: code call MPI_BARRIER( MPI_COMM_WORLD,code)

50 50/343 4 Communications collectives 4.3 Diffusion générale : MPI_BCAST() 4 Communications collectives 4.3 Diffusion générale : MPI_BCAST() 0 A A A 1 A 2 3 P0 P1 P2 A P3 MPI_BCAST() P0 A P1 A P2 A P3 A Figure 13 Diffusion générale : MPI_BCAST()

51 51/343 4 Communications collectives 4.3 Diffusion générale : MPI_BCAST() Diffusion générale : MPI_BCAST() <type et attribut> :: message integer :: longueur, type, rang_source, comm, code call MPI_BCAST(message, longueur, type, rang_source, comm, code) 1 Envoi, à partir de l adresse message, d un message constitué de longueur élément de type type, par le processus rang_source, à tous les autres processus du communicateur comm. 2 Réception de ce message à l adresse message pour les processus autre que rang_source.

52 52/343 4 Communications collectives 4.3 Diffusion générale : MPI_BCAST() 1 program bcast 2 use mpi 3 implicit none 4 5 integer :: rang,valeur,code 6 7 call MPI_INIT(code) 8 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 9 10 if (rang == 2) valeur=rang call MPI_BCAST(valeur,1, MPI_INTEGER,2, MPI_COMM_WORLD,code) print *, Moi, processus,rang,, j ai reçu,valeur, du processus call MPI_FINALIZE(code) end program bcast > mpiexec -n 4 bcast Moi, processus 2, j ai reçu 1002 du processus 2 Moi, processus 0, j ai reçu 1002 du processus 2 Moi, processus 1, j ai reçu 1002 du processus 2 Moi, processus 3, j ai reçu 1002 du processus 2

53 53/343 4 Communications collectives 4.4 Diffusion sélective : MPI_SCATTER() 4 Communications collectives 4.4 Diffusion sélective : MPI_SCATTER() 0 A0 A1 A2 1 A3 2 3 P0 P1 P2 A0 A1 A2 A3 P3 MPI_SCATTER() P0 A0 P1 A1 P2 A2 P3 A3 Figure 14 Diffusion sélective : MPI_SCATTER()

54 54/343 4 Communications collectives 4.4 Diffusion sélective : MPI_SCATTER() Diffusion sélective : MPI_SCATTER() <type et attribut>:: message_a_repartir, message_recu integer :: longueur_message_emis, longueur_message_recu integer :: type_message_emis, type_message_recu integer :: rang_source, comm, code call MPI_SCATTER(message_a_repartir,longueur_message_emis,type_message_emis, message_recu,longueur_message_recu,type_message_recu,rang_source,comm,code) 1 Distribution, par le processus rang_source, à partir de l adresse message_a_repartir, d un message de taille longueur_message_emis, de type type_message_emis, à tous les processus du communicateur comm ; 2 réception du message à l adresse message_recu, de longueur longueur_message_recu et de type type_message_recu par tous les processus du communicateur comm. Remarques : Les couples (longueur_message_emis, type_message_emis) et (longueur_message_recu, type_message_recu) doivent être tels que les quantités de données envoyées et reçues soient égales. Les données sont distribuées en tranches égales, une tranche étant constituée de longueur_message_emis éléments du type type_message_emis. La ième tranche est envoyée au ième processus.

55 55/343 4 Communications collectives 4.4 Diffusion sélective : MPI_SCATTER() 1 program scatter 2 3 use mpi implicit none integer, parameter integer :: nb_valeurs=8 :: nb_procs,rang,longueur_tranche,i,code 7 real, allocatable, dimension(:) :: valeurs,donnees 8 9 call MPI_INIT(code) 10 call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 11 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 12 longueur_tranche=nb_valeurs/nb_procs 13 allocate(donnees(longueur_tranche)) 14 allocate(valeurs(nb_valeurs)) if (rang == 2) then valeurs(:)=(/(1000.+i,i=1,nb_valeurs)/) print *, Moi, processus,rang, envoie mon tableau valeurs :,& end if valeurs(1:nb_valeurs) call MPI_SCATTER(valeurs,longueur_tranche, MPI_REAL,donnees,longueur_tranche, & 23 MPI_REAL,2, MPI_COMM_WORLD,code) print *, Moi, processus,rang,, j ai reçu, donnees(1:longueur_tranche), & du processus 2 26 call MPI_FINALIZE(code) end program scatter > mpiexec -n 4 scatter Moi, processus 2 envoie mon tableau valeurs : Moi, processus 0, j ai reçu du processus 2 Moi, processus 1, j ai reçu du processus 2 Moi, processus 3, j ai reçu du processus 2 Moi, processus 2, j ai reçu du processus 2

56 56/343 4 Communications collectives 4.5 Collecte : MPI_GATHER() 4 Communications collectives 4.5 Collecte : MPI_GATHER() 0 A0 A1 A2 1 A3 2 3 P0 A0 P1 A1 P2 A2 P3 A3 MPI_GATHER() P0 P1 P2 A0 A1 A2 A3 P3 Figure 15 Collecte : MPI_GATHER()

57 57/343 4 Communications collectives 4.5 Collecte : MPI_GATHER() Collecte : MPI_GATHER() <type et attribut>:: message_emis, message_recu integer :: longueur_message_emis, longueur_message_recu integer :: type_message_emis, type_message_recu integer :: rang_dest, comm, code call MPI_GATHER(message_emis,longueur_message_emis,type_message_emis, message_recu,longueur_message_recu,type_message_recu,rang_dest,comm,code) 1 Envoi de chacun des processus du communicateur comm, d un message message_emis, de taille longueur_message_emis et de type type_message_emis. 2 Collecte de chacun de ces messages, par le processus rang_dest, à partir l adresse message_recu, sur une longueur longueur_message_recu et avec le type type_message_recu. Remarques : Les couples (longueur_message_emis, type_message_emis) et (longueur_message_recu, type_message_recu) doivent être tels que les quantités de données envoyées et reçues soient égales. Les données sont collectées dans l ordre des rangs des processus.

58 58/343 4 Communications collectives 4.5 Collecte : MPI_GATHER() 1 program gather 2 use mpi 3 implicit none 4 integer, parameter :: nb_valeurs=8 5 integer :: nb_procs,rang,longueur_tranche,i,code 6 real, dimension(nb_valeurs) :: donnees 7 real, allocatable, dimension(:) :: valeurs 8 9 call MPI_INIT(code) 10 call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 11 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) longueur_tranche=nb_valeurs/nb_procs allocate(valeurs(longueur_tranche)) valeurs(:)=(/(1000.+rang*longueur_tranche+i,i=1,longueur_tranche)/) print *, Moi, processus,rang, envoie mon tableau valeurs :,& 19 valeurs(1:longueur_tranche) call MPI_GATHER(valeurs,longueur_tranche, MPI_REAL,donnees,longueur_tranche, & 22 MPI_REAL,2, MPI_COMM_WORLD,code) if (rang == 2) print *, Moi, processus 2, j ai reçu,donnees(1:nb_valeurs) call MPI_FINALIZE(code) end program gather > mpiexec -n 4 gather Moi, processus 1 envoie mon tableau valeurs : Moi, processus 0 envoie mon tableau valeurs : Moi, processus 2 envoie mon tableau valeurs : Moi, processus 3 envoie mon tableau valeurs : Moi, processus 2, j ai reçu

59 59/343 4 Communications collectives 4.6 Collecte générale : MPI_ALLGATHER() 4 Communications collectives 4.6 Collecte générale : MPI_ALLGATHER() A0 A0 0 A2 A1 A1 A0 A0 A2 A2 1 A1 2 A3 A3 A2 A1 3 A3 P0 A0 P1 A1 P2 A2 A3 MPI_ALLGATHER() P0 A0 A1 A2 A3 P1 A0 A1 A2 A3 P2 A0 A1 A2 A3 P3 A3 P3 A0 A1 A2 A3 Figure 16 Collecte générale : MPI_ALLGATHER()

60 60/343 4 Communications collectives 4.6 Collecte générale : MPI_ALLGATHER() Collecte générale : MPI_ALLGATHER() Correspond à un MPI_GATHER() suivi d un MPI_BCAST() : <type et attribut>:: message_emis, message_recu integer :: longueur_message_emis, longueur_message_recu integer :: type_message_emis, type_message_recu integer :: comm, code call MPI_ALLGATHER(message_emis,longueur_message_emis,type_message_emis, message_recu,longueur_message_recu,type_message_recu,comm,code) 1 Envoi de chacun des processus du communicateur comm, d un message message_emis, de taille longueur_message_emis et de type type_message_emis. 2 Collecte de chacun de ces messages, par tous les processus, à partir l adresse message_recu, sur une longueur longueur_message_recu et avec le type type_message_recu. Remarques : Les couples (longueur_message_emis, type_message_emis) et (longueur_message_recu, type_message_recu) doivent être tels que les quantités de données envoyées et reçues soient égales. Les données sont collectées dans l ordre des rangs des processus.

61 61/343 4 Communications collectives 4.6 Collecte générale : MPI_ALLGATHER() 1 program allgather 2 3 use mpi implicit none integer, parameter integer :: nb_valeurs=8 :: nb_procs,rang,longueur_tranche,i,code 7 real, dimension(nb_valeurs) :: donnees 8 real, allocatable, dimension(:) :: valeurs 9 10 call MPI_INIT(code) call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 13 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) longueur_tranche=nb_valeurs/nb_procs 16 allocate(valeurs(longueur_tranche)) valeurs(:)=(/(1000.+rang*longueur_tranche+i,i=1,longueur_tranche)/) call MPI_ALLGATHER(valeurs,longueur_tranche, MPI_REAL,donnees,longueur_tranche, & 21 MPI_REAL, MPI_COMM_WORLD,code) print *, Moi, processus,rang,, j ai reçu,donnees(1:nb_valeurs) call MPI_FINALIZE(code) end program allgather > mpiexec -n 4 allgather Moi, processus 1, j ai reçu Moi, processus 3, j ai reçu Moi, processus 2, j ai reçu Moi, processus 0, j ai reçu

62 62/343 4 Communications collectives 4.7 Collecte : MPI_GATHERV() 4 Communications collectives 4.7 Collecte : MPI_GATHERV() 0 A1 A0 A2 1 A3 2 3 P0 A0 P1 A1 P2 A2 P3 A3 MPI_GATHERV() P0 P1 P2 A0 A1 A2 A3 P3 Figure 17 Collecte : MPI_GATHERV()

63 63/343 4 Communications collectives 4.7 Collecte : MPI_GATHERV() Collecte "variable" : MPI_GATHERV() Correspond à un MPI_GATHER() pour lequel la taille des messages varie : <type et attribut>:: message_emis, message_recu integer :: longueur_message_emis integer :: type_message_emis, type_message_recu integer, dimension(:) :: nb_elts_recus, deplts integer :: rang_dest, comm, code call MPI_GATHERV(message_emis,longueur_message_emis,type_message_emis, message_recu,nb_elts_recus,deplts,type_message_recu, rang_dest,comm,code) Le ième processus du communicateur comm envoie au processus rang_dest, un message depuis l adresse message_emis, de taille longueur_message_emis, de type type_message_emis, avec réception du message à l adresse message_recu, de type type_message_recu, de taille nb_elts_recus(i) avec un déplacement de deplts(i). Remarques : Les couples (longueur_message_emis, type_message_emis) du ième processus et (nb_elts_recus(i), type_message_recu) du processus rang_dest doivent être tels que les quantités de données envoyées et reçues soient égales.

64 64/343 4 Communications collectives 4.7 Collecte : MPI_GATHERV() 1 program gatherv 2 use mpi 3 implicit none 4 integer, parameter :: nb_valeurs=10 5 integer :: reste, nb_procs, rang, longueur_tranche, i, code 6 real, dimension(nb_valeurs) :: donnees 7 real, allocatable, dimension(:) :: valeurs 8 integer, allocatable, dimension(:) :: nb_elements_recus,deplacements 9 10 call MPI_INIT(code) 11 call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 12 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) longueur_tranche=nb_valeurs/nb_procs 15 reste = mod(nb_valeurs,nb_procs) 16 if (reste > rang) longueur_tranche = longueur_tranche ALLOCATE(valeurs(longueur_tranche)) 19 valeurs(:) = (/(1000.+(rang*(nb_valeurs/nb_procs))+min(rang,reste)+i, & 20 i=1,longueur_tranche)/) PRINT *, Moi, processus, rang, envoie mon tableau valeurs :,& 23 valeurs(1:longueur_tranche) ALLOCATE(nb_elements_recus(nb_procs),deplacements(nb_procs)) 26 IF (rang == 2) THEN 27 nb_elements_recus(1) = nb_valeurs/nb_procs 28 if (reste > 0) nb_elements_recus(1) = nb_elements_recus(1) deplacements(1) = 0 DO i=2,nb_procs 31 deplacements(i) = deplacements(i-1)+nb_elements_recus(i-1) 32 nb_elements_recus(i) = nb_valeurs/nb_procs 33 if (reste > i-1) nb_elements_recus(i) = nb_elements_recus(i)+1 34 END DO 35 END IF

65 65/343 4 Communications collectives 4.7 Collecte : MPI_GATHERV() CALL MPI_GATHERV (valeurs,longueur_tranche, MPI_REAL,donnees,nb_elements_recus,& deplacements, MPI_REAL,2, MPI_COMM_WORLD,code) IF (rang == 2) PRINT *, Moi, processus 2 je recois, donnees(1:nb_valeurs) CALL MPI_FINALIZE (code) end program gatherv > mpiexec -n 4 gatherv Moi, processus 0 envoie mon tableau valeurs : Moi, processus 2 envoie mon tableau valeurs : Moi, processus 3 envoie mon tableau valeurs : Moi, processus 1 envoie mon tableau valeurs : Moi, processus 2 je reçois

66 66/343 4 Communications collectives 4.8 Échanges croisés : MPI_ALLTOALL() 4 Communications collectives 4.8 Échanges croisés : MPI_ALLTOALL() A0 A1 0 C0 B1 B0 A2 A3 C1 C2 1 B2 2 D1 D0 C3 B3 3 D2 P0 A0 A1 A2 A3 P1 B0 B1 B2 B3 P2 C0 C1 C2 C3 P3 D0 D1 D2 D3 D3 MPI_ALLTOALL() P0 A0 B0 C0 D0 P1 A1 B1 C1 D1 P2 A2 B2 C2 D2 P3 A3 B3 C3 D3 Figure 18 Échanges croisés : MPI_ALLTOALL()

67 67/343 4 Communications collectives 4.8 Échanges croisés : MPI_ALLTOALL() Échanges croisés : MPI_ALLTOALL() <type et attribut>:: message_emis, message_recu integer :: longueur_message_emis, longueur_message_recu integer :: type_message_emis, type_message_recu integer :: comm, code call MPI_ALLTOALL(message_emis,longueur_message_emis,type_message_emis, message_recu,longueur_message_recu,type_message_recu,comm,code) Correspond à un MPI_GATHER() étendu à tous les processus : le ième processus envoie la jème tranche au jème processus qui le place à l emplacement de la ième tranche. Remarque : Les couples (longueur_message_emis, type_message_emis) et (longueur_message_recu, type_message_recu) doivent être tels que les quantités de données envoyées et reçues soient égales.

68 68/343 4 Communications collectives 4.8 Échanges croisés : MPI_ALLTOALL() 1 program alltoall 2 use mpi 3 implicit none 4 5 integer, parameter :: nb_valeurs=8 6 integer :: nb_procs,rang,longueur_tranche,i,code 7 real, dimension(nb_valeurs) :: valeurs,donnees 8 9 call MPI_INIT(code) 10 call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 11 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) valeurs(:)=(/(1000.+rang*nb_valeurs+i,i=1,nb_valeurs)/) 14 longueur_tranche=nb_valeurs/nb_procs print *, Moi, processus,rang, envoie mon tableau valeurs :, & 17 valeurs(1:nb_valeurs) call MPI_ALLTOALL(valeurs,longueur_tranche, MPI_REAL,donnees,longueur_tranche, & 20 MPI_REAL, MPI_COMM_WORLD,code) print *, Moi, processus,rang,, j ai reçu,donnees(1:nb_valeurs) call MPI_FINALIZE(code) 25 end program alltoall

69 69/343 4 Communications collectives 4.8 Échanges croisés : MPI_ALLTOALL() > mpiexec -n 4 alltoall Moi, processus 1 envoie mon tableau valeurs : Moi, processus 0 envoie mon tableau valeurs : Moi, processus 2 envoie mon tableau valeurs : Moi, processus 3 envoie mon tableau valeurs : Moi, processus 0, j ai reçu Moi, processus 2, j ai reçu Moi, processus 1, j ai reçu Moi, processus 3, j ai reçu

70 70/343 4 Communications collectives 4.9 Réductions réparties 4 Communications collectives 4.9 Réductions réparties Réductions réparties Une réduction est une opération appliquée à un ensemble d éléments pour en obtenir une seule valeur. Des exemples typiques sont la somme des éléments d un vecteur SUM(A(:)) ou la recherche de l élément de valeur maximum dans un vecteur MAX(V(:)). MPI propose des sous-programmes de haut-niveau pour opérer des réductions sur des données réparties sur un ensemble de processus. Le résultat est obtenu sur un seul processus (MPI_REDUCE()) ou bien sur tous (MPI_ALLREDUCE(), qui est en fait équivalent à un MPI_REDUCE() suivi d un MPI_BCAST()). Si plusieurs éléments sont concernés par processus, la fonction de réduction est appliquée à chacun d entre eux. Le sous-programme MPI_SCAN() permet en plus d effectuer des réductions partielles en considérant, pour chaque processus, les processus précédents du communicateur et lui-même. Les sous-programmes MPI_OP_CREATE() et MPI_OP_FREE() permettent de définir des opérations de réduction personnelles.

71 71/343 4 Communications collectives 4.9 Réductions réparties Opérations Table 3 Principales opérations de réduction prédéfinies (il existe aussi d autres opérations logiques) Nom MPI_SUM MPI_PROD MPI_MAX MPI_MIN MPI_MAXLOC MPI_MINLOC MPI_LAND MPI_LOR MPI_LXOR Opération Somme des éléments Produit des éléments Recherche du maximum Recherche du minimum Recherche de l indice du maximum Recherche de l indice du minimum ET logique OU logique OU exclusif logique

72 72/343 4 Communications collectives 4.9 Réductions réparties = Figure 19 Réduction répartie : MPI_REDUCE() avec l opérateur somme

73 73/343 4 Communications collectives 4.9 Réductions réparties Réductions réparties : MPI_REDUCE() <type et attribut>:: message_emis, message_recu integer :: longueur, type, rang_dest integer :: operation, comm, code call MPI_REDUCE(message_emis,message_recu,longueur,type,operation,rang_dest,comm,code) 1 Réduction répartie des éléments situés à partir de l adresse message_emis, de taille longueur, de type type, pour les processus du communicateur comm, 2 stockage à l adresse message_recu pour le processus de rang rang_dest.

74 74/343 4 Communications collectives 4.9 Réductions réparties 1 program reduce 2 use mpi 3 implicit none 4 integer :: nb_procs,rang,valeur,somme,code 5 6 call MPI_INIT(code) 7 call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 8 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 9 10 if (rang == 0) then 11 valeur= else 13 valeur=rang 14 endif call MPI_REDUCE(valeur,somme,1, MPI_INTEGER, MPI_SUM,0, MPI_COMM_WORLD,code) if (rang == 0) then 19 print *, Moi, processus 0, j ai pour valeur de la somme globale,somme 20 end if call MPI_FINALIZE(code) 23 end program reduce > mpiexec -n 7 reduce Moi, processus 0, j ai pour valeur de la somme globale 1021

75 75/343 4 Communications collectives 4.9 Réductions réparties = Figure 20 Réduction répartie avec diffusion du résultat : MPI_ALLREDUCE (utilisation de l opérateur produit)

76 76/343 4 Communications collectives 4.9 Réductions réparties Réductions réparties avec diffusion du résultat : MPI_ALLREDUCE() <type et attribut>:: message_emis, message_recu integer :: longueur, type integer :: operation, comm, code call MPI_ALLREDUCE(message_emis,message_recu,longueur,type,operation,comm,code) 1 Réduction répartie des éléments situés à partir de l adresse message_emis, de taille longueur, de type type, pour les processus du communicateur comm, 2 stockage à l adresse message_recu pour tous les processus du communicateur comm.

77 77/343 4 Communications collectives 4.9 Réductions réparties 1 program allreduce 2 3 use mpi 4 implicit none 5 6 integer :: nb_procs,rang,valeur,produit,code 7 8 call MPI_INIT(code) 9 call MPI_COMM_SIZE( MPI_COMM_WORLD,nb_procs,code) 10 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) if (rang == 0) then 13 valeur=10 14 else 15 valeur=rang 16 endif call MPI_ALLREDUCE(valeur,produit,1, MPI_INTEGER, MPI_PROD, MPI_COMM_WORLD,code) print *, Moi, processus,rang,, j ai reçu la valeur du produit global,produit call MPI_FINALIZE(code) end program allreduce

78 78/343 4 Communications collectives 4.9 Réductions réparties > mpiexec -n 7 allreduce Moi, processus 6, j ai reçu la valeur du produit global 7200 Moi, processus 2, j ai reçu la valeur du produit global 7200 Moi, processus 0, j ai reçu la valeur du produit global 7200 Moi, processus 4, j ai reçu la valeur du produit global 7200 Moi, processus 5, j ai reçu la valeur du produit global 7200 Moi, processus 3, j ai reçu la valeur du produit global 7200 Moi, processus 1, j ai reçu la valeur du produit global 7200

79 79/343 4 Communications collectives 4.10 Compléments 4 Communications collectives 4.10 Compléments Compléments Les sous-programmes MPI_SCATTERV(), MPI_GATHERV(), MPI_ALLGATHERV() et MPI_ALLTOALLV() étendent MPI_SCATTER(), MPI_GATHER(), MPI_ALLGATHER() et MPI_ALLTOALL() au cas où le nombre d éléments à diffuser ou collecter est différent suivant les processus. Pour toutes les opérations de reduction, le mot-clé MPI_IN_PLACE peut être utilisé pour que les données et résultats de l opération soient stockés au même endroit : call MPI_REDUCE(MPI_IN_PLACE,message_recu,...) Deux nouveaux sous-programmes ont été ajoutés pour étendre les possibilités des sous-programmes collectifs dans quelques cas particuliers : MPI_ALLTOALLW() : version de MPI_ALLTOALLV() où les déplacements sont exprimés en octets et non en éléments, MPI_EXSCAN() : version exclusive de MPI_SCAN(), qui elle est inclusive.

80 80/343 5 Types de données dérivés 1 Introduction 2 Environnement 3 Communications point à point 4 Communications collectives 5 Types de données dérivés 5.1 Introduction Types contigus Types avec un pas constant Validation des types de données dérivés Exemples Types homogènes à pas variable Construction de sous-tableaux Types hétérogènes Taille des types de données Conclusion Modèles de communication 7 Communicateurs 8 MPI-IO 9 Conclusion 10 Annexes 11 Index

81 81/343 5 Types de données dérivés 5.1 Introduction 5 Types de données dérivés 5.1 Introduction Introduction Dans les communications, les données échangées sont typées : MPI_INTEGER, MPI_REAL, MPI_COMPLEX, etc. On peut créer des structures de données plus complexes à l aide de sous-programmes tels que MPI_TYPE_CONTIGUOUS(), MPI_TYPE_VECTOR(), MPI_TYPE_INDEXED() ou MPI_TYPE_CREATE_STRUCT(). Les types dérivés permettent notamment l échange de données non contiguës ou non homogènes en mémoire et de limiter le nombre d appels aux sous-programmes de communications.

82 82/343 5 Types de données dérivés 5.1 Introduction MPI_TYPE_CREATE_STRUCT MPI_TYPE_[CREATE_H]INDEXED MPI_TYPE_[CREATE_H]VECTOR MPI_TYPE_CONTIGUOUS MPI_REAL, MPI_INTEGER, MPI_LOGICAL Figure 21 Hiérarchie des constructeurs de type MPI

83 83/343 5 Types de données dérivés 5.2 Types contigus 5 Types de données dérivés 5.2 Types contigus Types contigus MPI_TYPE_CONTIGUOUS() crée une structure de données à partir d un ensemble homogène de type préexistant de données contiguës en mémoire call MPI_TYPE_CONTIGUOUS(5, MPI_REAL,nouveau_type,code) Figure 22 Sous-programme MPI_TYPE_CONTIGUOUS integer, intent(in) :: nombre, ancien_type integer, intent(out) :: nouveau_type,code call MPI_TYPE_CONTIGUOUS(nombre,ancien_type,nouveau_type,code)

84 84/343 5 Types de données dérivés 5.3 Types avec un pas constant 5 Types de données dérivés 5.3 Types avec un pas constant Types avec un pas constant MPI_TYPE_VECTOR() crée une structure de données à partir d un ensemble homogène de type préexistant de données distantes d un pas constant en mémoire. Le pas est donné en nombre d éléments call MPI_TYPE_VECTOR(6,1,5, MPI_REAL,nouveau_type,code) Figure 23 Sous-programme MPI_TYPE_VECTOR integer, intent(in) :: nombre_bloc,longueur_bloc integer, intent(in) :: pas! donné en éléments integer, intent(in) :: ancien_type integer, intent(out) :: nouveau_type,code call MPI_TYPE_VECTOR(nombre_bloc,longueur_bloc,pas,ancien_type,nouveau_type,code)

85 85/343 5 Types de données dérivés 5.3 Types avec un pas constant Types avec un pas constant MPI_TYPE_CREATE_HVECTOR() crée une structure de données à partir d un ensemble homogène de type préexistant de données distantes d un pas constant en mémoire. Le pas est donné en nombre d octets. Cette instruction est utile lorsque le type générique n est plus un type de base (MPI_INTEGER, MPI_REAL,...) mais un type plus complexe construit à l aide des sous-programmes MPI, parce qu alors le pas ne peut plus être exprimé en nombre d éléments du type générique. integer, intent(in) :: nombre_bloc,longueur_bloc integer(kind= MPI_ADDRESS_KIND), intent(in) :: pas! donné en octets integer, intent(in) :: ancien_type integer, intent(out) :: nouveau_type, code call MPI_TYPE_CREATE_HVECTOR(nombre_bloc,longueur_bloc,pas, ancien_type,nouveau_type,code)

86 86/343 5 Types de données dérivés 5.4 Validation des types de données dérivés 5 Types de données dérivés 5.4 Validation des types de données dérivés Validation des types de données dérivés Les types dérivés doivent être validés avant d être utilisé dans une communication. La validation s effectue à l aide du sous-programme MPI_TYPE_COMMIT(). integer, intent(inout) :: nouveau_type integer, intent(out) :: code call MPI_TYPE_COMMIT(nouveau_type,code) Si on souhaite réutiliser le même nom pour définir un autre type dérivé, on doit au préalable le libérer en utilisant le sous-programme MPI_TYPE_FREE(). integer, intent(inout) :: nouveau_type integer, intent(out) :: code call MPI_TYPE_FREE(nouveau_type,code)

87 87/343 5 Types de données dérivés 5.5 Exemples 5 Types de données dérivés 5.5 Exemples Type «colonne d une matrice» 1 program colonne 2 use mpi 3 implicit none 4 5 integer, parameter :: nb_lignes=5,nb_colonnes=6 6 integer, parameter :: etiquette=100 7 real, dimension(nb_lignes,nb_colonnes) :: a 8 integer, dimension( MPI_STATUS_SIZE) :: statut 9 integer :: rang,code,type_colonne call MPI_INIT(code) 12 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 13 14! Initialisation de la matrice sur chaque processus 15 a(:,:) = real(rang) 16 17! Définition du type type_colonne 18 call MPI_TYPE_CONTIGUOUS(nb_lignes, MPI_REAL,type_colonne,code) 19 20! Validation du type type_colonne 21 call MPI_TYPE_COMMIT(type_colonne,code)

88 88/343 5 Types de données dérivés 5.5 Exemples 22! Envoi de la première colonne 23 if ( rang == 0 ) then 24 call MPI_SEND(a(1,1),1,type_colonne,1,etiquette, MPI_COMM_WORLD,code) 25 26! Réception dans la dernière colonne 27 elseif ( rang == 1 ) then 28 call MPI_RECV(a(1,nb_colonnes),nb_lignes, MPI_REAL,0,etiquette,& 29 MPI_COMM_WORLD,statut,code) 30 end if 31 32! Libère le type 33 call MPI_TYPE_FREE(type_colonne,code) call MPI_FINALIZE(code) end program colonne

89 89/343 5 Types de données dérivés 5.5 Exemples 5 Types de données dérivés 5.5 Exemples Type «ligne d une matrice» 1 program ligne 2 use mpi 3 implicit none 4 5 integer, parameter :: nb_lignes=5,nb_colonnes=6 6 integer, parameter :: etiquette=100 7 real, dimension(nb_lignes,nb_colonnes):: a 8 integer, dimension( MPI_STATUS_SIZE) :: statut 9 integer :: rang,code,type_ligne call MPI_INIT(code) 12 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 13 14! Initialisation de la matrice sur chaque processus 15 a(:,:) = real(rang) 16 17! Définition du type type_ligne 18 call MPI_TYPE_VECTOR(nb_colonnes,1,nb_lignes, MPI_REAL,type_ligne,code) 19 20! Validation du type type_ligne 21 call MPI_TYPE_COMMIT(type_ligne,code)

90 90/343 5 Types de données dérivés 5.5 Exemples 22! Envoi de la deuxième ligne 23 if ( rang == 0 ) then 24 call MPI_SEND(a(2,1),nb_colonnes, MPI_REAL,1,etiquette, MPI_COMM_WORLD,code) 25 26! Réception dans l avant-dernière ligne 27 elseif ( rang == 1 ) then 28 call MPI_RECV(a(nb_lignes-1,1),1,type_ligne,0,etiquette,& 29 MPI_COMM_WORLD,statut,code) 30 end if 31 32! Libère le type type_ligne 33 call MPI_TYPE_FREE(type_ligne,code) call MPI_FINALIZE(code) end program ligne

91 91/343 5 Types de données dérivés 5.5 Exemples 5 Types de données dérivés 5.5 Exemples Type «bloc d une matrice» 1 program bloc 2 use mpi 3 implicit none 4 5 integer, parameter :: nb_lignes=5,nb_colonnes=6 6 integer, parameter :: etiquette=100 7 integer, parameter :: nb_lignes_bloc=2,nb_colonnes_bloc=3 8 real, dimension(nb_lignes,nb_colonnes):: a 9 integer, dimension( MPI_STATUS_SIZE) :: statut 10 integer :: rang,code,type_bloc call MPI_INIT(code) 13 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 14 15! Initialisation de la matrice sur chaque processus 16 a(:,:) = real(rang) 17 18! Création du type type_bloc 19 call MPI_TYPE_VECTOR(nb_colonnes_bloc,nb_lignes_bloc,nb_lignes,& 20 MPI_REAL,type_bloc,code) 21 22! Validation du type type_bloc 23 call MPI_TYPE_COMMIT(type_bloc,code)

92 92/343 5 Types de données dérivés 5.5 Exemples 24! Envoi d un bloc 25 if ( rang == 0 ) then 26 call MPI_SEND(a(1,1),1,type_bloc,1,etiquette, MPI_COMM_WORLD,code) 27 28! Réception du bloc 29 elseif ( rang == 1 ) then 30 call MPI_RECV(a(nb_lignes-1,nb_colonnes-2),1,type_bloc,0,etiquette,& 31 MPI_COMM_WORLD,statut,code) 32 end if 33 34! Libération du type type_bloc 35 call MPI_TYPE_FREE(type_bloc,code) call MPI_FINALIZE(code) end program bloc

93 93/343 5 Types de données dérivés 5.6 Types homogènes à pas variable 5 Types de données dérivés 5.6 Types homogènes à pas variable Types homogènes à pas variable MPI_TYPE_INDEXED() permet de créer une structure de données composée d une séquence de blocs contenant un nombre variable d éléments et séparés par un pas variable en mémoire. Ce dernier est exprimé en éléments. MPI_TYPE_CREATE_HINDEXED() a la même fonctionnalité que MPI_TYPE_INDEXED() sauf que le pas séparant deux blocs de données est exprimé en octets. Cette instruction est utile lorsque le type générique n est pas un type de base MPI (MPI_INTEGER, MPI_REAL,...) mais un type plus complexe construit avec les sous-programmes MPI vus précédemment. On ne peut exprimer alors le pas en nombre d éléments du type générique d où le recours à MPI_TYPE_CREATE_HINDEXED(). Pour MPI_TYPE_CREATE_HINDEXED(), comme pour MPI_TYPE_CREATE_HVECTOR(), utilisez MPI_TYPE_SIZE() ou MPI_TYPE_GET_EXTENT() pour obtenir de façon portable la taille du pas en nombre d octets.

94 94/343 5 Types de données dérivés 5.6 Types homogènes à pas variable nb=3, longueurs_blocs=(2,1,3), déplacements=(0,3,7) ancien_type nouveau_type Figure 24 Le constructeur MPI_TYPE_INDEXED integer,intent(in) :: nb integer,intent(in),dimension(nb) :: longueurs_blocs! Attention les déplacements sont donnés en éléments integer,intent(in),dimension(nb) :: deplacements integer,intent(in) :: ancien_type integer,intent(out) :: nouveau_type,code call MPI_TYPE_INDEXED(nb,longueurs_blocs,deplacements,ancien_type,nouveau_type,code)

95 95/343 5 Types de données dérivés 5.6 Types homogènes à pas variable nb=4, longueurs_blocs=(2,1,2,1), déplacements=(2,10,14,24) ancien_type nouveau_type Figure 25 Le constructeur MPI_TYPE_CREATE_HINDEXED integer,intent(in) :: nb integer,intent(in),dimension(nb) :: longueurs_blocs! Attention les déplacements sont donnés en octets integer(kind= MPI_ADDRESS_KIND),intent(in),dimension(nb) :: deplacements integer,intent(in) :: ancien_type integer,intent(out) :: nouveau_type,code call MPI_TYPE_CREATE_HINDEXED(nb,longueurs_blocs,deplacements, ancien_type,nouveau_type,code)

96 96/343 5 Types de données dérivés 5.6 Types homogènes à pas variable Exemple : matrice triangulaire Dans l exemple suivant, chacun des deux processus : 1 initialise sa matrice (nombres croissants positifs sur le processus 0 et négatifs décroissants sur le processus 1); 2 construit son type de données (datatype) : matrice triangulaire (supérieure pour le processus 0 et inférieure pour le processus 1) ; 3 envoie sa matrice triangulaire à l autre et reçoit une matrice triangulaire qu il stocke à la place de celle qu il a envoyée via l instruction MPI_SENDRECV_REPLACE() ; 4 libère ses ressources et quitte MPI.

97 97/343 5 Types de données dérivés 5.6 Types homogènes à pas variable Avant Après Processus Processus Figure 26 Échanges entre les 2 processus

98 98/343 5 Types de données dérivés 5.6 Types homogènes à pas variable 1 program triangle 2 3 use mpi implicit none 4 5 integer,parameter :: n=8,etiquette=100 6 real,dimension(n,n) :: a 7 integer,dimension( MPI_STATUS_SIZE) :: statut 8 integer :: i,code 9 integer :: rang,type_triangle 10 integer,dimension(n) :: longueurs_blocs,deplacements call MPI_INIT(code) 13 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 14 15! Initialisation de la matrice sur chaque processus 16 a(:,:) = reshape( (/ (sign(i,-rang),i=1,n*n) /), (/n,n/)) ! Création du type matrice triangulaire sup pour le processus 0! et du type matrice triangulaire inférieure pour le processus1 20 if (rang == 0) then 21 longueurs_blocs(:) = (/ (i-1,i=1,n) /) deplacements(:) else = (/ (n*(i-1),i=1,n) /) 24 longueurs_blocs(:) = (/ (n-i,i=1,n) /) deplacements(:) endif = (/ (n*(i-1)+i,i=1,n) /) call MPI_TYPE_INDEXED(n,longueurs_blocs,deplacements, MPI_REAL,type_triangle,code) 29 call MPI_TYPE_COMMIT(type_triangle,code) 30 31! Permutation des matrices triangulaires supérieure et inférieure 32 call MPI_SENDRECV_REPLACE(a,1,type_triangle,mod(rang+1,2),etiquette,mod(rang+1,2), & 33 etiquette, MPI_COMM_WORLD,statut,code) 34 35! Libération du type triangle 36 call MPI_TYPE_FREE(type_triangle,code) 37 call MPI_FINALIZE(code) 38 end program triangle

99 99/343 5 Types de données dérivés 5.7 Construction de sous-tableaux 5 Types de données dérivés 5.7 Construction de sous-tableaux Construction de sous-tableaux Le sous-programme MPI_TYPE_CREATE_SUBARRAY() permet de créer un sous-tableau à partir d un tableau. Rappels sur le vocabulaire relatif aux tableaux en Fortran 95 Le rang d un tableau est son nombre de dimensions. L étendue d un tableau est son nombre d éléments dans une dimension. Le profil d un tableau est un vecteur dont chaque élément est l étendue du tableau dans la dimension correspondante. Soit par exemple le tableau T(10,0:5,-10:10). Son rang est 3, son étendue dans la première dimension est 10, dans la seconde 6 et dans la troisième 21, son profil est le vecteur (10,6,21).

100 100/343 5 Types de données dérivés 5.7 Construction de sous-tableaux integer,intent(in) :: nb_dims integer,dimension(ndims),intent(in) :: profil_tab,profil_sous_tab,coord_debut integer,intent(in) :: ordre,ancien_type integer,intent(out) :: nouveau_type,code call MPI_TYPE_CREATE_SUBARRAY(nb_dims,profil_tab,profil_sous_tab,coord_debut, ordre,ancien_type,nouveau_type,code) Description des arguments nb_dims : rang du tableau profil_tab : profil du tableau à partir duquel on va extraire un sous-tableau profil_sous_tab : profil du sous-tableau coord_debut : coordonnées de départ si les indices du tableau commençaient à 0. Par exemple, si on veut que les coordonnées de départ du sous-tableau soient tab(2,3), il faut que coord_debut(:)=(/ 1,2 /) ordre : ordre de stockage des éléments MPI_ORDER_FORTRAN spécifie le mode de stockage en Fortran, c.-à-d. suivant les colonnes MPI_ORDER_C spécifie le mode de stockage en C, c.-à-d. suivant les lignes

101 101/343 5 Types de données dérivés 5.7 Construction de sous-tableaux AVANT APRES Processus 0 Processus Processus 1 Processus 1 Figure 27 Échanges entre les 2 processus

102 102/343 5 Types de données dérivés 5.7 Construction de sous-tableaux 1 program subarray 2 3 use mpi 4 implicit none 5 6 integer,parameter :: nb_lignes=4,nb_colonnes=3,& 7 etiquette=1000,nb_dims=2 8 integer :: code,rang,type_sous_tab,i 9 integer,dimension(nb_lignes,nb_colonnes) :: tab 10 integer,dimension(nb_dims) :: profil_tab,profil_sous_tab,coord_debut 11 integer,dimension( MPI_STATUS_SIZE) :: statut call MPI_INIT(code) 14 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 15 16! Initialisation du tableau tab sur chaque processus 17 tab(:,:) = reshape( (/ (sign(i,-rang),i=1,nb_lignes*nb_colonnes) /), & 18 (/ nb_lignes,nb_colonnes /) ) 19

103 103/343 5 Types de données dérivés 5.7 Construction de sous-tableaux 20! Profil du tableau tab à partir duquel on va extraire un sous-tableau 21 profil_tab(:) = shape(tab) 22! La fonction F95 shape donne le profil du tableau passé en argument. 23! ATTENTION, si le tableau concerné n a pas été alloué sur tous les processus, 24! il faut mettre explicitement le profil du tableau pour qu il soit connu 25! sur tous les processus, soit profil_tab(:) = (/ nb_lignes,nb_colonnes) /) 26 27! Profil du sous-tableau 28 profil_sous_tab(:) = (/ 2,2 /) 29 30! Coordonnées de départ du sous-tableau 31! Pour le processus 0 on part de l élément tab(2,1) 32! Pour le processus 1 on part de l élément tab(3,2) 33 coord_debut(:) = (/ rang+1,rang /) 34 35! Création du type dérivé type_sous_tab 36 call MPI_TYPE_CREATE_SUBARRAY(nb_dims,profil_tab,profil_sous_tab,coord_debut,& 37 MPI_ORDER_FORTRAN, MPI_INTEGER,type_sous_tab,code) 38 call MPI_TYPE_COMMIT(type_sous_tab,code) 39 40! Permutation du sous-tableau 41 call MPI_SENDRECV_REPLACE(tab,1,type_sous_tab,mod(rang+1,2),etiquette,& 42 mod(rang+1,2),etiquette, MPI_COMM_WORLD,statut,code) call MPI_TYPE_FREE(type_sous_tab,code) call MPI_FINALIZE(code) end program subarray

104 104/343 5 Types de données dérivés 5.8 Types hétérogènes 5 Types de données dérivés 5.8 Types hétérogènes Le sous-programme MPI_TYPE_CREATE_STRUCT() permet de créer une séquence de blocs de données en précisant le type, le nombre d éléments et le pas de chaque blocs. Il s agit du constructeur de types le plus complet. Il généralise MPI_TYPE_INDEXED() en permettant de définir un type différent pour chaque bloc. nb=5, longueurs_blocs=(3,1,5,1,1), déplacements=(0,7,11,21,26), anciens_types=(type1,type2,type3,type1,type3) anciens_types type 1 type 2 type 3 nouveau_type Figure 28 Le constructeur MPI_TYPE_CREATE_STRUCT integer,intent(in) :: nb integer,intent(in),dimension(nb) :: longueurs_blocs integer(kind= MPI_ADDRESS_KIND),intent(in),dimension(nb) :: deplacements integer,intent(in),dimension(nb) :: anciens_types integer, intent(out) call MPI_TYPE_CREATE_STRUCT(nb,longueurs_blocs,deplacements, anciens_types,nouveau_type,code) :: nouveau_type,code

105 105/343 5 Types de données dérivés 5.8 Types hétérogènes Calcul du déplacement entre deux variables MPI_TYPE_CREATE_STRUCT() est utile notamment pour créer des types MPI correspondant à des types dérivés Fortran ou à des structures C. L alignement en mémoire des structures de données hétérogènes dépend de l architecture et du compilateur. Le déplacement entre deux éléments d un type dérivé Fortran ou d une structure C peut-être obtenu en calculant la différence entre leurs adresses mémoires. Le sous-programme MPI_GET_ADDRESS() permet de récupérer l adresse d une variable. C est l équivalent de l opérateur de référencement (&) du C. Attention, même en C, il est préférable d utiliser ce sous-programme MPI pour des raisons de portabilité. <type>,intent(in) :: variable integer(kind= MPI_ADDRESS_KIND),intent(out) :: adresse_variable integer,intent(out) :: code call MPI_GET_ADDRESS(variable,adresse_variable,code)

106 106/343 5 Types de données dérivés 5.8 Types hétérogènes 1 program Interaction_Particules 2 3 use mpi 4 implicit none 5 6 integer, parameter :: n=1000,etiquette=100 7 integer, dimension( MPI_STATUS_SIZE) :: statut 8 integer :: rang,code,type_particule,i 9 integer, dimension(4) :: types,longueurs_blocs 10 integer(kind= MPI_ADDRESS_KIND), dimension(4) :: deplacements,adresses type Particule 13 character(len=5) :: categorie 14 integer :: masse 15 real, dimension(3) :: coords 16 logical :: classe 17 end type Particule 18 type(particule), dimension(n) :: p,temp_p call MPI_INIT(code) 21 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 22 23! Construction du type de données 24 types = (/ MPI_CHARACTER, MPI_INTEGER, MPI_REAL, MPI_LOGICAL/) 25 longueurs_blocs = (/5,1,3,1/)

107 107/343 5 Types de données dérivés 5.8 Types hétérogènes 26 call MPI_GET_ADDRESS(p(1)%categorie,adresses(1),code) 27 call MPI_GET_ADDRESS(p(1)%masse,adresses(2),code) 28 call MPI_GET_ADDRESS(p(1)%coords,adresses(3),code) 29 call MPI_GET_ADDRESS(p(1)%classe,adresses(4),code) 30 31! Calcul des déplacements relatifs à l adresse de départ 32 do i=1,4 33 deplacements(i)=adresses(i) - adresses(1) 34 end do 35 call MPI_TYPE_CREATE_STRUCT(4,longueurs_blocs,deplacements,types,type_particule, & 36 code) 37! Validation du type structuré 38 call MPI_TYPE_COMMIT(type_particule,code) 39! Initialisation des particules pour chaque processus ! Envoi des particules de 0 vers 1 42 if (rang == 0) then 43 call MPI_SEND(p(1)%categorie,n,type_particule,1,etiquette, MPI_COMM_WORLD,code) 44 else 45 call MPI_RECV(temp_p(1)%categorie,n,type_particule,0,etiquette, MPI_COMM_WORLD, & 46 statut,code) 47 endif 48 49! Libération du type 50 call MPI_TYPE_FREE(type_particule,code) call MPI_FINALIZE(code) end program Interaction_Particules

108 108/343 5 Types de données dérivés 5.9 Taille des types de données 5 Types de données dérivés 5.9 Taille des types de données MPI_TYPE_SIZE() retourne le nombre d octets nécessaire pour envoyer les éléments d un type de données. Cette valeur ne tient pas compte des trous présents dans le type de données. integer, intent(in) :: type integer, intent(out) :: taille, code call MPI_TYPE_SIZE(type,taille,code) L étendue d un type est l espace mémoire occupé par le type (en octets). Cette valeur intervient directement pour calculer la position du prochain élément en mémoire (c est-à-dire le pas entre des éléments successifs). integer, intent(in) :: type integer(kind= MPI_ADDRESS_KIND),intent(out):: borne_inf,etendue integer, intent(out) :: code call MPI_TYPE_GET_EXTENT(type,borne_inf,etendue,code)

109 109/343 5 Types de données dérivés 5.9 Taille des types de données L étendue est un paramètre du type de données. Par défaut, c est généralement l intervalle entre le premier et le dernier élément mémoire du type (bornes incluses et en tenant compte de l alignement mémoire). On peut modifier l étendue d un type pour créer un nouveau type adapté du précédent avec MPI_TYPE_CREATE_RESIZED(). Cela permet de choisir le pas entre des éléments successifs. integer, intent(in) :: ancien_type integer(kind= MPI_ADDRESS_KIND),intent(in) :: nouvelle_borne_inf,nouvelle_etendue integer, intent(out) :: nouveau_type,code call MPI_TYPE_CREATE_RESIZED(ancien_type,nouvelle_borne_inf,nouvelle_etendue, nouveau_type,code)

110 110/343 5 Types de données dérivés 5.9 Taille des types de données Exemple 1 : MPI_TYPE_INDEXED(2,(/2,1/),(/1,4/),MPI_INTEGER,type,code) Type dérivé : Deux éléments successifs : taille = 12 (3 entiers); borne_inf = 4 (1 entier); etendue = 16 (4 entiers) Exemple 2 : MPI_TYPE_VECTOR(3,1,nb_lignes,MPI_INTEGER,type_demi_ligne,code) Vue 2D : Vue 1D : taille = 12 (3 entiers); borne_inf = 0; etendue = 44 (11 entiers)

111 111/343 5 Types de données dérivés 5.9 Taille des types de données 1 program demi_ligne 2 use mpi 3 implicit none 4 integer, parameter :: nb_lignes=5,nb_colonnes=6, & 5 demi_ligne=nb_colonnes/2,etiquette= integer, dimension(nb_lignes,nb_colonnes) :: a 7 integer :: rang,i,taille_integer,code 8 integer :: type_demi_ligne1,type_demi_ligne2 9 integer(kind= MPI_ADDRESS_KIND) :: borne_inf1,etendue1,borne_inf2,etendue2 10 integer, dimension( MPI_STATUS_SIZE) :: statut call MPI_INIT(code) 13 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 14 15! Initialisation de la matrice A sur chaque processus 16 a(:,:) = reshape( (/ (sign(i,-rang),i=1,nb_lignes*nb_colonnes) /), & 17 (/ nb_lignes,nb_colonnes /) ) 18 19! Construction du type derivé type_demi_ligne1 20 call MPI_TYPE_VECTOR(demi_ligne,1,nb_lignes, MPI_INTEGER,type_demi_ligne1,code) 21 22! Connaître la taille du type de base MPI_INTEGER 23 call MPI_TYPE_SIZE( MPI_INTEGER,taille_integer,code) 24 25! Informations sur le type dérivé type_demi_ligne1 26 call MPI_TYPE_GET_EXTENT(type_demi_ligne1,borne_inf1,etendue1,code) 27 if (rang == 0) print *, "type_demi_ligne1: borne_inf=",borne_inf1,", etendue=",etendue ! Construction du type derivé type_demi_ligne2 30 borne_inf2 = 0 31 etendue2 = taille_integer 32 call MPI_TYPE_CREATE_RESIZED(type_demi_ligne1,borne_inf2,etendue2,& 33 type_demi_ligne2,code)

112 112/343 5 Types de données dérivés 5.9 Taille des types de données 34! Informations sur le type dérivé type_demi_ligne2 35 call MPI_TYPE_GET_EXTENT(type_demi_ligne2,borne_inf2,etendue2,code) 36 if (rang == 0) print *, "type_demi_ligne2: borne_inf=",borne_inf2,", etendue=",etendue ! Validation du type type_demi_ligne2 39 call MPI_TYPE_COMMIT(type_demi_ligne2,code) if (rang == 0) then 42! Envoi de la matrice A au processus 1 avec le type type_demi_ligne2 43 call MPI_SEND(A(1,1),2,type_demi_ligne2,1,etiquette, & 44 MPI_COMM_WORLD,code) 45 else 46! Réception pour le processus 1 dans la matrice A 47 call MPI_RECV(A(1,nb_colonnes-1),6, MPI_INTEGER,0,etiquette, & 48 MPI_COMM_WORLD,statut,code) 49 print *, Matrice A sur le processus 1 50 do i=1,nb_lignes 51 print *,A(i,:) 52 end do 53 end if call MPI_FINALIZE(code) 56 end program demi_ligne > mpiexec -n 2 demi_ligne type_demi_ligne1: borne_inf=0, etendue=44 type_demi_ligne2: borne_inf=0, etendue=4 Matrice A sur le processus

113 113/343 5 Types de données dérivés 5.10 Conclusion 5 Types de données dérivés 5.10 Conclusion Conclusion Les types dérivés MPI sont de puissants mécanismes portables de description de données. Ils permettent, lorsqu ils sont associés à des instructions comme MPI_SENDRECV(), de simplifier l écriture de sous-programmes d échanges interprocessus. L association des types dérivés et des topologies (décrites dans l un des prochains chapitres) fait de MPI l outil idéal pour tous les problèmes de décomposition de domaines avec des maillages réguliers ou irréguliers.

114 114/343 6 Modèles de communication 1 Introduction 2 Environnement 3 Communications point à point 4 Communications collectives 5 Types de données dérivés 6 Modèles de communication 6.1 Modes d envoi point à point Appel bloquant Appel non bloquant Communicateurs 8 MPI-IO 9 Conclusion 10 Annexes 11 Index

115 115/343 6 Modèles de communication 6.1 Modes d envoi point à point 6 Modèles de communication 6.1 Modes d envoi point à point Modes d envoi point à point Mode Bloquant Non bloquant Envoi standard MPI_SEND() MPI_ISEND() Envoi synchrone MPI_SSEND() MPI_ISSEND() Envoi bufferisé MPI_BSEND() MPI_IBSEND() Envoi en mode ready MPI_RSEND() MPI_IRSEND() Réception MPI_RECV() MPI_IRECV()

116 116/343 6 Modèles de communication 6.2 Appel bloquant 6 Modèles de communication 6.2 Appel bloquant Définition Un appel est bloquant si l espace mémoire servant à la communication peut être réutilisé immédiatement après la sortie de l appel. Les données envoyées peuvent être modifiées après l appel bloquant. Les données reçues peuvent être lues après l appel bloquant.

117 117/343 6 Modèles de communication 6.2 Appel bloquant 6 Modèles de communication 6.2 Appel bloquant Envois synchrones Définition Un envoi synchrone implique une synchronisation entre les processus concernés. Un envoi ne pourra commencer que lorsque sa réception sera postée. Il ne peut y avoir de communication que si les deux processus sont prêts à communiquer. Protocole de rendez-vous Le protocole de rendez-vous est généralement celui employé pour les envois en mode synchrone (dépend de l implémentation). L accusé de réception est optionnel. Temps Processus 0 Processus enveloppe prêt à recevoir données accusé réception

118 118/343 6 Modèles de communication 6.2 Appel bloquant Interface de MPI_SSEND() TYPE(*), intent(in) :: valeurs integer, intent(in) :: taille, type, dest, etiquette, comm integer, intent(out) :: code call MPI_SSEND(valeurs, taille, type, dest, etiquette, comm, code) Avantages Consomment peu de ressources (pas de buffer) Rapides si le récepteur est prêt (pas de recopie dans un buffer) Garantie de la réception grâce à la synchronisation Inconvénients Temps d attente si le récepteur n est pas là/pas prêt Risques d inter-blocage

119 119/343 6 Modèles de communication 6.2 Appel bloquant Exemple d inter-blocage Dans l exemple suivant, on a un inter-blocage, car on est en mode synchrone, les deux processus sont bloqués sur le MPI_SSEND() car ils attendent le MPI_RECV() de l autre processus. Or ce MPI_RECV() ne pourra se faire qu après le déblocage du MPI_SSEND(). 1 program ssendrecv 2 use mpi 3 implicit none 4 integer :: rang,valeur,num_proc,code 5 integer,parameter :: etiquette= call MPI_INIT(code) 8 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) 9 10! On suppose avoir exactement 2 processus 11 num_proc=mod(rang+1,2) call MPI_SSEND(rang+1000,1, MPI_INTEGER,num_proc,etiquette, MPI_COMM_WORLD,code) 14 call MPI_RECV(valeur,1, MPI_INTEGER, num_proc,etiquette, MPI_COMM_WORLD, & 15 MPI_STATUS_IGNORE,code) print *, Moi, processus,rang,, j ai reçu,valeur, du processus,num_proc call MPI_FINALIZE(code) 20 end program ssendrecv

120 120/343 6 Modèles de communication 6.2 Appel bloquant 6 Modèles de communication 6.2 Appel bloquant Envois bufferisés Définition Un envoi bufferisé implique la recopie des données dans un espace mémoire intermédiaire. Il n y a alors pas de couplage entre les deux processus de la communication. La sortie de ce type d envoi ne signifie donc pas que la réception a eu lieu. Protocole avec buffer utilisateur du côté de l émetteur Dans cette approche, le buffer se trouve du côté de l émetteur et est géré explicitement par l application. Un buffer géré par MPI peut exister du côté du récepteur. De nombreuses variantes sont possibles. L accusé de réception est optionnel. Temps Processus 0 recopie message accusé réception Processus

121 121/343 6 Modèles de communication 6.2 Appel bloquant Envois bufferisés Les buffers doivent être gérés manuellement (avec appels à MPI_BUFFER_ATTACH() et MPI_BUFFER_DETACH()). Ils doivent être alloués en tenant compte des surcoûts mémoire des messages (en ajoutant la constante MPI_BSEND_OVERHEAD pour chaque instance de message). Interfaces TYPE(*), intent(in) :: valeurs integer, intent(in) :: taille, type, dest, etiquette, comm integer, intent(out) :: code TYPE(*) :: buf integer :: taille_buf call MPI_BSEND(valeurs, taille, type, dest, etiquette, comm, code) call MPI_BUFFER_ATTACH(buf, taille_buf, code) call MPI_BUFFER_DETACH(buf, taille_buf, code)

122 122/343 6 Modèles de communication 6.2 Appel bloquant Protocole eager Le protocole eager est souvent employé pour les envois en mode standard (MPI_SEND()) pour les messages de petites tailles. Il peut aussi être utilisé pour les envois avec MPI_BSEND() avec des petits messages (dépend de l implémentation) et en court-circuitant le buffer utilisateur du côté de l émetteur. Dans cette approche, le buffer se trouve du côté du récepteur. L accusé de réception est optionnel. Temps Processus message accusé réception Processus

123 123/343 6 Modèles de communication 6.2 Appel bloquant Avantages Pas besoin d attendre le récepteur (recopie dans un buffer) Pas de risque de blocage (deadlocks) Inconvénients Consomment plus de ressources (occupation mémoire par les buffers avec risques de saturation) Les buffers d envoi doivent être gérés manuellement (souvent délicat de choisir une taille adaptée) Un peu plus lent que les envois synchrones si le récepteur est prêt Pas de garantie de la bonne réception (découplage envoi-réception) Risque de gaspillage d espace mémoire si les buffers sont trop sur-dimensionnés L application plante si les buffers sont trop petits Il y a aussi souvent des buffers cachés géré par l implémentation MPI du côté de l expéditeur et/ou du récepteur (et consommant des ressources mémoires)

124 124/343 6 Modèles de communication 6.2 Appel bloquant Absence d inter-blocage Dans l exemple suivant, on a pas d inter-blocage, car on est en mode bufferisé. Une fois la copie faite dans le buffer, l appel MPI_BSEND() retourne et on passe à l appel MPI_RECV(). 1 program bsendrecv 2 use mpi 3 implicit none 4 integer :: rang,valeur,num_proc,taille,surcout,code 5 integer,parameter :: etiquette=110, nb_elt=1 6 integer,dimension(:), allocatable :: buffer 7 8 call MPI_INIT(code) 9 call MPI_COMM_RANK( MPI_COMM_WORLD,rang,code) call MPI_TYPE_SIZE( MPI_INTEGER,taille,code) 12! Convertir taille MPI_BSEND_OVERHEAD (octets) en nombre d integer 13 surcout = int(1+( MPI_BSEND_OVERHEAD*1.)/taille) 14 allocate(buffer(nb_elt+surcout)) 15 call MPI_BUFFER_ATTACH( buffer,taille*(nb_elt+surcout),code) 16! On suppose avoir exactement 2 processus 17 num_proc=mod(rang+1,2) 18 call MPI_BSEND(rang+1000,nb_elt, MPI_INTEGER,num_proc,etiquette, MPI_COMM_WORLD,code) 19 call MPI_RECV(valeur,nb_elt, MPI_INTEGER, num_proc,etiquette, MPI_COMM_WORLD, & 20 MPI_STATUS_IGNORE,code) print *, Moi, processus,rang,, j ai reçu,valeur, du processus,num_proc 23 call MPI_BUFFER_DETACH(buffer,taille*(1+surcout),code) 24 call MPI_FINALIZE(code) 25 end program bsendrecv

125 125/343 6 Modèles de communication 6.2 Appel bloquant 6 Modèles de communication 6.2 Appel bloquant Envois standards Envois standards Un envoi standard se fait en appelant le sous-programme MPI_SEND(). Dans la plupart des implémentations, ce mode passe d un mode bufferisé à un mode synchrone lorsque la taille des messages croît. Interfaces TYPE(*), intent(in) :: valeurs integer, intent(in) :: taille, type, dest, etiquette, comm integer, intent(out) :: code call MPI_SEND(valeurs, taille, type, dest, etiquette, comm, code)

126 126/343 6 Modèles de communication 6.2 Appel bloquant Ping pong extranode balanced Vargas Standard Vargas Synchroneous Vargas Buffered Babel Standard Babel Synchroneous Babel Buffered Bandwidth (MiB/s) Message size (bytes)

127 127/343 6 Modèles de communication 6.2 Appel bloquant Avantages Souvent le plus performant (choix du mode le plus adapté par le constructeur) Le plus portable pour les performances Inconvénients Peu de contrôle sur le mode réellement utilisé (souvent accessible via des variables d environnement) Risque de deadlock selon le mode réel Comportement pouvant varier selon l architecture et la taille du problème

128 128/343 6 Modèles de communication 6.2 Appel bloquant 6 Modèles de communication 6.2 Appel bloquant Envois en mode ready Envois en mode ready Un envoi en mode ready se fait en appelant le sous-programme MPI_RSEND(). Attention : il est obligatoire de faire ces appels seulement lorsque la réception est déjà postée. Leur utilisation est fortement déconseillée. Avantages Légèrement plus performant que le mode synchrone car le protocole de synchronisation peut être simplifié Inconvénients Erreurs si le récepteur n est pas prêt lors de l envoi

129 129/343 6 Modèles de communication 6.3 Appel non bloquant 6 Modèles de communication 6.3 Appel non bloquant Présentation Le recouvrement des communications par des calculs est une méthode permettant de réaliser des opérations de communications en arrière-plan pendant que le programme continue de s exécuter. Sur Ada, la latence d une communication inter-nœud est de 1.5µs soit 4000 cycles processeur. Il est ainsi possible, si l architecture matérielle et logicielle le permet, de masquer tout ou une partie des coûts de communications. Le recouvrement calculs-communications peut être vu comme un niveau supplémentaire de parallélisme. Cette approche s utilise dans MPI par l utilisation de sous-programmes non-bloquants (i.e. MPI_ISEND(), MPI_IRECV() et MPI_WAIT()). Définition Un appel non bloquant rend la main très rapidement, mais n autorise pas la réutilisation immédiate de l espace mémoire utilisé dans la communication. Il est nécessaire de s assurer que la communication est bien terminée (avec MPI_WAIT() par exemple) avant de l utiliser à nouveau.

130 130/343 6 Modèles de communication 6.3 Appel non bloquant Recouvrement partiel Processus 0 requête Recouvrement total Processus 0 requête Temps terminé? envoi Temps envoi terminé? oui... oui