MPI Programing

Message Passing Interface (MPI)
Jalel Chergui Isabelle Dupays Denis Girou Pierre-Franois Lavalle Dimitri Lecas Philippe Wautelet
INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE
MPI Version 4.1 Avril 2012 J. Chergui, I. Dupays, D. Girou, P.-F. Lavalle, D. Lecas, P. Wautelet
MPI Plan I
1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 1.1 Dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 1.2 Concepts de lchange de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.3 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.4 Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 2 Environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21 2.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3 Communications point point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 3.1 Notions gnrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.2 Types de donnes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 3.3 Autres possibilits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 3.4 Exemple : anneau de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 4 Communications collectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43 4.1 Notions gnrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 4.2 Synchronisation globale : MPI_BARRIER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.3 Diusion gnrale : MPI_BCAST() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.4 Diusion slective : MPI_SCATTER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 4.5 Collecte : MPI_GATHER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.6 Collecte gnrale : MPI_ALLGATHER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.7 Collecte : MPI_GATHERV() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 4.8 changes croiss : MPI_ALLTOALL() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
MPI Plan II
4.9 Rductions rparties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 4.10 Complments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 5 Copies de mmoire mmoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69 5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 5.1.1 Rappel : concept de lchange de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 5.1.2 Concept des copies de mmoire mmoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 5.1.3 Approche RMA de MPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 5.2 Notion de fentre mmoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 5.3 Transfert des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 5.4 Achvement du transfert : la synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 5.4.1 Synchronisation de type cible active . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 5.4.2 Synchronisation de type cible passive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 5.5 Conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 6 Types de donnes drivs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .97 6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 6.2 Types contigus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 6.3 Types avec un pas constant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.4 Autres sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.5 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 6.5.1 Type colonne dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104 6.5.2 Type ligne dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.5.3 Type bloc dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
MPI Plan III

6.6 Types homognes pas variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.7 Construction de sous-tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 6.8 Types htrognes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 6.9 Sous-programmes annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 6.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 7 Optimisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 7.2 Modes denvoi point point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 7.2.1 Rappels terminologiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 7.2.2 Envois synchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 7.2.3 Envois bueriss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 7.2.4 Envois standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 7.2.5 Envois en mode ready . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 7.2.6 Performances des dirents modes denvoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 7.3 Recouvrement calculs-communications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 8 Communicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148 8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 8.2 Communicateur par dfaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 8.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 8.4 Groupes et communicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 8.5 Communicateur issu dun autre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 8.6 Topologies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
MPI Plan IV
8.6.1 Topologies cartsiennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 8.6.2 Subdiviser une topologie cartsienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
9 MPI-IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181 9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 9.1.1 Prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 9.1.2 Enjeux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 9.1.3 Dnitions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .187 9.2 Gestion de chiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 9.3 Lectures/critures : gnralits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 9.4 Lectures/critures individuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 9.4.1 Via des dplacements explicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 9.4.2 Via des dplacements implicites individuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 9.4.3 Via des dplacements implicites partags. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 9.5 Lectures/critures collectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 9.5.1 Via des dplacements explicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 9.5.2 Via des dplacements implicites individuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 9.5.3 Via des dplacements implicites partags. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 9.6 Positionnement explicite des pointeurs dans un chier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 9.7 Dnition de vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 9.8 Lectures/critures non bloquantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235 9.8.1 Via des dplacements explicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236 9.8.2 Via des dplacements implicites individuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
MPI Plan V
9.8.3 Lectures/critures collectives et non bloquantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241 9.9 Conseils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244 10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245 11 Annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247 11.1 Communications collectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 11.2 Types de donnes drivs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 11.2.1 Distribution dun tableau sur plusieurs processus . . . . . . . . . . . . . . . . . . . . . . . . . . 251 11.2.2 Types drivs numriques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .264 11.3 Optimisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 11.4 Communicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 11.4.1 Intra et intercommunicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 11.4.2 Graphe de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 11.5 Gestion de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 11.5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 11.5.2 Mode matre-ouvriers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 11.5.3 Mode client-serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 11.5.4 Suppression de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 11.5.5 Complments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312 11.6 MPI-IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 12 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314 12.1 Index des concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 12.2 Index des constantes MPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317
MPI Plan VI
12.3 Index des sous-programmes MPI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .320
8/326
1 Introduction
1 Introduction 1.1 Dnitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 1.2 Concepts de lchange de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12 1.3 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15 1.4 Bibliographie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 2 Environnement 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
9/326
1 Introduction
1.1 Dnitions
1 Introduction
1.1 Dnitions
Le modle de programmation squentiel : le programme est excut par un et un seul processus ; toutes les variables et constantes du programme sont alloues dans la mmoire alloue au processus ; un processus sexcute sur un processeur physique de la machine.
Mmoire Programme P
Figure 1 Modle de programmation squentiel
10/326
1 Introduction
1.1 Dnitions
Dans le modle de programmation par change de messages : le programme est crit dans un langage classique (Fortran , C , C++ , etc.) ; chaque processus excute ventuellement des parties direntes dun programme ; toutes les variables du programme sont prives et rsident dans la mmoire locale alloue chaque processus ; une donne est change entre deux ou plusieurs processus via un appel, dans le programme, des sous-programmes particuliers.
Mmoires
Processus Rseau
Programmes
Figure 2 Modle de programmation par change de messages

11/326
1 Introduction
1.1 Dnitions
Le modle dexcution SPMD : Single Program, M ultiple Data ; le mme programme est excut par tous les processus ; toutes les machines supportent ce modle de programmation et certaines ne supportent que celui-l ; cest un cas particulier du modle plus gnral MPMD (M ultiple Program, M ultiple Data), quil peut dailleurs muler.
Mmoires d0 d1 d2 d3
Processus Rseau
Programme (unique)
Figure 3 Single Program, Multiple Data

12/326
1 Introduction
1.2 Concepts de lchange de messages
1 Introduction
Si un message est envoy un processus, celui-ci doit ensuite le recevoir
0 source Jenvoie source
1 cible Je reois dans cible
Figure 4 change dun message
13/326
1 Introduction
Un message est constitu de paquets de donnes transitant du processus metteur au(x) processus rcepteur(s) En plus des donnes (variables scalaires, tableaux, etc.) transmettre, un message doit contenir les informations suivantes : lidenticateur du processus metteur ; le type de la donne ; sa longueur ; lidenticateur du processus rcepteur.
message emetteur rcepteur type longueur
Mmoires
d1
d2
Processus Rseau
1 message
Figure 5 Constitution dun message
O N d1 NE E
14/326
1 Introduction
Les messages changs sont interprts et grs par un environnement qui peut tre compar la tlphonie, la tlcopie, au courrier postal, la messagerie lectronique, etc. Le message est envoy une adresse dtermine Le processus rcepteur doit pouvoir classer et interprter les messages qui lui ont t adresss Lenvironnement en question est MPI (Message Passing Interface). Une application MPI est un ensemble de processus autonomes excutant chacun leur propre code et communiquant via des appels des sous-programmes de la bibliothque MPI
15/326
1 Introduction
1.3 Historique
1 Introduction
1.3 Historique
Version 1.0 : en juin 1994, le forum MPI (Message Passing Interface Forum), avec la participation dune quarantaine dorganisations, abouti la dnition dun ensemble de sous-programmes concernant la bibliothque dchanges 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 cohrence des dnominations de certains sous-programmes Version 1.3 : septembre 2008, avec des clarications dans MPI 1.2, en fonction des clarications elles-mmes apportes par MPI-2.1 Version 2.0 : apparue en juillet 1997, cette version apportait des complments essentiels volontairement non intgrs dans MPI 1.0 (gestion dynamique de processus, copies mmoire mmoire, entres-sorties parallles, etc.) Version 2.1 : juin 2008, avec seulement des clarications dans MPI 2.0 mais aucun changement Version 2.2 : septembre 2009, avec seulement de petites additions
16/326
1 Introduction
1.3 Historique
Version 3.0 changements et ajouts importants par rapport la version 2.2 ; pour un meilleur support des applications actuelles et futures, notamment sur les machines massivement parallles et many cores ; principaux changements actuellement envisags : communications collectives non bloquantes ; rvision de limplmentation des copies mmoire mmoire ; tolrance aux pannes ; Fortran (2003-2008) bindings ; interfaage doutils externes (pour le dbogage et les mesures de performance) ; etc. attendu en 2012 ; voir http://meetings.mpi-forum.org/MPI_3.0_main_page.php https://svn.mpi-forum.org/trac/mpi-forum-web/wiki
17/326
1 Introduction
1.4 Bibliographie
1 Introduction
1.4 Bibliographie
Message Passing Interface Forum, MPI : A Message-Passing Interface Standard, Version 2.2, High Performance Computing Center Stuttgart (HLRS), 2009 https://fs.hlrs.de/projects/par/mpi/mpi22/ 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 complmentaires : http://www.mpi-forum.org/docs/ http://www.mpi-forum.org/mpi2_1/index.htm http://www.mcs.anl.gov/research/projects/mpi/learning.html http://www.mpi-forum.org/archives/notes/notes.html
18/326
1 Introduction
1.4 Bibliographie
Implmentations MPI open source : elles peuvent tre installes sur un grand nombre darchitectures mais leurs performances sont en gnral en dessous de celles des implmentations constructeurs
1 2
MPICH2 : http://www.mcs.anl.gov/research/projects/mpich2/ Open MPI : http://www.open-mpi.org/
19/326
1 Introduction
1.4 Bibliographie
Dbogueurs 1 Totalview http://www.totalviewtech.com/home/ 2 DDT http://www.allinea.com/products/ddt/ Outils de mesure de performances 1 MPE : MPI Parallel Environment http://www.mcs.anl.gov/research/projects/perfvis/download/index.htm 2 Scalasca : Scalable Performance Analysis of Large-Scale Applications http://www.fz-juelich.de/jsc/scalasca/ 3 Vampir http://www.vampir.eu/
20/326
1 Introduction
1.4 Bibliographie
Quelques bibliothques scientiques parallles open source : 1 ScaLAPACK : rsolution de problmes dalgbre linaire par des mthodes directes. Les sources sont tlchargeables sur le site http://www.netlib.org/scalapack/ 2 PETSc : rsolution de problmes dalgbre linaire et non-linaire par des mthodes itratives. Les sources sont tlchargeables sur le site http://www.mcs.anl.gov/petsc/petsc-as/ 3 MUMPS : rsolution de grands systmes linaires creux par mthode directe multifrontale parallle. Les sources sont tlchargeables sur le site http://graal.ens-lyon.fr/MUMPS/ 4 FFTW : transformes de Fourier rapides. Les sources sont tlchargeables sur le site http://www.fftw.org
21/326
2 Environnement
1 Introduction 2 Environnement 2.1 Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 2.2 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
22/326
2 Environnement
2.1 Description
2 Environnement
2.1 Description
Tout unit de programme appelant des sous-programmes MPI doit inclure un chier den-ttes. En Fortran, il faut maintenant utiliser le module mpi introduit dans MPI-2 (dans MPI-1, il sagissait du chier mpif.h), et en C/C++ le chier mpi.h. Le sous-programme MPI_INIT() permet dinitialiser lenvironnement ncessaire :
integer, intent(out) :: code call MPI_INIT (code)
Rciproquement, le sous-programme MPI_FINALIZE() dsactive cet environnement :

integer, intent(out) :: code call MPI_FINALIZE (code)
23/326
2 Environnement
2.1 Description
Toutes les oprations eectues par MPI portent sur des communicateurs. Le communicateur par dfaut est MPI_COMM_WORLD qui comprend tous les processus actifs.
0 3
Figure 6 Communicateur MPI_COMM_WORLD
24/326
2 Environnement
2.1 Description
tout instant, on peut connatre le nombre de processus grs 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 mme, le sous-programme MPI_COMM_RANK() permet dobtenir le rang dun processus (i.e. son numro dinstance, qui est un nombre compris entre 0 et la valeur renvoye par MPI_COMM_SIZE() 1) :
integer, intent(out) :: rang,code call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code)
25/326
2 Environnement
2.2 Exemple
2 Environnement
2.2 Exemple
1 2 3 4 5 6 7 8 9 10 11 12 13 14
program qui_je_suis use mpi implicit none integer :: nb_procs,rang,code call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) print *,Je suis le processus ,rang, parmi ,nb_procs call MPI_FINALIZE (code) end program qui_je_suis > mpiexec -n 7 qui_je_suis Je Je Je Je Je Je Je suis suis suis suis suis suis suis le le le le le le le processus processus processus processus processus processus processus 3 0 4 1 5 2 6 parmi parmi parmi parmi parmi parmi parmi 7 7 7 7 7 7 7
26/326
3 Communications point point
1 Introduction 2 Environnement 3 Communications point point 3.1 Notions gnrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27 3.2 Types de donnes de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 3.3 Autres possibilits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 3.4 Exemple : anneau de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
27/326
3.1 Notions gnrales

3.1 Notions gnrales
Une communication dite point point a lieu entre deux processus, lun appel processus metteur et lautre processus rcepteur (ou destinataire).
0 3
2 metteur
1000
4 Rcepteur 5 6
Figure 7 Communication point point
28/326
3.1 Notions gnrales
Lmetteur et le rcepteur sont identis par leur rang dans le communicateur. Ce que lon appelle lenveloppe dun message est constitue : du rang du processus metteur ; du rang du processus rcepteur ; de ltiquette (tag) du message ; du communicateur qui dni le groupe de processus et le contexte de communication. Les donnes changes sont types (entiers, rels, etc ou types drivs personnels). Il existe dans chaque cas plusieurs modes de transfert, faisant appel des protocoles dirents qui seront vus au chapitre 7
29/326
3.1 Notions gnrales
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program point_a_point use mpi implicit none integer, dimension( MPI_STATUS_SIZE ) :: statut integer, parameter :: etiquette=100 integer :: rang,valeur,code call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) if (rang == 2) then valeur=1000 call MPI_SEND (valeur,1, MPI_INTEGER ,5,etiquette, MPI_COMM_WORLD ,code) elseif (rang == 5) then call MPI_RECV (valeur,1, MPI_INTEGER ,2,etiquette, MPI_COMM_WORLD ,statut,code) print *,Moi, processus 5, jai reu ,valeur, du processus 2. end if call MPI_FINALIZE (code) end program point_a_point > mpiexec -n 7 point_a_point Moi, processus 5 , jai reu 1000 du processus 2
30/326
3.2 Types de donnes de base

Table 1 Principaux types de donnes 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
31/326
Table 2 Principaux types de donnes 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
32/326
3.3 Autres possibilits

la rception dun message, le rang du processus et ltiquette peuvent tre des jokers , respectivement MPI_ANY_SOURCE et MPI_ANY_TAG. Une communication avec le processus ctif de rang MPI_PROC_NULL na aucun eet. MPI_STATUS_IGNORE est une constante prdnie qui peut tre utilise la place de la variable prvue pour rcuprer en rception le statut. MPI_SUCCESS est une constante prdnie qui permet de tester le code de retour dun sous-programme MPI. Il existe des variantes syntaxiques, MPI_SENDRECV() et MPI_SENDRECV_REPLACE(), qui enchanent un envoi et une rception (dans le premier cas, la zone de rception doit tre forcment dirente de la zone dmission). On peut crer des structures de donnes plus complexes grce ses propres types drivs (voir le chapitre 6).
33/326
1000
0
1001
Figure 8 Communication sendrecv entre les processus 0 et 1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
program sendrecv use mpi implicit none integer integer,parameter
:: rang,valeur,num_proc,code :: etiquette=110
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! On suppose avoir exactement 2 processus num_proc=mod(rang+1,2) call MPI_SENDRECV (rang+1000,1, MPI_INTEGER ,num_proc,etiquette,valeur,1, MPI_INTEGER , & num_proc,etiquette, MPI_COMM_WORLD , MPI_STATUS_IGNORE ,code) ! Test du code de retour du sous-programme MPI_SENDRECV if (code /= MPI_SUCCESS) call MPI_ABORT ( MPI_COMM_WORLD ,2,code) print *,Moi, processus,rang,, jai reu,valeur,du processus,num_proc call MPI_FINALIZE (code) end program sendrecv
34/326
> mpiexec -n 2 sendrecv Moi, processus 1 , jai reu 1000 du processus 0 Moi, processus 0 , jai reu 1001 du processus 1
Attention ! Il convient de noter que si le sous-programme MPI_SEND() est implment de faon synchrone (voir le chapitre 7) dans limplmentation de la version de la bibliothque MPI mise en uvre, le code prcdent serait en situation de verrouillage si la place de lordre MPI_SENDRECV() on utilisait un ordre MPI_SEND() suivi dun ordre MPI_RECV(). En eet, chacun des deux processus attendrait un ordre de rception qui ne viendrait jamais, puisque les deux envois resteraient en suspens. Pour des raisons de respect de la norme MPI et de portabilit, il faut donc absolument viter ces cas-l.
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)
35/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
program joker use mpi implicit none integer, parameter :: integer, dimension(m,m) :: integer :: integer, dimension( MPI_STATUS_SIZE ):: integer :: integer, dimension(:), allocatable ::
m=4,etiquette1=11,etiquette2=22 A nb_procs,rang,code statut nb_elements,i C
call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) A(:,:) = 0
36/326
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
if (rang == 0) then ! Initialisation de la matrice A sur le processus 0 A(:,:) = reshape((/ (i,i=1,m*m) /), (/ m,m /)) ! Envoi de 2 lments de la matrice A au processus 1 call MPI_SEND (A(1,1),2, MPI_INTEGER ,1,etiquette1, MPI_COMM_WORLD ,code) ! Envoi de 3 lments de la matrice A au processus 2 call MPI_SEND (A(1,2),3, MPI_INTEGER ,2,etiquette2, MPI_COMM_WORLD ,code) else ! On teste avant la rception si le message est arriv et de qui call MPI_PROBE ( MPI_ANY_SOURCE , MPI_ANY_TAG , MPI_COMM_WORLD ,statut,code) ! On regarde combien il y a dlments recevoir call MPI_GET_ELEMENTS (statut, MPI_INTEGER ,nb_elements,code) ! On alloue le tableau de rception C sur chaque processus if (nb_elements /= 0 ) allocate (C(1:nb_elements)) ! On reoit le message call MPI_RECV (C,nb_elements, MPI_INTEGER ,statut( MPI_SOURCE ),statut( MPI_TAG ), & MPI_COMM_WORLD ,statut,code) print *,Moi processus ,rang ,je reois ,nb_elements,lments du processus , & statut( MPI_SOURCE ), Mon tableau C vaut , C(:) end if call MPI_FINALIZE (code) end program joker
37/326
> mpiexec -n 3 sendrecv1 Moi processus 1 je reois Moi processus 2 je reois
2 3
lments du processus lments du processus
0 0
Mon tableau C vaut Mon tableau C vaut
1 2 5 6 7
38/326
3.4 Exemple : anneau de communication

1000
0
1002 1006
1
1003
3
1004 1001 1005
Figure 9 Anneau de communication
39/326
Si tous les processus font un envoi puis une rception, toutes les communications pourront potentiellement dmarrer simultanment et nauront donc pas lieu en anneau (outre le problme dj mentionn de portabilit, au cas o limplmentation du MPI_SEND() est faite de faon synchrone dans la version de la bibliothque MPI mise en uvre) :
... valeur=rang+1000 call MPI_SEND (valeur,1, MPI_INTEGER ,num_proc_suivant,etiquette, MPI_COMM_WORLD ,code) call MPI_RECV (valeur,1, MPI_INTEGER ,num_proc_precedent,etiquette, MPI_COMM_WORLD , & statut,code) ...
40/326
Pour que les communications se fassent rellement en anneau, limage dun passage de jeton entre processus, il faut procder diremment et faire en sorte quun processus initie la chane :
1006
1000
6
1005
1
1001
5
1004
2 4
1003
1002
Figure 10 Anneau de communication
41/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
program anneau use mpi implicit none integer, dimension( MPI_STATUS_SIZE ) :: statut integer, parameter :: etiquette=100 integer :: nb_procs,rang,valeur, & num_proc_precedent,num_proc_suivant,code call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) num_proc_suivant=mod(rang+1,nb_procs) num_proc_precedent=mod(nb_procs+rang-1,nb_procs) if (rang == 0) then call MPI_SEND (rang+1000,1, MPI_INTEGER ,num_proc_suivant,etiquette, & MPI_COMM_WORLD ,code) call MPI_RECV (valeur,1, MPI_INTEGER ,num_proc_precedent,etiquette, & MPI_COMM_WORLD ,statut,code) else call MPI_RECV (valeur,1, MPI_INTEGER ,num_proc_precedent,etiquette, & MPI_COMM_WORLD ,statut,code) call MPI_SEND (rang+1000,1, MPI_INTEGER ,num_proc_suivant,etiquette, & MPI_COMM_WORLD ,code) end if print *,Moi, proc. ,rang,, jai reu ,valeur, du proc. ,num_proc_precedent call MPI_FINALIZE (code) end program anneau
42/326
> mpiexec -n 7 anneau Moi, Moi, Moi, Moi, Moi, Moi, Moi, proc. proc. proc. proc. proc. proc. proc. 1, 2, 3, 4, 5, 6, 0, jai jai jai jai jai jai jai reu reu reu reu reu reu reu 1000 1001 1002 1003 1004 1005 1006 du du du du du du du proc. proc. proc. proc. proc. proc. proc. 0 1 2 3 4 5 6
43/326
4 Communications collectives
1 Introduction 2 Environnement 3 Communications point point 4 Communications collectives 4.1 Notions gnrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44 4.2 Synchronisation globale : MPI_BARRIER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 4.3 Diusion gnrale : MPI_BCAST() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47 4.4 Diusion slective : MPI_SCATTER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49 4.5 Collecte : MPI_GATHER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51 4.6 Collecte gnrale : MPI_ALLGATHER() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53 4.7 Collecte : MPI_GATHERV() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55 4.8 changes croiss : MPI_ALLTOALL() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58 4.9 Rductions rparties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 4.10 Complments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
44/326
4.1 Notions gnrales
4.1 Notions gnrales
Les communications collectives permettent de faire en une seule opration une srie de communications point point. Une communication collective concerne toujours tous les processus du communicateur indiqu. Pour chacun des processus, lappel se termine lorsque la participation de celui-ci lopration collective est acheve, au sens des communications point--point (donc quand la zone mmoire concerne peut tre modie). Il est inutile dajouter une synchronisation globale (barrire) aprs une opration collective. La gestion des tiquettes dans ces communications est transparente et la charge du systme. Elles ne sont donc jamais dnies explicitement lors de lappel ces sous-programmes. Cela a entre autres pour avantage que les communications collectives ninterfrent jamais avec les communications point point.
45/326
4.1 Notions gnrales
Il y a trois types de sous-programmes : celui qui assure les synchronisations globales : MPI_BARRIER(). ceux qui ne font que transfrer des donnes : diusion globale de donnes : MPI_BCAST() ; diusion slective de donnes : MPI_SCATTER() ; collecte de donnes rparties : MPI_GATHER() ; collecte par tous les processus de donnes rparties : MPI_ALLGATHER() ; diusion slective, par tous les processus, de donnes rparties : MPI_ALLTOALL(). ceux qui, en plus de la gestion des communications, eectuent des oprations sur les donnes transfres : oprations de rduction (somme, produit, maximum, minimum, etc.), quelles soient dun type prdni ou dun type personnel : MPI_REDUCE() ; oprations de rduction avec diusion du rsultat (quivalent un MPI_REDUCE() suivi dun MPI_BCAST()) : MPI_ALLREDUCE().
46/326
4.2 Synchronisation globale : MPI_BARRIER()
P0 P1 P2 P3
4.2 Synchronisation globale : MPI_BARRIER()

P0 P1 P2 P3 P0 P1 P2 P3
Barrire
Figure 11 Synchronisation globale : MPI_BARRIER()

integer, intent(out) :: code call MPI_BARRIER ( MPI_COMM_WORLD ,code)
47/326
4.3 Diusion gnrale : MPI_BCAST()
0
A
A A A
3
P0 P1 P2 A P3 MPI_BCAST() P0 A P1 A P2 A P3 A Figure 12 Diusion gnrale : MPI_BCAST()
48/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
program bcast use mpi implicit none integer :: rang,valeur,code call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) if (rang == 2) valeur=rang+1000 call MPI_BCAST (valeur,1, MPI_INTEGER ,2, MPI_COMM_WORLD ,code) print *,Moi, processus ,rang,, jai reu ,valeur, du processus 2 call MPI_FINALIZE (code) end program bcast > mpiexec -n 4 bcast Moi, Moi, Moi, Moi, processus processus processus processus 2, 0, 1, 3, jai jai jai jai reu reu reu reu 1002 1002 1002 1002 du du du du processus processus processus processus 2 2 2 2
49/326
4.4 Diusion slective : MPI_SCATTER()
0
A1
A0 A2 A3
3
P0 P1 P2 A0 A1 A2 A3 P3 MPI_SCATTER() P0 A0 P1 A1 P2 A2 P3 A3 Figure 13 Diusion slective : MPI_SCATTER()
50/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
program scatter use mpi implicit none integer, parameter :: nb_valeurs=8 integer :: nb_procs,rang,longueur_tranche,i,code real, allocatable, dimension(:) :: valeurs,donnees call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) longueur_tranche=nb_valeurs/nb_procs allocate(donnees(longueur_tranche)) if (rang == 2) then allocate(valeurs(nb_valeurs)) valeurs(:)=(/(1000.+i,i=1,nb_valeurs)/) print *,Moi, processus ,rang,envoie mon tableau valeurs : ,& valeurs(1:nb_valeurs) end if call MPI_SCATTER (valeurs,longueur_tranche, MPI_REAL ,donnees,longueur_tranche, & MPI_REAL ,2, MPI_COMM_WORLD ,code) print *,Moi, processus ,rang,, jai reu , donnees(1:longueur_tranche), & du processus 2 call MPI_FINALIZE (code) end program scatter > mpiexec -n 4 scatter Moi, processus 2 envoie mon tableau valeurs : 1001. 1002. 1003. 1004. 1005. 1006. 1007. 1008. Moi, Moi, Moi, Moi, processus processus processus processus 0, 1, 3, 2, jai jai jai jai reu reu reu reu 1001. 1003. 1007. 1005. 1002. 1004. 1008. 1006. du du du du processus processus processus processus 2 2 2 2
51/326
4.5 Collecte : MPI_GATHER()
0
A1
A0 A2 A3
3
P0 A0 P1 A1 P2 A2 P3 A3 MPI_GATHER() P0 P1 P2 A0 A1 A2 A3 P3 Figure 14 Collecte : MPI_GATHER()
52/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
program gather use mpi implicit none integer, parameter integer real, dimension(nb_valeurs) real, allocatable, dimension(:)
:: :: :: ::
nb_valeurs=8 nb_procs,rang,longueur_tranche,i,code donnees valeurs
call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) 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 : ,& valeurs(1:longueur_tranche) call MPI_GATHER (valeurs,longueur_tranche, MPI_REAL ,donnees,longueur_tranche, & MPI_REAL ,2, MPI_COMM_WORLD ,code) if (rang == 2) print *,Moi, processus 2, jai reu ,donnees(1:nb_valeurs) call MPI_FINALIZE (code) end program gather > mpiexec -n 4 Moi, processus Moi, processus Moi, processus Moi, processus gather 1 envoie 0 envoie 2 envoie 3 envoie mon mon mon mon tableau tableau tableau tableau valeurs valeurs valeurs valeurs : 1003. : 1001. : 1005. : 1007. 1004. 1002. 1006. 1008.
Moi, processus 2 , jai reu 1001. 1002. 1003. 1004. 1005. 1006. 1007. 1008.
53/326
4.6 Collecte gnrale : MPI_ALLGATHER()
A0
A0 A1 A1 A0
0
A2 A1 A3 A1 A3
A2 A0 A2
A2 A3
3
P0 A0 P1 A1 P2 A2 P3 A3
A3 MPI_ALLGATHER()
P0 A0 A1 A2 A3 P1 A0 A1 A2 A3 P2 A0 A1 A2 A3 P3 A0 A1 A2 A3
Figure 15 Collecte gnrale : MPI_ALLGATHER()

54/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program allgather use mpi implicit none integer, parameter integer real, dimension(nb_valeurs) real, allocatable, dimension(:) call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) 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)/) call MPI_ALLGATHER (valeurs,longueur_tranche, MPI_REAL ,donnees,longueur_tranche, & MPI_REAL , MPI_COMM_WORLD ,code) print *,Moi, processus ,rang,, jai reu ,donnees(1:nb_valeurs) call MPI_FINALIZE (code) end program allgather > mpiexec -n 4 allgather Moi, Moi, Moi, Moi, processus processus processus processus 1, 3, 2, 0, jai jai jai jai reu reu reu reu 1001. 1001. 1001. 1001. 1002. 1002. 1002. 1002. 1003. 1003. 1003. 1003. 1004. 1004. 1004. 1004. 1005. 1005. 1005. 1005. 1006. 1006. 1006. 1006. 1007. 1007. 1007. 1007. 1008. 1008. 1008. 1008. :: :: :: :: nb_valeurs=8 nb_procs,rang,longueur_tranche,i,code donnees valeurs
55/326
4.7 Collecte : MPI_GATHERV()
0
A1
A0 A2 A3
3
P0 P1 P2 P3 A0 A1 A2 A3 MPI_GATHERV() P0 P1 P2 P3 Figure 16 Collecte : MPI_GATHERV()
A0 A1 A2 A3
56/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
program gatherv use mpi implicit none integer, parameter integer real, dimension(nb_valeurs) real, allocatable, dimension(:) integer, allocatable, dimension(:)
:: :: :: :: ::
nb_valeurs=10 nb_procs, rang, longueur_tranche, i, code donnees valeurs nb_elements_recus,deplacements
call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) longueur_tranche=nb_valeurs/nb_procs reste = mod(nb_valeurs,nb_procs) if (reste > rang) longueur_tranche = longueur_tranche+1 ALLOCATE(valeurs(longueur_tranche)) valeurs(:) = (/(1000.+(rang*(nb_valeurs/nb_procs))+min(rang,reste)+i, & i=1,longueur_tranche)/) PRINT *, Moi, processus , rang,envoie mon tableau valeurs : ,& valeurs(1:longueur_tranche) IF (rang == 2) THEN ALLOCATE(nb_elements_recus(nb_procs),deplacements(nb_procs)) nb_elements_recus(1) = nb_valeurs/nb_procs if (reste > 0) nb_elements_recus(1) = nb_elements_recus(1)+1 deplacements(1) = 0 DO i=2,nb_procs deplacements(i) = deplacements(i-1)+nb_elements_recus(i-1) nb_elements_recus(i) = nb_valeurs/nb_procs if (reste > i-1) nb_elements_recus(i) = nb_elements_recus(i)+1 END DO END IF
57/326
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, Moi, Moi, Moi, processus processus processus processus 0 2 3 1 envoie envoie envoie envoie mon mon mon mon tableau tableau tableau tableau valeurs valeurs valeurs valeurs : : : : 1001. 1007. 1009. 1004. 1002. 1003. 1008. 1010. 1005. 1006.
Moi, processus 2 je reois 1009. 1010.
1001. 1002. 1003. 1004. 1005. 1006. 1007. 1008.
58/326
4.8 changes croiss : MPI_ALLTOALL()
A0
A1 B1 B0 A3
0
C1 B2 D1 B3 D0
C0 A2 C2
C3 D2 P0 A0 B0 C0 D0 P1 A1 B1 C1 D1 P2 A2 B2 C2 D2 P3 A3 B3 C3 D3
3
P0 A0 A1 A2 A3 P1 B0 B1 B2 B3 P2 C0 C1 C2 C3 P3 D0 D1 D2 D3 D3 MPI_ALLTOALL()
Figure 17 changes croiss : MPI_ALLTOALL()

59/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
program alltoall use mpi implicit none integer, parameter integer real, dimension(nb_valeurs) :: nb_valeurs=8 :: nb_procs,rang,longueur_tranche,i,code :: valeurs,donnees
call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) valeurs(:)=(/(1000.+rang*nb_valeurs+i,i=1,nb_valeurs)/) longueur_tranche=nb_valeurs/nb_procs print *,Moi, processus ,rang,envoie mon tableau valeurs : , & valeurs(1:nb_valeurs) call MPI_ALLTOALL (valeurs,longueur_tranche, MPI_REAL ,donnees,longueur_tranche, & MPI_REAL , MPI_COMM_WORLD ,code) print *,Moi, processus ,rang,, jai reu ,donnees(1:nb_valeurs) call MPI_FINALIZE (code) end program alltoall
60/326
> mpiexec -n 4 alltoall Moi, processus 1 envoie mon tableau valeurs : 1009. 1010. 1011. 1012. 1013. 1014. 1015. Moi, processus 0 envoie mon tableau valeurs : 1001. 1002. 1003. 1004. 1005. 1006. 1007. Moi, processus 2 envoie mon tableau valeurs : 1017. 1018. 1019. 1020. 1021. 1022. 1023. Moi, processus 3 envoie mon tableau valeurs : 1025. 1026. 1027. 1028. 1029. 1030. 1031. Moi, Moi, Moi, Moi, processus processus processus processus 0, 2, 1, 3, jai jai jai jai reu reu reu reu 1001. 1005. 1003. 1007. 1002. 1006. 1004. 1008.
1016. 1008. 1024. 1032. 1010. 1014. 1012. 1016. 1017. 1021. 1019. 1023. 1018. 1022. 1020. 1024. 1025. 1029. 1027. 1031. 1026. 1030. 1028. 1032.
1009. 1013. 1011. 1015.
61/326
4.9 Rductions rparties
Une rduction est une opration applique un ensemble dlments pour en obtenir une seule valeur. Des exemples typiques sont la somme des lments dun vecteur SUM(A(:)) ou la recherche de llment de valeur maximum dans un vecteur MAX(V(:)). MPI propose des sous-programmes de haut-niveau pour oprer des rductions sur des donnes rparties sur un ensemble de processus. Le rsultat est obtenu sur un seul processus (MPI_REDUCE()) ou bien sur tous (MPI_ALLREDUCE(), qui est en fait quivalent un MPI_REDUCE() suivi dun MPI_BCAST()). Si plusieurs lments sont concerns par processus, la fonction de rduction est applique chacun dentre eux. Le sous-programme MPI_SCAN() permet en plus deectuer des rductions partielles en considrant, pour chaque processus, les processus prcdents du communicateur et lui-mme. Les sous-programmes MPI_OP_CREATE() et MPI_OP_FREE() permettent de dnir des oprations de rduction personnelles.
62/326
Table 3 Principales oprations de rduction prdnies (il existe aussi dautres oprations logiques)
Nom MPI_SUM MPI_PROD MPI_MAX MPI_MIN MPI_MAXLOC MPI_MINLOC MPI_LAND MPI_LOR MPI_LXOR
Opration Somme des lments Produit des lments Recherche du maximum Recherche du minimum Recherche de lindice du maximum Recherche de lindice du minimum ET logique OU logique OU exclusif logique
63/326
1000+1+2+3+4+5+6 = 1021 1
1
4
2
5
3
6
Figure 18 Rduction rpartie (somme)
64/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program reduce use mpi implicit none integer :: nb_procs,rang,valeur,somme,code call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) if (rang == 0) then valeur=1000 else valeur=rang endif call MPI_REDUCE (valeur,somme,1, MPI_INTEGER , MPI_SUM ,0, MPI_COMM_WORLD ,code) if (rang == 0) then print *,Moi, processus 0, jai pour valeur de la somme globale ,somme end if call MPI_FINALIZE (code) end program reduce > mpiexec -n 7 reduce Moi, processus 0 , jai pour valeur de la somme globale 1021
65/326
7200 101234 56 = 7200 7200 1
1
7200
7200
2 5
3 7200
3
6 7200
4
7200
Figure 19 Rduction rpartie (produit) avec diusion du rsultat
66/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
program allreduce use mpi implicit none integer :: nb_procs,rang,valeur,produit,code call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) if (rang == 0) then valeur=10 else valeur=rang endif call MPI_ALLREDUCE (valeur,produit,1, MPI_INTEGER , MPI_PROD , MPI_COMM_WORLD ,code) print *,Moi, processus ,rang,, jai reu la valeur du produit global ,produit call MPI_FINALIZE (code) end program allreduce
67/326
> mpiexec -n 7 allreduce Moi, Moi, Moi, Moi, Moi, Moi, Moi, processus processus processus processus processus processus processus 6, 2, 0, 4, 5, 3, 1, jai jai jai jai jai jai jai reu reu reu reu reu reu reu la la la la la la la valeur valeur valeur valeur valeur valeur valeur du du du du du du du produit produit produit produit produit produit produit global global global global global global global 7200 7200 7200 7200 7200 7200 7200
68/326
4.10 Complments
4.10 Complments
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 dlments diuser ou collecter est dirent suivant les processus. Deux nouveaux sous-programmes ont t ajouts pour tendre les possibilits des sous-programmes collectifs dans quelques cas particuliers : MPI_ALLTOALLW() : version de MPI_ALLTOALLV() o les dplacements sont exprims en octets et non en lments, MPI_EXSCAN() : version exclusive de MPI_SCAN(), qui elle est inclusive.
69/326
5 Copies de mmoire mmoire
1 Introduction 2 Environnement 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70 5.1.1 Rappel : concept de lchange de messages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71 5.1.2 Concept des copies de mmoire mmoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72 5.1.3 Approche RMA de MPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73 5.2 Notion de fentre mmoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74 5.3 Transfert des donnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78 5.4 Achvement du transfert : la synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82 5.4.1 Synchronisation de type cible active . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 5.4.2 Synchronisation de type cible passive . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92 5.5 Conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
70/326
5.1 Introduction

5.1 Introduction
Diverses approches existent pour transfrer des donnes entre deux processus distincts. Parmi les plus utilises, on trouve : les communications point point par change de messages (MPI , etc.) ; les communications par copies de mmoire mmoire (accs direct la mmoire dun processus distant). Appeles RMA pour Remote Memory Access ou OSC pour One Sided Communication, cest lun des apports majeurs de MPI .
71/326
5.1 Introduction
5.1 Introduction 5.1.1 Rappel : concept de lchange de messages
0 source Jenvoie source
1 cible Je reois dans cible
Figure 20 Lchange de messages
Dans le concept de lchange de messages, un metteur (source) va envoyer un message un processus destinataire (cible) qui va faire la dmarche de recevoir ce message. Cela ncessite que lmetteur comme le destinataire prennent part la communication. Ceci peut tre contraignant et dicile mettre en uvre dans certains algorithmes (par exemple lorsquil faut grer un compteur global).
72/326
5.1 Introduction
5.1 Introduction 5.1.2 Concept des copies de mmoire mmoire
Le concept de communication par copies de mmoire mmoire nest pas nouveau, MPI ayant simplement uni les solutions constructeurs dj existantes (telles que shmem (CRAY), lapi (IBM), ...) en proposant ses propres primitives RMA. Via ces sous-programmes, un processus a directement accs (en lecture, criture ou mise jour) la mmoire dun autre processus distant. Dans cette approche, le processus distant na donc pas intervenir dans la procdure de transfert des donnes. Les principaux avantages sont les suivants : des performances amliores lorsque le matriel le permet, une programmation plus simple de certains algorithmes.
73/326
5.1 Introduction

5.1 Introduction 5.1.3 Approche RMA de MPI
Lapproche RMA de MPI peut tre divise en trois tapes successives : dnition sur chaque processus dune zone mmoire (fentre mmoire locale) visible et susceptible dtre accde par des processus distants ; dclenchement du transfert des donnes directement de la mmoire dun processus celle dun autre processus. Il faut alors spcier le type, le nombre et la localisation initiale et nale des donnes. achvement des transferts en cours par une tape de synchronisation, les donnes tant alors rellement disponibles pour les calculs.
74/326
5.2 Notion de fentre mmoire

Tous les processus prenant part une opration de copie de mmoire mmoire doivent spcier quelle partie de leur mmoire va tre accessible aux autres processus ; cest la notion de fentre mmoire. Plus prcisment, lopration collective MPI_WIN_CREATE() permet la cration dun objet MPI fentre. Cet objet est compos, pour chaque processus, dune zone mmoire spcique appele fentre mmoire locale. Au niveau de chaque processus, une fentre mmoire locale est caractrise par son adresse de dpart, sa taille en octets (qui peut tre nulle) et la taille de lunit de dplacement lintrieur de cette fentre (en octets). Ces caractristiques peuvent tre direntes sur chacun des processus.
75/326
Exemple : Objet MPI fentre win1 0 Premire fentre locale Deuxime fentre locale Premire fentre locale 1 Deuxime fentre locale
Objet MPI fentre win2

Figure 21 Cration de deux objets MPI fentre, win1 et win2
76/326
Une fois les transferts termins, on doit librer la fentre avec le sous-programme MPI_WIN_FREE(). MPI_WIN_GET_ATTR() permet de connatre les caractristiques dune fentre mmoire locale en utilisant les mots cls MPI_WIN_BASE, MPI_WIN_SIZE ou MPI_WIN_DISP_UNIT. Remarque : Le choix de lunit de dplacement associe la fentre mmoire locale est important (indispensable dans un environnement htrogne et facilitant le codage dans tous les cas). Lobtention de la taille dun type MPI prdni se fait en appelant le sous-programme MPI_TYPE_SIZE().
77/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
program fenetre use mpi implicit none integer :: code, rang, taille_reel, win, n=4 integer (kind= MPI_ADDRESS_KIND ) :: dim_win, taille, base, unite real(kind=kind(1.d0)), dimension(:), allocatable :: win_local logical :: flag call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD , rang, code) call MPI_TYPE_SIZE ( MPI_DOUBLE_PRECISION ,taille_reel,code) if (rang==0) n=0 allocate(win_local(n)) dim_win = taille_reel*n call MPI_WIN_CREATE (win_local, dim_win, taille_reel, MPI_INFO_NULL , & MPI_COMM_WORLD , win, code) call MPI_WIN_GET_ATTR (win, MPI_WIN_SIZE , taille, flag, code) call MPI_WIN_GET_ATTR (win, MPI_WIN_BASE , base, flag, code) call MPI_WIN_GET_ATTR (win, MPI_WIN_DISP_UNIT , unite, flag, code) call MPI_WIN_FREE (win,code) print *,"processus", rang,"taille, base, unite = ", & taille, base, unite call MPI_FINALIZE (code) end program fenetre > mpiexec -n 3 processus 1 processus 0 processus 2 fenetre taille, base, unite = taille, base, unite = taille, base, unite = 32 17248330400 0 2 8 32 17248330400 8 8
78/326
5.3 Transfert des donnes

MPI permet un processus de lire (MPI_GET()), dcrire (MPI_PUT()) et de mettre jour (MPI_ACCUMULATE()) des donnes situes dans la fentre mmoire locale dun processus distant. On nomme origine le processus qui fait lappel au sous-programme dinitialisation du transfert et cible le processus qui possde la fentre mmoire locale qui va tre utilise dans la procdure de transfert. Lors de linitialisation du transfert, le processus cible nappelle aucun sous-programme MPI . Toutes les informations ncessaires sont spcies sous forme de paramtres lors de lappel au sous-programme MPI par lorigine.
79/326
En particulier, on trouve : des paramtres ayant rapport lorigine : le type des lments ; leur nombre ; ladresse mmoire du premier lment. des paramtres ayant rapport la cible : le rang de la cible ainsi que lobjet MPI fentre, ce qui dtermine de faon unique une fentre mmoire locale ; un dplacement dans cette fentre locale ; le nombre et le type des donnes transfrer.
80/326
1 2 3 4 5 6 7 8
program exemple_put integer :: nb_orig=10, nb_cible=10, cible=1, win, code integer (kind= MPI_ADDRESS_KIND ) :: deplacement=40 integer, dimension(10) :: B ... call MPI_PUT (B,nb_orig, MPI_INTEGER ,cible,deplacement,nb_cible, MPI_INTEGER ,win,code) ... end program exemple_put
Dplacement de 40 units dans la fentre locale 1 0 Premire fentre locale Premire fentre locale
B(1 :10)
Figure 22 Exemple dun MPI_PUT
81/326
Remarques : La syntaxe de MPI_GET est identique celle de MPI_PUT, seul le sens de transfert des donnes tant invers. Les sous-programmes de transfert de donnes RMA sont des primitives non bloquantes (choix dlibr de MPI ). Sur le processus cible, les seules donnes accessibles sont celles contenues dans la fentre mmoire locale. MPI_ACCUMULATE() admet parmi ses paramtres une opration qui doit tre soit du type MPI_REPLACE, soit lune des oprations de rduction prdnies : MPI_SUM, MPI_PROD, MPI_MAX, etc. Ce ne peut en aucun cas tre une opration dnie par lutilisateur.
82/326
5.4 Achvement du transfert : la synchronisation
Le transfert des donnes dbute aprs lappel lun des sous-programmes non bloquants (MPI_PUT(), ...). Mais quand le transfert est-il termin et les donnes rellement disponibles ? Aprs une synchronisation qui est la charge du programmeur. Ces synchronisations peuvent tre classes en deux types : synchronisation de type cible active (opration collective, tous les processus associs la fentre prenant part la synchronisation) ; synchronisation de type cible passive (seul le processus origine appelle le sous-programme de synchronisation).
83/326
5.4 Achvement du transfert : la synchronisation 5.4.1 Synchronisation de type cible active
Se fait en utilisant le sous-programme MPI MPI_WIN_FENCE(). MPI_WIN_FENCE() est une opration collective sur tous les processus associs lobjet MPI fentre. MPI_WIN_FENCE() agit comme une barrire de synchronisation. Elle attend la n de tous les transferts de donnes (RMA ou non) utilisant la fentre mmoire locale et initis depuis le dernier appel MPI_WIN_FENCE(). Cette primitive va permettre de sparer les parties calcul du code (o lon utilise des donnes de la fentre mmoire locale via des load ou des store) des parties de transfert de donnes de type RMA. Un argument assert de la primitive MPI_WIN_FENCE(), de type entier, permet daner son comportement en vue de meilleures performances. Diverses valeurs sont prdnies MPI_MODE_NOSTORE, MPI_MODE_NOPUT, MPI_MODE_NOPRECEDE, MPI_MODE_NOSUCCEED. Une valeur de zro pour cet argument est toujours valide.
84/326
Remarques : Le fait davoir choisi des sous-programmes RMA dinitialisation du transfert non bloquants et une synchronisation pour lachvement des transferts en cours autorise limplmentation regrouper lors de lexcution divers transferts vers la mme cible en un transfert unique. Leet de la latence est ainsi rduit et les performances amliores. Le caractre collectif de la synchronisation a pour consquence quon na pas rellement aaire ce que lon appelle du One Sided Communication ... En fait tous les processus du communicateur vont devoir prendre part la synchronisation, ce qui perd de son intrt !
85/326
Du bon usage de MPI_WIN_FENCE

Il faut sassurer quentre deux appels successifs MPI_WIN_FENCE() il ny a soit que des aectations locales (load/store) sur des variables contenues dans la fentre mmoire locale du processus, soit que des oprations RMA de type MPI_PUT() ou MPI_ACCUMULATE(), mais jamais les deux en mme temps ! 0 MPI_WIN_FENCE() | MPI_WIN_FENCE() MPI_PUT() MPI_WIN_FENCE() 1 MPI_WIN_FENCE() win_loc(:) = win_loc(:) + 1.0 MPI_WIN_FENCE() MPI_WIN_FENCE()
Le programme prcdent est-il conforme au bon usage de MPI_WIN_FENCE() ? Tout dpend de la portion de code reprsente par . Si celle-ci nengendre pas de load/store sur la fentre locale (aectation ou utilisation dune variable stocke dans la fentre locale), alors cest bon ; dans le cas contraire, le rsultat est indni.
86/326
Exemple rcapitulatif
P0
tab
P1
win_loc MPI_PUT
ligne correspondante l. 1,30 l. 31,35
1 2 3 4 1 2 3 4 1 2 3 6 3 2 3 6 3 2 3 8 3 2 3 8
0 0 0 0 0 1 2 0 0 1 2 3 0 1 2 3 1 2 3 4 1 4 6 12
tab
win_loc
l. 37 l. 38,42
tab
win_loc MPI_GET
l. 44 l. 45,49
tab
win_loc
l. 50 l. 51,55
tab
win_loc
l. 57
MPI_ACCUMULATE tab win_loc
l. 58,63 l. 65
Figure 23 Exemple rcapitulatif correspondant au code ex_fence

87/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program ex_fence use mpi implicit none integer, parameter :: assert=0 integer :: code, rang, taille_reel, win, i, nb_elements, cible, m=4, n=4 integer (kind= MPI_ADDRESS_KIND ) :: deplacement, dim_win real(kind=kind(1.d0)), dimension(:), allocatable :: win_local, tab call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD , rang, code) call MPI_TYPE_SIZE ( MPI_DOUBLE_PRECISION ,taille_reel,code) if (rang==0) then n=0 allocate(tab(m)) endif allocate(win_local(n)) dim_win = taille_reel*n call MPI_WIN_CREATE (win_local, dim_win, taille_reel, MPI_INFO_NULL , & MPI_COMM_WORLD , win, code)
88/326
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
if (rang==0) then tab(:) = (/ (i, i=1,m) /) else win_local(:) = 0.0 end if call MPI_WIN_FENCE (assert,win,code) if (rang==0) then cible = 1; nb_elements = 2; deplacement = 1 call MPI_PUT (tab, nb_elements, MPI_DOUBLE_PRECISION , cible, deplacement, & nb_elements, MPI_DOUBLE_PRECISION , win, code) end if call MPI_WIN_FENCE (assert,win,code) if (rang==0) then tab(m) = sum(tab(1:m-1)) else win_local(n) = sum(win_local(1:n-1)) endif call MPI_WIN_FENCE (assert,win,code) if (rang==0) then nb_elements = 1; deplacement = m-1 call MPI_GET (tab, nb_elements, MPI_DOUBLE_PRECISION , cible, deplacement, & nb_elements, MPI_DOUBLE_PRECISION , win, code) end if
89/326
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
call MPI_WIN_FENCE (assert,win,code) if (rang==0) then tab(m) = sum(tab(1:m-1)) else win_local(:) = win_local(:) + 1 endif call MPI_WIN_FENCE (assert,win,code) if (rang==0) then nb_elements = m-1; deplacement = 1 call MPI_ACCUMULATE (tab(2), nb_elements, MPI_DOUBLE_PRECISION , cible, & deplacement, nb_elements, MPI_DOUBLE_PRECISION , & MPI_SUM , win, code) end if call MPI_WIN_FENCE (assert,win,code) call MPI_WIN_FREE (win,code) if (rang==0) then print *,"processus", rang, "tab=",tab(:) else print *,"processus", rang, "win_local=",win_local(:) endif call MPI_FINALIZE (code) end program ex_fence
90/326
Quelques prcisions et restrictions...

Il est possible de travailler sur des fentres mmoire locales direntes qui se recouvrent, mme si cela nest pas recommand (une telle utilisation impliquant de trop nombreuses restrictions). Dans la suite on supposera ne pas tre dans ce cas. Il faut toujours sparer par un appel MPI_WIN_FENCE() un store et lappel un sous-programme MPI_PUT() ou MPI_ACCUMULATE() accdant la mme fentre mmoire locale mme des endroits dirents ne se recouvrant pas. Entre deux appels successifs au sous-programme MPI_WIN_FENCE(), on a les contraintes suivantes : les sous-programmes MPI_PUT() nadmettent pas le recouvrement lintrieur dune mme fentre mmoire locale. En dautres termes, les zones mmoires mises en jeu lors dappels plusieurs sous-programmes MPI_PUT() agissant sur la mme fentre mmoire locale, ne doivent pas se recouvrir ;
91/326
les sous-programmes MPI_ACCUMULATE() admettent le recouvrement lintrieur dune mme fentre mmoire locale, la condition que les types des donnes et lopration de rduction utiliss soient identiques lors de tous ces appels ; les sous-programmes MPI_PUT() et MPI_ACCUMULATE() utiliss conscutivement nadmettent pas le recouvrement lintrieur dune mme fentre mmoire locale ; un load et un appel au sous-programme MPI_GET() peuvent accder concurremment nimporte quelle partie de la fentre locale, pourvu quelle nait pas t mise jour auparavant soit par un store, soit lors de lappel un sous-programme de type MPI_PUT() ou MPI_ACCUMULATE().
92/326
5.4 Achvement du transfert : la synchronisation 5.4.2 Synchronisation de type cible passive
Se fait via les appels aux sous-programmes MPI MPI_WIN_LOCK() et MPI_WIN_UNLOCK(). Contrairement la synchronisation par MPI_WIN_FENCE() (qui est une opration collective de type barrire), ici seul le processus origine va participer la synchronisation. De ce fait tous les appels ncessaires au transfert des donnes (initialisation du transfert, synchronisation) ne font intervenir que le processus origine ; cest du vrai One Sided Communication . Les oprations de lock et dunlock ne sappliquent qu une fentre mmoire locale donne (i.e. identie par un numro de processus cible et un objet MPI fentre). La priode qui commence au lock et se termine lunlock est appele une priode daccs la fentre mmoire locale. Ce nest que durant cette priode que le processus origine va avoir accs la fentre mmoire locale du processus cible.
93/326
Pour lutiliser, il sut pour le processus origine dentourer lappel aux primitives RMA dinitialisation de transfert de donnes par MPI_WIN_LOCK() et MPI_WIN_UNLOCK(). Pour le processus cible, aucun appel de sous-programmes MPI nest faire. Lorsque MPI_WIN_UNLOCK() rend la main, tous les transferts de donnes initis aprs le MPI_WIN_LOCK() sont termins. Le premier argument de MPI_WIN_LOCK() permet de spcier si le fait de faire plusieurs accs simultans via des oprations de RMA sur une mme fentre mmoire locale est autoris (MPI_LOCK_SHARED) ou non (MPI_LOCK_EXCLUSIVE). Une utilisation basique des synchronisations de type cible passive consiste crer des versions bloquantes des RMA (put, get, accumulate) sans que la cible ait besoin de faire appel des sous-programmes MPI .
94/326
1 2 3 4 5 6 7 8 9 10 11 12 13
subroutine get_bloquant(orig_addr, orig_count, orig_datatype, target_rank, & target_disp, target_count, target_datatype, win, code) integer, intent(in) :: orig_count, orig_datatype, target_rank, target_count, & target_datatype, win integer, intent(out) :: code integer(kind= MPI_ADDRESS_KIND ), intent(in) :: target_disp real(kind=kind(1.d0)), dimension(:) :: orig_addr call MPI_WIN_LOCK ( MPI_LOCK_SHARED , target_rank, 0, win, code) call MPI_GET (orig_addr, orig_count, orig_datatype, target_rank, target_disp, & target_count, target_datatype, win, code) call MPI_WIN_UNLOCK (target_rank, win, code) end subroutine get_bloquant
95/326
Remarque concernant les codes Fortran

Pour tre portable, lors de lutilisation des synchronisations de type cible passive (MPI_WIN_LOCK(), MPI_WIN_UNLOCK()), il faut allouer la fentre mmoire avec MPI_ALLOC_MEM(). Cette fonction admet comme argument des pointeurs de type C (i.e. pointeurs Fortran CRAY, qui ne font pas partie de la norme Fortran95). Dans le cas o ces derniers ne sont pas disponibles, il faut utiliser un programme C pour faire lallocation de la fentre mmoire...
96/326
5.5 Conclusions

5.5 Conclusions
Les concepts RMA de MPI sont compliqus mettre en uvre sur des applications non triviales. Une connaissance approfondie de la norme est ncessaire pour ne pas tomber dans les nombreux piges. Les performances peuvent tre trs variables dune implmentation lautre. Lintrt du concept RMA de MPI rside essentiellement dans lapproche cible passive. Cest seulement dans ce cas que lutilisation des sous-programmes RMA est rellement indispensable (application ncessitant quun processus accde des donnes appartenant un processus distant sans interruption de ce dernier...).
97/326
6 Types de donnes drivs
1 Introduction 2 Environnement 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 6.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 6.2 Types contigus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 6.3 Types avec un pas constant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101 6.4 Autres sous-programmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103 6.5 Exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104 6.5.1 Type colonne dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .104 6.5.2 Type ligne dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 6.5.3 Type bloc dune matrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108 6.6 Types homognes pas variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.7 Construction de sous-tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116 6.8 Types htrognes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121 6.9 Sous-programmes annexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125 6.10 Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
98/326
6.1 Introduction

6.1 Introduction
Dans les communications, les donnes changes sont types : MPI_INTEGER, MPI_REAL, MPI_COMPLEX, etc On peut crer des structures de donnes plus complexes laide de sous-programmes tels que MPI_TYPE_CONTIGUOUS(), MPI_TYPE_VECTOR(), MPI_TYPE_CREATE_HVECTOR() chaque fois que lon cre un type de donnes, il faut le valider laide du sous-programme MPI_TYPE_COMMIT(). Si on souhaite rutiliser le mme nom pour dnir un autre type driv, on doit au pralable le librer avec le sous-programme MPI_TYPE_FREE()
99/326
6.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 24 Hirarchie des constructeurs de type MPI
100/326
6.2 Types contigus

6.2 Types contigus
MPI_TYPE_CONTIGUOUS() cre une structure de donnes partir dun ensemble homogne de type prexistant de donnes contigus en mmoire. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30.
call MPI_TYPE_CONTIGUOUS (5, MPI_REAL ,nouveau_type,code)
Figure 25 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)
101/326
6.3 Types avec un pas constant

MPI_TYPE_VECTOR() cre une structure de donnes partir dun ensemble homogne de type prexistant de donnes distantes dun pas constant en mmoire. Le pas est donn en nombre dlments. 1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. 14. 15. 16. 17. 18. 19. 20. 21. 22. 23. 24. 25. 26. 27. 28. 29. 30.
call MPI_TYPE_VECTOR (6,1,5, MPI_REAL ,nouveau_type,code)
Figure 26 Sous-programme MPI_TYPE_VECTOR

integer, integer, integer, integer, intent(in) intent(in) intent(in) intent(out) :: :: :: :: nombre_bloc,longueur_bloc pas ! donn en lments ancien_type nouveau_type,code
call MPI_TYPE_VECTOR (nombre_bloc,longueur_bloc,pas,ancien_type,nouveau_type,code)

102/326
MPI_TYPE_CREATE_HVECTOR() cre une structure de donnes partir dun ensemble homogne de type prdni de donnes distantes dun pas constant en mmoire. Le pas est donn en nombre doctets. Cette instruction est utile lorsque le type gnrique nest plus un type de base (MPI_INTEGER, MPI_REAL,...) mais un type plus complexe construit laide des sous-programmes MPI, parce qualors le pas ne peut plus tre exprim en nombre dlments du type gnrique.
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)
103/326
6.4 Autres sous-programmes

6.4 Autres sous-programmes
Il est ncessaire de valider tout nouveau type de donnes driv laide du sous-programme MPI_TYPE_COMMIT().
integer, intent(inout) :: nouveau_type integer, intent(out) :: code call MPI_TYPE_COMMIT (nouveau_type,code)
La libration dun type de donnes driv se fait par le sous-programme MPI_TYPE_FREE().

integer, intent(inout) :: nouveau_type integer, intent(out) :: code call MPI_TYPE_FREE (nouveau_type,code)
104/326
6.5 Exemples

6.5 Exemples 6.5.1 Type colonne dune matrice
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
program colonne use mpi implicit none integer, parameter integer, parameter real, dimension(nb_lignes,nb_colonnes) integer, dimension( MPI_STATUS_SIZE ) integer :: :: :: :: :: nb_lignes=5,nb_colonnes=6 etiquette=100 a statut rang,code,type_colonne
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation de la matrice sur chaque processus a(:,:) = real(rang) ! Dfinition du type type_colonne call MPI_TYPE_CONTIGUOUS (nb_lignes, MPI_REAL ,type_colonne,code) ! Validation du type type_colonne call MPI_TYPE_COMMIT (type_colonne,code)
105/326
6.5 Exemples
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
! Envoi de la premire colonne if ( rang == 0 ) then call MPI_SEND (a(1,1),1,type_colonne,1,etiquette, MPI_COMM_WORLD ,code) ! Rception dans la dernire colonne elseif ( rang == 1 ) then call MPI_RECV (a(1,nb_colonnes),1,type_colonne,0,etiquette,& MPI_COMM_WORLD ,statut,code) end if ! Libre le type call MPI_TYPE_FREE (type_colonne,code) call MPI_FINALIZE (code) end program colonne
106/326
6.5 Exemples

6.5 Exemples 6.5.2 Type ligne dune matrice
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
program ligne use mpi implicit none integer, parameter :: integer, parameter :: real, dimension(nb_lignes,nb_colonnes):: integer, dimension( MPI_STATUS_SIZE ) :: integer :: nb_lignes=5,nb_colonnes=6 etiquette=100 a statut rang,code,type_ligne
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation de la matrice sur chaque processus a(:,:) = real(rang) ! Dfinition du type type_ligne call MPI_TYPE_VECTOR (nb_colonnes,1,nb_lignes, MPI_REAL ,type_ligne,code) ! Validation du type type_ligne call MPI_TYPE_COMMIT (type_ligne,code)
107/326
6.5 Exemples
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
! Envoi de la deuxime ligne if ( rang == 0 ) then call MPI_SEND (a(2,1),1,type_ligne,1,etiquette, MPI_COMM_WORLD ,code) ! Rception dans lavant-dernire ligne elseif ( rang == 1 ) then call MPI_RECV (a(nb_lignes-1,1),1,type_ligne,0,etiquette,& MPI_COMM_WORLD ,statut,code) end if ! Libre le type type_ligne call MPI_TYPE_FREE (type_ligne,code) call MPI_FINALIZE (code) end program ligne
108/326
6.5 Exemples

6.5 Exemples 6.5.3 Type bloc dune matrice
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program bloc use mpi implicit none integer, parameter :: integer, parameter :: integer, parameter :: real, dimension(nb_lignes,nb_colonnes):: integer, dimension( MPI_STATUS_SIZE ) :: integer :: nb_lignes=5,nb_colonnes=6 etiquette=100 nb_lignes_bloc=2,nb_colonnes_bloc=3 a statut rang,code,type_bloc
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation de la matrice sur chaque processus a(:,:) = real(rang) ! Cration du type type_bloc call MPI_TYPE_VECTOR (nb_colonnes_bloc,nb_lignes_bloc,nb_lignes,& MPI_REAL ,type_bloc,code) ! Validation du type type_bloc call MPI_TYPE_COMMIT (type_bloc,code)
109/326
6.5 Exemples
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
! Envoi dun bloc if ( rang == 0 ) then call MPI_SEND (a(1,1),1,type_bloc,1,etiquette, MPI_COMM_WORLD ,code) ! Rception du bloc elseif ( rang == 1 ) then call MPI_RECV (a(nb_lignes-1,nb_colonnes-2),1,type_bloc,0,etiquette,& MPI_COMM_WORLD ,statut,code) end if ! Libration du type type_bloc call MPI_TYPE_FREE (type_bloc,code) call MPI_FINALIZE (code) end program bloc
110/326
6.6 Types homognes pas variable

MPI_TYPE_INDEXED() permet de crer une structure de donnes compose dune squence de blocs contenant un nombre variable dlments et spars par un pas variable en mmoire. Ce dernier est exprim en lments. MPI_TYPE_CREATE_HINDEXED() a la mme fonctionnalit que MPI_TYPE_INDEXED() sauf que le pas sparant deux blocs de donnes est exprim en octets. Cette instruction est utile lorsque le type gnrique nest pas un type de base MPI (MPI_INTEGER, MPI_REAL, ...) mais un type plus complexe construit avec les sous-programmes MPI vus prcdemment. On ne peut exprimer alors le pas en nombre dlments du type gnrique do 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 faon portable la taille du pas en nombre doctets.
111/326
nb=3, longueurs_blocs=(2,1,3), dplacements=(0,3,7) ancien_type nouveau_type Figure 27 Le constructeur MPI_TYPE_INDEXED

integer,intent(in) :: nb integer,intent(in),dimension(nb) :: longueurs_blocs ! Attention les dplacements sont donns en lments 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)
112/326
nb=4, longueurs_blocs=(2,1,2,1), dplacements=(2,10,14,24) ancien_type nouveau_type Figure 28 Le constructeur MPI_TYPE_CREATE_HINDEXED

integer,intent(in) integer,intent(in),dimension(nb) ! Attention les dplacements sont donns en octets integer(kind= MPI_ADDRESS_KIND ),intent(in),dimension(nb) integer,intent(in) integer,intent(out) :: nb :: longueurs_blocs :: deplacements :: ancien_type :: nouveau_type,code
call MPI_TYPE_CREATE_HINDEXED (nb,longueurs_blocs,deplacements, ancien_type,nouveau_type,code)
113/326
Dans lexemple suivant, chacun des deux processus : initialise sa matrice (nombres croissants positifs sur le processus 0 et ngatifs dcroissants sur le processus 1) ; construit son type de donnes (datatype) : matrice triangulaire (suprieure pour le processus 0 et infrieure pour le processus 1) ; envoie sa matrice triangulaire lautre et reoit une matrice triangulaire quil stocke la place de celle quil a envoye via linstruction MPI_SENDRECV_REPLACE() ; libre ses ressources et quitte MPI.
114/326
Avant
1 2 3 9 17 25 33 41 49 57 1 2 3 4 5 6 7 8 -2 10 -3 -4 10 18 26 34 42 50 58 11 19 27 35 43 51 59 12 20 28 36 44 52 60 13 21 29 37 45 53 61 14 22 30 38 46 54 62 15 23 31 39 47 55 63 16 24 32 40 48 56 64
Aprs
-5 -8 -14 -22 -32 -6 -11 -15 -23 -38 -7 -12 -16 -24 -39
11 19
Processus 0
4 5 6 7 8
12 20 28 -13 -20 -29 -40 13 21 29 37 -21 -30 -47 14 22 30 38 46 -31 -48 15 23 31 39 47 55 -56 16 24 32 40 48 56 64
-1
-9 -17 -25 -33 -41 -49 -57
-1 9
-9 -17 -25 -33 -41 -49 -57 -10 -18 -26 -34 -42 -50 -58
-2 -10 -18 -26 -34 -42 -50 -58 -3 -11 -19 -27 -35 -43 -51 -59
17 34 -19 -27 -35 -43 -51 -59 18 35 44 -28 -36 -44 -52 -60 25 36 45 52 -37 -45 -53 -61 26 41 49 53 58 -46 -54 -62 27 42 50 54 59 61 -55 -63 33 43 51 57 60 62 63 -64
Processus 1
-4 -12 -20 -28 -36 -44 -52 -60 -5 -13 -21 -29 -37 -45 -53 -61 -6 -14 -22 -30 -38 -46 -54 -62 -7 -15 -23 -31 -39 -47 -55 -63 -8 -16 -24 -32 -40 -48 -56 -64
Figure 29 changes entre les 2 processus

115/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
program triangle use mpi implicit none integer,parameter real,dimension(n,n) integer,dimension( MPI_STATUS_SIZE ) integer integer integer,dimension(n) :: :: :: :: :: :: n=8,etiquette=100 a statut i,code rang,type_triangle longueurs_blocs,deplacements
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation de la matrice sur chaque processus a(:,:) = reshape( (/ (sign(i,-rang),i=1,n*n) /), (/n,n/)) ! Cration du type matrice triangulaire sup pour le processus 0 ! et du type matrice triangulaire infrieure pour le processus1 if (rang == 0) then longueurs_blocs(:) = (/ (i-1,i=1,n) /) deplacements(:) = (/ (n*(i-1),i=1,n) /) else longueurs_blocs(:) = (/ (n-i,i=1,n) /) deplacements(:) = (/ (n*(i-1)+i,i=1,n) /) endif call MPI_TYPE_INDEXED (n,longueurs_blocs,deplacements, MPI_REAL ,type_triangle,code) call MPI_TYPE_COMMIT (type_triangle,code) ! Permutation des matrices triangulaires suprieure et infrieure call MPI_SENDRECV_REPLACE (a,1,type_triangle,mod(rang+1,2),etiquette,mod(rang+1,2), & etiquette, MPI_COMM_WORLD ,statut,code) ! Libration du type triangle call MPI_TYPE_FREE (type_triangle,code) call MPI_FINALIZE (code) end program triangle
116/326
6.7 Construction de sous-tableaux

Le sous-programme MPI_TYPE_CREATE_SUBARRAY() permet de crer un sous-tableau partir dun tableau.

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)
117/326
Rappels sur le vocabulaire relatif aux tableaux en Fortran 95

Le rang dun tableau est son nombre de dimensions. Ltendue dun tableau est son nombre dlments dans une dimension. Le prol dun tableau est un vecteur dont chaque dimension est ltendue 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 premire dimension est 10, dans la seconde 6 et dans la troisime 21, son prol est le vecteur (10,6,21). nb_dims : rang du tableau prol_tab : prol du tableau partir duquel on va extraire un sous-tableau prol_sous_tab : prol du sous-tableau coord_debut : coordonnes de dpart si les indices du tableau commenaient 0. Par exemple, si on veut que les coordonnes de dpart du sous-tableau soient tab(2,3), il faut que coord_debut(:)=(/ 1,2 /) ordre : ordre de stockage des lments 1 MPI_ORDER_FORTRAN spcie le mode de stockage en Fortran, c.--d. suivant les colonnes 2 MPI_ORDER_C spcie le mode de stockage en C, c.--d. suivant les lignes
118/326
AVANT 1 2 3 4 5 6 7 8 9 10 11 12 1 -7 -8 4
APRES 5 -11 -12 8 9 10 11 12
Processus 0
Processus 0
-1 -2 -3 -4
-5 -6 -7 -8
-9 -10 -11 -12
-1 -2 -3 -4
-5 -6 2 3
-9 -10 6 7
Processus 1
Processus 1
Figure 30 changes entre les 2 processus
119/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
program subarray use mpi implicit none integer,parameter :: nb_lignes=4,nb_colonnes=3,& etiquette=1000,nb_dims=2 integer :: code,rang,type_sous_tab,i integer,dimension(nb_lignes,nb_colonnes) :: tab integer,dimension(nb_dims) :: profil_tab,profil_sous_tab,coord_debut integer,dimension( MPI_STATUS_SIZE ) :: statut call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation du tableau tab sur chaque processus tab(:,:) = reshape( (/ (sign(i,-rang),i=1,nb_lignes*nb_colonnes) /) , & (/ nb_lignes,nb_colonnes /) )
120/326
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48
! Profil du tableau tab partir duquel on va extraire un sous-tableau profil_tab(:) = shape(tab) ! La fonction F95 shape donne le profil du tableau pass en argument. ! ATTENTION, si le tableau concern na pas t allou sur tous les processus, ! il faut mettre explicitement le profil du tableau pour quil soit connu ! sur tous les processus, soit profil_tab(:) = (/ nb_lignes,nb_colonnes) /) ! Profil du sous-tableau profil_sous_tab(:) = (/ 2,2 /) ! Coordonnes de dpart du sous-tableau ! Pour le processus 0 on part de llment tab(2,1) ! Pour le processus 1 on part de llment tab(3,2) coord_debut(:) = (/ rang+1,rang /) ! Cration du type driv type_sous_tab call MPI_TYPE_CREATE_SUBARRAY (nb_dims,profil_tab,profil_sous_tab,coord_debut,& MPI_ORDER_FORTRAN , MPI_INTEGER ,type_sous_tab,code) call MPI_TYPE_COMMIT (type_sous_tab,code) ! Permutation du sous-tableau call MPI_SENDRECV_REPLACE (tab,1,type_sous_tab,mod(rang+1,2),etiquette,& 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
121/326
6.8 Types htrognes

6.8 Types htrognes
Le sous-programme MPI_TYPE_CREATE_STRUCT() est le constructeur de types le plus gnral. Il a les mmes fonctionnalits que MPI_TYPE_INDEXED() mais permet en plus la rplication de blocs de donnes de types dirents. Les paramtres de MPI_TYPE_CREATE_STRUCT() sont les mmes que ceux de MPI_TYPE_INDEXED() avec en plus : le champ anciens_types est maintenant un vecteur de types de donnes MPI ; compte tenu de lhtrognit des donnes et de leur alignement en mmoire, le calcul du dplacement entre deux lments repose sur la dirence de leurs adresses ; MPI, via MPI_GET_ADDRESS(), fournit un sous-programme portable qui permet de retourner ladresse dune variable.
122/326
6.8 Types htrognes
nb=5, longueurs_blocs=(3,1,5,1,1), dplacements=(0,7,11,21,26), anciens_types=(type1,type2,type3,type1,type3) type 1 anciens_types nouveau_type

Figure 31 Le constructeur MPI_TYPE_CREATE_STRUCT
integer,intent(in) integer,intent(in),dimension(nb) integer(kind= MPI_ADDRESS_KIND ),intent(in),dimension(nb) integer,intent(in),dimension(nb) integer, intent(out) :: :: :: :: nb longueurs_blocs deplacements anciens_types
type 2
type 3
:: nouveau_type,code
call MPI_TYPE_CREATE_STRUCT (nb,longueurs_blocs,deplacements, anciens_types,nouveau_type,code) <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)
123/326
6.8 Types htrognes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
program Interaction_Particules use mpi implicit none integer, parameter integer, dimension( MPI_STATUS_SIZE ) integer integer, dimension(4) integer(kind= MPI_ADDRESS_KIND ), dimension(4) type Particule character(len=5) integer real, dimension(3) logical end type Particule type(Particule), dimension(n) call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Construction du type de donnes types = (/ MPI_CHARACTER , MPI_INTEGER , MPI_REAL , MPI_LOGICAL /) longueurs_blocs = (/5,1,3,1/) :: :: :: :: :: :: :: :: :: n=1000,etiquette=100 statut rang,code,type_particule,i types,longueurs_blocs deplacements,adresses categorie masse coords classe
:: p,temp_p
124/326
6.8 Types htrognes
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54
call call call call
MPI_GET_ADDRESS (p(1)%categorie,adresses(1),code) MPI_GET_ADDRESS (p(1)%masse,adresses(2),code) MPI_GET_ADDRESS (p(1)%coords,adresses(3),code) MPI_GET_ADDRESS (p(1)%classe,adresses(4),code)
! Calcul des dplacements relatifs ladresse de dpart do i=1,4 deplacements(i)=adresses(i) - adresses(1) end do call MPI_TYPE_CREATE_STRUCT (4,longueurs_blocs,deplacements,types,type_particule, & code) ! Validation du type structur call MPI_TYPE_COMMIT (type_particule,code) ! Initialisation des particules pour chaque processus .... ! Envoi des particules de 0 vers 1 if (rang == 0) then call MPI_SEND (p(1)%categorie,n,type_particule,1,etiquette, MPI_COMM_WORLD ,code) else call MPI_RECV (temp_p(1)%categorie,n,type_particule,0,etiquette, MPI_COMM_WORLD , & statut,code) endif ! Libration du type call MPI_TYPE_FREE (type_particule,code) call MPI_FINALIZE (code) end program Interaction_Particules
125/326
6.9 Sous-programmes annexes

La taille totale dun type de donnes : MPI_TYPE_SIZE()

integer, intent(in) :: type_donnee integer, intent(out) :: taille, code call MPI_TYPE_SIZE (type_donnee,taille,code)
Ltendue ainsi que la borne infrieure dun type driv, en tenant compte des ventuels alignements mmoire : MPI_TYPE_GET_EXTENT()
integer, intent(in) :: type_derive integer(kind= MPI_ADDRESS_KIND ),intent(out):: borne_inf_alignee,taille_alignee integer, intent(out) :: code call MPI_TYPE_GET_EXTENT (type_derive,borne_inf_alignee,taille_alignee,code)
On peut modier la borne infrieure dun type driv et son tendue pour crer un nouveau type adapt du prcdent
integer, intent(in) :: ancien_type integer(kind= MPI_ADDRESS_KIND ),intent(in) :: nouvelle_borne_inf,nouvelle_taille integer, intent(out) :: nouveau_type,code call MPI_TYPE_CREATE_RESIZED (ancien_type,nouvelle_borne_inf,nouvelle_taille, nouveau_type,code)
126/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
program ma_ligne use mpi implicit none integer, parameter :: nb_lignes=5,nb_colonnes=6, & demi_ligne=nb_colonnes/2,etiquette=1000 integer, dimension(nb_lignes,nb_colonnes) :: a integer :: typeDemiLigne,typeDemiLigne2 integer :: code,taille_integer,rang,i integer(kind= MPI_ADDRESS_KIND ) :: borneInf=0, tailleDeplacement integer, dimension( MPI_STATUS_SIZE ) :: statut call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation de la matrice A sur chaque processus a(:,:) = reshape( (/ (sign(i,-rang),i=1,nb_lignes*nb_colonnes) /), & (/ nb_lignes,nb_colonnes /) ) ! Construction du type deriv typeDemiLigne call MPI_TYPE_VECTOR (demi_ligne,1,nb_lignes, MPI_INTEGER ,typeDemiLigne,code) ! Connatre la taille du type de base MPI_INTEGER call MPI_TYPE_SIZE ( MPI_INTEGER , taille_integer, code) ! Construction du type deriv typeDemiLigne2 tailleDeplacement = taille_integer call MPI_TYPE_CREATE_RESIZED (typeDemiLigne,borneInf,tailleDeplacement,& typeDemiLigne2,code)
127/326
31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
! Validation du type typeDemiLigne2 call MPI_TYPE_COMMIT (typeDemiLigne2,code) if (rang == 0) then ! Envoi de la matrice A au processus 1 avec le type typeDemiLigne2 call MPI_SEND (A(1,1), 2, typeDemiLigne2, 1, etiquette, & MPI_COMM_WORLD , code) else ! Rception pour le processus 1 dans la matrice A call MPI_RECV (A(1,nb_colonnes-1), 6, MPI_INTEGER , 0, etiquette,& MPI_COMM_WORLD ,statut, code) print *,Matrice A sur le processus 1 do i=1,nb_lignes print *,A(i,:) end do end if call MPI_FINALIZE (code) end program ma_ligne > mpiexec -n 4 demi_ligne Matrice A sur le processus 1 -1 -6 -11 -16 1 12 -2 -7 -12 -17 6 -27 -3 -8 -13 -18 11 -28 -4 -9 -14 -19 2 -29 -5 -10 -15 -20 7 -30
128/326
6.10 Conclusion

6.10 Conclusion
Les types drivs MPI sont de puissants mcanismes portables de description de donnes Ils permettent, lorsquils sont associs des instructions comme MPI_SENDRECV(), de simplier lcriture de sous-programmes dchanges interprocessus. Lassociation des types drivs et des topologies (dcrites dans lun des prochains chapitres) fait de MPI loutil idal pour tous les problmes de dcomposition de domaines avec des maillages rguliers ou irrguliers.
129/326
7 Optimisations
1 Introduction 2 Environnement 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 7.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130 7.2 Modes denvoi point point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 7.2.1 Rappels terminologiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132 7.2.2 Envois synchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 7.2.3 Envois bueriss . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 7.2.4 Envois standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139 7.2.5 Envois en mode ready . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140 7.2.6 Performances des dirents modes denvoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141 7.3 Recouvrement calculs-communications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
130/326
7 Optimisations
7.1 Introduction
7 Optimisations
7.1 Introduction
Loptimisation des communications MPI doit tre un souci essentiel lorsque la part de ces dernires par rapport aux calculs devient assez importante. Loptimisation des communications, au-del du choix de lalgorithme le plus ecace possible, peut saccomplir de nombreux niveaux dont, par exemple : choisir le mode de communication le plus adapt ; recouvrir les communications par des calculs.
131/326
7 Optimisations
7.2 Modes denvoi point point
7 Optimisations
Mode Envoi standard Envoi synchrone Envoi bueris Envoi en mode ready Rception
Bloquant MPI_SEND MPI_SSEND MPI_BSEND MPI_RSEND MPI_RECV
Non bloquant MPI_ISEND MPI_ISSEND MPI_IBSEND MPI_IRSEND MPI_IRECV
132/326
7 Optimisations
7 Optimisations
7.2 Modes denvoi point point 7.2.1 Rappels terminologiques
Il est important de bien comprendre la dnition de certains termes au sens MPI. Appel bloquant : un appel est bloquant si lespace mmoire servant la communication peut tre rutilis immdiatement aprs la sortie de lappel. Les donnes qui ont t ou seront envoyes sont celles qui taient dans cet espace au moment de lappel. Sil sagit dune rception, les donnes ont t reues dans cet espace (si le code de retour est MPI_SUCCESS)). Appel non bloquant : un appel non bloquant rend la main trs rapidement, mais nautorise pas la rutilisation immdiate de lespace mmoire utilis dans la communication. Il est ncessaire de sassurer que la communication est bien termine (avec MPI_WAIT par exemple) avant de lutiliser nouveau. Envoi synchrone : un envoi synchrone implique une synchronisation entre les processus concerns. Il ne peut donc y avoir communication que si les deux processus sont prts communiquer. Un envoi ne pourra commencer que lorsque sa rception sera poste. Envoi bueris : un envoi bueris implique la recopie des donnes dans un espace mmoire intermdiaire. Il ny a alors pas de couplage entre les deux processus de la communication. La sortie de ce type denvoi ne signie donc pas que la rception a eu lieu.
133/326
7 Optimisations
7 Optimisations
7.2 Modes denvoi point point 7.2.2 Envois synchrones
Un envoi synchrone se fait en appelant le sous-programme MPI_SSEND ou MPI_ISSEND. Protocole de rendez-vous

Processus 0
envelopp e
Processus 1
Le protocole de rendez-vous est gnralement celui employ pour les envois en mode synchrone (dpend de limplmentation). Laccus de rception est optionnel.
Temps
ir recevo prt
donnes
....... ....... ....... .......
accus
pti rce
on
....... .......
....... ....... .......
134/326
7 Optimisations
Avantages Consomment peu de ressources (pas de buer) Rapides si le rcepteur est prt (pas de recopie dans un buer) Garantie de la rception grce la synchronisation Inconvnients Temps dattente si le rcepteur nest pas l/pas prt Risques de deadlocks
135/326
7 Optimisations
7 Optimisations
7.2 Modes denvoi point point 7.2.3 Envois bueriss
Envois bueriss Un envoi bueris se fait en appellant le sous-programme MPI_BSEND ou MPI_IBSEND. Les buers doivent tre grs manuellement (avec appels MPI_ATTACH et MPI_DETACH). Ils doivent tre allous en tenant compte des surcots mmoire des messages (en ajoutant la constante MPI_BSEND_OVERHEAD pour chaque instance de message).
136/326
7 Optimisations
Protocole avec buer utilisateur du ct de lmetteur Cette approche est celle gnralement employe pour les appels MPI_BSEND ou MPI_IBSEND. Dans cette approche, le buer se trouve du ct de lmetteur et est gr explicitement par lapplication. Un buer gr par MPI peut exister du ct du rcepteur. De nombreuses variantes sont possibles. Laccus de rception est optionnel.
Processus 0
recop ie
message
Processus 1
....... ....... ....... ....... ....... ....... ....... .......
....... ....... ....... .......

on
Temps
accus
rcepti
....... ....... ....... ....... .......
137/326
7 Optimisations
Protocole eager Le protocole eager est souvent employ pour les envois en mode standard pour les messages de petites tailles. Il peut aussi tre utilis pour les envois avec MPI_BSEND avec des petits messages (dpend de limplmentation) et en court-circuitant le buer utilisateur du ct de lmetteur. Dans cette approche, le buer se trouve du ct du rcepteur. Laccus de rception est optionnel.
Processus 0
message
Processus 1
....... ....... ....... ....... .......
....... ....... ....... .......

on
Temps
accus
pti rce
....... ....... ....... ....... .......
138/326
7 Optimisations
Avantages Pas besoin dattendre le rcepteur (recopie dans un buer) Pas de risque de blocage (deadlocks) Inconvnients Consomment plus de ressources (occupation mmoire par les buers avec risques de saturation) Les buers denvoi utiliss dans les appels MPI_BSEND ou MPI_IBSEND doivent tre grs manuellement (souvent dlicat de choisir une taille adapte) Un peu plus lent que les envois synchrones si le rcepteur est prt Pas de garantie de la bonne rception (dcouplage envoi-rception) Risque de gaspillage despace mmoire si les buers sont trop surdimensionns Lapplication plante si les buers sont trop petits Il y a aussi souvent des buers cachs gr par limplmentation MPI du ct de lexpditeur et/ou du rcepteur (et consommant des ressources mmoires)
139/326
7 Optimisations
7 Optimisations
7.2 Modes denvoi point point 7.2.4 Envois standards
Envois standards Un envoi standard se fait en appelant le sous-programme MPI_SEND ou MPI_ISEND. Dans la plupart des implmentations, ce mode passe dun mode bueris un mode synchrone lorsque la taille des messages crot. Avantages Souvent le plus performant (choix du mode le plus adapt par le constructeur) Le plus portable pour les performances Inconvnients Peu de contrle sur le mode rellement utilis (souvent accessible via des variables denvironnement) Risque de deadlock selon le mode rel Comportement pouvant varier selon larchitecture et la taille du problme
140/326
7 Optimisations
7 Optimisations
7.2 Modes denvoi point point 7.2.5 Envois en mode ready
Envois en mode ready Un envoi en mode ready se fait en appellant le sous-programme MPI_RSEND ou MPI_IRSEND. Attention : il est obligatoire de faire ces appels seulement lorsque la rception est dj poste. Leur utilisation est fortement dconseille. Avantages Lgrement plus performant que le mode synchrone car le protocole de synchronisation peut tre simpli Inconvnients Erreurs si le rcepteur nest pas prt lors de lenvoi
141/326
7 Optimisations
10
Pingpong extranode balanced

Vargas Standard Vargas Synchroneous Vargas Buffered Babel Standard Babel Synchroneous Babel Buffered
10
Bandwidth (MiB/s)
10
10
10
10
10
10
10
10
Message size (bytes)

142/326
7 Optimisations
7.3 Recouvrement calculs-communications
7 Optimisations
Prsentation Le recouvrement des communications par des calculs est une mthode permettant de raliser des oprations de communications en arrire-plan pendant que le programme continue de sexcuter. Il est ainsi possible, si larchitecture matrielle et logicielle le permet, de masquer tout ou une partie des cots de communications. Le recouvrement calculs-communications peut tre vu comme un niveau supplmentaire de paralllisme. Cette approche sutilise dans MPI par lutilisation de sous-programmes non-bloquants (i.e. MPI_ISEND, MPI_IRECV et MPI_WAIT).
143/326
7 Optimisations
Recouvrement partiel
Processus 0
requte
Recouvrement total
Processus 0
requte
....... .......
Temps
termin ?
Temps
envo
....... ....... ....... ....... ....... ....... .......

termin ?
envo
oui
.......
oui
144/326
7 Optimisations
Avantages Possibilit de masquer tout ou une partie des cots des communications (si larchitecture le permet) Pas de risques de deadlock Inconvnients Surcots plus importants (plusieurs appels pour un seul envoi ou rception, gestion des requtes) Complexit plus leve et maintenance plus complique Peu performant sur certaines machines (par exemple avec transfert commenant seulement lappel de MPI_WAIT) Risque de perte de performance sur les noyaux de calcul (par exemple gestion direncie entre la zone proche de la frontire dun domaine et la zone intrieure entranant une moins bonne utilisation des caches mmoires) Limit aux communications point point (a t tendu aux collectives dans MPI 3.0)
145/326
7 Optimisations
Utilisation Lenvoi dun message se fait en 2 tapes : Initier lenvoi ou la rception par un appel un sous-programme commenant par MPI_ISEND ou MPI_IRECV (ou une de leurs variantes) Attendre la n de la contribution locale par un appel MPI_WAIT (ou une de ses variantes). Les communications sont recouvertes par toutes les oprations qui se droulent entre ces deux tapes. Laccs aux donnes en cours de rception est interdit avant la n de lappel MPI_WAIT (laccs aux donnes en cours denvoi est galement interdit pour les implmentations MPI antrieures la 2.2).
146/326
7 Optimisations
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
integer, dimension(2) :: req do i=1,niter ! Initie les communications call MPI_IRECV (data_ext, sz, MPI_REAL ,dest,tag,comm, & req(1),code) call MPI_ISEND (data_bound,sz, MPI_REAL ,dest,tag,comm, & req(2),code) ! Calcule le domaine interieur (data_ext et data_bound ! non utilises) pendant que les communications ont lieu call calcul_domaine_interieur(data_int) ! Attend la fin des communications call MPI_WAITALL (2,req, MPI_STATUSES_IGNORE ,code) ! Calcule le domaine exterieur call calcul_domaine_exterieur(data_int,data_bound,data_ext) end do
147/326
7 Optimisations
Niveau de recouvrement sur direntes machines Machine Blue Gene/P DCMF_INTERRUPT=0 Blue Gene/P DCMF_INTERRUPT=1 Power6 InniBand NEC SX-8 CURIE Niveau 34% 100% 38% 10% 0%
Mesures faites en recouvrant un noyau de calcul et un noyau de communication de mmes dures et en utilisant dirents schmas de communications (intra/extra-nuds, par paires, processus alatoires...). Selon le schma de communication, les rsultats peuvent tre totalement dirents. Un recouvrement de 0% signie que la dure totale dexcution vaut 2x la dure dun noyau de calcul (ou communication). Un recouvrement de 100% signie que la dure totale vaut 1x la dure dun noyau de calcul (ou communication).
148/326
8 Communicateurs
1 Introduction 2 Environnement 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 8.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 149 8.2 Communicateur par dfaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150 8.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151 8.4 Groupes et communicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153 8.5 Communicateur issu dun autre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 8.6 Topologies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159 8.6.1 Topologies cartsiennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160 8.6.2 Subdiviser une topologie cartsienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
149/326
8 Communicateurs
8.1 Introduction
8 Communicateurs
8.1 Introduction
Il sagit de partitionner un ensemble de processus an de crer des sous-ensembles sur lesquels on puisse eectuer des oprations telles que des communications point point, collectives, etc. Chaque sous-ensemble ainsi cr aura son propre espace de communication.
MPI_COMM_WORLD
c2 e4 b1 h 7
a0 g6 f5 d3
Figure 32 Partitionnement dun communicateur
150/326
8 Communicateurs
8.2 Communicateur par dfaut
8 Communicateurs
8.2 Communicateur par dfaut
Cest lhistoire de la poule et de luf... On ne peut crer un communicateur qu partir dun autre communicateur Fort heureusement, cela a t rsolu en postulant que la poule existait dj. En eet, un communicateur est fourni par dfaut, dont lidenticateur MPI_COMM_WORLD est un entier dni dans les chiers den-tte. Ce communicateur initial MPI_COMM_WORLD est cr pour toute la dure dexcution du programme lappel du sous-programme MPI_INIT() Ce communicateur ne peut tre dtruit que via lappel MPI_FINALIZE() Par dfaut, il xe donc la porte des communications point point et collectives tous les processus de lapplication
151/326
8 Communicateurs
8.3 Exemple
8 Communicateurs
8.3 Exemple
Dans lexemple qui suit, nous allons : regrouper dune part les processus de rang pair et dautre part les processus de rang impair ; ne diuser un message collectif quaux processus de rang pair et un autre quaux processus de rang impair.
MPI_COMM_WORLD
a0 e 4 g6 c2
a0 0 3 g6
2 e4 1 c2
h7 f 5 b1 d 3
2 h3 f5 7 b0 d1 1 3 2 h 3 f5 7 b0 d 1 1 3
$ mpirun np 8 CommPairImpair call MPI_INIT(...)
call MPI_COMM_SPLIT(...)
2 a0 e4 0 3 1 g6 c2
call MPI_BCAST(...)
a0 e 4 g6 c2
h7 f 5 b1 d 3
call MPI_COMM_FREE(...)
Figure 33 Cration/destruction dun communicateur

152/326
8 Communicateurs
8.3 Exemple
Que faire pour que le processus 2 diuse ce message au sous-ensemble de processus de rang pair, par exemple ? Boucler sur des send/recv peut tre trs pnalisant surtout si le nombre de processus est lev. De plus un test serait obligatoire dans la boucle pour savoir si le rang du processus auquel le processus 2 doit envoyer le message est pair ou impair. La solution est de crer un communicateur regroupant ces processus de sorte que le processus 2 diuse le message eux seuls
MPI_COMM_WORLD
a0 e4 g6 c2
h7 b1
f5 d3
Figure 34 Un nouveau communicateur
153/326
8 Communicateurs
8.4 Groupes et communicateurs
8 Communicateurs
Un communicateur est constitu : dun groupe, qui est un ensemble ordonn de processus ; dun contexte de communication mis en place lappel du sous-programme de construction du communicateur, qui permet de dlimiter lespace de communication. Les contextes de communication sont grs par MPI (le programmeur na aucune action sur eux : cest un attribut cach ) En pratique, pour construire un communicateur, il existe deux faons de procder : par lintermdiaire dun groupe de processus ; directement partir dun autre communicateur.
154/326
8 Communicateurs
Dans la bibliothque MPI, divers sous-programmes existent pour construire des communicateurs : MPI_CART_CREATE(), MPI_CART_SUB(), MPI_COMM_CREATE(), MPI_COMM_DUP(), MPI_COMM_SPLIT() Les constructeurs de communicateurs sont des oprateurs collectifs (qui engendrent des communications entre les processus) Les communicateurs que le programmeur cre peuvent tre grs dynamiquement et, de mme quil est possible den crer, il est possible den dtruire en utilisant le sous-programme MPI_COMM_FREE()
155/326
8 Communicateurs
8.5 Communicateur issu dun autre
8 Communicateurs
Lutilisation directe des groupes prsente dans ce cas divers inconvnients, car elle impose de : nommer diremment les deux communicateurs (par exemple comm_pair et comm_impair) ; passer par les groupes pour construire ces deux communicateurs ; laisser le soin MPI dordonner le rang des processus dans ces deux communicateurs ; faire des tests conditionnels lors de lappel au sous-programme MPI_BCAST() :
if (comm_pair /= MPI_COMM_NULL ) then ... ! Diffusion du message seulement aux processus de rangs pairs call MPI_BCAST (a,m, MPI_REAL ,rang_ds_pair,comm_pair,code) elseif (comm_impair /= MPI_COMM_NULL ) then ... ! Diffusion du message seulement aux processus de rangs impairs call MPI_BCAST (a,m, MPI_REAL ,rang_ds_impair,comm_impair,code) end if
156/326
8 Communicateurs
Le sous-programme MPI_COMM_SPLIT() permet de partitionner un communicateur donn en autant de communicateurs que lon veut...
integer, intent(in) :: comm, couleur, clef integer, intent(out) :: nouveau_comm, code call MPI_COMM_SPLIT (comm,couleur,clef,nouveau_comm,code)
processus rang_monde couleur clef rang_nv_com
a 0 0 2 1
b 1 2 15 1
c 2 3 0 0
d 3 0 0 0
e 4 3 1 1
f 5 0 3 2
g 6 2 11 0
h 7 3 1 2
MPI_COMM_WORLD 2 a1 f5 0
d0 3 g0 6
1 b1
c0 2 h2 7
e1 4
Figure 35 Construction de communicateurs avec MPI_COMM_SPLIT()
Un processus qui se voit attribuer une couleur gale la valeur MPI_UNDEFINED nappartiendra qu son communicateur initial.
157/326
8 Communicateurs
Voyons comment procder pour construire le communicateur qui va subdiviser lespace de communication entre processus de rangs pairs et impairs, via le constructeur MPI_COMM_SPLIT().
MPI_COMM_WORLD
processus rang_monde couleur clef rang_pairs_imp
a 0 0 0 1
b 1 1 1 1
c 2 0 -1 0
d 3 1 3 2
e 4 0 4 2
f 5 1 -1 0
g 6 0 6 3
h 7 1 7 3
a1 g3 0 6 c0 e2 2 4
2 d3 f0 5
h3 b1 7 1
Figure 36 Construction du communicateur CommPairsImpairs avec MPI_COMM_SPLIT()
En pratique, ceci se met en place trs simplement...
158/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
8 Communicateurs
program PairsImpairs use mpi implicit none integer, parameter integer integer real, dimension(m) :: :: :: :: m=16 clef,CommPairsImpairs rang_dans_monde,code a
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang_dans_monde,code) ! Initialisation du vecteur A a(:)=0. if(rang_dans_monde == 2) a(:)=2. if(rang_dans_monde == 5) a(:)=5. clef = rang_dans_monde if (rang_dans_monde == 2 .OR. rang_dans_monde == 5 ) then clef=-1 end if ! Cration des communicateurs pair et impair en leur donnant une mme dnomination call MPI_COMM_SPLIT ( MPI_COMM_WORLD ,mod(rang_dans_monde,2),clef,CommPairsImpairs,code) ! Diffusion du message par le processus 0 de chaque communicateur aux processus ! de son groupe call MPI_BCAST (a,m, MPI_REAL ,0,CommPairsImpairs,code) ! Destruction des communicateurs call MPI_COMM_FREE (CommPairsImpairs,code) call MPI_FINALIZE (code) end program PairsImpairs
159/326
8 Communicateurs
8.6 Topologies
8 Communicateurs
8.6 Topologies
Dans la plupart des applications, plus particulirement dans les mthodes de dcomposition de domaine o lon fait correspondre le domaine de calcul la grille de processus, il est intressant de pouvoir disposer les processus suivant une topologie rgulire MPI permet de dnir des topologies virtuelles du type cartsien ou graphe Topologies de type cartsien chaque processus est dni dans une grille de processus ; la grille peut tre priodique ou non ; les processus sont identis par leurs coordonnes dans la grille. Topologies de type graphe gnralisation des topologies plus complexes.
160/326
8 Communicateurs
8.6 Topologies
8 Communicateurs
8.6 Topologies 8.6.1 Topologies cartsiennes
Une topologie cartsienne est dnie lorsquun ensemble de processus appartenant un communicateur donn comm_ancien appellent le sous-programme MPI_CART_CREATE().
integer, integer, logical, logical, intent(in) dimension(ndims),intent(in) dimension(ndims),intent(in) intent(in) :: :: :: :: comm_ancien, ndims dims periods reorganisation
integer, intent(out)
:: comm_nouveau, code
call MPI_CART_CREATE (comm_ancien, ndims,dims,periods,reorganisation,comm_nouveau,code)
161/326
8 Communicateurs
8.6 Topologies
Exemple sur une grille comportant 4 domaines suivant x et 2 suivant y, priodique en y.

use mpi integer integer, parameter integer, dimension(ndims) logical, dimension(ndims) logical :: :: :: :: :: comm_2D, code ndims = 2 dims periods reorganisation
............................................... dims(1) = 4 dims(2) = 2 periods(1) = .false. periods(2) = .true. reorganisation = .false. call MPI_CART_CREATE ( MPI_COMM_WORLD ,ndims,dims,periods,reorganisation,comm_2D,code)
Si reorganisation = .false. alors le rang des processus dans le nouveau communicateur (comm_2D) est le mme que dans lancien communicateur (MPI_COMM_WORLD). Si reorganisation = .true., limplmentation MPI choisit lordre des processus.
162/326
8 Communicateurs
8.6 Topologies
1 0 1 0
3 2 3 2
5 4 5 4
7 6 7 6 x
Figure 37 Topologie cartsienne 2D priodique en y
163/326
8 Communicateurs
8.6 Topologies
Exemple sur une grille 3D comportant 4 domaines suivant x, 2 suivant y et 2 suivant z, non priodique.
use mpi integer integer, parameter integer, dimension(ndims) logical, dimension(ndims) logical :: :: :: :: :: comm_3D,code ndims = 3 dims periods reorganisation
............................................... dims(1) = 4 dims(2) = 2 dims(3) = 2 periods(:) = .false. reorganisation = .false. call MPI_CART_CREATE ( MPI_COMM_WORLD ,ndims,dims,periods,reorganisation,comm_3D,code)
164/326
8 Communicateurs
8.6 Topologies
2 0
6 4
10 8
14 12 z=0 3
3 1
7 5
11 9
15 13 z=1
11
15
10
14 13 12 z=1 z=0
0 y z x
Figure 38 Topologie cartsienne 3D non priodique
165/326
8 Communicateurs
8.6 Topologies
Dans une topologie cartsienne, le sous-programme MPI_DIMS_CREATE() retourne le nombre de processus dans chaque dimension de la grille en fonction du nombre total de processus.
integer, intent(in) :: nb_procs, ndims integer, dimension(ndims),intent(inout) :: dims integer, intent(out) :: code call MPI_DIMS_CREATE (nb_procs,ndims,dims,code)
Remarque : si les valeurs de dims en entre valent toutes 0, cela signie quon laisse MPI le choix du nombre de processus dans chaque direction en fonction du nombre total de processus. dims en entre (0,0) (0,0,0) (0,4,0) (0,3,0) call MPI_DIMS_CREATE (8,2,dims,code) (16,3,dims,code) (16,3,dims,code) (16,3,dims,code) dims en sortie (4,2) (4,2,2) (2,4,2) error
166/326
8 Communicateurs
8.6 Topologies
Dans une topologie cartsienne, le sous-programme MPI_CART_RANK() retourne le rang du processus associ aux coordonnes dans la grille.
integer, intent(in) :: comm_nouveau integer, dimension(ndims),intent(in) :: coords integer, intent(out) :: rang, code
call MPI_CART_RANK (comm_nouveau,coords,rang,code)
167/326
8 Communicateurs
8.6 Topologies
1 (0,1) 0 (0,0) 1 (0,1) 0 (0,0)
3 (1,1) 2 (1,0) 3 (1,1) 2 (1,0)
5 (2,1) 4 (2,0) 5 (2,1) 4 (2,0)
7 (3,1) 6 (3,0) 7 (3,1) 6 (3,0)

coords(1)=dims(1)-1 do i=0,dims(2)-1 coords(2) = i call MPI_CART_RANK (comm_2D,coords,rang(i),code) end do ............................................ i=0,en entre coords=(3,0),en sortie rang(0)=6. i=1,en entre coords=(3,1),en sortie rang(1)=7.
168/326
8 Communicateurs
8.6 Topologies
Dans une topologie cartsienne, le sous-programme MPI_CART_COORDS() retourne les coordonnes dun processus de rang donn dans la grille.
integer, intent(in) :: comm_nouveau, rang, ndims integer, dimension(ndims),intent(out) :: coords integer, intent(out) :: code call MPI_CART_COORDS (comm_nouveau, rang, ndims, coords, code)
169/326
8 Communicateurs
8.6 Topologies
1 (0,1) 0 (0,0) 1 (0,1) 0 (0,0)
3 (1,1) 2 (1,0) 3 (1,1) 2 (1,0)
5 (2,1) 4 (2,0) 5 (2,1) 4 (2,0)
7 (3,1) 6 (3,0) 7 (3,1) 6 (3,0)

if (mod(rang,2) == 0) then call MPI_CART_COORDS (comm_2D,rang,2,coords,code) end if ............................................ En entre, les valeurs de rang sont : 0,2,4,6. En sortie, les valeurs de coords sont : (0,0),(1,0),(2,0),(3,0).
170/326
8 Communicateurs
8.6 Topologies
Dans une topologie cartsienne, un processus appelant le sous-programme MPI_CART_SHIFT() se voit retourner le rang de ses processus voisins dans une direction donne.
integer, intent(in) :: comm_nouveau, direction, pas integer, intent(out) :: rang_precedent,rang_suivant integer, intent(out) :: code call MPI_CART_SHIFT (comm_nouveau, direction, pas, rang_precedent, rang_suivant, code)
Le paramtre direction correspond laxe du dplacement (xyz). Le paramtre pas correspond au pas du dplacement.
171/326
8 Communicateurs
8.6 Topologies
1 0 1 (0,1) 0 (0,0)
3 2 3 (1,1) 2 (1,0)
5 4 5 (2,1) 4 (2,0)
7 6 7 (3,1) 6 (3,0) direction = 1 x
direction = 0
Figure 41 Appel du sous-programme MPI_CART_SHIFT()

call MPI_CART_SHIFT (comm_2D,0,1,rang_gauche,rang_droit,code) ............................................ Pour le processus 2, rang_gauche=0, rang_droit=4 call MPI_CART_SHIFT (comm_2D,1,1,rang_bas,rang_haut,code) ............................................ Pour le processus 2, rang_bas=3, rang_haut=3
172/326
8 Communicateurs
8.6 Topologies
3 2 0 y z x
11
15
6 4
10 8
14 13 12 z=1 z=0
direction=0 direction=1 direction=2
Figure 42 Appel du sous-programme MPI_CART_SHIFT()

call MPI_CART_SHIFT (comm_3D,0,1,rang_gauche,rang_droit,code) ............................................ Pour le processus 0, rang_gauche=-1, rang_droit=4 call MPI_CART_SHIFT (comm_3D,1,1,rang_bas,rang_haut,code) ............................................ Pour le processus 0, rang_bas=-1, rang_haut=2 call MPI_CART_SHIFT (comm_3D,2,1,rang_avant,rang_arriere,code) ............................................ Pour le processus 0, rang_avant=-1, rang_arriere=1
173/326
8 Communicateurs
8.6 Topologies
Exemple de programme :
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
program decomposition use mpi implicit none integer integer integer, integer, integer, integer, logical, logical :: :: dimension(4) :: parameter :: parameter :: dimension (ndims) :: dimension (ndims) :: :: rang_ds_topo,nb_procs code,comm_2D voisin N=1,E=2,S=3,W=4 ndims = 2 dims,coords periods reorganisation
call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) ! Connatre le nombre de processus suivant x et y dims(:) = 0 call MPI_DIMS_CREATE (nb_procs,ndims,dims,code)
174/326
8 Communicateurs
8.6 Topologies
22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
! Cration grille 2D priodique en y periods(1) = .false. periods(2) = .true. reorganisation = .false. call MPI_CART_CREATE ( MPI_COMM_WORLD ,ndims,dims,periods,reorganisation,comm_2D,code) ! Connatre mes coordonnes dans la topologie call MPI_COMM_RANK (comm_2D,rang_ds_topo,code) call MPI_CART_COORDS (comm_2D,rang_ds_topo,ndims,coords,code) ! Initialisation du tableau voisin la valeur MPI_PROC_NULL voisin(:) = MPI_PROC_NULL ! Recherche de mes voisins Ouest et Est call MPI_CART_SHIFT (comm_2D,0,1,voisin(W),voisin(E),code) ! Recherche de mes voisins Sud et Nord call MPI_CART_SHIFT (comm_2D,1,1,voisin(S),voisin(N),code) call MPI_FINALIZE (code) end program decomposition
175/326
8 Communicateurs
8.6 Topologies
8 Communicateurs
8.6 Topologies 8.6.2 Subdiviser une topologie cartsienne
La question est de savoir comment dgnrer une topologie cartsienne 2D ou 3D de processus en une topologie cartsienne respectivement 1D ou 2D. Pour MPI, dgnrer une topologie cartsienne 2D (ou 3D) revient crer autant de communicateurs quil y a de lignes ou de colonnes (resp. de plans) dans la grille cartsienne initiale. Lintrt majeur est de pouvoir eectuer des oprations collectives restreintes un sous-ensemble de processus appartenant : une mme ligne (ou colonne), si la topologie initiale est 2D ; un mme plan, si la topologie initiale est 3D.
176/326
8 Communicateurs
8.6 Topologies
2 1 0 0 0 1
2 4 3 1
5 7 6 2
11 1 0 0 0 1
2 4 3 1
5 7 6 2
8 10 9 3
11
V
10 9 3
Figure 43 Deux exemples de distribution de donnes dans une topologie 2D dgnre
177/326
8 Communicateurs
8.6 Topologies
Il existe deux faons de faire pour dgnrer une topologie : en utilisant le sous-programme gnral MPI_COMM_SPLIT() ; en utilisant le sous-programme MPI_CART_SUB() prvu cet eet.
logical,intent(in),dimension(NDim) :: conserve_dims integer,intent(in) :: CommCart integer,intent(out) :: CommCartD, code call MPI_CART_SUB (CommCart,conserve_dims,CommCartD,code)
2 1 0 0 0 1
v(:)=0. v(:)=5. v(:)=0. v(:)=0.
v(:)=0. v(:)=4. v(:)=0. v(:)=0.
11
2 1 0 0 0 1
w=5
v(:)=0. v(:)=3. v(:)=0. v(:)=0.
10
w=4
3 1
6 2
9 3
w=3
3 1
v(:)=3 w=3 w=3
v(:)=4 w=4 w=4
v(:)=5 w=5 w=5
11
w=5
10
w=4
6 2
9 3
w=3
Figure 44 Reprsentation initiale dun tableau V dans la grille 2D et reprsentation nale aprs la distribution de celui-ci sur la grille 2D dgnre
178/326
8 Communicateurs
8.6 Topologies
1 2 3 4 5 6 7 8 9 10 11 12
program CommCartSub use mpi implicit none integer integer,parameter integer,dimension(NDim2D) logical,dimension(NDim2D) logical integer,parameter real, dimension(m) real :: :: :: :: :: :: :: :: Comm2D,Comm1D,rang,code NDim2D=2 Dim2D,Coord2D Periode,conserve_dims Reordonne m=4 V(:)=0. W=0.
179/326
8 Communicateurs
8.6 Topologies
13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
call MPI_INIT (code) ! Cration de la grille 2D initiale Dim2D(1) = 4 Dim2D(2) = 3 Periode(:) = .false. ReOrdonne = .false. call MPI_CART_CREATE ( MPI_COMM_WORLD ,NDim2D,Dim2D,Periode,ReOrdonne,Comm2D,code) call MPI_COMM_RANK (Comm2D,rang,code) call MPI_CART_COORDS (Comm2D,rang,NDim2D,Coord2D,code) ! Initialisation du vecteur V if (Coord2D(1) == 1) V(:)=real(rang) ! Chaque ligne de la grille doit tre une topologie cartsienne 1D conserve_dims(1) = .true. conserve_dims(2) = .false. ! Subdivision de la grille cartsienne 2D call MPI_CART_SUB (Comm2D,conserve_dims,Comm1D,code) ! Les processus de la colonne 2 distribuent le vecteur V aux processus de leur ligne call MPI_SCATTER (V,1, MPI_REAL ,W,1, MPI_REAL ,1,Comm1D,code) print ("Rang : ",I2," ; Coordonnees : (",I1,",",I1,") ; W = ",F2.0), & rang,Coord2D(1),Coord2D(2),W call MPI_FINALIZE (code) end program CommCartSub
180/326
8 Communicateurs
8.6 Topologies
> mpiexec Rang : 0 Rang : 1 Rang : 3 Rang : 8 Rang : 4 Rang : 5 Rang : 6 Rang : 10 Rang : 11 Rang : 9 Rang : 2 Rang : 7
-n 12 CommCartSub ; Coordonnees : (0,0) ; Coordonnees : (0,1) ; Coordonnees : (1,0) ; Coordonnees : (2,2) ; Coordonnees : (1,1) ; Coordonnees : (1,2) ; Coordonnees : (2,0) ; Coordonnees : (3,1) ; Coordonnees : (3,2) ; Coordonnees : (3,0) ; Coordonnees : (0,2) ; Coordonnees : (2,1)
; ; ; ; ; ; ; ; ; ; ; ;
W W W W W W W W W W W W
= = = = = = = = = = = =
3. 4. 3. 5. 4. 5. 3. 4. 5. 3. 5. 4.
181/326
9 MPI-IO
1 Introduction 2 Environnement 3 Communications point point 4 5 6 7 Communications collectives Copies de mmoire mmoire Types de donnes drivs Optimisations
8 Communicateurs 9 MPI-IO 9.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 9.1.1 Prsentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182 9.1.2 Enjeux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184 9.1.3 Dnitions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .187 9.2 Gestion de chiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 9.3 Lectures/critures : gnralits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 9.4 Lectures/critures individuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 9.4.1 Via des dplacements explicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196 9.4.2 Via des dplacements implicites individuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 9.4.3 Via des dplacements implicites partags. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 9.5 Lectures/critures collectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 9.5.1 Via des dplacements explicites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210 9.5.2 Via des dplacements implicites individuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 9.5.3 Via des dplacements implicites partags. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 9.6 Positionnement explicite des pointeurs dans un chier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 9.7 Dnition de vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 9.8 Lectures/critures non bloquantes . . . . . . . . . . . . . . . . . . . . . . . . .MPI. . . Version. . . . .. . . . . . 2012 . . . . . . . . . 4.1 Avril 235 9.8.1 Via des dplacements explicitesDupays,. . . . Girou, .P.-F. .Lavalle, .D. .Lecas, .P.. Wautelet J. Chergui, I. . . . . . . D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
182/326
9 MPI-IO
9.1 Introduction
9 MPI-IO
9.1 Introduction 9.1.1 Prsentation
Trs logiquement, les applications qui font des calculs volumineux manipulent galement des quantits importantes de donnes externes, et gnrent donc un nombre consquent dentres-sorties. Le traitement ecace de celles-ci inue donc parfois trs fortement sur les performances globales des applications.
183/326
9 MPI-IO
9.1 Introduction
Loptimisation des entres-sorties de codes parallles se fait par la combinaison : de leur paralllisation, pour viter de crer un goulet dtranglement en raison de leur srialisation ; de techniques mises en uvre explicitement au niveau de la programmation (lectures / critures non-bloquantes) ; doprations spciques prises en charge par le systme dexploitation (regroupement des requtes, gestion des tampons dentres-sorties, etc.). Les buts de MPI-IO, via linterface de haut niveau quil propose, sont dorir simplicit, expressivit et souplesse, tout en autorisant des implmentations performantes prenant en compte les spcicits matrielles et logicielles des dispositifs dentres-sorties des machines cibles. MPI-IO ore une interface calque sur celle utilise pour lchange de messages. La dnition des donnes accdes suivant les processus se fait par lutilisation de types de donnes (de base ou bien drivs). Quant aux notions doprations collectives et de non-bloquantes, elles sont gres de faon similaire ce que propose MPI pour les messages. MPI-IO autorise des accs aussi bien squentiels qualatoires.
184/326
9 MPI-IO
9.1 Introduction
9 MPI-IO
9.1 Introduction 9.1.2 Enjeux
Cest une interface de haut niveau, o, comme on la dit, certaines techniques doptimisation sont accessibles aux utilisateurs, mais o beaucoup doptimisations essentielles peuvent tre implmentes de faon transparente. Deux exemples importants en sont : le cas daccs nombreux, par un seul processus, de petits blocs discontinus : ceci peut tre trait par un mcanisme de passoire (data sieving), aprs regroupement dun ensemble de requtes, lecture dun grand bloc contigu du disque vers une zone mmoire tampon, puis aectation aux zones mmoire utilisateur des sous-ensembles adquats de donnes ;
185/326
9 MPI-IO
9.1 Introduction
Requtes sur de petits blocs non contigus dun chier Lecture dun grand bloc contigu et transfert dans une zone mmoire tampon Copies mmoire des lments requis dans les variables du programme
Figure 45 Mcanisme de passoire dans le cas daccs nombreux, par un seul processus, de petits blocs discontinus
186/326
9 MPI-IO
9.1 Introduction
le cas daccs, par un ensemble de processus, des blocs discontinus (cas des tableaux distribus, par exemple) : ceci peut tre trait par des entres-sorties collectives en dcomposant les oprations en deux phases.
Requte proc. 0 Requte proc. 1 Requte proc. 2
Fichier
Domaine du processus 0 Domaine du processus 1 Domaine du processus 2
Lecture
Tampon mm. processus 0
Lecture
Lecture
Communications
Variable du processus 0
Figure 46 Lecture en deux phases, par un ensemble de processus

187/326
9 MPI-IO
9.1 Introduction
9 MPI-IO
9.1 Introduction 9.1.3 Dnitions
chier (le) : un chier MPI est un ensemble ordonn de donnes types. Un chier est ouvert collectivement par tous les processus dun communicateur. Toutes les oprations dentres-sorties collectives ultrieures se feront dans ce cadre. dplacement initial (displacement) : cest une adresse absolue, exprime en octets, par rapport au dbut du chier et partir de laquelle une vue commence. type lmentaire de donnes type_lm (etype) : cest lunit de donne utilise pour calculer les positionnements et pour accder aux donnes. Ce peut tre nimporte quel type de donne MPI, prdni ou bien cr en tant que type driv. motif (letype) : cest un masque qui constitue la base du partitionnement dun chier entre processus (si le chier est vu comme un pavage une dimension, le motif est la tuile lmentaire qui sert au pavage). Cest ou bien un type lmentaire de donnes, ou bien un type driv MPI construit comme une rptition doccurrences dun tel type lmentaire de donnes (les trous parties de chiers non accdes doivent galement tre un multiple du type_lm utilis).
188/326
9 MPI-IO
9.1 Introduction
vue (view) : une vue dnit lensemble des donnes visibles (et donc accessibles) dun chier, une fois que celui-ci a t ouvert. Cest un ensemble ordonn de types lmentaires de donnes. position (oset) : cest la position dans le chier, exprime en nombre de type_lm, relativement la vue courante (les trous dnis dans la vue ne sont pas comptabiliss pour calculer les positions). descripteur (le handle) : le descripteur est un objet cach cr louverture et dtruit la fermeture dun chier. Toutes les oprations sur un chier se font en spciant comme rfrence son descripteur. pointeur (le pointer) : ils sont tenus jour automatiquement par MPI et dterminent des positions lintrieur du chier. Il y en a de deux sortes : les pointeurs individuels qui sont propres chaque processus ayant ouvert le chier ; les pointeurs partags qui sont communs tous les processus ayant ouvert le chier. taille du chier (le size) : la taille dun chier MPI est mesure en nombre doctets.
189/326
9 MPI-IO
9.2 Gestion de chiers
9 MPI-IO
Les tches courantes de gestion de chiers sont des oprations collectives faites par tous les processus du communicateur indiqu. Nous ne dcrivons ici que les principaux sous-programmes (ouverture, fermeture, obtention des caractristiques) mais dautres sont disponibles (suppression, pr-allocation, etc.). Les attributs (dcrivant les droits daccs, le mode douverture, la destruction ventuelle la fermeture, etc.) doivent tre prciss par oprations sur des constantes prdnies. Tous les processus du communicateur au sein duquel un chier est ouvert participeront aux oprations collectives ultrieures daccs aux donnes. Louverture dun chier renvoie un descripteur, qui sera ensuite utilis dans toutes les oprations portant sur ce chier. Les informations disponibles via le sous-programme MPI_FILE_SET_INFO() varient dune implmentation lautre.
190/326
9 MPI-IO
Table 4 Attributs pouvant tre positionns lors de louverture des chiers Attribut MPI_MODE_RDONLY MPI_MODE_RDWR MPI_MODE_WRONLY MPI_MODE_CREATE MPI_MODE_EXCL MPI_MODE_UNIQUE_OPEN MPI_MODE_SEQUENTIAL MPI_MODE_APPEND MPI_MODE_DELETE_ON_CLOSE Signication seulement en lecture en lecture et criture seulement en criture cration du chier sil nexiste pas erreur si le chier existe erreur si le chier est dj ouvert par une autre application accs squentiel pointeurs en n de chier (mode ajout) destruction aprs la fermeture
191/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
program open01 use mpi implicit none integer :: descripteur,code call MPI_INIT (code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"fichier.txt", & MPI_MODE_RDWR + MPI_MODE_CREATE , MPI_INFO_NULL ,descripteur,code) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program open01
> ls -l fichier.txt -rw------1 nom grp 0 Feb 08 12:13 fichier.txt
192/326
9 MPI-IO
9.3 Lectures/critures : gnralits
9 MPI-IO
Les transferts de donnes entre chiers et zones mmoire des processus se font via des appels explicites des sous-programmes de lecture et dcriture. On distingue trois proprits des accs aux chiers : le positionnement, qui peut tre explicite (en spciant par exemple le nombre voulu doctets depuis le dbut du chier) ou implicite, via des pointeurs grs par le systme (ces pointeurs peuvent tre de deux types : soit individuels chaque processus, soit partags par tous les processus) ; la synchronisation, les accs pouvant tre de type bloquants ou non bloquants ; le regroupement, les accs pouvant tre collectifs (cest--dire eectus par tous les processus du communicateur au sein duquel le chier a t ouvert) ou propres seulement un ou plusieurs processus. Il y a de nombreuses variantes disponibles : nous en dcrirons un certain nombre, sans pouvoir tre exhaustif.
193/326
9 MPI-IO
Table 5 Rsum des types daccs possibles
Positionnement
Synchronisation
Regroupement individuel MPI_FILE_READ_AT MPI_FILE_WRITE_AT MPI_FILE_IREAD_AT
collectif
adresses explicites
MPI_FILE_READ_AT_ALL bloquantes MPI_FILE_WRITE_AT_ALL MPI_FILE_READ_AT_ALL_BEGIN MPI_FILE_READ_AT_ALL_END non bloquantes MPI_FILE_IWRITE_AT MPI_FILE_WRITE_AT_ALL_BEGIN MPI_FILE_WRITE_AT_ALL_END suite page suivante
194/326
9 MPI-IO
Positionnement
Synchronisation bloquantes
Regroupement individuel MPI_FILE_READ MPI_FILE_WRITE MPI_FILE_IREAD MPI_FILE_IWRITE
collectif
pointeurs implicites individuels non bloquantes
MPI_FILE_READ_ALL MPI_FILE_WRITE_ALL MPI_FILE_READ_ALL_BEGIN MPI_FILE_READ_ALL_END MPI_FILE_WRITE_ALL_BEGIN MPI_FILE_WRITE_ALL_END
MPI_FILE_READ_SHARED MPI_FILE_READ_ORDERED MPI_FILE_WRITE_SHARED MPI_FILE_WRITE_ORDERED pointeurs MPI_FILE_IREAD_SHARED MPI_FILE_READ_ORDERED_BEGIN implicites MPI_FILE_READ_ORDERED_END partags non bloquantes MPI_FILE_IWRITE_SHARED MPI_FILE_WRITE_ORDERED_BEGIN MPI_FILE_WRITE_ORDERED_END bloquantes
195/326
9 MPI-IO
Il est possible de mlanger les types daccs eectus un mme chier au sein dune application. Les zones mmoire accdes sont dcrites par trois quantits : ladresse initiale de la zone concerne ; le nombre dlments pris en compte ; le type de donnes, qui doit correspondre une suite de copies contigu du type lmentaire de donne (type_lm) de la vue courante.
196/326
9 MPI-IO
9.4 Lectures/critures individuelles
9 MPI-IO
9.4 Lectures/critures individuelles 9.4.1 Via des dplacements explicites
La position est exprime en nombre doccurrences dun type de donnes, lequel doit tre un multiple du type lmentaire de donne de la vue courante. Le chier ne doit pas avoir t ouvert avec lattribut MPI_MODE_SEQUENTIAL.
197/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
program write_at use mpi implicit none integer, parameter integer integer(kind= MPI_OFFSET_KIND ) integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: :: nb_valeurs=10 i,rang,descripteur,code,nb_octets_entier position_fichier valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) valeurs(:)= (/(i+rang*100,i=1,nb_valeurs)/) print *, "criture processus",rang, ":",valeurs(:) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_WRONLY + MPI_MODE_CREATE , & MPI_INFO_NULL ,descripteur,code) call MPI_TYPE_SIZE ( MPI_INTEGER ,nb_octets_entier,code) position_fichier=rang*nb_valeurs*nb_octets_entier call MPI_FILE_WRITE_AT (descripteur,position_fichier,valeurs,nb_valeurs, MPI_INTEGER , & statut,code) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program write_at
198/326
9 MPI-IO
Processus 0
10
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1
101 102 103 104 105 106 107 108 109 110
Figure 47 Exemple dutilisation de MPI_FILE_WRITE_AT()
> mpiexec -n 2 write_at criture processus 0 : criture processus 1 : 1, 101, 2, 102, 3, 103, 4, 104, 5, 105, 6, 106, 7, 107, 8, 108, 9, 109, 10 110
199/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
program read_at use mpi implicit none integer, parameter integer integer(kind= MPI_OFFSET_KIND ) integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: :: nb_valeurs=10 rang,descripteur,code,nb_octets_entier position_fichier valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_TYPE_SIZE ( MPI_INTEGER ,nb_octets_entier,code) position_fichier=rang*nb_valeurs*nb_octets_entier call MPI_FILE_READ_AT (descripteur,position_fichier,valeurs,nb_valeurs, MPI_INTEGER , & statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_at
200/326
9 MPI-IO
Processus 0
10
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1 101 102 103 104 105 106 107 108 109 110
Figure 48 Exemple dutilisation de MPI_FILE_READ_AT()
> mpiexec -n 2 read_at Lecture processus 0 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Lecture processus 1 : 101, 102, 103, 104, 105, 106, 107, 108, 109, 110
201/326
9 MPI-IO
9 MPI-IO
9.4 Lectures/critures individuelles 9.4.2 Via des dplacements implicites individuels
Dans ces cas-ci, un pointeur individuel est gr par le systme, et ceci par chier et par processus. Pour un processus donn, deux accs successifs au mme chier permettent donc daccder automatiquement aux lments conscutifs de celui-ci. Dans tous ces sous-programmes, les pointeurs partags ne sont jamais accds ou modis. Aprs chaque accs, le pointeur est positionn sur le type lmentaire de donne suivant. Le chier ne doit pas avoir t ouvert avec lattribut MPI_MODE_SEQUENTIAL.
202/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
program read01 use mpi implicit none integer, parameter integer integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: nb_valeurs=10 rang,descripteur,code valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_FILE_READ (descripteur,valeurs,6, MPI_INTEGER ,statut,code) call MPI_FILE_READ (descripteur,valeurs(7),4, MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read01
203/326
9 MPI-IO
Processus 0 1
9 10
Fichier
9 10 101 102 103 104 105 106 107 108 109 110
Processus 1 1
9 10
Figure 49 Exemple 1 dutilisation de MPI_FILE_READ()
> mpiexec -n 2 read01 Lecture processus 1 : Lecture processus 0 : 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10 10
204/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program read02 use mpi implicit none integer, parameter integer integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: nb_valeurs=10 rang,descripteur,code valeurs=0 statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) if (rang == 0) then call MPI_FILE_READ (descripteur,valeurs,5, MPI_INTEGER ,statut,code) else call MPI_FILE_READ (descripteur,valeurs,8, MPI_INTEGER ,statut,code) call MPI_FILE_READ (descripteur,valeurs,5, MPI_INTEGER ,statut,code) end if print *, "Lecture processus",rang,":",valeurs(1:8) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read02
205/326
9 MPI-IO
1 Processus 0 0
2 0
3 0
4 0
5 0
Fichier
9 10 101 102 103 104 105 106 107 108 109 110
Processus 1 1
9 10 101 102 103 6 1 2 3 4 5
Figure 50 Exemple 2 dutilisation de MPI_FILE_READ()
> mpiexec -n 2 read02 Lecture processus 0 : Lecture processus 1 : 1, 9, 2, 3, 4, 5, 10, 101, 102, 103, 0, 6, 0, 7, 0 8
206/326
9 MPI-IO
9 MPI-IO
9.4 Lectures/critures individuelles 9.4.3 Via des dplacements implicites partags
Il existe un et un seul pointeur partag par chier, commun tous les processus du communicateur dans lequel le chier a t ouvert. Tous les processus qui font une opration dentre-sortie utilisant le pointeur partag doivent employer pour ce faire la mme vue du chier. Si on utilise les variantes non collectives des sous-programmes, lordre de lecture nest pas dterministe. Si le traitement doit tre dterministe, il faut explicitement grer lordonnancement des processus ou utiliser les variantes collectives. Aprs chaque accs, le pointeur est positionn sur le type lmentaire de donne suivant. Dans tous ces sous-programmes, les pointeurs individuels ne sont jamais accds ou modis.
207/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
program read_shared01 use mpi implicit none integer integer, parameter integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: rang,descripteur,code nb_valeurs=10 valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_FILE_READ_SHARED (descripteur,valeurs,4, MPI_INTEGER ,statut,code) call MPI_FILE_READ_SHARED (descripteur,valeurs(5),6, MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_shared01
208/326
9 MPI-IO
Processus 0 101 102 103 104
101 102 103 104 105 106 107 108 109 110
Fichier
9 10 101 102 103 104 105 106 107 108 109 110
Processus 1 1
9 10
Figure 51 Exemple 2 dutilisation de MPI_FILE_READ_SHARED()
> mpiexec -n 2 read_shared01 Lecture processus Lecture processus 1 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 0 : 101, 102, 103, 104, 105, 106, 107, 108, 109, 110
209/326
9 MPI-IO
9.5 Lectures/critures collectives
9 MPI-IO
Tous les processus du communicateur au sein duquel un chier est ouvert participent aux oprations collectives daccs aux donnes. Les oprations collectives sont gnralement plus performantes que les oprations individuelles, parce quelles autorisent davantage de techniques doptimisation mises en uvre automatiquement (comme les accs en deux phases voir le paragraphe 2). Dans les oprations collectives, les accs sont eectus dans lordre des rangs des processus. Le traitement est donc dans ce cas dterministe.
210/326
9 MPI-IO
9 MPI-IO
9.5 Lectures/critures collectives 9.5.1 Via des dplacements explicites program read_at_all use mpi implicit none integer, parameter integer integer(kind= MPI_OFFSET_KIND ) integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: :: nb_valeurs=10 rang,descripteur,code,nb_octets_entier position_fichier valeurs statut
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_TYPE_SIZE ( MPI_INTEGER ,nb_octets_entier,code) position_fichier=rang*nb_valeurs*nb_octets_entier call MPI_FILE_READ_AT_ALL (descripteur,position_fichier,valeurs,nb_valeurs, & MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_at_all
211/326
9 MPI-IO
Processus 0
10
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1 101 102 103 104 105 106 107 108 109 110
Figure 52 Exemple dutilisation de MPI_FILE_READ_AT_ALL()
> mpiexec -n 2 read_at_all Lecture processus 0 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Lecture processus 1 : 101, 102, 103, 104, 105, 106, 107, 108, 109, 110
212/326
9 MPI-IO
9 MPI-IO
9.5 Lectures/critures collectives 9.5.2 Via des dplacements implicites individuels
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program read_all01 use mpi implicit none integer integer, parameter integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: rang,descripteur,code nb_valeurs=10 valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_FILE_READ_ALL (descripteur,valeurs,4, MPI_INTEGER ,statut,code) call MPI_FILE_READ_ALL (descripteur,valeurs(5),6, MPI_INTEGER ,statut,code) print *, "Lecture processus ",rang, ":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_all01
213/326
9 MPI-IO
Processus 0 1
9 10
Fichier
9 10 101 102 103 104 105 106 107 108 109 110
Processus 1 1
9 10
Figure 53 Exemple 1 dutilisation de MPI_FILE_READ_ALL()
> mpiexec -n 2 read_all01 Lecture processus 0 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Lecture processus 1 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
214/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
program read_all02 use mpi implicit none integer, parameter integer integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: nb_valeurs=10 rang,descripteur,indice1,indice2,code valeurs=0 statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) if (rang == 0) then indice1=3 indice2=6 else indice1=5 indice2=9 end if call MPI_FILE_READ_ALL (descripteur,valeurs(indice1),indice2-indice1+1, & MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_all02
215/326
9 MPI-IO
Processus 0
1 0
2 0
3 0
4 0
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1
1 0
2 0
3 0
4 0
5 0
216/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
program read_all03 use mpi implicit none integer, parameter integer integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: nb_valeurs=10 rang,descripteur,code valeurs=0 statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) if (rang == 0) then call MPI_FILE_READ_ALL (descripteur,valeurs(3),4, MPI_INTEGER ,statut,code) else call MPI_FILE_READ_ALL (descripteur,valeurs(5),5, MPI_INTEGER ,statut,code) end if print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_all03
217/326
9 MPI-IO
Processus 0
1 0
2 0
3 0
4 0
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1
1 0
2 0
3 0
4 0
5 0
218/326
9 MPI-IO
9 MPI-IO
9.5 Lectures/critures collectives 9.5.3 Via des dplacements implicites partags
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program read_ordered use mpi implicit none integer integer, parameter integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: rang,descripteur,code nb_valeurs=10 valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_FILE_READ_ORDERED (descripteur,valeurs,4, MPI_INTEGER ,statut,code) call MPI_FILE_READ_ORDERED (descripteur,valeurs(5),6, MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_ordered
219/326
9 MPI-IO
Processus 0 1
9 10 101 102 103 104
Fichier
9 10 101 102 103 104 105 106 107 108 109 110
Processus 1 5
8 105 106 107 108 109 110
Figure 56 Exemple dutilisation de MPI_FILE_ORDERED()
> mpiexec -n 2 read_ordered Lecture processus 1 : 5, 6, 7, 8, 105, 106, 107, 108, 109, 110 Lecture processus 0 : 1, 2, 3, 4, 9, 10, 101, 102, 103, 104
220/326
9.6 9 MPI-IO Positionnement explicite des pointeurs dans un chier
9 MPI-IO
9.6 Positionnement explicite des pointeurs dans un chier
Les sous-programmes MPI_FILE_GET_POSITION() et MPI_FILE_GET_POSITION_SHARED() permettent de connatre respectivement la valeur courante des pointeurs individuels et celle du pointeur partag. Il est possible de positionner explicitement les pointeurs individuels laide du sous-programme MPI_FILE_SEEK(), et de mme le pointeur partag avec le sous-programme MPI_FILE_SEEK_SHARED(). Il y a trois modes possibles pour xer la valeur dun pointeur : MPI_SEEK_SET xe une valeur absolue ; MPI_SEEK_CUR xe une valeur relative ; MPI_SEEK_END positionne le pointeur la n du chier, laquelle un dplacement ventuel est ajout.
Avec MPI_SEEK_CUR, on peut spcier une valeur ngative, ce qui permet de revenir en arrire dans le chier.
221/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
program seek use mpi implicit none integer, parameter integer integer(kind= MPI_OFFSET_KIND ) integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE )
:: :: :: :: ::
nb_valeurs=10 rang,descripteur,nb_octets_entier,code position_fichier valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_FILE_READ (descripteur,valeurs,3, MPI_INTEGER ,statut,code) call MPI_TYPE_SIZE ( MPI_INTEGER ,nb_octets_entier,code) position_fichier=8*nb_octets_entier call MPI_FILE_SEEK (descripteur,position_fichier, MPI_SEEK_CUR ,code) call MPI_FILE_READ (descripteur,valeurs(4),3, MPI_INTEGER ,statut,code) position_fichier=4*nb_octets_entier call MPI_FILE_SEEK (descripteur,position_fichier, MPI_SEEK_SET ,code) call MPI_FILE_READ (descripteur,valeurs(7),4, MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program seek
222/326
Processus 0
3 102103104
3 102103104 5
Fichier
10
101 102 103 104 105 106 107 108 109 110
Processus 1
3 102103104
3 102103104 5
Figure 57 Exemple dutilisation de MPI_FILE_SEEK()
> mpiexec -n 2 seek Lecture processus 1 : 1, 2, 3, 102, 103, 104, 5, 6, 7, 8 Lecture processus 0 : 1, 2, 3, 102, 103, 104, 5, 6, 7, 8
223/326
9 MPI-IO
9.7 Dnition de vues
9 MPI-IO
9.7 Dnition de vues
Les vues sont un mcanisme souple et puissant pour dcrire les zones accdes dans les chiers. Les vues sont construites laide de types drivs MPI Chaque processus a sa propre vue (ou ses propres vues) dun chier, dnie par trois variables : un dplacement initial, un type lmentaire de donnes et un motif . Une vue est dnie comme rptition du motif, une fois le positionnement initial eectu. Il est possible de dnir des trous dans une vue, de faon ne pas tenir compte de certaines parties des donnes. Des processus dirents peuvent parfaitement avoir des vues direntes du chier, de faon accder des parties complmentaires de celui-ci. Un processus donn peut dnir et utiliser plusieurs vues direntes du mme chier. Un pointeur partag nest utilisable avec une vue que si tous les processus ont la mme vue.
224/326
9 MPI-IO
9.7 Dnition de vues
Si le chier est ouvert en criture, les zones dcrites par les types lmentaires et les motifs ne peuvent se recouvrir, mme partiellement. La vue par dfaut consiste en une simple suite doctets (dplacement initial nul, type_lm et motif gaux MPI_BYTE). type_lm motif trous chier dplacement initial donnes accessibles
Figure 58 Type lmentaire de donne et motif
225/326
9 MPI-IO
9.7 Dnition de vues
type_lm motif proc. 0 motif proc. 1 motif proc. 2 chier dplacement initial
Figure 59 Exemple de dnition de motifs dirents selon les processus
226/326
9 MPI-IO
9.7 Dnition de vues
dp_initial 2 entiers type_lm motif trous

Figure 60 Motif employ dans lexemple 1 dutilisation de MPI_FILE_SET_VIEW()
program read_view01 use mpi implicit none integer, parameter integer(kind= MPI_ADDRESS_KIND ),parameter integer integer(kind= MPI_OFFSET_KIND ) integer(kind= MPI_ADDRESS_KIND ) integer, dimension(2) integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: :: :: :: :: nb_valeurs=10 borne_inf_zero=0 rang,descripteur,motif_temp,motif,code deplacement_initial borne_inf,taille longueurs,deplacements valeurs statut
MPI_INTEGER
1 2 3 4 5 6 7 8 9 10 11 12 13
227/326
14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
9 MPI-IO
9.7 Dnition de vues
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) deplacements(1)=1 deplacements(2)=4 longueurs(1)=2 longueurs(2)=1 call call call call MPI_TYPE_INDEXED (2,longueurs,deplacements, MPI_INTEGER ,motif_temp,code) MPI_TYPE_GET_EXTENT (motif_temp,borne_inf,taille,code) MPI_TYPE_CREATE_RESIZED (motif_temp,borne_inf_zero,borne_inf+taille,motif,code) MPI_TYPE_COMMIT (motif,code)
! Ne pas omettre de passer par une variable intermdiaire de reprsentation ! MPI_OFFSET_KIND, pour des raisons de portabilit deplacement_initial=0 call MPI_FILE_SET_VIEW (descripteur,deplacement_initial, MPI_INTEGER ,motif, & "native", MPI_INFO_NULL ,code) call MPI_FILE_READ (descripteur,valeurs,7, MPI_INTEGER ,statut,code) call MPI_FILE_READ (descripteur,valeurs(8),3, MPI_INTEGER ,statut,code) print *,"Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_view01
228/326
9 MPI-IO
9.7 Dnition de vues
Processus 0 2
8 10 102
8 10 102 103 105 107
Fichier
9 10 101 102 103 104 105 106 107 108 109 110
Processus 1 2
8 10 102
8 10 102 103 105 107
Figure 61 Exemple 1 dutilisation de MPI_FILE_SET_VIEW()
> mpiexec -n 2 read_view01 Lecture processus 1 : 2, 3, 5, 7, 8, 10, 102, 103, 105, 107 Lecture processus 0 : 2, 3, 5, 7, 8, 10, 102, 103, 105, 107
229/326
9 MPI-IO
9.7 Dnition de vues
dp_initial type_lm motif proc. 0 motif proc. 1
0 MPI_INTEGER
Figure 62 Motif employ dans lexemple 2 dutilisation de MPI_FILE_SET_VIEW()

program read_view02 use mpi implicit none integer, parameter integer integer(kind= MPI_OFFSET_KIND ) integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: :: nb_valeurs=10 rang,descripteur,coord,motif,code deplacement_initial valeurs statut
1 2 3 4 5 6 7 8 9 10
230/326
9 MPI-IO
9.7 Dnition de vues
11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) if (rang == 0) then coord=1 else coord=3 end if call MPI_TYPE_CREATE_SUBARRAY (1,(/4/),(/2/),(/coord - 1/), & MPI_ORDER_FORTRAN , MPI_INTEGER ,motif,code) call MPI_TYPE_COMMIT (motif,code) deplacement_initial=0 call MPI_FILE_SET_VIEW (descripteur,deplacement_initial, MPI_INTEGER ,motif, & "native", MPI_INFO_NULL ,code) call MPI_FILE_READ (descripteur,valeurs,nb_valeurs, MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_view02
231/326
9 MPI-IO
9.7 Dnition de vues
Processus 0
10 103 104 107 108
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1
8 101 102 105 106 109 110
232/326
9 MPI-IO
9.7 Dnition de vues
dp_initial 0 type_lm motif_1

(a) motif_1
MPI_INTEGER
dp_initial 0 type_lm motif_2

(b) motif_2
MPI_INTEGER
dp_initial 2 entiers type_lm motif_3

(c) motif_3
MPI_INTEGER
Figure 64 Motifs employs dans lexemple 3 dutilisation de MPI_FILE_SET_VIEW()

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
program read_view03 use mpi implicit none integer, parameter integer :: nb_valeurs=10 :: rang,descripteur,code, & motif_1,motif_2,motif_3,nb_octets_entier integer(kind= MPI_OFFSET_KIND ) :: deplacement_initial integer, dimension(nb_valeurs) :: valeurs integer, dimension( MPI_STATUS_SIZE ) :: statut call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code)
233/326
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
9 MPI-IO
9.7 Dnition de vues
call MPI_TYPE_CREATE_SUBARRAY (1,(/4/),(/2/),(/0/), & MPI_ORDER_FORTRAN , MPI_INTEGER ,motif_1,code) call MPI_TYPE_COMMIT (motif_1,code) call MPI_TYPE_CREATE_SUBARRAY (1,(/4/),(/2/),(/2/), & MPI_ORDER_FORTRAN , MPI_INTEGER ,motif_2,code) call MPI_TYPE_COMMIT (motif_2,code) call MPI_TYPE_CREATE_SUBARRAY (1,(/4/),(/1/),(/3/), & MPI_ORDER_FORTRAN , MPI_INTEGER ,motif_3,code) call MPI_TYPE_COMMIT (motif_3,code) deplacement_initial=0 call MPI_FILE_SET_VIEW (descripteur,deplacement_initial, MPI_INTEGER ,motif_1, & "native", MPI_INFO_NULL ,code) call MPI_FILE_READ (descripteur,valeurs,4, MPI_INTEGER ,statut,code) call MPI_FILE_SET_VIEW (descripteur,deplacement_initial, MPI_INTEGER ,motif_2, & "native", MPI_INFO_NULL ,code) call MPI_FILE_READ (descripteur,valeurs(5),3, MPI_INTEGER ,statut,code) call MPI_TYPE_SIZE ( MPI_INTEGER ,nb_octets_entier,code) deplacement_initial=2*nb_octets_entier call MPI_FILE_SET_VIEW (descripteur,deplacement_initial, MPI_INTEGER ,motif_3, & "native", MPI_INFO_NULL ,code) call MPI_FILE_READ (descripteur,valeurs(8),3, MPI_INTEGER ,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_view03
234/326
9 MPI-IO
9.7 Dnition de vues
Processus 0 1 2 5 6
1 2 5 6 3 4 7
1 2 5 6 3 4 7 6 10104
Fichier
9 10 101 102 103 104 105 106 107 108 109 110
Processus 1 1 2 5 6
1 2 5 6 3 4 7
1 2 5 6 3 4 7 6 10104
235/326
9 MPI-IO
9.8 Lectures/critures non bloquantes
9 MPI-IO
Les entres-sorties non bloquantes sont implmentes suivant le modle utilis pour les communications non bloquantes. Un accs non-bloquant doit donner lieu ultrieurement un test explicite de compltude ou une mise en attente (via MPI_TEST(), MPI_WAIT(), etc.), de faon similaire la gestion des messages non bloquants. Lintrt est de faire un recouvrement entre les calculs et les entres-sorties.
236/326
9 MPI-IO
9 MPI-IO
9.8 Lectures/critures non bloquantes 9.8.1 Via des dplacements explicites
1 2 3 4 5 6 7 8 9 10 11 12 13 14
program iread_at use mpi implicit none integer, parameter integer :: nb_valeurs=10 :: i,nb_iterations=0,rang,nb_octets_entier, & descripteur,requete,code integer(kind= MPI_OFFSET_KIND ) :: position_fichier integer, dimension(nb_valeurs) :: valeurs integer, dimension( MPI_STATUS_SIZE ) :: statut logical :: termine call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code)
237/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_TYPE_SIZE ( MPI_INTEGER ,nb_octets_entier,code) position_fichier=rang*nb_valeurs*nb_octets_entier call MPI_FILE_IREAD_AT (descripteur,position_fichier,valeurs,nb_valeurs, & MPI_INTEGER ,requete,code) do while (nb_iterations < 5000) nb_iterations=nb_iterations+1 ! Calculs recouvrant le temps demand par lopration de lecture ... call MPI_TEST (requete,termine,statut,code) if (termine) exit end do print *,"Aprs",nb_iterations,"iterations, lecture processus",rang,":",valeurs call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program iread_at
238/326
9 MPI-IO
Processus 0
10
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1 101 102 103 104 105 106 107 108 109 110
Figure 66 Exemple dutilisation de MPI_FILE_IREAD_AT()
> mpiexec -n 2 iread_at Aprs 1 iterations, lecture processus 0 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Aprs 1 iterations, lecture processus 1 : 101, 102, 103, 104, 105, 106, 107, 108, 109, 110
239/326
9 MPI-IO
9 MPI-IO
9.8 Lectures/critures non bloquantes 9.8.2 Via des dplacements implicites individuels
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
program iread use mpi implicit none integer, parameter integer integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: nb_valeurs=10 rang,descripteur,requete,code valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_FILE_IREAD (descripteur,valeurs,nb_valeurs, MPI_INTEGER ,requete,code) ! Calcul recouvrant le temps demand par lopration de lecture ... call MPI_WAIT (requete,statut,code) print *, "Lecture processus",rang,":",valeurs(:) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program iread
240/326
9 MPI-IO
Processus 0
10
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1
10
Figure 67 Exemple 1 dutilisation de MPI_FILE_IREAD()
> mpiexec -n 2 iread Lecture processus 0 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Lecture processus 1 : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
241/326
9 MPI-IO
Il est possible deectuer des oprations qui soient la fois collectives et non bloquantes, via une forme particulire dopration collective non bloquante. Celle-ci ncessite un appel deux sous-programmes distincts, lun pour dclencher lopration et lautre pour la terminer. On ne peut modier la zone mmoire concerne entre les deux phases de lopration. Nanmoins, il est possible pendant ce temps de faire des oprations non collectives sur le chier. Il ne peut y avoir quune seule telle opration en cours la fois par processus.
242/326
9 MPI-IO
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
program read_ordered_begin_end use mpi implicit none integer integer, parameter integer, dimension(nb_valeurs) integer, dimension( MPI_STATUS_SIZE ) :: :: :: :: rang,descripteur,code nb_valeurs=10 valeurs statut
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"donnees.dat", MPI_MODE_RDONLY , MPI_INFO_NULL , & descripteur,code) call MPI_FILE_READ_ORDERED_BEGIN (descripteur,valeurs,4, MPI_INTEGER ,code) print *, "Processus numro :",rang call MPI_FILE_READ_ORDERED_END (descripteur,valeurs,statut,code) print *, "Lecture processus",rang,":",valeurs(1:4) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program read_ordered_begin_end
243/326
9 MPI-IO
Processus 0
Fichier
10 101 102 103 104 105 106 107 108 109 110
Processus 1
Figure 68 Exemple dutilisation de MPI_FILE_READ_ORDERED_BEGIN()
> mpiexec -n 2 read_ordered_begin_end Processus numro : 0 Lecture processus 0 : 1, 2, 3, 4 Processus numro : 1 Lecture processus 1 : 5, 6, 7, 8
244/326
9 MPI-IO
9.9 Conseils
9 MPI-IO
9.9 Conseils
Comme on a pu le voir, MPI-IO ore un ensemble trs riche de fonctionnalits, en mme temps quune interface de haut niveau. Celle-ci, tout en restant portable, permet la fois de masquer aux utilisateurs des oprations complexes et dimplmenter de faon transparente des optimisations particulires aux machines cibles. Certains choix semblent clairement conseiller : lorsque les oprations font intervenir tous les processus, ou un ensemble dentre eux qui peuvent tre dnis dans un communicateur particulier, il faut gnralement privilgier la forme collective des oprations ; lutilisation des sous-programmes positionnement explicite dans les chiers ne sont employer que dans des cas particuliers, lutilisation implicite de pointeurs individuels ou partags orant une interface de plus haut niveau ; exactement comme pour le traitement des messages lorsque ceux-ci reprsentent une part importante de lapplication, le non-bloquant est une voie privilgie doptimisation mettre en uvre par les programmeurs, mais ceci ne doit tre implment quaprs quon se soit assur du comportement correct de lapplication en mode bloquant.
245/326
10 Conclusion
1 Introduction 2 Environnement 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index
246/326
10 Conclusion
10 Conclusion
Utiliser les communications point--point bloquantes, ceci avant de passer aux communications non-bloquantes. Il faudra alors essayer de faire du recouvrement calcul/communications. Utiliser les fonctions dentres-sorties bloquantes, ceci avant de passer aux entres-sorties non-bloquantes. De mme, il faudra alors faire du recouvrement calcul/entres-sorties. crire les communications comme si les envois taient synchrones (MPI_SSEND()). viter les barrires de synchronisation (MPI_BARRIER()), surtout sur les fonctions collectives qui sont bloquantes. La programmation mixte MPI/OpenMP peut apporter des gains dextensibilit, mais pour que cette approche fonctionne bien, il est videmment ncessaire davoir de bonnes performances OpenMP lintrieur de chaque processus MPI. Un cours est dispens lIDRIS (https://cours.idris.fr/).
247/326
11 Annexes
1 Introduction 2 Environnement 3 Communications point point 4 5 6 7 Communications collectives Copies de mmoire mmoire Types de donnes drivs Optimisations
8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 11.1 Communications collectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249 11.2 Types de donnes drivs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251 11.2.1 Distribution dun tableau sur plusieurs processus . . . . . . . . . . . . . . . . . . . . . . . . . . 251 11.2.2 Types drivs numriques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .264 11.3 Optimisations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 11.4 Communicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 11.4.1 Intra et intercommunicateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 11.4.2 Graphe de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280 11.5 Gestion de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 11.5.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288 11.5.2 Mode matre-ouvriers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290 11.5.3 Mode client-serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304 11.5.4 Suppression de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310 11.5.5 Complments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312 11.6 MPI-IO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .MPI. . . Version. . . . .. . . . . . 2012 . . . . . . . . . 4.1 Avril 313
J. Chergui, I. Dupays, D. Girou, P.-F. Lavalle, D. Lecas, P. Wautelet
248/326
11 Annexes
11 Annexes
Il sagit ici de programmes concernant direntes fonctionnalits de MPI qui sont : moins frquentes dutilisation (cration de sa propre opration de rduction, type drivs spciques, topologie de type graphe, communications persistantes) ; qui ne sont pas disponibles sur lensemble des machines (gestion dynamique de processus, mode client serveur).
249/326
11 Annexes
11.1 Communications collectives
11 Annexes
Dans cet exemple, on se propose de crer sa propre opration de rduction, produit de vecteurs de nombres complexes.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program ma_reduction use mpi implicit none integer :: rang,code,i, mon_operation integer, parameter :: n=4 complex, dimension(n) :: a,resultat external mon_produit call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation du vecteur A sur chaque processus a(:) = (/ (cmplx(rang+i,rang+i+1),i=1,n) /) ! Cration de lopration commutative mon_operation call MPI_OP_CREATE (mon_produit,.true., mon_operation ,code) ! Collecte sur le processus 0 du produit global call MPI_REDUCE (a,resultat,n, MPI_COMPLEX , mon_operation ,0, MPI_COMM_WORLD ,code) ! Affichage du rsultat if (rang == 0) then print *,Valeur du produit,resultat end if call MPI_FINALIZE (code) end program ma_reduction
250/326
11 Annexes
24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
! Dfinition du produit terme terme de deux vecteurs de nombres complexes integer function mon_produit(vecteur1,vecteur2,longueur,type_donnee) result(inutilise) implicit none complex,dimension(longueur) :: vecteur1,vecteur2 integer :: longueur,type_donnee,i do i=1,longueur vecteur2(i) = cmplx(real(vecteur1(i))*real(vecteur2(i)) - & aimag(vecteur1(i))*aimag(vecteur2(i)), & real(vecteur1(i))*aimag(vecteur2(i)) + & aimag(vecteur1(i))*real(vecteur2(i))) end do inutilise=0 end function mon_produit
> mpiexec -n 5 ma_reduction Valeur du produit (155.,-2010.), (-1390.,-8195.), (-7215.,-23420.), (-22000.,-54765.)
251/326
11 Annexes
11.2 Types de donnes drivs
11 Annexes
11.2 Types de donnes drivs 11.2.1 Distribution dun tableau sur plusieurs processus
Le sous-programme MPI_TYPE_CREATE_DARRAY() permet de gnrer un tableau sur un ensemble de processus suivant une distribution par blocs ou cyclique.
integer,intent(in) :: nb_procs,rang,nb_dims integer,dimension(nb_dims),intent(in) :: profil_tab,mode_distribution integer,dimension(nb_dims),intent(in) :: profil_sous_tab,distribution_procs integer,intent(in) :: ordre,ancien_type integer,intent(out) :: nouveau_type,code call MPI_TYPE_CREATE_DARRAY (nb_procs,rang,nb_dims,profil_tab,mode_distribution, profil_sous_tab,distribution_procs,ordre,ancien_type, nouveau_type,code)
252/326
11 Annexes
nb_dims : rang du tableau nb_procs : nombre total de processus rang : rang de chaque processus prol_tab : prol du tableau distribuer mode_distribution : mode de distribution dans chaque dimension du tableau, soit : 1 MPI_DISTRIBUTE_BLOCK indique une distribution par blocs 2 MPI_DISTRIBUTE_CYCLIC indique une distribution cyclique 3 MPI_DISTRIBUTE_NONE indique quil ny a pas de distribution prol_sous_tab : prol dun bloc distribution_procs : nombre de processus dans chaque dimension
253/326
11 Annexes
Quelques remarques : lordre des processus est le mme que pour les topologies ; pour que lappel au sous-programme soit correct, on doit avoir nb_dims nb_procs = i=1 distribution_procs(i) ; lorsquune dimension i est distribue par blocs, via le paramtre MPI_DISTRIBUTE_BLOCK, la rgle suivante doit tre respecte profil_sous_tab(i) * distribution_procs(i) profil_tab(i) ; lorsquune dimension i nest pas distribue, via le paramtre MPI_DISTRIBUTE_NONE, le nombre de processus choisi dans cette dimension doit valoir 1 (distribution_procs(i) = 1) et le prol du bloc dans cette dimension (profil_sous_tab(i)) est ignor.
254/326
11 Annexes
Distribution par blocs dun tableau suivant 4 processus

nb_procs = 4, distribution_procs(:) = (/ 2,2 /) profil_tab(:) = (/ 4,6 /), profil_sous_tab(:) = (/ 2,3 /) mode_distribution(:)=(/MPI_DISTRIBUTE_BLOCK,MPI_DISTRIBUTE_BLOCK/)
1 0 1 11 11 11 11 0 00 00 00 00 1 11 11 11 11 0 00 00 00 00 11 00 11 00 1 11 0 00 111 000 11 11 00 00 1 11 0 00 111 000 11 11 00 00 1 11 0 00 111 000
1 11 1 11 0 00 0 00 1 11 1 11 0 00 0 00 11 00 1 11 1 11 0 00 0 00 11 00
1 11 0 00 1 11 0 00 1 11 0 00 1 11 0 00 1 11 0 00
11 00 11 00 11 00
11 00
Processus 0 Processus 1
11 11 00 00 Processus 2 11 11 00 00 11 00 11 00 11 00 Processus3 11 11 00 00 11 00 11 00
Figure 69 Dnition du type driv sur chaque processus pour une distribution par blocs
255/326
11 Annexes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program darray_bloc use mpi implicit none integer,parameter :: nb_lignes=4,nb_colonnes=6, & nb_dims=2,etiquette1=1000,etiquette2=1001 integer :: nb_procs,code,rang,i,type_bloc integer,dimension(nb_lignes,nb_colonnes) :: tab integer,dimension(nb_dims) :: profil_tab,mode_distribution, & profil_sous_tab,distribution_procs integer,dimension( MPI_STATUS_SIZE ) :: statut call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation du tableau tab sur chaque processus tab(:,:)=reshape((/(i*(rang+1),i=1,nb_lignes*nb_colonnes)/),(/nb_lignes,nb_colonnes/)) ! Profil du tableau tab profil_tab(:) = shape(tab) ! Mode de distribution mode_distribution(:) = (/ MPI_DISTRIBUTE_BLOCK , MPI_DISTRIBUTE_BLOCK /) ! Profil dun bloc profil_sous_tab(:) = (/ 2,3 /)
256/326
11 Annexes
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
! Nombre de processus dans chaque dimension distribution_procs(:) = (/ 2,2 /) ! Cration du type driv type_bloc call MPI_TYPE_CREATE_DARRAY (nb_procs,rang,nb_dims,profil_tab,mode_distribution, & profil_sous_tab, distribution_procs, MPI_ORDER_FORTRAN , & MPI_INTEGER ,type_bloc,code) call MPI_TYPE_COMMIT (type_bloc,code) select case(rang) case(0) ! Le processus 0 envoie son tableau tab au processus 1 call MPI_SEND (tab,1,type_bloc,1,etiquette1, MPI_COMM_WORLD ,code) case(1) ! Le processus 1 reoit son tableau tab du processeur 0 call MPI_RECV (tab,1,type_bloc,0,etiquette1, MPI_COMM_WORLD ,statut,code) case(2) ! Le processus 2 envoie son tableau tab au processus 3 call MPI_SEND (tab,1,type_bloc,3,etiquette2, MPI_COMM_WORLD ,code) case(3) ! Le processus 3 reoit son tableau tab du processeur 2 call MPI_RECV (tab,1,type_bloc,2,etiquette2, MPI_COMM_WORLD ,statut,code) end select ! Affichage du tableau tab sur chaque processus ....................................... call MPI_TYPE_FREE (type_bloc,code) call MPI_FINALIZE (code) end program darray_bloc
257/326
11 Annexes
> mpiexec -n 4 darray_bloc Tableau tab obtenu sur le 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19, 4, 8, 12, 16, 20, Tableau tab obtenu sur le 3, 15, 27, 39, 51, 6, 18, 30, 42, 54, 9, 21, 33, 45, 57, 12, 24, 36, 48, 60, processus 0 21 22 23 24 processus 2 63 66 69 72 Tableau tab obtenu sur le 2, 10, 18, 1, 5, 4, 12, 20, 2, 6, 6, 14, 22, 30, 38, 8, 16, 24, 32, 40, Tableau tab obtenu sur le 4, 20, 36, 52, 68, 8, 24, 40, 56, 72, 12, 28, 44, 9, 21, 16, 32, 48, 12, 24, processus 1 9 10 46 48 processus 3 84 88 33 36
258/326
11 Annexes
Distribution cyclique dun tableau suivant 4 processus

nb_procs = 4, distribution_procs(:) = (/ 2,2 /) profil_tab(:) = (/ 4,6 /), profil_sous_tab(:) = (/ 1,2 /) mode_distribution(:)=(/MPI_DISTRIBUTE_CYCLIC,MPI_DISTRIBUTE_CYCLIC/)
1 11 0 00 1 11 0 00 1 11 0 00 1 11 0 00
1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 111 000 11 00 1 11 11111 0 00 00000 11 00 1 11 11111 0 00 00000 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0
11 1 00 0 11 1 00 0 11 1 00 0 11 1 00 0
1 0 1 0
11 00 11 00 11 00 1 0 1 0 1 0 11 00 11 00
11 00 11 00
Processus 0 Processus 1 Processus 2 Processus3
11 11 00 00 11 11 11 11 00 00 00 00 11 11 11 11 00 00 00 00
Figure 70 Dnition du type driv sur chaque processus pour une distribution cyclique
259/326
11 Annexes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program darray_cyclique use mpi implicit none integer,parameter :: nb_lignes=4,nb_colonnes=6, & nb_dims=2,etiquette1=1000,etiquette2=1001 integer :: nb_procs,code,rang,i,type_cyclique integer,dimension(nb_lignes,nb_colonnes) :: tab integer,dimension(nb_dims) :: profil_tab,mode_distribution, & profil_sous_tab,distribution_procs integer,dimension( MPI_STATUS_SIZE ) :: statut call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_procs,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) ! Initialisation du tableau tab sur chaque processus tab(:,:)=reshape((/(i*(rang+1),i=1,nb_lignes*nb_colonnes)/),(/nb_lignes,nb_colonnes/)) ! Profil du tableau tab profil_tab(:) = shape(tab) ! Mode de distribution mode_distribution(:) = (/ MPI_DISTRIBUTE_CYCLIC , MPI_DISTRIBUTE_CYCLIC /) ! Profil dun bloc profil_sous_tab(:) = (/ 1,2 /)
260/326
28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
11 Annexes
! Nombre de processus dans chaque dimension distribution_procs(:) = (/ 2,2 /) ! Cration du type driv type_cyclique call MPI_TYPE_CREATE_DARRAY (nb_procs,rang,nb_dims,profil_tab,mode_distribution, & profil_sous_tab, distribution_procs, MPI_ORDER_FORTRAN , & MPI_INTEGER ,type_cyclique,code) call MPI_TYPE_COMMIT (type_cyclique,code) select case(rang) case(0) ! Le processus 0 envoie son tableau tab au processus 2 call MPI_SEND (tab,1,type_cyclique,2,etiquette1, MPI_COMM_WORLD ,code) case(2) ! Le processus 2 reoit son tableau tab du processus 0 call MPI_RECV (tab,1,type_cyclique,0,etiquette1, MPI_COMM_WORLD ,statut,code) case(1) ! Le processus 1 envoie son tableau tab au processus 3 call MPI_SEND (tab,1,type_cyclique,3,etiquette2, MPI_COMM_WORLD ,code) case(3) ! Le processus 3 reoit son tableau tab du processus 1 call MPI_RECV (tab,1,type_cyclique,1,etiquette2, MPI_COMM_WORLD ,statut,code) end select ! Affichage du tableau tab sur chaque processus ....................................... call MPI_TYPE_FREE (type_cyclique,code) call MPI_FINALIZE (code) end program darray_cyclique
261/326
11 Annexes
> mpiexec -n 4 darray_cyclique Tableau tab obtenu sur le 1, 5, 9, 13, 17, 2, 6, 10, 14, 18, 3, 7, 11, 15, 19, 4, 8, 12, 16, 20, Tableau tab obtenu sur le 3, 15, 27, 39, 51, 1, 5, 30, 42, 17, 9, 21, 33, 45, 57, 3, 7, 36, 48, 19, processus 0 21 22 23 24 processus 2 63 21 69 23 Tableau tab obtenu sur le 2, 10, 18, 26, 34, 4, 12, 20, 28, 36, 6, 14, 22, 30, 38, 8, 16, 24, 32, 40, Tableau tab obtenu sur le 4, 20, 36, 52, 68, 8, 24, 18, 26, 72, 12, 28, 44, 60, 76, 16, 32, 22, 30, 80, processus 1 42 44 46 48 processus 3 84 88 92 96
262/326
11 Annexes
Autres exemples
nb_procs = 4, distribution_procs(:) = (/ 2,2 /) profil_tab(:) = (/ 4,3 /), profil_sous_tab(:) = (/ 2,2 /) mode_distribution(:)=(/MPI_DISTRIBUTE_BLOCK,MPI_DISTRIBUTE_BLOCK/)
11 11 00 00 11 11 00 00 11 11 00 00 11 11 00 00
1 0 1 0 1 0 1 0 1 0 1 0
1 0
1 0 1 0 1 0 1 0 111 000 111 000 111 000
Processus 0 Processus 1 Processus 2 Processus3
1 0 1 11 11 0 00 00 1 11 11 0 00 00 11 00 1 0 1 11 0 00 1 0 1 11 0 00 1 0 1 11 0 00
Figure 71 Dnition du type driv sur chaque processus
263/326
11 Annexes
nb_procs = 3, distribution_procs(:) = (/ 3,1 /) profil_tab(:) = (/ 5,5 /), profil_sous_tab(:) = (/ 1,5 /) mode_distribution(:)=(/MPI_DISTRIBUTE_CYCLIC,MPI_DISTRIBUTE_NONE/)
1 11 1100 1 0 00 00 11 0
1 11 11 0 00 00 1 11 11 0 00 00 1 0 1 0 1 0 1 0 1 0 1 0 11 00 11 11 11 11 00 00 00 00 11 11 11 11 00 00 00 00
11 00
11 00 11 00 11 00 11 00 11 00
Processus 0 Processus 1 Processus 2
1 0 1 0 1 0 Figure
1 11 1 1 1 0 00 0 0 0
11 11 00 00 1 0 11 11 00 00 1 0 11 11 00 00 1 0 72 Dnition du
1 0 1 0 1 0 type driv sur chaque processus
264/326
11 Annexes
11 Annexes
11.2 Types de donnes drivs 11.2.2 Types drivs numriques
Le langage Fortran 95 introduit deux fonctions intrinsques selected_int_kind() et selected_real_kind() qui permettent de dnir la prcision et/ou ltendue dun nombre entier, rel ou complexe MPI devait donc assurer la portabilit de ces types de donnes en dnissant essentiellement les sous-programmes suivants : MPI_TYPE_CREATE_F90_INTEGER(), MPI_TYPE_CREATE_F90_REAL() et MPI_TYPE_CREATE_F90_COMPLEX() Ces sous-programmes renvoient des types drivs MPI
265/326
11 Annexes
Rappels (extrait du cours Fortran 95 de lIDRIS)

La fonction intrinsque selected_int_kind(e) reoit en argument un nombre entier e positif et retourne une valeur qui correspond au sous-type permettant de reprsenter les entiers n tels que 10+e < n < 10+e La fonction intrinsque selected_real_kind(p,e) admet deux arguments optionnels positifs p et e (toutefois lun des deux doit obligatoirement tre fourni) indiquant respectivement la prcision (nombre de chires dcimaux signicatifs) et ltendue (la plage des nombres reprsentables en machine) dsires. Elle retourne un entier correspondant au sous-type permettant de reprsenter les rels x tels que 10e < |x| < 10+e . (Fin de lextrait) Exemple : on souhaite reprsenter le nombre rel 12345.1234568 sur p = 8 chires signicatifs avec une tendue par dfaut. Au mieux, ce nombre aurait la valeur x = 12345.123 en machine. (Fin des rappels)
266/326
11 Annexes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
program precision use mpi implicit none integer, parameter integer ! Le sous-type k reprsentera integer, parameter complex( kind=k ), dimension(n)
:: n=101, preci=12 :: rang, mon_complex, code une prcision dau moins 12 chiffres significatifs :: k=selected_real_kind(preci) :: donnee
call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD , rang, code) ! Construction du type MPI mon_complex associ la prcision demande call MPI_TYPE_CREATE_F90_COMPLEX (preci, MPI_UNDEFINED , mon_complex , code) if (rang == 0) donnee(:) = cmplx(rang, rang, kind=k ) ! Utilisation du type mon_complex call MPI_BCAST (donnee, n, mon_complex, 0, MPI_COMM_WORLD , code) call MPI_FINALIZE (code) end program precision
267/326
11 Annexes
Remarques
En ralit, les types gnrs par ces sous-programmes sont prdnis par MPI Par consquent, ils ne peuvent pas tre librs avec MPI_TYPE_FREE() De plus, il nest pas ncessaire de les valider avec MPI_TYPE_COMMIT()
268/326
11 Annexes
11.3 Optimisations
11 Annexes
11.3 Optimisations
Dans un programme, il arrive parfois que lon soit contraint de boucler un certain nombre de fois sur un envoi et une rception de message o la valeur des donnes manipules change mais pas leurs adresses en mmoire ni leurs nombres ni leurs types. En outre, lappel un sous-programme de communication chaque itration peut tre trs pnalisant la longue do lintrt des communications persistantes. Elles consistent : crer un schma persistant de communication une fois pour toutes ( lextrieur de la boucle) ; activer rellement la requte denvoi ou de rception dans la boucle ; librer, si ncessaire, la requte en n de boucle. envoi standard envoi synchroneous envoi buered rception standard
MPI_SEND_INIT() MPI_SSEND_INIT() MPI_BSEND_INIT() MPI_RECV_INIT()
269/326
11 Annexes
11.3 Optimisations
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38
if (rang == 0) then do k = 1, 1000 call MPI_ISSEND (c,m*m, MPI_REAL ,1,etiquette, MPI_COMM_WORLD ,requete0,code) call sgetrf(na, na, a, na, pivota, code) call MPI_WAIT (requete0,statut,code) c(1:nb,1:nb) = matmul(a(1:nb,1:nb),b) end do elseif (rang == 1) then do k = 1, 1000 call sgetrf(na, na, a, na, pivota, code) call MPI_IRECV (c,m*m, MPI_REAL ,0,etiquette, MPI_COMM_WORLD ,requete1,code) call sgetrf(nb, nb, b, nb, pivotb, code) call MPI_WAIT (requete1,statut,code) a(:,:) = transpose(c(1:na,1:na)) + a(:,:) end do end if > mpiexec -n 2 AOptimiser Temps : 235 secondes
Lutilisation dun schma persistant de communication permet de cacher la latence et de rduire les surcots induits par chaque appel aux sous-programmes de communication dans la boucle. Le gain peut tre important lorsque ce mode de communication est rellement implment.
270/326
11 Annexes
11.3 Optimisations
23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
if (rang == 0) then call MPI_SSEND_INIT (c,m*m, MPI_REAL ,1,etiquette, MPI_COMM_WORLD ,requete0,code) do k = 1, 1000 call MPI_START (requete0,code) call sgetrf(na, na, a, na, pivota, code) call MPI_WAIT (requete0,statut,code) c(1:nb,1:nb) = matmul(a(1:nb,1:nb),b) end do elseif (rang == 1) then call MPI_RECV_INIT (c,m*m, MPI_REAL ,0,etiquette, MPI_COMM_WORLD ,requete1,code) do k = 1, 1000 call sgetrf(na, na, a, na, pivota, code) call MPI_START (requete1,code) call sgetrf(nb, nb, b, nb, pivotb, code) call MPI_WAIT (requete1,statut,code) a(:,:) = transpose(c(1:na,1:na)) + a(:,:) end do end if > mpiexec -n 2 AOptimiser Temps : 235 secondes
Ici, limplmentation MPI et/ou linfrastructure matrielle de la machine ne permettent malheureusement pas une utilisation ecace du mode persistant.
271/326
11 Annexes
11.3 Optimisations
Remarques : Une communication active par MPI_START() sur une requte cre par lun des sous-programmes MPI_xxxx_INIT() est quivalente une communication non bloquante MPI_Ixxxx(). Pour rednir un nouveau schma persistant avec la mme requte, il faut auparavant librer celle associe lancien schma en appelant le sous-programme MPI_REQUEST_FREE(requete,code). Ce sous-programme ne librera la requte requete quune fois que la communication associe sera rellement termine.
272/326
11 Annexes
11.4 Communicateurs
11 Annexes
11.4 Communicateurs 11.4.1 Intra et intercommunicateurs
Les communicateurs que nous avons construits jusqu prsent sont des intracommunicateurs car ils ne permettent pas que des processus appartenant des communicateurs distincts puissent communiquer entre eux. Des processus appartenant des intracommunicateurs distincts ne peuvent communiquer que sil existe un lien de communication entre ces intracommunicateurs. Un intercommunicateur est un communicateur qui permet ltablissement de ce lien de communication. Le sous-programme MPI MPI_INTERCOMM_CREATE() permet de construire des intercommunicateurs. Le couplage des modles ocan/atmosphre illustre bien lutilit des intra et intercommunicateurs...
273/326
11 Annexes
11.4 Communicateurs
11 Annexes
11.4 Communicateurs 11.4.1 Intra et intercommunicateurs
Exemple rcapitulatif sur les intra et intercommunicateurs
MPI_COMM_WORLD IntraComm (ocean) IntraComm (atmosphere) IntraComm (visualisation)
a0 0 d1 3 2 g6
InterComm OceanAtmos...
b0 1 1 e4
2 h7
c0 2
InterComm VisuAtmos...
f1 5
Figure 73 Couplage ocan/atmosphre

274/326
11 Annexes
11.4 Communicateurs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
program OceanAtmosphere use mpi implicit none integer,parameter :: tag1=1111, tag2=2222 integer :: RangMonde, NombreIntraComm, couleur, code, & IntraComm, CommOceanAtmosphere, CommVisuAtmosphere call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,RangMonde,code) ! Construction des 3 IntraCommunicateurs NombreIntraComm = 3 couleur = mod(RangMonde,NombreIntraComm) ! = 0,1,2 call MPI_COMM_SPLIT ( MPI_COMM_WORLD ,couleur,RangMonde,IntraComm,code)
275/326
11 Annexes
11.4 Communicateurs
16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
! Construction des deux InterCommunicateurs et et appel des sous-programmes de calcul select case(couleur) case(0) ! InterCommunicateur OceanAtmosphere pour que le groupe 0 communique ! avec le groupe 1 call MPI_INTERCOMM_CREATE (IntraComm,0, MPI_COMM_WORLD ,1,tag1,CommOceanAtmosphere, & code) call ocean(IntraComm,CommOceanAtmosphere) case(1) ! InterCommunicateur OceanAtmosphere pour que le groupe 1 communique ! avec le groupe 0 call MPI_INTERCOMM_CREATE (IntraComm,0, MPI_COMM_WORLD ,0,tag1,CommOceanAtmosphere, & code) ! InterCommunicateur CommVisuAtmosphere pour que le groupe 1 communique ! avec le groupe 2 call MPI_INTERCOMM_CREATE (IntraComm,0, MPI_COMM_WORLD ,2,tag2,CommVisuAtmosphere,code) call atmosphere(IntraComm,CommOceanAtmosphere,CommVisuAtmosphere) case(2) ! InterCommunicateur CommVisuAtmosphere pour que le groupe 2 communique ! avec le groupe 1 call MPI_INTERCOMM_CREATE (IntraComm,0, MPI_COMM_WORLD ,1,tag2,CommVisuAtmosphere,code) call visualisation(IntraComm,CommVisuAtmosphere) end select end program OceanAtmosphere
276/326
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
11 Annexes
11.4 Communicateurs
subroutine ocean(IntraComm,CommOceanAtmosphere) use mpi implicit none integer,parameter real,dimension(n) integer integer,dimension( MPI_STATUS_SIZE ) integer,intrinsic :: :: :: :: :: n=1024,tag1=3333 a,b,c rang,code,germe(1),IntraComm,CommOceanAtmosphere statut irtc
! Les processus 0, 3, 6 ddis au modle ocanographique effectuent un calcul germe(1)=irtc() call random_seed(put=germe) call random_number(a) call random_number(b) call random_number(c) a(:) = b(:) * c(:) ! Les processus impliqus dans le modle ocan effectuent une opration collective call MPI_ALLREDUCE (a,c,n, MPI_REAL , MPI_SUM ,IntraComm,code) ! Rang du processus dans IntraComm call MPI_COMM_RANK (IntraComm,rang,code) ! change de messages avec les processus associs au modle atmosphrique call MPI_SENDRECV_REPLACE (c,n, MPI_REAL ,rang,tag1,rang,tag1, & CommOceanAtmosphere,statut,code) ! Le modle ocanographique tient compte des valeurs atmosphriques a(:) = b(:) * c(:) end subroutine ocean
277/326
11 Annexes
11.4 Communicateurs
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
subroutine atmosphere(IntraComm,CommOceanAtmosphere,CommVisuAtmosphere) use mpi implicit none integer,parameter real,dimension(n) integer :: n=1024,tag1=3333,tag2=4444 :: a,b,c :: rang,code,germe(1),IntraComm, & CommOceanAtmosphere,CommVisuAtmosphere integer,dimension( MPI_STATUS_SIZE ) :: statut integer,intrinsic :: irtc
! Les processus 1, 4, 7 ddis au modle atmosphrique effectuent un calcul germe(1)=irtc() call random_seed(put=germe) call random_number(a) call random_number(b) call random_number(c) a(:) = b(:) + c(:)
278/326
11 Annexes
11.4 Communicateurs
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
! Les processus ddis au modle atmosphre effectuent une opration collective call MPI_ALLREDUCE (a,c,n, MPI_REAL , MPI_MAX ,IntraComm,code) ! Rang du processus dans IntraComm call MPI_COMM_RANK (IntraComm,rang,code) ! change de messages avec les processus ddis au modle ocanographique call MPI_SENDRECV_REPLACE (c,n, MPI_REAL ,rang,tag1,rang,tag1, & CommOceanAtmosphere,statut,code) ! Le modle atmosphre tient compte des valeurs ocanographiques a(:) = b(:) * c(:) ! Envoi des rsultats aux processus ddis la visualisation if (rang == 0 .or. rang == 1) then call MPI_SSEND (a,n, MPI_REAL ,rang,tag2,CommVisuAtmosphere,code) end if end subroutine atmosphere
279/326
11 Annexes
11.4 Communicateurs
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131
subroutine visualisation(IntraComm,CommVisuAtmosphere) use mpi implicit none integer,parameter real,dimension(n) integer integer,dimension( MPI_STATUS_SIZE ) :: :: :: :: n=1024,tag2=4444 a,b,c rang,code,IntraComm,CommVisuAtmosphere statut
! Les processus 2 et 5 sont chargs de la visualisation call MPI_COMM_RANK (IntraComm,rang,code) ! Rception des valeurs du champ tracer call MPI_RECV (a,n, MPI_REAL ,rang,tag2,CommVisuAtmosphere,statut,code) print*,Moi, processus ,rang, je trace mon champ A : ,a(:) end subroutine visualisation
280/326
11 Annexes
11.4 Communicateurs
11 Annexes
11.4 Communicateurs 11.4.2 Graphe de processus
Il arrive cependant que dans certaines applications (gomtries complexes), la dcomposition de domaine ne soit plus une grille rgulire mais un graphe dans lequel un sous-domaine peut avoir un ou plusieurs voisins quelconques. Le sous-programme MPI_DIST_GRAPH_CREATE() permet alors de dnir une topologie de type graphe.
1 2 3 4 5 6 7 8 9
integer, integer, integer, logical,
intent(in) dimension(:),intent(in) dimension(nb_voisins_max),intent(in) intent(in)
:: :: :: ::
comm_ancien,n,info source,degres liste_voisins,poids reorganisation
integer, intent(out)
:: comm_nouveau, code
call MPI_DIST_GRAPH_CREATE (comm_ancien,n,sources,degres,liste_voisins,poids,& info,reorganisation, comm_nouveau,code)
281/326
11 Annexes
11.4 Communicateurs
Les tableaux dentiers poids et liste_voisins permettent de dnir le poids attribu et la liste des voisins ceci pour chacun des nuds.
3 0 1 5 2 4
Numro de processus 0 1 2 3 4 5
liste_voisins 1 0,5,2,3 1,3,4 1,2,4 3,2,5 1,4
Figure 74 Graphe de processus

poids (:) = 1;liste_voisins = (/ 1, 0,5,2,3, 1,3,4, 1,2,4, 3,2,5, 1,4 /)
282/326
11 Annexes
11.4 Communicateurs
Deux autres fonctions sont utiles pour connatre : le nombre de voisins pour un processus donn :
integer, integer, integer, integer, intent(in) intent(in) intent(out) intent(out) :: :: :: :: comm_nouveau rang nb_voisins code
call MPI_GRAPH_NEIGHBORS_COUNT (comm_nouveau,rang,nb_voisins,code)
la liste des voisins pour un processus donn :

integer, integer, integer, integer, integer, intent(in) :: intent(in) :: intent(in) :: dimension(nb_voisins_max), intent(out) :: intent(out) :: comm_nouveau rang nb_voisins voisins code
call MPI_GRAPH_NEIGHBORS (comm_nouveau,rang,nb_voisins,voisins,code)
283/326
11 Annexes
11.4 Communicateurs
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
program graphe use mpi implicit none integer integer, integer, integer, integer, real :: rang,rang_monde,code,nb_processus,comm_graphe,& n, nb_voisins,i,iteration=0 etiquette=100 liste_voisins,poids voisins,sources,degres statut propagation, & ! Propagation du feu ! depuis les voisins feu=0., & ! Valeur du feu bois=1., & ! Rien na encore brl arret=1. ! Tout a brl si arret <= 0.01
parameter :: dimension(16) :: allocatable,dimension(:) :: dimension( MPI_STATUS_SIZE ):: ::
call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD ,nb_processus,code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang_monde,code) allocate(sources(0:nb_processus-1),degres(0:nb_processus-1)) if (rang_monde==0) then n=nb_processus else n=0 end if
284/326
11 Annexes
11.4 Communicateurs
29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49
do i=0,nb_processus-1 sources(i)=i end do degres(:)= (/ 1,4,3,3,3,2 /) liste_voisins(:)= (/ 1,0,5,2,3,1,3,4,1,2,4,3,2,5,1,4 /) poids(:) = 1 call MPI_DIST_GRAPH_CREATE ( MPI_COMM_WORLD ,n,sources,degres,liste_voisins,poids, & MPI_INFO_NULL ,.false.,comm_graphe,code) call MPI_COMM_RANK (comm_graphe,rang,code) if (rang == 2) feu=1. ! Le feu se dclare arbitrairement sur la parcelle 2
call MPI_GRAPH_NEIGHBORS_COUNT (comm_graphe,rang,nb_voisins,code) allocate(voisins(nb_voisins)) ! Allocation du tableau voisins call MPI_GRAPH_NEIGHBORS (comm_graphe,rang,nb_voisins,voisins,code)
285/326
11 Annexes
11.4 Communicateurs
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
do while (arret > 0.01)
! On arrte ds quil ny a plus rien brler
do i=1,nb_voisins ! On propage le feu aux voisins call MPI_SENDRECV (minval((/1.,feu/)),1, MPI_REAL ,voisins(i),etiquette, & propagation, 1, MPI_REAL ,voisins(i),etiquette, & comm_graphe,statut,code) ! Le feu se dveloppe en local sous linfluence des voisins feu=1.2*feu + 0.2*propagation*bois bois=bois/(1.+feu) ! On calcule ce qui reste de bois sur la parcelle end do call MPI_ALLREDUCE (bois,arret,1, MPI_REAL , MPI_SUM ,comm_graphe,code) iteration=iteration+1 print ("Itration ",i2," parcelle ",i2," bois=",f5.3),iteration,rang,bois call MPI_BARRIER (comm_graphe,code) if (rang == 0) print ("--") end do deallocate(voisins) call MPI_FINALIZE (code) end program graphe
286/326
11 Annexes
11.4 Communicateurs
> mpiexec -n 6 graphe Iteration 1 parcelle 0 bois=1.000 Iteration 1 parcelle 3 bois=0.602 Iteration 1 parcelle 5 bois=0.953 Iteration 1 parcelle 4 bois=0.589 Iteration 1 parcelle 1 bois=0.672 Iteration 1 parcelle 2 bois=0.068 -................................... Iteration 10 parcelle 0 bois=0.008 Iteration 10 parcelle 1 bois=0.000 Iteration 10 parcelle 3 bois=0.000 Iteration 10 parcelle 5 bois=0.000 Iteration 10 parcelle 2 bois=0.000 Iteration 10 parcelle 4 bois=0.000 --
287/326
11 Annexes
11.4 Communicateurs
2 1 3 4 1
2 3 4 1
2 3 4
(a) Itration 0
(b) Itration 1
(c) Itration 2
2 1 3 4 1
2 3 4 1
2 3 4
(d) Itration 3
(e) Itration 4
(f) Itration 10
Figure 75 Dnition dune topologie quelconque via un graphe Exemple de la propagation dun feu de fort
288/326
11 Annexes
11.5 Gestion de processus
11 Annexes
11.5 Gestion de processus 11.5.1 Introduction
La gestion dynamique des processus a t lun des apports majeurs de MPI-2 Cest la possibilit de crer (et dans certaines conditions de supprimer) des processus durant lexcution de lapplication Le dmarrage dune application reste dpendant de lenvironnement dexcution qui sera dni par le constructeur
289/326
11 Annexes
Lactivation dun ou plusieurs processus peut se faire selon deux modes bien distincts : Le mode matre-ouvriers : lun au moins des processus dune application active un ou plusieurs autres processus. Les processus ouvriers ainsi activs dynamiquement excutent un code soit identique (modle SPMD) soit dirent (modle MPMD) du processus matre qui les a gnr. Le mode client-serveur : un ou plusieurs processus dune application serveur (lance au pralable) sont en attente de connexion dun ou plusieurs processus dune application cliente (lance plus tard). Une fois la connexion eectue, un lien de communication est tabli entre les processus des deux applications.
290/326
11 Annexes
11 Annexes
11.5 Gestion de processus 11.5.2 Mode matre-ouvriers
Activation dun programme unique

Dans lexemple que nous allons dcrire, nous suivons le modle MPMD o un programme parallle matre active, avec le sous-programme MPI_COMM_SPAWN(), plusieurs copies dun programme parallle unique ouvriers . Ce sous-programme est collectif. Il est bloquant pour tous les processus appartenant au communicateur incluant le processus matre , celui qui active rellement les processus ouvriers. Nous aurons galement besoin du sous-programme MPI_INTERCOMM_MERGE() qui permet de fusionner dans un mme intracommunicateur deux communicateurs lis par un intercommunicateur donn.
291/326
11 Annexes
> mpiexec -n 3 -max_np 7 maitre
MPI_COMM_WORLD (maitre)
a0 c a0 c a
0 2 2
b1
inter_comm
MPI_COMM_WORLD (ouvriers)
CALL MPI_INIT(code)
b1
e1 d
0
f2 g
5 3
CALL MPI_COMM_SPAWN(...)
intra_comm
b1 c2
e4 d
3
CALL MPI_INTERCOMM_MERGE(...)
g6
Figure 76 Utilisation de MPI_COMM_SPAWN()
292/326
11 Annexes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
program maitre use mpi implicit none integer :: nb_procs_maitres,nb_procs_ouvriers=4,nb_procs,rang,code integer :: inter_comm,intra_comm,rang_maitre=1 logical :: drapeau=.false. call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD , nb_procs_maitres , code) ! Activation des processus ouvriers call MPI_COMM_SPAWN ("ouvriers", MPI_ARGV_NULL , nb_procs_ouvriers, MPI_INFO_NULL , & rang_maitre, MPI_COMM_WORLD , inter_comm , MPI_ERRCODES_IGNORE ,code) ! Fusion des communicateurs associs inter_comm. Dans intra_comm, les rangs ! des processus seront ordonns selon la valeur de largument drapeau call MPI_INTERCOMM_MERGE (inter_comm, drapeau, intra_comm , code) call MPI_COMM_SIZE (intra_comm, nb_procs , code) call MPI_COMM_RANK (intra_comm, rang , code) print *,"maitre de rang ", rang, "; intra_comm de taille ",nb_procs, & "; mon MPI_COMM_WORLD de taille ", nb_procs_maitres call MPI_FINALIZE (code) end program maitre
293/326
11 Annexes
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
program ouvriers use mpi implicit none integer :: nb_procs_ouvriers, nb_procs, rang, code integer :: inter_comm, intra_comm logical :: drapeau=.true. call MPI_INIT (code) call MPI_COMM_SIZE ( MPI_COMM_WORLD , nb_procs_ouvriers , code) ! Ai-je un processus matre ? call MPI_COMM_GET_PARENT ( inter_comm , code) if (inter_comm == MPI_COMM_NULL ) then print *,Pas de processus matre call MPI_FINALIZE (code) stop end if ! Fusion des communicateurs associs inter_comm. Dans intra_comm, les rangs ! des processus seront ordonns selon la valeur de largument drapeau call MPI_INTERCOMM_MERGE (inter_comm, drapeau, intra_comm , code) call MPI_COMM_SIZE (intra_comm, nb_procs , code) call MPI_COMM_RANK (intra_comm, rang , code) print *,"ouvrier de rang ", rang, "; intra_comm de taille ",nb_procs, & "; mon MPI_COMM_WORLD de taille : ", nb_procs_ouvriers call MPI_FINALIZE (code) end program ouvriers
294/326
11 Annexes
> mpiexec -n 3 -max_np 7 maitre maitre de rang 0 ; intra_comm maitre de rang 2 ; intra_comm ouvrier de rang 5 ; intra_comm ouvrier de rang 4 ; intra_comm ouvrier de rang 6 ; intra_comm maitre de rang 1 ; intra_comm ouvrier de rang 3 ; intra_comm
de de de de de de de
taille taille taille taille taille taille taille
7 7 7 7 7 7 7
; ; ; ; ; ; ;
mon mon mon mon mon mon mon
MPI_COMM_WORLD MPI_COMM_WORLD MPI_COMM_WORLD MPI_COMM_WORLD MPI_COMM_WORLD MPI_COMM_WORLD MPI_COMM_WORLD
de de de de de de de
taille taille taille taille taille taille taille
3 3 4 4 4 3 4
Noter que, dans ce cas, la fusion des communicateurs ne modie pas le rang des processus associs au programme matre.
295/326
11 Annexes
Signication de MPI_COMM_SELF
MPI_COMM_SELF est un communicateur prdni par MPI. lappel de MPI_COMM_SPAWN(), ce communicateur inclut un et un seul processus. Ce processus est celui qui active les processus ouvriers. MPI_COMM_SELF nincluera donc que le processus matre.
... ! Activation des processus ouvriers rang_maitre=1 nb_procs_ouvriers=4 call MPI_COMM_SPAWN ("ouvriers", MPI_ARGV_NULL , nb_procs_ouvriers, MPI_INFO_NULL , & rang_maitre, MPI_COMM_SELF , inter_comm , MPI_ERRCODES_IGNORE ,code) ...
296/326
11 Annexes
a0 c2
b1
inter_comm
MPI_COMM_WORLD (ouvriers)
CALL MPI_INIT(code)
b1 0 c2
e1 d0
MPI_COMM_SELF
f2 g
3
CALL MPI_COMM_SPAWN(...)
intra_comm
b0
e2
d1 f
3
g4
Figure 77 Signication de MPI_COMM_SELF
297/326
11 Annexes
Signication de MPI_INFO_NULL
Ce paramtre est aussi utilis dans dautres contextes, notamment dans les entres/sorties parallles avec MPI-IO que lon verra dans le chapitre 9 Sil est spci lappel du sous-programme MPI_COMM_SPAWN() (ou bien MPI_COMM_SPAWN_MULTIPLE() que lon introduira par la suite), il indique le mode de recherche par dfaut des programmes ouvriers . Les constructeurs peuvent toutefois dnir dautres valeurs plus spciques leur environnement. Le mode de recherche par dfaut voudra dire gnralement que les programmes ouvriers se trouvent sur la machine locale et dans le mme rpertoire que le programme matre Pour modier ces valeurs par dfaut, il faut utiliser les sous-programmes MPI_INFO_CREATE(), MPI_INFO_SET() et MPI_INFO_FREE()
298/326
11 Annexes
integer :: rang_maitre=1, nb_procs_ouvriers=4, info_spawn ... ! Redfinition du mode de recherche des programmes ouvriers call MPI_INFO_CREATE ( info_spawn , code) call MPI_INFO_SET ( info_spawn , "host", "aleph.idris.fr", code) call MPI_INFO_SET ( info_spawn , "wdir", "/workdir/idris/rech/rgrp001", code) ! Activation des processus ouvriers call MPI_COMM_SPAWN ("ouvriers", MPI_ARGV_NULL , nb_procs_ouvriers, info_spawn , & rang_maitre, MPI_COMM_SELF , inter_comm, MPI_ERRCODES_IGNORE ,code) ! Libration du paramtre info_spawn call MPI_INFO_FREE ( info_spawn , code) ...
299/326
11 Annexes
Signication de MPI_UNIVERSE_SIZE
MPI_UNIVERSE_SIZE est une clef MPI dont on peut connatre la valeur grce au sous-programme MPI_COMM_GET_ATTR(). Si la version de MPI utilise limplmente, il est associ au nombre total de processus quun utilisateur peut activer.
... ! Nombre de processus maximum que lon peut activer call MPI_COMM_GET_ATTR ( MPI_COMM_WORLD , MPI_UNIVERSE_SIZE , nb_procs_total , logique ,code) if (logique) then ! Ici nb_procs_ouvriers vaudra 7-3=4 nb_procs_ouvriers = nb_procs_total - nb_procs_maitres else print *,"MPI_UNIVERSE_SIZE nest pas support" nb_procs_ouvriers = 4 end if ! Activation des processus ouvriers rang_maitre=1 call MPI_COMM_SPAWN ("ouvriers", MPI_ARGV_NULL , nb_procs_ouvriers, MPI_INFO_NULL , & rang_maitre, MPI_COMM_WORLD , inter_comm , MPI_ERRCODES_IGNORE ,code) ...
300/326
11 Annexes
Activation de programmes multiples

Dans ce second exemple, nous suivons le modle MPMD o un programme parallle matre active avec le sous-programme MPI_COMM_SPAWN_MULTIPLE() plusieurs copies de 4 programmes parallles dirents ouvriers1 , ..., ouvriers4 . Ce sous-programme est collectif. Il est bloquant pour tous les processus appartenant au communicateur incluant le processus matre , celui qui active rellement lensemble des processus ouvriers. Dans ce cas, pour des raisons de performance, il est conseill de ne pas appeler le sous-programme MPI_COMM_SPAWN() autant de fois quil y a de programmes ouvriers mais plutt dappeler le sous-programme MPI_COMM_SPAWN_MULTIPLE() une seule fois pour activer lensemble des programmes ouvriers.
301/326
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
11 Annexes
program maitre use mpi implicit none integer :: inter_comm,intra_comm, rang_maitre=1,code logical :: drapeau=.false. ! On souhaite activer 4 programmes ouvriers integer, parameter :: nb_prog_ouvriers=4 character(len=12), dimension(nb_prog_ouvriers) :: ouvriers integer, dimension(nb_prog_ouvriers) :: nb_procs_ouvriers=(/3,2,1,2/),infos ! Un code derreur par programme et par processus activ integer, dimension(8) :: codes_erreurs ! 8=3+2+1+2 call MPI_INIT (code) ouvriers(:) = (/"ouvriers1", "ouvriers2", "ouvriers3", "ouvriers4"/) infos(:) = MPI_INFO_NULL codes_erreurs(:) = MPI_ERRCODES_IGNORE ! Activation de plusieurs programmes ouvriers call MPI_COMM_SPAWN_MULTIPLE (nb_prog_ouvriers,ouvriers, MPI_ARGVS_NULL , & nb_procs_ouvriers,infos,rang_maitre, MPI_COMM_WORLD , & inter_comm ,codes_erreurs,code) ! Fusion des communicateurs associs inter_comm. Dans intra_comm, les rangs ! des processus seront ordonns selon la valeur de largument drapeau call MPI_INTERCOMM_MERGE (inter_comm, drapeau, intra_comm , code) ! Inclure ici le code correspondant aux calculs faire par les processus matres ... call MPI_FINALIZE (code) end program maitre
302/326
11 Annexes
a0 c2
b1
MPI_COMM_WORLD (Ouvriers)
CALL MPI_INIT(code)
ouvriers1
e1 d 0 f 2
ouvriers2
g3 h4 b1 c
2
i5 j 6 k7
CALL MPI_COMM_SPAWN_MULTIPLE() ouvriers3
inter_comm intra_comm
ouvriers4
a0 b 1 c2 e4
f5 d
3
g6 h7
i8 j
9
k10
Figure 78 Utilisation de MPI_COMM_SPAWN_MULTIPLE()
303/326
11 Annexes
Remarques
MPI_COMM_SPAWN() et MPI_COMM_SPAWN_MULTIPLE() sont des sous-programmes collectifs qui doivent tre appels par lensemble des processus du communicateur incluant le processus matre Attention lordre des processus dans le nouvel intracommunicateur issu de la fusion des deux communicateurs associs lintercommunicateur renvoy par MPI_COMM_SPAWN() ou MPI_COMM_SPAWN_MULTIPLE() Contrairement ce que lon aurait obtenu si MPI_COMM_SPAWN() avait t utilis pour activer plusieurs programmes, MPI_COMM_SPAWN_MULTIPLE() inclut tous les processus de tous les programmes ouvriers dans le mme communicateur MPI_COMM_WORLD Tous les arguments de MPI_COMM_SPAWN_MULTIPLE() ont la mme signication que ceux de MPI_COMM_SPAWN() Dans MPI_COMM_SPAWN_MULTIPLE(), certains arguments sont toutefois transforms en tableaux du fait de la multiplicit des programmes ouvriers activer Avec MPI_COMM_SPAWN_MULTIPLE(), les variables MPI_INFO_NULL, MPI_COMM_SELF et MPI_UNIVERSE_SIZE conservent les mmes caractristiques que celles que lon a vues avec MPI_COMM_SPAWN()
304/326
11 Annexes
11 Annexes
11.5 Gestion de processus 11.5.3 Mode client-serveur
Deux programmes indpendants peuvent tablir entre eux un lien de communication alors que leurs processus ne partagent aucun communicateur. Cette situation peut se produire : lorsque deux parties dune application dmarrent indpendamment lune de lautre et veulent, un moment de leur vie, changer des informations ; lorsquune application parallle serveur accepte des connexions de plusieurs applications parallles clientes ; lorsquun outil de visualisation veut sattacher un processus en cours dexcution pour extraire certaines informations. Lenvironnement (machines, systmes dexploitation, etc.) dans lequel sexcute lapplication serveur peut tre dirent de celui des applications clientes.
305/326
11 Annexes
Machine A
MPI_COMM_WORLD (serveur)
Machine B
MPI_COMM_WORLD (client)
linstant t
Machine A
MPI_COMM_WORLD (serveur)
Machine B
MPI_COMM_WORLD (client)
linstant t + t
lien de communication (intercommunicateur)
Figure 79 Schma dapplication client-serveur
306/326
11 Annexes
Processus serveur
Pour accepter un lien de communication avec le processus client, le processus serveur passe par trois tapes : ouverture dun port de communication : MPI_OPEN_PORT() ; publication dun nom arbitraire de connexion : MPI_PUBLISH_NAME() ; acceptation de la connexion : MPI_COMM_ACCEPT() Pour fermer ce lien de communication, de mme : fermeture de la connexion avec le processus client : MPI_COMM_DISCONNECT() ; retrait du nom de connexion : MPI_UNPUBLISH_NAME() ; fermeture du port de communication : MPI_CLOSE_PORT().
307/326
11 Annexes
Le processus serveur excutera la squence de code suivante :

... integer :: rang_serveur=2, inter_comm, code character(len= MPI_MAX_PORT_NAME ) :: nom_de_port ... if ( rang == rang_serveur ) then call MPI_OPEN_PORT ( MPI_INFO_NULL , nom_de_port ,code) call MPI_PUBLISH_NAME ("nom_de_connexion", MPI_INFO_NULL , nom_de_port, code) end if call MPI_COMM_ACCEPT (nom_de_port, MPI_INFO_NULL , rang_serveur, MPI_COMM_WORLD , & inter_comm, code) ! Inclure ici le code du serveur ... call MPI_COMM_DISCONNECT (inter_comm, code) if ( rang == rang_serveur ) then call MPI_UNPUBLISH_NAME ("nom_de_connexion", MPI_INFO_NULL , nom_de_port, code) call MPI_CLOSE_PORT (nom_de_port, code) end if ...
308/326
11 Annexes
Processus client
Le client doit tout dabord se connecter au port de communication du serveur, ce qui se ralise en deux tapes : recherche du port de communication associ au nom publi par le serveur : MPI_LOOKUP_NAME() ; connexion avec le serveur : MPI_COMM_CONNECT(). Ensuite, pour interrompre la connexion avec le serveur, le client devra obligatoirement appeler le sous-programme MPI_COMM_DISCONNECT().
... integer :: rang_client=1, inter_comm, code character(len= MPI_MAX_PORT_NAME ) :: nom_de_port ... if ( rang == rang_client ) & call MPI_LOOKUP_NAME ("nom_de_connexion", MPI_INFO_NULL , nom_de_port , code) call MPI_COMM_CONNECT (nom_de_port, MPI_INFO_NULL , rang_client, MPI_COMM_WORLD , & inter_comm, code) ! Inclure ici le code du client ... call MPI_COMM_DISCONNECT (inter_comm, code) ...
309/326
11 Annexes
Remarques
MPI_COMM_CONNECT(), MPI_COMM_ACCEPT() et MPI_COMM_DISCONNECT() sont des sous-programmes collectifs (donc bloquants), bien quun seul processus participe la connexion de part et dautre MPI_CLOSE_PORT() libre le port de communication (le serveur devient injoignable) alors que MPI_COMM_DISCONNECT() ne fait que rompre le lien de communication entre deux intracommunicateurs pour quventuellement un autre lien puisse stablir sur le mme port MPI_COMM_SELF peut tre utilis la place de MPI_COMM_WORLD dans les appels aux sous-programmes MPI_COMM_ACCEPT() et MPI_COMM_CONNECT(). Dans ce cas, la connexion stablit entre deux intracommunicateurs ne contenant chacun que le processus appelant lun ou lautre sous-programme. Sans le mcanisme des sous-programmes MPI_PUBLISH_NAME() et MPI_LOOKUP_NAME(), on aurait t amen prciser explicitement au processus client par un moyen quelconque (sur lentre standard ou par lintermdiaire dun chier), le nom du port de communication renvoy par le processus serveur
310/326
11 Annexes
11 Annexes
11.5 Gestion de processus 11.5.4 Suppression de processus
Sil est possible de crer des processus, on devrait pouvoir les supprimer Or, il nexiste pas de sous-programme MPI spcique pour supprimer un processus gnr en cours dexcution En revanche, il est toujours possible de diriger (ex. par change de messages) lexcution de ce processus vers une terminaison normale Un processus MPI se termine normalement lappel du sous-programme MPI_FINALIZE() et la n de lexcution du programme principal Il existe trois contraintes : le nouveau communicateur MPI_COMM_WORLD gnr ne doit contenir que le processus dont on veut se dbarrasser ; il ne doit exister aucun lien de communication (intercommunicateur) entre le communicateur MPI_COMM_WORLD contenant le processus pre (ou serveur) et celui contenant le processus ls (ou client) supprimer ; tout intracommunicateur contenant le processus dtruire doit tre invalid avant la terminaison du processus ls (ou client).
311/326
11 Annexes
Il faut galement noter que il nest pas possible de se dbarrasser dun seul processus ouvrier si son communicateur MPI_COMM_WORLD inclut dautres processus ; dans ce cas, la terminaison ne seectue proprement que si tous les processus de MPI_COMM_WORLD appellent le sous-programme MPI_FINALIZE() et atteignent normalement la n de lexcution.
312/326
11 Annexes
11 Annexes
11.5 Gestion de processus 11.5.5 Complments
Dans certains cas, comme celui de MPI_UNIVERSE_SIZE, les implmentations ont des clefs spciques dont la valeur peut tre connue grce au sous-programme :
integer, intent(in) :: comm, clef integer(kind= MPI_ADDRESS_KIND ), intent(out) :: valeur logical, intent(out) :: logique integer, intent(out) :: code call MPI_COMM_GET_ATTR (comm, clef, valeur, logique, code)
On peut cependant modier la valeur associe une clef dnie au pralable, en utilisant le sous-programme :
integer, intent(inout) :: integer, intent(in) :: integer(kind= MPI_ADDRESS_KIND ), intent(in) :: integer, intent(out) :: comm clef valeur code
call MPI_COMM_SET_ATTR (comm, clef, valeur, code)
Plus gnralement, on peut dnir un couple (clef, valeur) spcique son application par lintermdiaire des sous-programmes MPI_COMM_CREATE_KEYVAL() et MPI_COMM_SET_ATTR()
313/326
11 Annexes
11.6 MPI-IO
11 Annexes
11.6 MPI-IO
Il est possible dobtenir certaines informations spciques sur un chier.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
program open02 use mpi implicit none integer :: rang,descripteur,attribut,longueur,code character(len=80) :: libelle logical :: defini call MPI_INIT (code) call MPI_COMM_RANK ( MPI_COMM_WORLD ,rang,code) call MPI_FILE_OPEN ( MPI_COMM_WORLD ,"fichier.txt", MPI_MODE_RDWR + MPI_MODE_CREATE , & MPI_INFO_NULL ,descripteur,code) call MPI_FILE_GET_INFO (descripteur,attribut,code) call MPI_INFO_GET_VALUELEN (attribut,"cb_nodes",longueur,defini,code) if (defini) then call MPI_INFO_GET (attribut,"cb_nodes",longueur,libelle,defini,code) if (rang==0) print *,"Fichier fichier.txt sur ",libelle(1:longueur)," processus" end if call MPI_INFO_FREE (attribut,code) call MPI_FILE_CLOSE (descripteur,code) call MPI_FINALIZE (code) end program open02 > mpiexec -n 2 open02 Fichier fichier.txt sur 2 processus
314/326
12 Index
1 Introduction 2 Environnement 3 Communications point point 4 Communications collectives 5 Copies de mmoire mmoire 6 Types de donnes drivs 7 Optimisations 8 Communicateurs 9 MPI-IO 10 Conclusion 11 Annexes 12 Index 12.1 Index des concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315 12.2 Index des constantes MPI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 317 12.3 Index des sous-programmes MPI. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .320
315/326
12 Index
12.1 Index des concepts
barrire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46 bloquantes (communications) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28, 34, 39 non-bloquantes (communications) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 collectives (communications) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14 communicateur . . . . . . . . . . . . . . . . . . . . . . . . . . 14, 23, 24, 28, 44, 149, 150, 152, 154157, 160, 175 intercommunicateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 intracommunicateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14, 131, 149, 150, 154, 268, 271, 272 contexte de communication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28, 154 envoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 tiquette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28, 44 groupe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61, 154, 155 intercommunicateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 intracommunicateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272 message . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10, 1214, 152 MPMD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
316/326
12 Index
12.1 Index des concepts
performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155 persistantes (communications) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268, 271 portabilit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110, 128 processeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .9 processus . . 1014, 23, 24, 27, 28, 32, 39, 40, 44, 61, 68, 128, 149, 152, 154156, 159, 160, 165, 166, 168, 170, 272 rang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24, 28, 32, 155, 156, 166, 168, 170 rception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268 requte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268, 271 SPMD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 topologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14, 128, 159, 160, 165, 166, 168, 170, 175, 177 types derivs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
317/326
12 Index
12.2 Index des constantes MPI
mpi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 mpi.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 MPI_ADDRESS_KIND . . . . . . . . . . . . . . . 77, 80, 87, 94, 102, 112, 122, 123, 125, 126, 226, 312 MPI_ANY_SOURCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32, 36 MPI_ANY_TAG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32, 36 MPI_ARGV_NULL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292, 295, 298, 299 MPI_ARGVS_NULL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301 MPI_BSEND_OVERHEAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 MPI_BYTE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224 MPI_CHARACTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 MPI_COMM_NULL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155, 293 MPI_COMM_SELF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295, 296, 298, 303, 309 MPI_COMM_WORLD 2325, 29, 3336, 39, 41, 46, 48, 50, 52, 54, 56, 57, 59, 64, 66, 77, 87, 104109, 115, 119, 120, 123, 124, 126, 127, 150, 158, 161, 163, 173, 174, 179, 191, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 232, 236, 237, 239, 242, 249, 255, 256, 259, 260, 266, 269, 270, 274, 275, 283, 284, 292294, 299, 301, 303, 307311, 313 MPI_COMPLEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98, 249 MPI_DISTRIBUTE_BLOCK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252255, 262 MPI_DISTRIBUTE_CYCLIC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252, 258, 259, 263 MPI_DISTRIBUTE_NONE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252, 253, 263 MPI_DOUBLE_PRECISION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77, 8789 MPI_ERRCODES_IGNORE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292, 295, 298, 299, 301 MPI_INFO_NULL . . . 77, 87, 191, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 232, 233, 237, 239, 242, 284, 292, 295, 299, 301, 303, 307, 308, 313
318/326
12 Index
MPI_INTEGER . . 29, 33, 34, 36, 39, 41, 48, 64, 66, 80, 98, 102, 110, 120, 123, 126, 127, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 233, 237, 239, 242, 256, 260 MPI_LOCK_EXCLUSIVE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 MPI_LOCK_SHARED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93, 94 MPI_LOGICAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 MPI_MAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81, 278 MPI_MAX_PORT_NAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307, 308 MPI_MODE_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191, 197, 313 MPI_MODE_NOPRECEDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 MPI_MODE_NOPUT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 MPI_MODE_NOSTORE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 MPI_MODE_NOSUCCEED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83 MPI_MODE_RDONLY . 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 232, 237, 239, 242 MPI_MODE_RDWR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191, 313 MPI_MODE_SEQUENTIAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .196, 201 MPI_MODE_WRONLY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197 MPI_OFFSET_KIND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197, 199, 210, 221, 226, 229, 232, 236 MPI_ORDER_C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .117 MPI_ORDER_FORTRAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117, 120, 230, 233, 256, 260 MPI_PROC_NULL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32, 174 MPI_PROD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66, 81 MPI_REAL . 50, 52, 54, 57, 59, 98, 100102, 104, 106, 108, 110, 115, 123, 146, 155, 158, 179, 269, 270, 276, 278, 279, 285
319/326
12 Index
MPI_REPLACE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81 MPI_SEEK_CUR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220, 221 MPI_SEEK_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 MPI_SEEK_SET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220, 221 MPI_SOURCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 MPI_STATUS_IGNORE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32, 33 MPI_STATUS_SIZE . . 29, 35, 41, 104, 106, 108, 115, 119, 123, 126, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 226, 229, 232, 236, 239, 242, 255, 259, 276, 277, 279, 283 MPI_STATUSES_IGNORE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 MPI_SUCCESS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32, 132 MPI_SUM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .64, 81, 89, 276, 285 MPI_TAG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 MPI_UNDEFINED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156, 266 MPI_UNIVERSE_SIZE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299, 303, 312 MPI_WIN_BASE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76, 77 MPI_WIN_DISP_UNIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76, 77 MPI_WIN_SIZE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76, 77 mpif.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
320/326
12 Index
12.3 Index des sous-programmes MPI
MPI_ABORT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33 MPI_ACCUMULATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .78, 81, 85, 8991 MPI_ALLGATHER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 54, 68 MPI_ALLGATHERV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 MPI_ALLOC_MEM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 MPI_ALLREDUCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 61, 66, 276, 278, 285 MPI_ALLTOALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 59, 68 MPI_ALLTOALLV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 MPI_ALLTOALLW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 MPI_ATTACH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 MPI_BARRIER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 46, 285 MPI_BCAST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 48, 61, 155, 158, 266 MPI_BSEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 135138 MPI_CART_COORDS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168, 169, 174, 179 MPI_CART_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .154, 160, 161, 163, 174, 179 MPI_CART_RANK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166, 167 MPI_CART_SHIFT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170172, 174 MPI_CART_SUB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154, 177, 179 MPI_CLOSE_PORT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306, 307, 309 MPI_COMM_ACCEPT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306, 307, 309 MPI_COMM_CONNECT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .308, 309 MPI_COMM_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 MPI_COMM_CREATE_KEYVAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312 MPI_COMM_DISCONNECT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306309 MPI_COMM_DUP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154 MPI_COMM_FREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154, 158
321/326
12 Index
MPI_COMM_GET_ATTR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299, 312 MPI_COMM_GET_PARENT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293 MPI_COMM_RANK . . 24, 25, 29, 33, 35, 41, 48, 50, 52, 54, 56, 59, 64, 66, 77, 87, 104, 106, 108, 115, 119, 123, 126, 158, 174, 179, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 232, 236, 239, 242, 249, 255, 259, 266, 274, 276, 278, 279, 283, 284, 292, 293, 313 MPI_COMM_SET_ATTR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312 MPI_COMM_SIZE . . . . 24, 25, 35, 41, 50, 52, 54, 56, 59, 64, 66, 173, 255, 259, 283, 292, 293 MPI_COMM_SPAWN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290292, 295, 297300, 303 MPI_COMM_SPAWN_MULTIPLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297, 300303 MPI_COMM_SPLIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154, 156158, 177, 274 MPI_DETACH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135 MPI_DIMS_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165, 173 MPI_DIST_GRAPH_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280, 284 MPI_EXSCAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 MPI_FILE_CLOSE 191, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 233, 237, 239, 242, 313 MPI_FILE_GET_INFO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 MPI_FILE_GET_POSITION . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 MPI_FILE_GET_POSITION_SHARED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 MPI_FILE_IREAD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194, 239 MPI_FILE_IREAD_AT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193, 237 MPI_FILE_IREAD_SHARED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_IWRITE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_IWRITE_AT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .193
322/326
12 Index
MPI_FILE_IWRITE_SHARED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_OPEN . 191, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 232, 237, 239, 242, 313 MPI_FILE_READ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194, 202, 204, 221, 227, 230, 233 MPI_FILE_READ_ALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194, 212, 214, 216 MPI_FILE_READ_ALL_BEGIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_READ_ALL_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_READ_AT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193, 199 MPI_FILE_READ_AT_ALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193, 210 MPI_FILE_READ_AT_ALL_BEGIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 MPI_FILE_READ_AT_ALL_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 MPI_FILE_READ_ORDERED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194, 218 MPI_FILE_READ_ORDERED_BEGIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194, 242 MPI_FILE_READ_ORDERED_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194, 242 MPI_FILE_READ_SHARED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194, 207 MPI_FILE_SEEK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220, 221 MPI_FILE_SEEK_SHARED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220 MPI_FILE_SET_INFO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 MPI_FILE_SET_VIEW . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227, 230, 233 MPI_FILE_WRITE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_WRITE_ALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_WRITE_ALL_BEGIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_WRITE_ALL_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_WRITE_AT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193, 197 MPI_FILE_WRITE_AT_ALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
323/326
12 Index
MPI_FILE_WRITE_AT_ALL_BEGIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 MPI_FILE_WRITE_AT_ALL_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193 MPI_FILE_WRITE_ORDERED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_WRITE_ORDERED_BEGIN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_WRITE_ORDERED_END . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FILE_WRITE_SHARED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194 MPI_FINALIZE . . . 22, 25, 29, 33, 36, 41, 48, 50, 52, 54, 57, 59, 64, 66, 77, 89, 105, 107, 109, 115, 120, 124, 127, 150, 158, 174, 179, 191, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 233, 237, 239, 242, 249, 256, 260, 266, 285, 292, 293, 301, 310, 311, 313 MPI_GATHER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 52, 68 MPI_GATHERV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .57, 68 MPI_GET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78, 81, 88, 91, 94 MPI_GET_ADDRESS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121, 122, 124 MPI_GET_ELEMENTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 MPI_GRAPH_NEIGHBORS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .282, 284 MPI_GRAPH_NEIGHBORS_COUNT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282, 284 MPI_IBSEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 135, 136, 138 MPI_INFO_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .297, 298 MPI_INFO_FREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297, 298, 313 MPI_INFO_GET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 MPI_INFO_GET_VALUELEN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313 MPI_INFO_SET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297, 298
324/326
12 Index
MPI_INIT 22, 25, 29, 33, 35, 41, 48, 50, 52, 54, 56, 59, 64, 66, 77, 87, 104, 106, 108, 115, 119, 123, 126, 150, 158, 173, 179, 191, 197, 199, 202, 204, 207, 210, 212, 214, 216, 218, 221, 227, 230, 232, 236, 239, 242, 249, 255, 259, 266, 274, 283, 292, 293, 301, 313 MPI_INTERCOMM_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272, 275 MPI_INTERCOMM_MERGE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290, 292, 293, 301 MPI_IRECV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 142, 145, 146, 269 MPI_IRSEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 140 MPI_ISEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 139, 142, 145, 146 MPI_ISSEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 133, 269 MPI_LOOKUP_NAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308, 309 MPI_OP_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61, 249 MPI_OP_FREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61 MPI_OPEN_PORT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306, 307 MPI_PROBE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36 MPI_PUBLISH_NAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306, 307, 309 MPI_PUT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78, 8082, 85, 88, 90, 91 MPI_RECV . . . . . . . . . . . . . . . . . . . 29, 34, 36, 39, 41, 105, 107, 109, 124, 127, 131, 256, 260, 279 MPI_RECV_INIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 MPI_REDUCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .45, 61, 64, 249 MPI_REQUEST_FREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271 MPI_RSEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 140 MPI_SCAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .61, 68 MPI_SCATTER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45, 50, 68, 179 MPI_SCATTERV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68 MPI_SEND . . . . . . . . . . . . . . . . . . . 29, 34, 36, 39, 41, 105, 107, 109, 124, 127, 131, 139, 256, 260
325/326
12 Index
MPI_SENDRECV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3234, 128, 285 MPI_SENDRECV_REPLACE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32, 113, 115, 120, 276, 278 MPI_SSEND . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131, 133, 278 MPI_SSEND_INIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270 MPI_START . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 270, 271 MPI_TEST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235, 237 MPI_TYPE_COMMIT . . 98, 103, 104, 106, 108, 115, 120, 124, 127, 227, 230, 233, 256, 260, 267 MPI_TYPE_CONTIGUOUS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98, 100, 104 MPI_TYPE_CREATE_DARRAY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251, 256, 260 MPI_TYPE_CREATE_F90_COMPLEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264, 266 MPI_TYPE_CREATE_F90_INTEGER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 MPI_TYPE_CREATE_F90_REAL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264 MPI_TYPE_CREATE_HINDEXED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .110, 112 MPI_TYPE_CREATE_HVECTOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98, 102, 110 MPI_TYPE_CREATE_RESIZED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125, 126, 227 MPI_TYPE_CREATE_STRUCT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121, 122, 124 MPI_TYPE_CREATE_SUBARRAY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116, 120, 230, 233 MPI_TYPE_FREE . . . . . . . . . . . . . . . . . . . . . 98, 103, 105, 107, 109, 115, 120, 124, 256, 260, 267 MPI_TYPE_GET_EXTENT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110, 125, 227 MPI_TYPE_INDEXED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110, 111, 115, 121, 227 MPI_TYPE_SIZE . . . . . . . . . . . . . . . . . . . . 76, 77, 87, 110, 125, 126, 197, 199, 210, 221, 233, 237 MPI_TYPE_VECTOR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98, 101, 106, 108, 126 MPI_UNPUBLISH_NAME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306, 307 MPI_WAIT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .132, 142, 144, 145, 235, 239, 269, 270
326/326
12 Index
MPI_WAITALL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146 MPI_WIN_CREATE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74, 77, 87 MPI_WIN_FENCE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .83, 85, 8890, 92 MPI_WIN_FREE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76, 77, 89 MPI_WIN_GET_ATTR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76, 77 MPI_WIN_LOCK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9295 MPI_WIN_UNLOCK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9295

MPI Programing

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

MPI Programing

Încărcat de

Drepturi de autor:

Formate disponibile

Message Passing Interface (MPI)

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

MPI Plan III

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Figure 1 Modle de programmation squentiel

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Figure 2 Modle de programmation par change de messages

Figure 3 Single Program, Multiple Data

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

1.2 Concepts de lchange de messages

1.2 Concepts de lchange de messages

Si un message est envoy un processus, celui-ci doit ensuite le recevoir

0 source Jenvoie source

1 cible Je reois dans cible

Figure 4 change dun message

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

1.2 Concepts de lchange de messages

Figure 5 Constitution dun message

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

1.2 Concepts de lchange de messages

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

MPICH2 : http://www.mcs.anl.gov/research/projects/mpich2/ Open MPI : http://www.open-mpi.org/

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Rciproquement, le sous-programme MPI_FINALIZE() dsactive cet environnement :

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

Figure 6 Communicateur MPI_COMM_WORLD

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

3 Communications point point

3 Communications point point

3.1 Notions gnrales

3 Communications point point

Figure 7 Communication point point

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

3 Communications point point

3.1 Notions gnrales

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

3 Communications point point

3.1 Notions gnrales

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

3 Communications point point

3.2 Types de donnes de base

3 Communications point point

Table 1 Principaux types de donnes 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

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

3 Communications point point

3.2 Types de donnes de base

Table 2 Principaux types de donnes de base (C)

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

3 Communications point point

3.3 Autres possibilits

3 Communications point point

INSTITUT DU DVELOPPEMENT ET DES RESSOURCES EN INFORMATIQUE SCIENTIFIQUE

3 Communications point point