CRIHAN - Novembre 2001 Formation Illiac8 - Page 1 Environnement SGI Origin 2000 v 3.0 Guy Moebs...

CRIHAN - Novembre 2001Formation Illiac8 -

Environnement SGI Origin 2000v 3.0

Guy [email protected]


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) :


• 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



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



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



• Organisation de la mémoire



• Temps d’accès mémoire



• 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

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, PVMversion 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.



• 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”



#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 [email protected] 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



• 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)



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’analysessaggregate –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


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.



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



• Précision des constantes scalaires :INTEGER, PARAMETER :: rp = KIND(1.0D0) ! rp = 8REAL(rp) :: x ! REAL*8 :: xx = 2.0 / 3.0 = 0.66666668653488159x = 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 / vDO i = 1, 100 DO i = 1, 100 A (i) = A (i) / v => A (i) = A (i) * uEND DO END DO

=> risque de perte de précision



• 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

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.



• 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) ) )

END DO



• 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 }



– 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 …



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 DOEND 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



– 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.



– 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 parDO i = 1, N write (21) A(i) write (21) AENDDO

– 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.



• Option -O2 (-O) : optimisations globalesTransformations 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 agressivesOptimisations plus pousséesCouplage 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.



• Option -Ofast : optimisations maximales-Ofast=ip27 : maximalise les performances en tenant compte de l’architecture de la

machinepertes 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.



• -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 tableauxsetenv F90_BOUNDS_CHECK_ABORT YES (arrêt demandé)– traitement débordement de tableaux F90setenv F90_CONFORM_CHECK_ABORT YES (arrêt demandé)

• Optimisation– garder le même processeur pour un processussetenv _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 DataMPMD = 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.



Communication bloquante : attendre la fin de lacommunication 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



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



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.



• 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)



• 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)

!$OMP SECTION

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

END DO

!$OMP END PARALLEL DO



=> 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

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.



=> 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


A(I,J) = B(I,J) + C(I,J)

END DO

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.



!$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

!$OMP DO

DO I = 1, M

Y (I) = SQRT( Z (I) )

END DO

!$OMP END DO [NOWAIT]

!$OMP END PARALLEL



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


T = A(I,J) - B(I,J)

somme = somme + T

err = err + T * ( A(I,J) + B(I,J) )

END DO

END 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

nbproc = 1

!$ nbproc = OMP_GET_NUM_THREADS ()

WRITE (6,*) ‘Nombre de threads : ‘, nbproc

!$OMP END SINGLE <- barrière de synchronisation incluse



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


=> 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’environnementOMP_SCHEDULE, OMP_NUM_THREADS, OMP_DYNAMIC.

• Gestion par appel à des fonctionsOMP_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écutionsetenv 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.

CRIHAN - Novembre 2001 Formation Illiac8 - Page 1 Environnement SGI Origin 2000 v 3.0 Guy Moebs...

Documents

Transcript of CRIHAN - Novembre 2001 Formation Illiac8 - Page 1 Environnement SGI Origin 2000 v 3.0 Guy Moebs...