Introduction ` a la Programmation parall` ele – Institut Galil´ ee –
— INFO 3 —
Camille Coti 1
camille.coti@lipn.univ-paris13.fr
1Universit´e de Paris XIII, CNRS UMR 7030, France
2 / 50
Plan du cours
1
Introduction aux machines parall` eles Pourquoi des machines parall` eles ?
Mod` eles de m´ emoire pour machines parall` eles Exemples d’architectures
Parall´ elisation d’un programme Performance du calcul parall` ele
2
Programmation de machines en m´ emoire partag´ ee Programmation multithread´ ee
OpenMP Scheduling
3
Programmation de machines en m´ emoire distribu´ ee Passage de messages
La norme MPI
Communications point-` a-point
Communications collectives
3 / 50
Pourquoi des machines parall` eles ?
Comment augmenter la puissance de calcul des machines Augmenter la fr´ equence d’horloge
Augmenter le nombre d’op´ erations effectu´ ees en un cycle
On se heurte aux limitation des techniques de fabrication des puces
Autre solution : augmenter le nombre d’unit´ es de calcul Plusieurs pipelines
Architectures superscalaires
Plusieurs processeurs logiques (avec leurs propres registres et PC, IC) HyperThreading
Plusieurs unit´ es de calcul par puce multi-cœur
Plusieurs processeurs par carte m` ere Symmetric Multi-Processor (SMP) Plusieurs machines reli´ ees par un r´ eseau
Clusters
4 / 50
Mod` eles de m´ emoire pour machines parall` eles
M´ emoire partag´ ee
Plusieurs unit´ es de calcul ont directement acc` es ` a la m´ emoire Threads
Processus Au niveau syst` eme :
La m´ emoire doit ˆ etre physiquement accessible par toutes les unit´ es de calcul
Une seule instance du syst` eme d’exploitation orchestre les acc` es m´ emoire
Exemple
Machine multi-cœur Un thread par cœur
Les threads ont tous acc` es ` a la m´ emoire Programmation : pthread par exemple
M´ emoire partag´ ee
5 / 50
Mod` eles de m´ emoire pour machines parall` eles
M´ emoire distribu´ ee
Chaque unit´ e de calcul a son propre banc de m´ emoire Un processus par unit´ e de calcul
Les processus ne peuvent acc´ eder qu’` a leur banc de m´ emoire Au niveau syst` eme :
Les ´ echanges de donn´ ees entre processus sont explicites (passage de messages)
Chaque unit´ e de calcul est g´ er´ ee par une instance du syst` eme d’exploitation
Exemple Cluster
Un processus par nœud
Un CPU, un banc de m´ emoire et une carte r´ eseau par nœud Programmation utilisant une biblioth` eque de communications
´ Echanges de donn´ ees via le r´ eseau
6 / 50
Comparaison des deux mod` eles
Mise en œuvre
La m´ emoire partag´ ee est peu scalable Nombre limit´ e de cœurs par carte m` ere
Scalabilit´ e du scheduler du syst` eme d’exploitation
Programmation
La m´ emoire distribu´ ee demande plus de travail au programmeur Mouvements de donn´ ees explicites
La m´ emoire partag´ ee est parfois faussement facile Deadlocks, race conditions...
Machines hybrides Clusters de multi-cœurs:
Plusieurs cœurs par nœud → m´ emoire partag´ ee
Plusieurs nœuds reli´ es par un r´ eseau → m´ emoire distribu´ ee
7 / 50
Exemples d’architectures
Cluster of workstations Solution ´ economique
Composants produits en masse PC utilis´ es pour les nœuds
R´ eseau Ethernet ou haute vitesse (InfiniBand, Myrinet...)
Longtemps appel´ e “le supercalculateur du pauvre”
8 / 50
Exemples d’architectures
Supercalculateur massivement parall` ele (MPP) Solution sp´ ecifique
Composants sp´ ecifiques CPU diff´ erent de ceux des PC
R´ eseaux sp´ ecifique (parfois propri´ etaire) Parfois sans disque dur
Coˆ uteux
9 / 50
Exemples d’architectures Exemple : Cray XT5m
CPU : deux AMD Istanbul 6 cœurs chacun 2 puces par machine Empil´ ees sur la mˆ eme socket Bus : crossbar
Pas de disque dur
R´ eseau
Propri´ etaire : SeaStar Topologie : tore 2D
Connexion directe avec ses 4 voisins
Environnement logiciel
OS : Cray Linux Environment
Compilateurs, biblioth` eques de calcul
sp´ ecifiques (tun´ es pour l’architecture)
Biblioth` eques de communications
r´ egl´ ees pour la machine
10 / 50
Top 500 www.top500.org
Classement des machines les plus rapides
Bas´ e sur un benchmark (LINPACK) effectuant des op´ erations typiques de calcul scientifique
Permet de r´ ealiser des statistiques Tendances architecturales Par pays, par OS...
´ Evolution !
Depuis juin 1993, d´ evoil´ e tous les ans en juin et novembre
Dernier classement : juin 2010
1. Jaguar - Cray XT5-HE - Oak Ridge National Lab
2. Nebulae - Dawning TC3600 Blade - National Supercomputing Centre in Shenzhen (NSCS)
3. Roadrunner - IBM BladeCenter QS22/LS21 Cluster - Los Alamos National Lab
4. Kraken - Cray XT5-HE - Univ. of Tennessee / Oak Ridge National Lab
5. JUGENE - IBM Blue Gene/P - Forschungszentrum Juelich (FZJ)
11 / 50
Top 500 - Type de syst` emes
12 / 50
Top 500 - Nombre de CPU
13 / 50
Top 500 - Nombre de CPU juin 2010
14 / 50
Parall´ elisation d’un programme
Parall´ elisation du calcul entre les unit´ es de calcul
But : diviser le travail entre les processus ou les threads disponibles Approche “divide and conquer”
Types de programmes parall` eles Classification de Flynn (1969)
Single Instruction Single Data (SISD) : calcul s´ equentiel Multiple Instruction Single Data (MISD) : calcul vectoriel Single Instruction Multiple Data (SIMD) : calcul parall` ele Multiple Instruction Multiple Data (MIMD) : calcul parall` ele
On traite plusieurs flux de donn´ ees en parall` ele
15 / 50
Mesure de la performance des programmes parall` eles
Comment d´ efinir cette performance Pourquoi parall´ elise-t-on ?
Pour diviser un calcul qui serait trop long / trop gros sinon Diviser le probl` eme ↔ diviser le temps de calcul ?
Lancement
processus 0 processus 1 processus 2
Finalisation
Sources de ralentissement
Synchronisations entre processus Mouvements de donn´ ees Attentes
Synchronisations Adaptations algorithmiques
L’algorithme parall` ele peut ˆ etre diff´ erent de l’algorithme s´ equentiel
Calculs suppl´ ementaires
Efficacit´ e du parall´ elisme ?
16 / 50
Acc´ el´ eration
D´ efinition
L’acc´ el´ eration d’un programme parall` ele (ou speedup) repr´ esente le gain en rapidit´ e d’ex´ ecution obtenu par son ex´ ecution sur plusieurs processeurs.
Mesure de l’acc´ el´ eration
On la mesure par le rapport entre le temps d’ex´ ecution du programme s´ equentiel et le temps d’ex´ ecution sur p processeurs
S
p= T
seqT
pAppr´ eciation de l’acc´ el´ eration
Acc´ el´ eration lin´ eaire : parall´ elisme optimal
Acc´ el´ eration sur-lin´ eaire : attention
Acc´ el´ eration sub-lin´ eaire : ralentissement
dˆ u au parall´ elisme
17 / 50
Loi d’Amdahl
D´ ecomposition d’un programme parall` ele
D´ ecomposition du temps d’ex´ ecution d’une application parall` ele Une partie purement s´ equentielle ;
Une partie parall´ elisable
´ Ennonc´ e
On note s la proportion parall´ elisable de l’ex´ ecution et p le nombre de processus. Le rendement est donn´ e par la formule :
R = 1
(1 − s) +
spRemarques
si p → ∞ : R =
(1−s)1L’acc´ el´ eration est toujours limit´ ee par la partie non-parall´ elisable du programme
Si (1 − s) → 0, on a R ∼ p : l’acc´ el´ eration est lin´ eaire
18 / 50
Passage ` a l’´ echelle (scalabilit´ e)
Remarque pr´ eliminaire
On a vu avec la loi d’Amdahl que la performance augmente th´ eoriquement lorsque l’on ajoute des processus.
Comment augmente-t-elle en r´ ealit´ e ?
Y a-t-il des facteurs limitants (goulet d’´ etranglement...) Augmente-t-elle ` a l’infini ?
D´ efinition
Le passage ` a l’´ echelle d’un programme parall` ele d´ esigne l’augmentation des performances obtenues lorsque l’on ajoute des processus.
Obstacles ` a la scalabilit´ e Synchronisations
Algorithmes ne passant pas ` a l’´ echelle (complexit´ e de l’algo) Complexit´ e en op´ erations
Complexit´ e en communications
19 / 50
Passage ` a l’´ echelle (scalabilit´ e)
La performance d’un programme parall` ele a plusieurs dimensions
Scalabilit´ e forte
On fixe la taille du probl` eme et on augmente le nombre de processus Relative au speedup
Si on a une hyperbole : scalabilit´ e forte parfaite
On augmente le nombre de processus pour calculer plus vite
Scalabilit´ e faible
On augmente la taille du probl` eme avec le nombre de processus Le probl` eme est ` a taille constante par processus
Si le temps de calcul est constant : scalabilit´ e faible parfaite
On augmente le nombre de processus pour r´ esoudre des probl` emes de plus
grande taille
20 / 50
1
Introduction aux machines parall` eles Pourquoi des machines parall` eles ?
Mod` eles de m´ emoire pour machines parall` eles Exemples d’architectures
Parall´ elisation d’un programme Performance du calcul parall` ele
2
Programmation de machines en m´ emoire partag´ ee Programmation multithread´ ee
OpenMP Scheduling
3
Programmation de machines en m´ emoire distribu´ ee Passage de messages
La norme MPI
Communications point-` a-point
Communications collectives
21 / 50
Programmation multithread´ ee
Acc` es m´ emoire
Tous les threads ont acc` es ` a une m´ emoire commune Mod` ele PRAM
Techniques de programmation Utilisation de processus
Cr´ eation avec fork()
Communication via un segment de m´ emoire partag´ ee Utilisation de threads POSIX
Cr´ eation avec pthread create(), destruction avec pthread join() Communication via un segment de m´ emoire partag´ ee ou des variables globales dans le tas
Rappel : la pile est propre ` a chaque thread, le tas est commun Utilisation d’un langage sp´ ecifique
Exemple : OpenMP
22 / 50
Exemple : OpenMP
Fonctionnement Langage d’annotations
Le code est relativement peu modifi´ e Directives de compilation
Utilisation de #pragma : si le compilateur ne connait pas, OpenMP est d´ ebray´ e et le code fonctionne en s´ equentiel
Thread maˆıtre fork
R´ egion parall` ele
join fork
R´ egion parall` ele
join
Thread maˆıtre
23 / 50
Exemple : parall´ elisation d’une boucle
Calcul d’un maximum global sur un tableau
Algorithm 1: Calcul s´ equentiel du maximum d’un tableau begin
Data: Un tableau de taille N d’entiers positifs tab[]
Result: Un entier MAX
M AX = 0;
for i ← 0 to N do
if tab[i] > M AX then M AX = tab[i];
end
Par´ ell´ elisation du calcul Parall´ elisation de la boucle for
On “tranche” l’intervalle sur lequel a lieu de calcul
Les tranches sont r´ eparties entre les threads
24 / 50
Annotations OpenMP
Sections parall` eles
#pragma omp parallel : d´ ebut d’une section parall` ele (fork)
#pragma omp for : boucle for parall´ elis´ ee
Synchronisations
#pragma omp critical : section critique
#pragma omp barrier : barri` ere de synchronisation
Visibilit´ e des donn´ ees
Priv´ ee = visible uniquement de ce thread Partag´ ee = partag´ ee entre tous les threads Par d´ efaut :
Ce qui est d´ eclar´ e dans la section parall` ele est priv´ e Ce qui est d´ eclar´ e en-dehors est partag´ e
#pragma omp parallel private (tid) shared (result)
25 / 50
Compilation et ex´ ecution
En-tˆ etes
#include <omp.h>
Compilation
Activation avec une option du compilateur Pour gcc : -fopenmp
Ex´ euction
Nombre de threads :
Par d´ efaut : d´ ecouverte du nombre de cœurs et utilisation de tous
Fix´ e par l’utilisateur via la variable d’environnement $OMP NUM THREADS
26 / 50
Exemple : HelloWorld
Code complet du Hello World
#include <stdio.h>
#include <stdlib.h>
#include <omp.h>
int main() {
int nbthreads, tid;
#pragma omp parallel private ( tid ) shared ( nbthreads ) {
tid = omp get thread num();
if( 0 == tid )
nbthreads = omp get num threads();
#pragma omp barrier
printf( "Hello World! I am thread %d/%d\ n", tid, nbthreads );
}
return EXIT SUCCESS;
}
27 / 50
Exemple : Calcul d’un maximum global
Approche na¨ıve
On peut parall´ elise la boucle et ´ ecrire le r´ esultat directement dans une variable partag´ ee
Algorithme max = 0
parfor i = 0 ` a N-1 :
si max < tab[i] : alors max = tab[i]
Probl` eme : les acc` es ` a max doivent se faire dans une section critique Solution : utilisation de #pragma omp critical
S´ equentialisation des acc` es → s´ equentialisation de la boucle !
Meilleure approche
Calcul d’un maximum local puis ` a la fin du calcul, maximum global des maximums locaux
code parmax.c
28 / 50
Options de d´ ecoupage des boucles (scheduling)
Static
Le d´ ecoupage est fait ` a l’avance
Des tranches de tailles ´ egales sont attribu´ ees aux threads
Adapt´ e aux boucles dont les it´ erations ont des temps de calcul ´ equivalent
Dynamic
Le d´ ecoupage est fait ` a l’ex´ ecution
Le scheduler attribue une tranche aux threads libres
Attention ` a la taille des tranches : si trop petites, seul le thread 0 travaillera
Guided
Similaire ` a dynamic
Les tailles des tranches diminuent durant l’ex´ ecution
Utilisation
#pragma omp for schedule (type, taille)
29 / 50
1
Introduction aux machines parall` eles Pourquoi des machines parall` eles ?
Mod` eles de m´ emoire pour machines parall` eles Exemples d’architectures
Parall´ elisation d’un programme Performance du calcul parall` ele
2
Programmation de machines en m´ emoire partag´ ee Programmation multithread´ ee
OpenMP Scheduling
3
Programmation de machines en m´ emoire distribu´ ee Passage de messages
La norme MPI
Communications point-` a-point
Communications collectives
30 / 50
Communications inter-processus
Passage de messages
Envoi de messages explicite entre deux processus Un processus A envoie ` a un processus B
A ex´ ecute la primitive : send( dest, &msgptr ) B ex´ ecute la primitive : recv( dest, &msgptr )
Les deux processus ´ emetteur-r´ ecepteur doivent ex´ ecuter une primitive, de r´ eception pour le r´ ecepteur et d’envoi pour l’´ emetteur
Nommage des processus
On a besoin d’une fa¸ con unique de d´ esigner les processus Association adresse / port → portabilit´ e ?
On utilise un rang de processus , unique, entre 0 et N-1
31 / 50
Gestion des donn´ ees
Tampons des messages Chaque processus (´ emetteur et
r´ ecepteur) a un tampon (buffer) pour le message
La m´ emoire doit ˆ etre allou´ ee cˆ ot´ e
´
emetteur et cˆ ot´ e r´ ecepteur On n’envoie pas plus d’´ el´ ements que la taille disponible en ´ emission
Lin´ earisation des donn´ ees Les donn´ ees doivent ˆ etre s´ erialis´ ees (marshalling) dans le tampon
On envoie un tampon, un tableau d’´ el´ ements, une suite d’octets...
send( P1, &addr )
recv( P0, &addr )
addr addr
P0
P1
32 / 50
La norme MPI
Message Passing Interface
Norme de facto pour la programmation parall` ele par passage de messages N´ ee d’un effort de standardisation
Chaque fabriquant avait son propre langage Portabilit´ e des applications !
Effort commun entre industriels et laboratoires de recherche But : ˆ etre ` a la fois portable et offrir de bonnes performances
Impl´ ementations
Portabilit´ e des applications ´ ecrites en MPI
Applis MPI ex´ ecutables avec n’importe quelle impl´ ementation de MPI Propri´ etaire ou non, fournie avec la machine ou non
Fonctions MPI
Interface d´ efinie en C, C++, Fortran 77 et 90 List´ ees et document´ ees dans la norme Commencent par MPI et une lettre majuscule
Le reste est en lettres minuscules
33 / 50
Historique de MPI
´ Evolution
Appel ` a contributions : SC 1992 1994 : MPI 1.0
Communications point-` a-point de base Communications collectives
1995 : MPI 1.1 (clarifications de MPI 1.0) 1997 : MPI 1.2 (clarifications et corrections) 1998 : MPI 2.0
Dynamicit´ e
Acc` es distant ` a la m´ emoire des processus (RDMA) 2008 : MPI 2.1 (clarifications)
2009 : MPI 2.2 (corrections, peu d’additions) En cours : MPI 3.0
Tol´ erance aux pannes
Collectives non bloquantes
et d’autres choses
34 / 50
D´ esignation des processus
Communicateur
Les processus communiquant ensemble sont dans un communicateur Ils sont tous dans MPI COMM WORLD
Chacun est tout seul dans son MPI COMM SELF MPI COMM NULL ne contient personne
Possibilit´ e de cr´ eer d’autres communicateurs au cours de l’ex´ ecution
Rang
Les processus sont d´ esign´ es par un rang Unique dans un communicateur donn´ e
Rang dans MPI COMM WORLD= rang absolu dans l’application
Utilis´ e pour les envois / r´ eception de messages
35 / 50
D´ eploiement de l’application
Lancement
mpiexec lance les processus sur les machines distantes
Lancement = ex´ ecution d’un programme sur la machine distante Le binaire doit ˆ etre accessible de la machine distante
Possibilit´ e d’ex´ ecuter un binaire diff´ erent suivant les rangs
“vrai” MIMD
Transmission des param` etres de la ligne de commande
Redirections
Les entr´ ees-sorties sont redirig´ ees
stderr, stdout, stdin sont redirig´ es vers le lanceur MPI-IO pour les I/O
Finalisation
mpiexec retourne quand tous les processus ont termin´ e normalement ou un
seul a termin´ e anormalement (plantage, d´ efaillance...)
36 / 50
Hello World en MPI
D´ ebut / fin du programme Initialisation de la biblioth` eque MPI
MPI Init( &argc, &argv );
Finalisation du programme MPI Finalize( );
Si un processus quitte avant MPI Finalize( );, ce sera consid´ er´ e comme une erreur.
Ces deux fonctions sont OBLIGATOIRES !!!
Qui suis-je ?
Combien de processus dans l’application ?
MPI Comm size( MPI COMM WORLD, &size );
Quel est mon rang ?
MPI Comm rank( MPI COMM WORLD, &rank );
37 / 50
Hello World en MPI
Code complet
#include <stdio.h>
#include <stdlib.h>
#include <mpi.h>
int main( int argc, char** argv ) { int size, rank;
MPI Init( &argc, &argv );
MPI Comm rank( MPI COMM WORLD, &rank );
MPI Comm size( MPI COMM WORLD, &size );
fprintf( stdout, "Hello, I am rank %d in %d\n’’, rank, size );
MPI Finalize();
return EXIT SUCCESS;
}
38 / 50
Hello World en MPI
Compilation
Compilateur C : mpicc
Wrapper autour du compilateur C install´ e Fournit les chemins vers le mpi.h et la lib MPI Equivalent ` ´ a
gcc -L/path/to/mpi/lib -lmpi -I/path/to/mpi/include mpicc -o helloworld helloworld.c
Ex´ ecution
Lancement avec mpiexec
On fournit une liste de machines (machinefile) Le nombre de processus ` a lancer
mpiexec --machinefile ./machinefile -n 4 ./helloworld Hello, I am rank 1 in 4
Hello, I am rank 2 in 4
Hello, I am rank 0 in 4
Hello, I am rank 3 in 4
39 / 50
Communications point-` a-point
Communications bloquantes Envoi : MPI Send
int MPI Send( void *buf, int count, MPI Datatype datatype, int dest, int tag, MPI Comm comm )
R´ eception : MPI Recv
int MPI Recv( void *buf, int count, MPI Datatype datatype,
int dest, int tag, MPI Comm comm, MPI Status *status )
40 / 50
Communications point-` a-point
Donn´ ees
buf : tampon d’envoi / r´ eception
count : nombre d’´ el´ ements de type datatype datatype : type de donn´ ees
Utilisation de datatypes MPI
Assure la portabilit´ e (notamment 32/64 bits, environnements h´ et´ erog` enes...) Types standards et possibilit´ e d’en d´ efinir de nouveaux
Identification des processus
Utilisation du couple communicateur / rang
En r´ eception : possibilit´ e d’utilisation d’une wildcard MPI ANY SOURCE
Apr` es r´ eception, l’´ emetteur du message est dans le status
Identification de la communication Utilisation du tag
En r´ eception : possibilit´ e d’utilisation d’une wildcard MPI ANY TAG
Apr` es r´ eception, le tag du message est dans le status
41 / 50
Ping-pong entre deux processus
Code complet
#include <stdlib.h>
#include <mpi.h>
int main( int argc, char** argv ) { int rank;
int token = 42;
MPI Status status;
MPI Init( &argc, &argv );
MPI Comm rank( MPI COMM WORLD, &rank );
if( 0 == rank ) {
MPI Send( &token, 1, MPI INT, 1, 0, MPI COMM WORLD);
MPI Recv( &token, 1, MPI INT, 1, 0, MPI COMM WORLD, &status );
} else if( 1 == rank ) {
MPI Recv( &token, 1, MPI INT, 0, 0, MPI COMM WORLD, &status );
MPI Send( &token, 1, MPI INT, 0, 0, MPI COMM WORLD);
}
MPI Finalize();
return EXIT SUCCESS;
}
42 / 50
Ping-pong entre deux processus
Remarques
A un envoi correspond ` toujours une r´ eception Mˆ eme communicateur, mˆ eme tag
Rang de l’´ emetteur et rang du destinataire On utilise le rang pour d´ eterminer ce que l’on fait On envoie des entiers → MPI INT
Sources d’erreurs fr´ equentes
Le datatype et le nombre d’´ el´ ements doivent ˆ etre identiques en ´ emission et en r´ eception
On s’attend ` a recevoir ce qui a ´ et´ e envoy´ e
Attention ` a la correspondance MPI Send et MPI Recv
Deux MPI Send ou deux MPI Recv = deadlock !
43 / 50
Communications non-bloquantes
But
La communication a lieu pendant qu’on fait autre chose Superposition communication/calcul
Plusieurs communications simultan´ ees sans risque de deadlock Quand on a besoin des donn´ ees, on attend que la communication ait ´ et´ e effectu´ ee compl` etement
Communications Envoi : MPI Isend
int MPI Isend( void *buf, int count, MPI Datatype datatype, int dest, int tag, MPI Comm comm, MPI Request *request ) R´ eception : MPI Irecv
int MPI Irecv( void *buf, int count, MPI Datatype datatype,
int dest, int tag, MPI Comm comm, MPI Request *request )
44 / 50
Communications non-bloquantes Attente de compl´ etion
Pour une communication :
int MPI Wait( MPI Request *request, MPI Status *status ) Attendre plusieurs communications : MPI {Waitall, Waitany, Waitsome}
Test de compl´ etion Pour une communication :
int MPI Test( MPI Request *request, int *flag, MPI Status
*status )
Tester plusieurs communications : MPI {Testall, Testany, Testsome}
Annuler une communication en cours
Communication non-bloquante identifi´ ee par sa request int MPI Cancel(MPI Request *request)
Diff´ erences
MPI Wait est bloquant, MPI Test ne l’est pas
MPI Test peut ˆ etre appel´ e simplement pour entrer dans la biblioth` eque
MPI (lui redonner la main pour faire avancer des op´ erations)
45 / 50
Communications collectives
Int´ erˆ et
On peut avoir besoin d’effectuer une op´ eration sur tous les processus Synchronisation
D´ eplacement de donn´ ees Calcul global
Certaines communications collectives effectuent plusieurs de ces actions
Caract´ eristiques communes
Les collectives sont effectu´ ees sur un communicateur Tous les processus de ce communicateur l’effectuent Pour la norme MPI 1.x et 2.x, les collectives sont bloquantes
Synchronisation avec effets de bord (attention ` a ne pas s’y fier)
Pas de tag donc une seule collective ` a la fois
46 / 50
Communications collectives
Synchronisation Barri` ere
MPI Barrier( MPI Comm comm );
On ne sort de la barri` ere qu’une fois que tous les processus du communicateur y sont entr´ es
Assure une certaine synchronisation entre les processus
Diffusion d’une donn´ ee Broadcast
int MPI Bcast( void *buffer, int count, MPI Datatype datatype, int root, MPI Comm comm );
Envoie une donn´ ee (buffer)
A partir d’un processus racine (root) `
Vers tous les processus du communicateur
47 / 50
Communications collectives
Calcul global
R´ eduction vers une racine
int MPI Reduce( void *sendbuf, void *recvbuf, int count, MPI Datatype datatype, MPI Op op, int root, MPI Comm comm );
Effectue une op´ eration (op)
Sur une donn´ ee disponible sur tous les processus du communicateur Vers la racine de la r´ eduction (root)
Op´ erations disponibles dans le standard (MPI SUM, MPI MAX, MPI MIN...) et possibilit´ e de d´ efinir ses propres op´ erations
La fonction doit ˆ etre associative mais pas forc´ ement commutative Pour mettre le r´ esultat dans le tampon d’envoi (sur le processus racine) : MPI IN PLACE
Calcul global avec r´ esultat sur tous les processus R´ eduction globale
int MPI Allreduce( void *sendbuf, void *recvbuf, int count, MPI Datatype datatype, MPI Op op, MPI Comm comm );
Similaire ` a MPI Reduce sans la racine
48 / 50
Communications collectives
Rassemblement
Concat´ enation du contenu des tampons
int MPI Gather( void *sendbuf, int sendcount, MPI Datatype sendtype, void *recvbuf, int recvcount, MPI Datatype recvtype, int root, MPI Comm comm );
Les contenus des tampons sont envoy´ es vers la racine de la concat´ enation Possibilit´ e d’utiliser des datatypes diff´ erents en envoi et en r´ eception (attention, source d’erreurs)
recvbuf ne sert que sur la racine Possibilit´ e d’utiliser MPI IN PLACE
Rassemblement avec r´ esultat sur tous les processus Concat´ enation globale du contenu des tampons
int MPI Allgather( void *sendbuf, int sendcount, MPI Datatype sendtype, void *recvbuf, int recvcount, MPI Datatype
recvtype, MPI Comm comm );
Similaire ` a MPI Gather sans la racine
49 / 50
Communications collectives
Distribution de donn´ ees
Distribution d’un tampon vers plusieurs processus
int MPI Scatter( void *sendbuf, int sendcount, MPI Datatype sendtype, void *recvbuf, int recvcount, MPI Datatype recvtype, int root, MPI Comm comm );
Des fractions de taille sendcount de tampon d’envoi disponible sur la
racine sont envoy´ es vers tous les processus du communicateur
Possibilit´ e d’utiliser MPI IN PLACE
50 / 50
