Environnement SGI Origin 2000 v 3.0 Guy Moebs Guy.Moebs@crihan.fr

Plan de la formation 1. Environnement de travail 2. Outils d’aide au développement 3. Optimisation scalaire 4. Parallélisme

1- Environnement de travail A. Présentation matérielle B. Présentation logicielle C. Arborescence D. Soumission batch

1- A. Architecture matérielle O2000 Architecture O2000 (64 processeurs) :

1- A. Architecture matérielle O2000 Sommet du cube constitué : un router deux noeuds Router connecté à 4 routers voisins Noeud composé : 2 processeurs R10000 un commutateur HUB une mémoire partagée (1 Go) R

1- A. Architecture matérielle O2000 Le HUB : est connecté aux deux processeurs du noeud, sert d'interface entrées/sorties et et de connexion avec le reste des processeurs de la machine. La mémoire : est partagée entre les processeurs du noeud, est adressable par l'ensemble des processeurs de la machine.

1- A. Architecture matérielle O2000 Processeurs type R10000 (MIPS IV) : une fréquence horloge de 195 MHz, une puissance crête/processeur de 390 Mflops, un transfert crête de données vers le cache secondaire de 2.08 gbits/s, deux espaces cache : un cache primaire d'instructions de 32 Ko et de données de 32Ko, un cache secondaire de 4 Mo. Mémoire totale : 32 Go.

1- A. Architecture matérielle O2000 Organisation de la mémoire

1- A. Architecture matérielle O2000 Temps d’accès mémoire

1- A. Architecture matérielle O2000 Volume de stockage disque : 270 Go Configuration avec robot d'archivage et de sauvegarde de marque ADIC-GRAU AML/S 1000 (Technologie DLT 7000) Capacité de 10.5 Téra Octets Accès à illiac8 via une interface ATM OC-3 (155Mbits/s)

1- B. Présentation logicielle 1. Compilateurs 2. Modules 3. Débogueurs - éditeurs - logiciels de graphisme 4. Bibliothèques scientifiques 5. Outils de développement 6. Parallélisation

1- B. Présentation logicielle 1. Compilateurs Compilateurs SGI : Fortran 77 : f77 Fortran 90 : f90 C : cc C++ : CC Adressage des données : -n32 ou -64 selon l’espace d’adressage (< ou > 2Go) Compilateur HPF (Portland Group) : HPF (High Performance Fortran) : pghpf langage data parallel basé sur le F90

1- B. Présentation logicielle 2. Modules Module MPT (Message Passing Toolkit) : Environnement d’utilisation de MPI, SHMEM, PVM => chemins, variables d’environnement, librairies, exécutables Installation statique pour les versions >= 1.4 Installation par module pour les versions <= 1.3 => commande « module » (module help) : module avail : ensemble des modules présents module list : ensemble des modules déjà activés module load mpt : activation du module mpt module unload mpt : désactivation du module mpt

1- B. Présentation logicielle 3. Débogueurs dbx, cvd (outil SGI). Éditeurs : vi, emacs, xedit, nedit. Logiciels de graphisme : xmgr, gnuplot.

1- B. Présentation logicielle 4. Bibliothèques Bibliothèque SCSL (optimisées par SGI) : BLAS (portabilité complète), LAPACK (portabilité complète), FFT (portabilité restreinte !). en INTEGER*4 : link avec –lscs ou -lscs_mp (version parallèle) en INTEGER*8 : link avec –lscs_i8 ou –lscs_i8_mp (version parallèle) Mathématique, => link avec -lfastm (au lieu de -lm par défaut) Bibliothèques domaine public : SCALAPACK, => link avec /local/SCALAPACK/libscalapack[64/n32].a BLACS, => link avec /local/BLACS/libmpiblacs[64/n32].a

1- B. Présentation logicielle 5. Outils Perfex : comptage d’évèments matériels Speedshop : ssrun : effectue les mesures, prof : analyse des échantillonnages. WorkShop : Build Manager (cvbuild/cvmake) : aide à la compilation, Static Analyser (cvstatic) : aide à l’analyse de programmes, Debugger (cvd) : débogueur, Performance Analyser (cvperf) : profilage de programmes, Parallel Analyser (cvpav) : aide à la parallélisation. Documentation : manpage et insight

1- B. Présentation logicielle 6. Parallélisation Parallélisme SMP (Shared Memory Processing) : insertion de directives de compilation : OpenMP Parallélisme MPP (Massively Parallel Processing) : modules mpt : MPI, SHMEM, PVM version constructeur Parallélisme de données (data parallelism) : HPF (Portland Group)

1- C. Arborescence Compte informatique utilisateur :

1- C. Arborescence Sauvegarde des $HOME_DIR toutes les nuits Migration des $HOME_SAVE à l’aide de DMF : dmls, dmget, dmput $HOME_WORK non sauvegardés Quota disques : quota -v Assistance : http://www.crihan.fr/assistance/tickets-illiac8.html Consommation CPU : http://www.crihan.fr/CRIHAN/calcul/compta.html Documentation utilisateur : http://www.crihan.fr/CRIHAN/calcul/par/doc/Illiac8/index.html

1- D. Environnement batch Mode batch = traitement des commandes par lots préparation d’un ensemble de commandes dans un fichier (script), un “job” soumission à NQE (Network Queueing Environment) (cqsub) : => Recherche d’une queue batch éligible selon les ressources demandées => cqstatl -a => transmis à NQS si les ressources sont disponibles => mis en attente, status “pending” NQS (Network Queueing System) vérifie les limites des queues batch => qstat -a => running (Rxx) => queueing (Qyy) -> signification de yy : manpage de qstat Priorité d’exécution des "jobs" en fonction des ressources demandées.

1- D. Environnement batch Utilisation du batch : Rajouter dans votre home le fichier .nqshosts : illiac8.crihan.fr Création du script Paramètres CQSUB : -lM : fixe la mémoire maximale de la requête => somme des mémoires résidentes (colonne RES de top) -lm : fixe la mémoire maximale par processus => mémoire virtuelle maximale (colonne SIZE de top) -lT : fixe le temps CPU maximal de la requête -lt : fixe le temps CPU maximal par processus -l mpp_p=nb_procs : fixe le nombre maximal de processeurs utilisés !!! MPI, OpenMP, PVM nécessitent “nb_procs +1” comme arguments pour “-l mpp_p”

1- D. Environnement batch #QSUB -r omp  nom du job soumis #QSUB -u gm  login de l’utilisateur #QSUB -x  passage des variables d’environnement #QSUB -eo  fusion fichier de log et fichier d’erreur #QSUB -lM 1Go  mémoire maximale de la requête #QSUB -lm 600Mo  mémoire maximale par processus #QSUB -lT 1300  temps CPU maximal de la requête #QSUB -lt 300  temps CPU maximal par processus #QSUB -me  envoi d’un mail à la fin du job #QSUB -mu gm@crihan.fr  adresse e-mail pour l’envoi #QSUB -l mpp_p=5  nombre de processus maximal du job setenv OMP_NUM_THREADS 4 echo "Lancement MASTER” cd /crihan/gm/OMP timex ./a.out

1- D. Environnement batch Lancement : cqsub run_batch Contrôle de l’exécution : cqstatl -a  au niveau de NQE qstat -a  au niveau de NQS Destruction : cqdel -k identifier (txxxxx ou yyyyy.illiac8.crihan.fr)

1- D. Environnement batch GM-illiac8% qstat -a ---------------------------------- NQS 3.3.0.15 BATCH REQUEST SUMMARY IDENTIFIER NAME USER LOCATION/QUEUE JID PRTY REQMEM REQTIM ST ------------- ------- -------- --------------------- ---- ---- ------ ------ --- 432.illiac8.crihan.fr V_N32 gm mem64@illiac8 635267 20 4 14999 R05 429.illiac8.crihan.fr V_64 gm big64@illiac8 48 10000 45000 Qgm GM-illiac8% cqstatl -a ----------------------------- NQE 3.3.0.15 Database Task Summary IDENTIFIER NAME SYSTEM-OWNER OWNER LOCATION ST -------------------- ------- ---------------- -------- ------------------- ---- t411 (429.illiac8.c) V_64 lws.illiac8 gm nqs@illiac8 NSubm t414 (432.illiac8.c) V_N32 monitor.main gm NQE Database NComp

2- Outils d’aide au développement A. Static Analyser : cvstatic B. Build Manager : cvbuild / cvmake C. Debugger : cvd D. Performance Analyser : cvperf E. Parallel Analyser : cvpav F. Speedshop / perfex

2- Outils A. Static Analyser (cvstatic) Aide à l’analyse et à la documentation de programmes la structure du programme, les fichiers qui le constituent, les arbres d’appel, les listes de fonctions, le suivi des variables. Deux modes d’analyse : mode scanner : mode rapide, sans analyse relative au langage de programmation, => vue d’ensemble du programme. mode parser : analyse relative au langage de programmation, possibilité de faire des interrogations. => étude plus poussée.

2- Outils A. Static Analyser Commande de lancement : cvstatic ou à partir de cvd Démarche : création d’un fileset : sélection des fichiers, du langage, option Admin/Edit FileSet, => création d’une base de données de références croisées, interrogations à l’aide de requêtes classées par thèmes, menu Queries, visualisation graphique possible par l’option View/Call Tree View, sauvegarde des requêtes précédentes, menu History, filtrage des sorties, option Admin/Results Filter.

2- Outils A. Static Analyser

2- Outils B. Build Manager (cvmake) Aide à la compilation de programmes Composé de : Build View, Build Analyser. A l’aide d’une interface graphique, le Build View permet de : compiler des programmes, corriger les erreurs de compilation, visualiser les sources. Commande de lancement : cvmake ou à partir de cvd.

2- Outils B. Build Manager (cvbuild) A l’aide d’une interface graphique, le Build Analyser permet de : visualiser les inter-dépendances entre les fichiers, déterminer les cibles obsolètes à compiler/recompiler, option Admin/Refresh Graph Display, faire des interrogations, menu Query. Commande de lancement : cvbuild ou à partir de cvd.

2- Outils B. Build Manager

2- Outils C. Debugger (cvd) Aide au déboguage Compilation avec les options –O0 –g3 –DEBUG:… Constitué de : Un éditeur, Source View, Une barre de menus, Un panneau de contrôle, Une ligne d’état, Une ligne de commande. Commande de lancement : cvd.

2- Outils C. Debugger Menu Admin : configuration du débogueur. Menu Trap : gestion des points d’arrêts conditionnels/inconditionnels. Menu PC : interaction avec le Program Counter. Menus Display et Query : gestion de l’affichage et interrogation. Menu View : visualisation. Variable Browser : affichage des variables du sous-programme courant Expression View : évaluation de formules utilisant les variables Call Stack View : affichage de la hiérarchie des appels de fonctions

2- Outils C. Debugger

2- Outils D. Performance Analyser (cvperf) Outil d’analyse des performances de codes. recueil et visualisation des informations de profilage (coûts cpu des routines et des lignes sources), utilisation de la mémoire, Recherche des exceptions flottantes (underflow, overflow, …). Compilation du code avec le niveau d’optimisation –O3 Commande de lancement : cvperf ou à partir de cvd Version graphique de prof et ssrun

2- Outils D. Performance Analyser Démarche d’instrumentation : Choix du type de données et de la fréquence de l’échantillonnage, Sampling Data : comptage du nombre d’exécutions d’un bloc d’instructions Tracing Data : récupération des évènements altérant les performances Sélection de la tâche : option Perf/Select Tasks Instrumentation de l’exécution : bouton run Analyse des résultats : option Perf/Examine Results

2- Outils D. Performance Analyser

2- Outils E. Parallel Analyser (cvpav) Aide à la parallélisation automatique (APO) et à la parallélisation par directives (OpenMP). Compilation avec le niveau d’optimisation –O3 (Loop Nest Analyser : analyse des boucles). Examen du code source, indications à l’aide de symboles. Insertion de directives pour le compilateur, définition de régions parallèles. Commande de lancement : cvpav ou à partir de cvd

2- Outils E. Parallel Analyser

2- F. SpeedShop ssrun : génère les fichiers de statistiques (ssrun [options] prgm) -pcsamp : statistiques sur le Program Counter, -usertime : temps (inclusif et exclusif) du programme, -ideal : statistiques de comptage pour les blocs basiques. ssaggregate : fusionne les fichiers d’analyse ssaggregate –e files.exp.pid –o file.exp prof : traite les données et établit un rapport (prof [options] file.exp) -lines : fournit les numéros des lignes des sous-programmes, -q n : tronque la sortie après les n premiers sous-programmes affichés. perfex : compte les évènements matériels (perfex -a -x -y prgm) => nombres de cycles, accès mémoire en dehors du cache, …

2- F. SpeedShop

2- F. SpeedShop

3- Optimisation scalaire A. Ecriture du code, B. Bibliothèques scientifiques, C. Modularité, D. Déboguage / validation, E. Analyse des performances, F. Optimisations par re-écriture, G. Optimisations par options de compilation H. Variables d’environnement.

3- Optimisation A. Ecriture du code Réflexion au préalable sur papier, Algorithmes performants (!), Déclaration explicite de toutes les variables et des fonctions externes : Directive IMPLICIT NONE dans tous les fichiers source, Type générique pour les variables (REAL, INTEGER), Précision imposée à la déclaration : REAL(rp) avec rp=4 ou 8, Appels aux noms de fonctions génériques, exemple : SQRT au lieu de DSQRT, Séparation des types dans les commons : CHARACTER et LOGICAL à part.

3- Optimisation A. Ecriture du code Déclaration explicite des dimensions des tableaux, Initialisation explicite des variables avant leur utilisation, Indentation du source pour le rendre plus lisible, Code aéré avec des commentaires, Tests arithmétiques flottants selon la précision machine : Bon : IF ( ABS(reel1 - reel2) .LT. machep ) THEN ... Mauvais : IF ( reel1 .EQ. reel2 ) THEN ... Bon : IF ( ABS(DET) .LT. machep) THEN ... Mauvais : IF ( DET .EQ. 0 ) THEN ...

3- Optimisation A. Ecriture du code Précision des constantes scalaires : INTEGER, PARAMETER :: rp = KIND(1.0D0) ! rp = 8 REAL(rp) :: x ! REAL*8 :: x x = 2.0 / 3.0 = 0.66666668653488159 x = 2.0_rp / 3.0_rp = 0.66666666666666663 Tests arithmétiques flottants selon la précision machine : machep = 1.0_rp DO WHILE (machep + 1.0_rp > 1.0_rp ) machep = 0.5_rp * machep END DO machep = 2.0_rp * machep Fonction epsilon du Fortran 90

3- Optimisation B. Bibliothèques scientifiques Ensembles de sous-programmes testés, validés, optimisés. => Gain de temps et de travail et applications portables. => sources et documentations diverses : http://www.netlib.org BLAS : algèbre linéaire de base (blas 1, 2, 3) LAPACK : algèbre linéaire poussé FFT : transformées de Fourier rapides, convolution (portabilité !) Version SGI dans SCSL : link avec –lscs_i8 ou -lscs_i8_mp _i8 : INTEGER*8 au lieu de INTEGER*4 Bibliothèque mathématique : link avec -lfastm au lieu de -lm

3- Optimisation C. Modularité Fractionner le source, Mettre un sous-programme par fichier, Mettre un module, un common par fichier, Construire des bibliothèques thématiques, Travailler avec un fichier Makefile, Gestion des fichiers de reprise, Tester les routines après écriture sur des exemples.

3- Optimisation D. Déboguage / validation Options de compilation recommandées: -O0 : aucune optimisation ! -u : signale les variables non déclarées (mettre IMPLICIT NONE dans le code), -g3 : enrichir la table des symboles pour le débogueur (dbx, cvd), -fullwarn : recevoir un maximum (-woff num) d’informations du compilateur, -DEBUG:trap_uninitialized=ON : mise à NaN des variables non initialisées, -DEBUG:subscript_check=ON : vérification des indices pour les tableaux, -DEBUG:div_check=3 : vérification des quotients d’entiers et des overflows, -DEBUG:verbose_runtime=ON : informations lors de l’exécution, -lfpe : recherche des exceptions flottantes + variable d’environnement TRAP_FPE

3- Optimisation E. Analyse des performances Compilation avec le niveau d’optimisation -O3 Speedshop : code séquentiel ou OpenMP : ssrun -[f]pcsamp[x] prgm code MPI : mpirun –np nbproc ssrun –[f]pcsamp[x] prgm fusion : ssaggregate –e prgm.exp.pids –o prgm.ssrun analyse : prof -lines prgm.pcsamp Workshop: cvperf (version graphique de ssrun/prof) => Localiser la consommation du cpu pour optimiser les zones coûteuses

3- Optimisation F. Optimisation par re-écriture Opérations en virgule flottante : => remplacer une multiplication par une addition (coût divisé par 2) : z = 2.0_rp * y => z = y + y => remplacer une division par une multiplication (coût divisé par 4) : u = 1.0_rp / v DO i = 1, 100 DO i = 1, 100 A (i) = A (i) / v => A (i) = A (i) * u END DO END DO => risque de perte de précision

3- Optimisation F. Optimisation par re-écriture Optimisation des boucles : réduire les boucles extérieures en cas de boucles imbriquées, prendre un schéma d’adressage qui ne bride pas les performances DO j=1,M DO j=1,M DO j=1,M DO j=1,M DO i=1,N DO i=1,N DO i=1,N DO i=1,N A(i,j) A(i+(j-1)*N) k=k+1 A( index(i,j) ) A(k) END DO END DO END DO END DO ++ + - -- fusionner des boucles consécutives ayant les mêmes bornes d’utilisation. => Fournir des opportunités pour les optimiseurs.

3- Optimisation F. Optimisation par re-écriture Optimisation des tests : la présence de tests booléens inhibe le travail des optimiseurs => les remplacer par des fonctions arithmétiques intrinsèques . rmax = 0.0 DO i = 1, N IF ( ABS(V(I)) > rmax ) rmax = V(I) END DO devient rmax = 0.0_rp DO I = 1, N rmax = MAX( rmax, ABS( V(I) ) )

3- Optimisation F. Optimisation par re-écriture Optimisation mémoire : Aligner les données en mémoire (plus rapide car minimise les accès mémoire), Accéder aux tableaux de la même façon qu’ils sont stockés : En Fortran parcours suivant les colonnes : En C parcours suivant les lignes : DO i = 1, n for (i=1; i < (n+1); i++) { DO j = 1, n for (j=1; j < (n+1); j++) { A (i,j) = B (i,j) lent A[i][j] = B[i][j]; rapide C (j,i) = D (j,i) rapide C[j][i] = D[j][i]; lent END DO } END DO }

3- Optimisation F. Optimisation par re-écriture Utiliser des algorithmes qui ont une approche locale des variables : => travail sur des données contiguës, minimiser la navigation aléatoire dans de gros volumes de données (adressage indirect) Utiliser des algorithmes “par blocs” (cas d’opérations matricielles) : => travailler sur des blocs de données qui rentrent dans le cache de données => Augmentation des performances si : 1. nombre d’itérations >> nombre de données utilisées, 2. Les boucles sont permutables, 3. taille du bloc < taille du cache disponible. => le compilateur essaye de le faire lors de boucles imbriquées (cache blocking) => principe …

3- Optimisation F. Optimisation par re-écriture DO j1 = 1, n, jblock j2 = min (j1 + jblock - 1, n) DO i1 = 1, m, iblock i2 = min (i1 + iblock - 1, m) DO j = 1, n DO j = j1, j2 DO i = 1, m DO i = i1, i2 ... ==>> ... END DO END DO END DO END DO END DO Règle : “nb_tab*iblock*jblock*sizeof(real) < 0.90 * cache L1 en octets” Rmq : j2= min(j1+jblock-1,n) bien meilleur que IF (j1+jblock-1 > n) j2= n

3- Optimisation F. Optimisation par re-écriture Librairie de gestion rapide de la mémoire : link avec -lmalloc en C Allouer une grosse zone mémoire que l’on redistribue plutôt que de nombreux petits blocs => le but est à chaque fois de donner des opportunités pour optimiser une boucle, réarranger des opérations pour une meilleure efficacité : maximiser l’utilisation des registres. Optimiser les I/O (Entrées/Sorties) I/O = lectures/écritures de données => pertes de performances, éviter les fichiers temporaires, garder les données en mémoire, rediriger les I/O du terminal (clavier/écran) vers des fichiers, chemins d’accès courts, répertoires non surpeuplés.

3- Optimisation F. Optimisation par re-écriture I/O de deux types : I/O formatées : traduction des données sous forme de caractères à l’aide d’un descripteur; I/O non formatées : transfert des données sans les éditer. => architecture-dépendant Remplacer par DO i = 1, N write (21) A(i) write (21) A ENDDO Employer les fonctions C (gain : 20%) : printf Utilisation des I/O : post-processing, représentation graphique : I/O formatées; fichiers de reprise (impératif à prévoir dans un code !) : I/O non formatées.

3- Optimisation G. Optimisation par options Optimisation gérée par options de compilation : -On Option -O0 : aucune optimisation Valeur par défaut sur SGI, Utilisation pour le déboguage. Option -O1 : optimisations locales Au niveau des instructions MIPS par les générateurs assembleur et code, Superposition des instructions sur les réels, Remplissage des temps d’attente (lecture/écriture en mémoire), Sauvegarde des résultats des registres, Élimination de code inutile car sans effet.

3- Optimisation G. Optimisation par options Option -O2 (-O) : optimisations globales Transformations du code, Étude des dépendances à l’intérieur des procédures, Minimisation des lectures/écritures en mémoire, Déroulement des boucles, => Niveau maximal d’optimisation sans risque de perte de précision. Option -O3 : optimisations agressives Optimisations plus poussées Couplage avec d’autres options : -OPT (Optimization options, man opt) : précision sur les calculs en flottants, -LNO (Loop Nest Optimizer, man lno) : optimisation des boucles, -IPA (Inter Procedural Analysis, man ipa) : analyse interprocédurale,inlining. => Pertes de précision potentielles, comparer les résultats.

3- Optimisation G. Optimisation par options Option -Ofast : optimisations maximales -Ofast=ip27 : maximalise les performances en tenant compte de l’architecture de la machine pertes de précision probables dûes au réarrangement des opérations. Bibliothèque mathématique : -lfastm Configuration maximale : -n32/-64 -r10000 -mips4 -Ofast=ip27 -OPT:IEEE_arithmetic=3:roundoff=3 Configuration conseillée : -n32/-64 -r10000 -mips4 -O3 -OPT:IEEE_arithmetic=1:roundoff=0 F90 (allocation dynamique, modules, interfaces…) : la norme F77 est incluse dans la norme F90.

3- Optimisation G. Optimisation par options

3- Optimisation G. Optimisation par options -flist : résultat de la compilation après optimisations; -auto_use mpi_interface : vérification des appels à des routines MPI; -r8 / -i8 / -d8 : réels, entiers, doubles précisions sur 64 bits; -col120 : source sur 120 colonnes au lieu de 72; manpages utiles (à lire !) : f77, f90, cc, CC, ld : compilation / édition de liens; opt, lno, ipa, debug_group : optimisation, déboguage; mp : parallélisation; pe _environ : variables d’environnement; handle_sigfpes, sigfpe : exceptions flottantes.

3- Optimisation H. Variables d’environnement Déboguage traitement exceptions flottantes : TRAP_FPE + librairie libfpe setenv TRAP_FPE ”ALLCOUNT;UNDERFLOW=ZERO;OVERFL=TRACE(2),ABORT(2);INVALID=TRACE(2),ABORT(2)” TRACE(n) : affiche des n premiers, ABORT(p) : arrêt au p-ième traitement débordement de tableaux setenv F90_BOUNDS_CHECK_ABORT YES (arrêt demandé) traitement débordement de tableaux F90 setenv F90_CONFORM_CHECK_ABORT YES (arrêt demandé) Optimisation garder le même processeur pour un processus setenv _DSM_MUSTRUN

4- Parallélisme A. Définitions / Présentations B. Parallélisme par échanges de messages C. Parallélisme à mémoire partagée D. Analyses de performances

4- Parallélisme A. Définition Principe du parallélisme : “Diviser pour régner” Une définition du parallélisme : Ensemble de techniques logicielles et matérielles permettant l’exécution simultanée de séquences d’instructions indépendantes, sur des processeurs différents

4- Parallélisme A. Programmations parallèles Parallélisme SMP (Shared Memory Processing) OpenMP (http://www.openmp.org) Parallélisme par échanges de données (Massively Parallel Processing) MPI (http://www.mpi-forum.org), PVM (http://www.epm.ornl.gov/pvm/pvm_home.html), SHMEM (spécifique SGI/CRAY … portage chez d’autres constructeurs) Parallélisme de données HPF (Portland Group) http://www.pgroup.com Parallélisme mixte MPP&SMP échanges de messages + SMP

4- Parallélisme A. Types de parallélisme Parallélisme de données Données régulières et en grand nombre Traitement identique sur chaque donnée => Programmation Data-parallèle Le parallélisme découle de l’application simultanée du même traitement sur des données différentes Parallélisme de tâches Plusieurs traitements Traitements indépendants => Echanges de données, directives de contrôle Le parallélisme découle de la réalisation simultanée de différents traitements sur les données

4- Parallélisme A. Modèles de programmation Implicite : Paralléliseurs automatiques : APO Directives parallélisme à mémoire partagée : OpenMP Outils Data-parallèle : HPF Explicite : Echanges de messages : MPI, PVM Copie de mémoire à mémoire : SHMEM

4- Parallélisme B. Par échange de données SPMD = Single Program Multiple Data MPMD = Multiple Program Multiple Data

4- Parallélisme B. Par échange de données Modèle de programmation explicite : Communications et synchronisations à la charge du programmeur Echanges de données par messages MPI et PVM programmation portable MPI norme (modèle à privilégier) PVM standard (en voie de disparition) Echanges de données par mémoire partagée copie de mémoire à mémoire SHMEM : modèle propriétaire (supporté par Compaq)

4 Parallélisme B. MPI : Message Passing Interface Création d’un programme parallèle SPMD Lancement de l’exécutable en parallèle sur n processus P1 P1 P1

4- Parallélisme B. MPI : environnement Environnement parallèle : activation : MPI_INIT (irc) désactivation : MPI_FINALIZE (irc) Communicateur : “univers de communication” => Ensemble de processus actifs rang (identité) : MPI_COMM_RANK (MPI_COMM_WORLD, mon_rang, irc) Nombre de processus : MPI _COMM_SIZE (MPI_COMM_WORLD, nbproc, irc) INTEGER :: irc = 0 INTEGER :: mon _rang, nbproc => exemple 1

4- Parallélisme B. MPI : échange de messages Message = donnée à transmettre entre des processus; Informations nécessaires : processus source(s), type de la donnée, longueur, étiquette (tag), processus destinataire(s); Communications entre 2 processus : point-à-point; Comunications entre plusieurs processus : collectives.

4- Parallélisme B. MPI : point-à-point => communications entre 2 processus : source et destinataire Paramètres de la communication : processus identifiés par leur rang dans le communicateur, données, types des données : MPI_INTEGER, MPI _REAL, MPI _COMPLEX, MPI_LOGICAL, MPI _CHARACTER, ... longueur des données, étiquette, communicateur.

4- Parallélisme B. MPI : point-à-point Communication bloquante : attendre la fin de la communication avant de continuer l’exécution. Envoi : MPI _SEND (don, taille, type, dest, tag, comm, irc) Envoi d’un message identifié tag, de taille taille, de type type, à partir de l’adresse don, au processus dest, dans le communicateur comm. Réception : MPI _RECV (don, taille, type, source, tag, comm, statut, irc) INTEGER, DIMENSION (MPI _STATUS _SIZE) :: statut Réception d’un message identifié tag, de taille taille, de type type, placé à partir de l’adresse don, du processus source, dans le communicateur comm. => exemple 2

4- Parallélisme B. MPI : point-à-point Communication non bloquante : suite de l’exécution sans attendre la réception ou la fin de la communication. => possibilité de recouvrement de la communication par du calcul mais il faut s’assurer de l’envoi et de la réception; => fonctions de vérification, d’attente. Envoi : MPI _ISEND (don, taille, type, dest, tag, comm, requete, irc) Envoi d’un message identifié tag, de taille taille, de type type, à partir de l’adresse don, au processus dest, dans le communicateur comm. requete identifie l’envoi (différent de tag). INTEGER :: requete

4- Parallélisme B. MPI : point-à-point Réception : MPI _IRECV (don, taille, type, source, tag, comm, requete, irc) Réception d’un message identifié tag, de taille taille, de type type, placé à partir de l’adresse don, du processus source, dans le communicateur comm. Validation : MPI _TEST (requete, flag, status, irc) LOGICAL :: flag Attente : MPI _WAIT (requete, status, irc) Libération : MPI _REQUEST _ FREE (requete, irc) => exemple 3

4- Parallélisme B. MPI : collectives Tous les processus d’un même communicateur sont impliqués. Communication collective = plusieurs communications point-à-point en une seule opération avec possibilité d’effectuer une opération sur les données. Pas de gestion des étiquettes. 3 types de communications collectives : synchronisation globale : MPI _BARRIER (comm, irc); diffusion simple; diffusion avec opération sur les données.

4- Parallélisme B. MPI : collectives Diffusion simple : Diffusion globale : MPI_BCAST (don, taille, type, source, comm, irc) Envoi par le processus source, à tous les processus de comm, d’un message de taille taille, de type type, à partir de l’adresse don. Diffusion sélective : MPI_SCATTER (sdon, staille, stype, rdon, rtaille, rtype, source, comm, irc) Diffusion sélective de données réparties, par tous les processus : MPI_ALLTOALL (sdon, staille, stype, rdon, rtaille, rtype, comm, irc) Collecte de données réparties : MPI_GATHER (sdon, staille, stype, rdon, rtaille, rtype, source, comm, irc) Collecte de données réparties, par tous les processus : MPI_ALLGATHER (sdon, staille, stype, rdon, rtaille, rtype, comm, irc)

4- Parallélisme B. MPI : collectives

4- Parallélisme B. MPI : collectives Diffusion et opérations sur les données => opération de réduction = appliquer la même opération sur des valeurs réparties entre les processus. => opérations prédéfinies : MPI _MAX, MPI _MIN, MPI _SUM, ... MPI _REDUCE (don, res, taille, type, oper, dest, comm, irc) Depuis tous les processus de comm, envoi d’un message de taille taille, de type type, à partir de l’adresse don, faire l’operation oper sur ces valeurs. Réception du résultat res par le processus dest. => exemple 4 MPI _ALLREDUCE = MPI _REDUCE + MPI _BCAST

4- Parallélisme B. MPI : environnement Version MPI : 1.2 + (grandes évolutions en ver 2.0) Fichier .rhosts dans le home : illiac8.crihan.fr login Includes : mpif.h ou module MPI en f90 (fortran) ou mpi.h (C) Bibliothèque : libmpi.so (C et fortran) version 32 ou 64 bits appelée en fonction de l’option -n32 ou -64 lors de la compilation et l’édition de liens (-lmpi) Commande d’exécution : /usr/bin/mpirun ex : mpirun -np nb_proc pgm !!! #QSUB -l mpp_p=“nb_proc”+1 Manpages : mpi, mpirun, pe_environ, mpi_send, … Variables : setenv MPC_GANG OFF, MPI_DSM_MUSTRUN, MPI_DSM_PPM 1

4- Parallélisme B.Conclusions échange de données Avantages : parallélisation à gros grains portabilité de l’application MPI (ou PVM) (SHMEM reste liée à SGI/CRAY mais supportée par Compaq,...) Inconvénients : Développement de l’application tout ou rien pas d’outil de parallélisation automatique

4- Parallélisme B. Mise en œuvre sur Illiac8 MPT : Message Passage Toolkit (ver. 1.4) ensemble logiciel pour la programmation par échange de messages : MPI, PVM, SHMEM; installation statique: rien à faire ! anciennes versions, commande : module avail / list / load / unload Initialisation de l’environnement (variables d’environnement, chemins, librairies, fichiers inclus, …). mpt1.3 : adressage 64 bits (> 2Go), version 1.3 de mpt mpt.1.3.n32_mips4 : adressage 32 bits (< 2Go), version 1.3 de mpt => prendre la version 32bits, généralement suffisante.

4- Parallélisme C. A mémoire partagée Motivation : pas de standard portable pour le SMP => OMP (http://www.openmp.org) F77 et C; évolution vers C++, syntaxe F90 Modèle implicite Parallélisation “gros grains” et “petits grains” Basé sur le principe du fork & join : création d’une équipe de threads à l’entrée d’une région parallèle dont le nombre est controlé par variable d’environnement ou appel librairie.

4. Parallélisme C. OpenMP : directives OpenMP est un ensemble de constructions bâties sur des directives et leurs clauses, qui sont des commentaires structurés commençant par une sentinelle : !$OMP … & format ou C$OMP format !$OMP libre C$OMP+ … fixe Parallélisation d’une région : !$OMP PARALLEL [clauses] !$OMP END PARALLEL => ces directives doivent être présentes dans le même sous-programme(fichier) => la région parallèle est constituée des instructions entre ces deux directives (portée lexicale) et des sous-programmes appelés au sein de la région; => les branchements hors d’une région parallèle sont interdits; => sa création peut être conditionnelle.

4. Parallélisme C. OpenMP : clauses PRIVATE : arguments privés à chaque thread mais indéfinis, SHARED : arguments visibles pour toutes les threads, DEFAULT : imposer un attribut à tous les arguments de la zone parallèle, FIRSTPRIVATE : arguments privés à chaque thread et initialisés, LASTPRIVATE(*1) : arguments privés à chaque thread, impose la dernière valeur en sortie, REDUCTION : opération de réduction sur les arguments, IF(*2) : clause conditionnelle d’exécution en parallèle, COPYIN : copie de blocs common vers les threads. (*1) la clause LASTPRIVATE est spécifique aux boucles; (*2) la clause IF est spécifique aux régions parallèles; => les clauses permettent de délimiter la visibilité des variables au sein des constructions (régions, boucles, …).

4. Parallélisme C. OpenMP : région parallèle INTEGER :: rank = 0 INTEGER :: nbthrds = 1 !$OMP PARALLEL DEFAULT (NONE) & !$OMP SHARED (nbthrds) & !$OMP PRIVATE (rank) !$OMP MASTER !$ nbthrds = OMP_GET_NUM_THREADS () !$OMP END MASTER !$OMP BARRIER !$ rank = OMP_GET_THREAD_NUM () write (6,*) ‘rang = ‘, rank, ‘ sur ‘, nbthrds, ‘ processus’ !$OMP END PARALLEL

4. Parallélisme C. OpenMP : section parallèle Parallélisation par section (mode MPMD) : !$OMP PARALLEL SECTIONS, & !$OMP SHARED (a,b) !$OMP SECTION CALL work1 (a) CALL work2 (b) !$OMP END SECTIONS !$OMP END PARALLEL => chaque section est exécutée par une unique tâche, => méthode non scalable, => les directives SECTIONS / SECTION / END SECTIONS doivent figurer dans le même sous-programme (fichier)

4. Parallélisme C. OpenMP : boucle parallèle => boucle avec indices entiers, => bornes identiques pour toutes les tâches, => directive PARALLEL DO = région parallèle limitée à la prochaine boucle. !$OMP PARALLEL DO DEFAULT (NONE), PRIVATE (I,J) & !$OMP FIRSTPRIVATE (alpha, beta, N, M) & !$OMP SHARED (A, B, C, D) DO J = 1, N DO I = 1, M A(I,J) = alpha * B(I,J) + beta * ( C(I,J) + D(I,J) ) END DO !$OMP END PARALLEL DO

4. Parallélisme C. OpenMP : boucle parallèle => boucle privée : !$OMP PARALLEL DEFAULT(NONE) & !$OMP&PRIVATE (I, J, A) & !$OMP&SHARED (B, C, N, M) DO J = 1, N <-- boucle dupliquée DO I = 1, M <-- boucle dupliquée A(I,J) = B(I,J) + C(I,J) END DO ... CALL WORK (A,N,M) <-- copie privée de A par processus !$OMP END PARALLEL => toutes les tâches exécutent la boucle.

4. Parallélisme C. OpenMP : boucle parallèle => boucle partagée : !$OMP PARALLEL DEFAULT(NONE) & !$OMP&PRIVATE (I, J) & !$OMP&SHARED (A, B, C, N, M) !$OMP DO DO J = 1, N <-- boucle partagée DO I = 1, M <-- boucle dupliquée A(I,J) = B(I,J) + C(I,J) END DO !$OMP END DO ... CALL WORK (A,N,M) <-- variable A partagée !$OMP END PARALLEL => chaque tâche n’exécute qu’une partie des itérations.

4. Parallélisme C. OpenMP : boucle parallèle !$OMP PARALLEL DEFAULT (NONE) & !$OMP SHARED (A,B,Y,Z,N,M) & !$OMP PRIVATE (I) !$OMP DO DO I = 2, N B (I) = 0.5_rp * ( A (I) + A (I-1) ) END DO !$OMP END DO [NOWAIT] <- on peut ne pas synchroniser DO I = 1, M Y (I) = SQRT( Z (I) ) !$OMP END DO [NOWAIT] !$OMP END PARALLEL

4. Parallélisme C. OpenMP : boucle parallèle clause d’ordonnancement !$OMP PARALLEL DO SCHEDULE (type, chunk) ou !$OMP DO SCHEDULE (type, chunk) => 4 modes de répartition mode static : paquets de taille fixe, chunk si précisé, affectés à une tâche précise, mode dynamic : paquets de taille fixe, chunk si précisé, affectés à la première tâche disponible, mode guided : paquets de taille décroissante au moins égale à chunk, affectés à la première tâche disponible, mode runtime : choix différé à l’exécution par variable d’environnement : setenv OMP_SCHEDULE “mode,chunk”

4. Parallélisme C. OpenMP : réduction !$OMP PARALLEL DO DEFAULT (NONE), REDUCTION (+: err, somme)& !$OMP PRIVATE (I,J,T), SHARED (N, M, A, B, C, err, somme) DO J = 1, N <-- boucle parallélisée + réduction DO I = 1, M <-- boucle dupliquée T = A(I,J) - B(I,J) somme = somme + T err = err + T * ( A(I,J) + B(I,J) ) END DO !$OMP END PARALLEL DO => variable lue et mise à jour par une tâche à la fois, => variable publique (shared), de type scalaire intrinsèque, => opérateurs associatifs usuels, => somme et err sont des instances privées jusqu’à la fin.

4. Parallélisme C. OpenMP : exécution unique !$OMP PARALLEL DO DEFAULT (NONE) & !$OMP SHARED (nbproc) !$OMP MASTER nbproc = 1 !$ nbproc = OMP_GET_NUM_THREADS () WRITE (6,*) ‘Nombre de threads : ‘, nbproc !$OMP END MASTER <- pas de barrière de synchronisation incluse !$OMP BARRIER <- peut être nécessaire plus efficace que !$OMP SINGLE !$OMP END SINGLE <- barrière de synchronisation incluse !$OMP END PARALLEL DO

4. Parallélisme C. OpenMP : mise à jour atomic somme = 0.0_rp !$OMP PARALLEL DO DEFAULT (NONE) & !$OMP SHARED (A, N, somme) & !$OMP PRIVATE (I DO I = 1, N !$OMP ATOMIC somme = somme + A (I) END DO !$OMP END PARALLEL DO => Une seule ligne affectée, immédiatement après la directive, contrairement à MASTER …END MASTER et SINGLE …END SINGLE, => lecture et mise à jour par une tâche à la fois, => variable scalaire intrinsèque.

4. Parallélisme C. OpenMP : environnement Gestion par variables d’environnement OMP_SCHEDULE, OMP_NUM_THREADS, OMP_DYNAMIC. Gestion par appel à des fonctions OMP_SET_NUM_THREADS, OMP_GET_NUM_THREADS, OMP_GET_THREAD_NUM. Autres variables : DSM_PPM, DSM_MUSTRUN Compilation (niveau d’optimisation : -O3 au minimum) -mp : multi-processing Exécution setenv OMP_NUM_THREADS 10 timex ./a.out !!! #QSUB -l mpp_p=“OMP_NUM_THREADS”+1

4- Parallélisme C. Conclusions mémoire partagée Avantages : Standard portable Parallélisme à gros grains et petits grains Respect de la sémantique du code séquentiel Pas de gestions explicite des processus Scalable Inconvénients : Problèmes pour les I/O parallèles

4- Parallélisme D. Analyses de performances Accélération : A(p) = T(1) / T(p) => T(n) : temps écoulé pour n processus Efficacité (en %) : E(p) = 100 x A(p) / p Mesure par SpeedShop : mpirun –np nbproc ssrun –fpcsampx ./a_mpi.out setenv OMP_NUM_THREADS nbproc ssrun –fpcsampx ./a_omp.out => on obtient nbproc fichiers de la forme a_xxx.out.fpcsampx.pid

4- Parallélisme D. Analyses de performances Load-balancing : prof –lines a_xxx.out.fpcsampx.pid1 > xxx.pid1_ssrun etc … grep ‘\[1\]’ xxx.pid*_ssrun Comparaison séquentiel / parallèle : ssrun –fpcsampx a_seq.out prof –lines a_seq.out.fpcsampx.pid > seq_ssrun ssaggregate –e a_xxx.out.fpcsampx.pid* –o xxx.cumul_fpcsampx prof –lines xxx.cumul_fpcsampx > xxx_ssrun grep ‘subroutine’ xxx_ssrun seq_ssrun

4- Parallélisme : Conclusions Parallélisme par échanges de messages : => MPI, SHMEM, PVM Parallélisme sur mémoire partagée => OpenMP

Conclusions Le portage et le développement se font en suivant des règles : respect des normes du langage, utilisations d’outils d’aide, options de compilation adaptées.  L’optimisation d’un code a plusieurs facettes : optimisation scalaire : par re-écriture et options de compilation, optimisations parallèles : plusieurs techniques de parallélisation possibles, à choisir selon le profil du code et les machines d’utilisation.