Outils d’aide à l’optimisation scalaire sur Origin 2000 v 2

Présentation au sujet: "Outils d’aide à l’optimisation scalaire sur Origin 2000 v 2"— Transcription de la présentation:

1 Outils d’aide à l’optimisation scalaire sur Origin 2000 v 2
Outils d’aide à l’optimisation scalaire sur Origin 2000 v 2.0 Guy Moebs Présentations mutuelles : Présentateurs L’assistance : noms, laboratoires, thème de recherche, projet séquentiel ou parallèle, connaissance autre type de machines parallèles ...

2 Plan de la formation 1. Architecture matérielle Origin2000
2. Environnement logiciel 3. Perfex 4. Speedshop 5. Load balancing MPI

3 1- Architecture matérielle O2000
Architecture O2000 (64 procs) :

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

5 1- Architecture matérielle O2000
Le HUB : est connecté aux deux processeurs du noeud, sert d'interface entrées/sorties et connexions 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.

6 1- 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, une mémoire totale de 32 Go.

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

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

9 2- Environnement logiciel
A. Compilateurs Déboguage, Optimisation, Groupes d’options et manpages utiles. B. Makefile C. Eléments de Fortran 90 Déclarations, Allocation dynamique, Interface.

10 2- A. Compilateurs : déboguage
Options : -O0 : aucune optimisation, -g3 : enrichir la table des symboles, -fullwarn : recevoir tous les messages du compilateurs (-woff pour filtrer), -DEBUG:trap_uninitialized=ON : mise à NaN des variables non initialisées, -DEBUG:subscript_check=ON : vérification des indices des tableaux, -DEBUG:div_check=3 : vérification des divisions et des overflows pour les entiers, -DEBUG:verbose_runtime=ON : numéros des lignes source des erreurs. Bibliothèques : -lfpe : bibliothèque de gestion des exceptions flottantes setenv TRAP_FPE “ALLCOUNT;UNDERFLOW=ZERO;OVERFL=TRACE(2),ABORT(2);INVALID=TRACE(2),ABORT(2)“

11 2- A. Compilateurs : optimisation
Procéder par étapes, Valider les résultats à chaque étape, Étapes : -O0 : résultats de référence, -O2 : optimisations locales/globales fiables, -O3 -OPT:IEEE_arithmetic=1:roundoff=0 : optimisations plus aggressives, -O3 -OPT:IEEE_arithmetic=3:roundoff=3 : optimisations très aggressives. Utiliser les outils perfex, speedshop, workshop pour étudier les performances après validation des résultats. Quelques règles : respect la norme du langage, accès aux données de la même façon qu’elles sont stockées, utilisation de bibliothèques scientifiques optimisées.

12 2- A. Compilateurs : groupes d’options
-IPA (inter procedural analysis) : analyse inter-procédurale -LNO (loop nest optimizer) : optimisation des boucles imbriquées -OPT (optimization options) : précision sur les calculs en flottants -DEBUG : déboguage Manpages F77, F90, cc, CC ipa, lno, opt, debug_group mp, pe_environ, sigfpe, handle_sigfpes Options -auto_use mpi_interface -flist, -col120, ...

13 2- B. Compilateurs : Makefile
Compilation faite par le compilateur, Outil make permet de gérer la compilation, Makefile = fichier d’instructions pour la commande make, repose sur des targets, des règles de compilation. FC = f90 FFLAGS = -n32 -r mips4 -O3 LIBS = -lmpi -lfastm OBJS = bloc.o calcul.o erreur.o pmm.o main.o .o.f90: <TAB>$(FC) $(FFLAGS) <$ -c All: $(OBJS) <TAB>$(FC) $(LDFLAGS) $(OBJS) -o $(PROG) $(LIBS)

14 2- C. Eléments de Fortran 90 Déclaration des variables
INTEGER, PARAMETER :: n = 10 INTEGER :: ierr = 0 REAL(8), DIMENSION (-n:n, 0:1) :: a, b REAL(4), DIMENSION(:), ALLOCATABLE :: z Allocation dynamique ALLOCATE ( z(n+4*m+2), STAT=ierr) IF ( ierr /= 0 ) STOP ou IF ( ierr == 0 ) THEN … DEALLOCATE ( z ) Interface SUBROUTINE calcul (n,a,b,c) INTEGER, INTENT(IN) :: n REAL(8), INTENT(OUT) :: a REAL(8), INTENT(IN) :: b, c

15 3- perfex A. compteurs d’événement B. options C. statistiques
D. application : produit matriciel

16 3- A. perfex : compteurs les processeurs R1k000 disposent de compteurs d’évènements pour suivre l’activité durant l’exécution. quelques compteurs d’évènements importants : 7 : quadwords written back from L2 9 : L1 instruction cache misses 10 : L2 instruction cache misses 21 : graduated floating point instructions 22 : quadwords written back from L1 23 : TLB misses (TLB = translation look-aside buffer) 25 : L1 data cache misses 26 : L2 data cache misses deux compteurs peuvent être suivis en même temps => mesure précise de 2 compteurs => mesure partielle puis extrapolation de tous les compteurs (multiplexage)

17 3- B. perfex : options Perfex [-e e0] [-e e1] [-a] [-mp] [-y] [-x] prog [args] e0, e1 : identifiants d’évènements qui doivent appartenir à deux groupes distincts (0-15) et (16-31); -a : multiplexage de tous les évènements; -mp : comptage pour chaque thread et pour l’ensemble; -y : estimation des temps et statistiques; -x : comptage des exceptions. perfex -a -x -y ./s.out perfex -a -x -y [-mp] mpirun -np 4 ./p.out

18 3- C. perfex : statistiques
Statistiques importantes : Graduated instructions / cycle => proche de 2 Graduated floating point instructions / cycle Graduated loads & stores / cycle Graduated loads & stores / floating point instructions L1 Cache Line Reuse L2 Cache Line Reuse L1 Data Cache Hit Rate => > 0.90 L2 Data Cache Hit Rate Time accessing memory / Total time L1--L2 bandwidth used (MB/s, average per process) Memory bandwidth used (MB/s, average per process) MFLOPS (average per process)

19 3- D. perfex : application
but : Montrer les pertes de performances lorsque les données sont hors des caches principe : Calcul d’un produit matrice-matrice démarche : 1) compilation : -O2; 2) étude des performances pour n tel que les 3 tableaux rentrent dans les caches L1, L2 ou la mémoire; cache L1 : 32ko, cache L2 : 1Mo; 4Mo, 8Mo (dépend de l’architecture => hinv) 3 tableaux en double précision : 3x8xnxn octets 3) étude des performances en modifiants l’ordre des boucles; 4) compilation : -O3; 5) refaire les étapes 2) et 3).

20 3- D. perfex : application
analyse : 1) compteurs d’évènements : évolution du classement d’importance selon la valeur de n 2) statistiques : évolution des valeurs des quantités selon la valeur de n 3) comparaison des résultats en -O2 et -O3

21 3- D. perfex : analyse compilation en -O2
L1 (n = 20), L2 (n = 300) et MEM (n=1000) Based on 195 MHz IP27 MIPS R10000 CPU CPU revision 2.x Typical Minimum Maximum Event Counter Name Counter Value Time (sec) Time (sec) Time (sec) =============================================================================================================== 0 Cycles 16 Cycles 25 Primary data cache misses 26 Secondary data cache misses 23 TLB misses 0 Cycles 16 Cycles 25 Primary data cache misses 23 TLB misses 26 Secondary data cache misses 0 Cycles 16 Cycles 23 TLB misses 25 Primary data cache misses 26 Secondary data cache misses

22 3- D. perfex : analyse compilation en -O3
L1 (n = 20), L2 (n = 300) et MEM (n=1000) Based on 195 MHz IP27 MIPS R10000 CPU CPU revision 2.x Typical Minimum Maximum Event Counter Name Counter Value Time (sec) Time (sec) Time (sec) =============================================================================================================== 0 Cycles 16 Cycles 25 Primary data cache misses 26 Secondary data cache misses 23 TLB misses 0 Cycles 16 Cycles 25 Primary data cache misses 23 TLB misses 26 Secondary data cache misses 0 Cycles 16 Cycles 25 Primary data cache misses 26 Secondary data cache misses 23 TLB misses

23 3- D. perfex : analyse compilation en -O2/-O3
Statistics L L MEM n = n = n = 1000 ================================================================================================================= Graduated instructions/cycle Graduated floating point instructions/cycle Graduated loads & stores/cycle Graduated loads & stores/floating point instruction L1 Cache Line Reuse L2 Cache Line Reuse L1 Data Cache Hit Rate L2 Data Cache Hit Rate Time accessing memory/Total time L1--L2 bandwidth used (MB/s, average per process) Memory bandwidth used (MB/s, average per process) MFLOPS (average per process) Graduated instructions/cycle Graduated floating point instructions/cycle Graduated loads & stores/cycle Graduated loads & stores/floating point instruction L1 Cache Line Reuse L2 Cache Line Reuse L1 Data Cache Hit Rate L2 Data Cache Hit Rate Time accessing memory/Total time L1--L2 bandwidth used (MB/s, average per process) Memory bandwidth used (MB/s, average per process) MFLOPS (average per process)

24 3- D. perfex : commentaires
L’option -O3 permet de conserver les données dans le cache secondaire à l’aide du cache blocking. L’option -flist permet d’obtenir la traduction en Fortran du code optimisé. L’option -O3 active des groupes d’option (LNO, OPT,…) qui fournissent des optimisations supplémentaires; gain d’un facteur supérieur à 15 ici.

25 4- speedshop A. ssrun : expériences B. ssrun : types d’expérience
C. ssrun : options D. prof : analyse E. prof : options F. application : ADI

26 4- A. ssrun : expériences ssrun est un outil de profilage :
- mesure effectuée durant l’exécution du programme, - usage ne nécessite pas de compilation particulière, - appliqué à un programme compilé avec options d’optimisation. 2 types d’expérience: - échantillonnage statistique durant l’exécution du programme, - comptage exact d’occurrence d’évènements. ssrun s’applique aux programmes séquentiel et parallèle

27 4- B. ssrun : type d’expérience
l’échantillonnage dépend d’une base temporelle : arrêt du programme toutes les 10 ou 1 ms, incrément d’un compteur associé à la ligne du code exécutée (-[f]pcsamp[x]); arrêt du programme toutes les 3 ms, incrément d’un compteur associé à toutes les routines de la pile d’appels (-usertime). le comptage est lié à un type d’événement : arrêt du programme lors du débordement de compteur d’évènements, incrément d’un compteur associé à la ligne du code source (-hwc); arrêt du programme lors d’une exception flottante, incrément d’un compteur associé à toutes les routines de la pile d’appels (-fpe); Comptage du temps `idéal` d’exécution du code (-ideal).

28 4- C. ssrun : options ssrun -exp prog [args] exp : type d’expériences;
prog : application à analyser. création d’un fichier binaire d’informations de la forme progname.expname.D#pid #pid : process id; D : lettre dont la signification est : m : processus master crée par ssrun; p : processus slave OpenMP ( crée par sproc() ); f : processus slave MPI ( crée par fork() ); e : processus slave PVM ( crée par exec() ); s : processus système.

29 4- D. prof : analyse lecture du(/des) fichier(s) binaire(s) généré(s) par ssrun création d’un fichier ascii après analyse fichier global pour l’ensemble des processus ou fichier individuel

30 4- E. prof : options prof -options progname.exp.name.D#pid options :
-heavy (-h) : résultats affichés pour chaque ligne par ordre décroissant de temps; -lines (-l) : résultats affichés pour chaque ligne par ordre du source; -only (-o) sub : affichage pour la routine sub uniquement; -gprof : ajoute le temps inclusif pour l’expérience -usertime; -q n [%] : tronque l ’affichage après n lignes ou n %.

31 4- F. application : ADI but : principe : Démarche :
Montrer les pertes de performances et les localiser. principe : Calcul de contributions dans un tableau 3D, routines xsweep, ysweep et zsweep Démarche : 1) comparer les coûts théoriques des routines avec -ideal; 2) comparer les coûts réels des routines avec -pcsamp; 3) analyser les évènements avec perfex -a -y -x; 4) affiner les valeurs des principaux compteurs avec perfex -e e0; 5) localiser les lignes du source responsables avec ssrun -hwc : setenv SPEEDSHOP HWC_COUNTER_NUMBER compteur setenv SPEEDSHOP HWC_COUNTER_OVERFLOW valeur

32 4- F. application : ADI résultats de ssrun -ideal par prof -lines :
Function list, in descending order by exclusive ideal time [index] excl.secs excl.% cum.% cycles instructions calls function (dso: file, line) [1] % % xsweep (adi2: adi2.f90, 70) [2] % % ysweep (adi2: adi2.f90, 90) [3] % % zsweep (adi2: adi2.f90, 110) [4] % % irand_ (libftn.so: rand_.c, 62) [5] % % rand_ (libftn.so: rand_.c, 67) [6] % % adi2 (adi2: adi2.f90, 1) résultats de ssrun -pcsamp par prof -lines : Function list, in descending order by time [index] secs % cum.% samples function (dso: file, line) [1] % 78.1% zsweep (adi2: adi2.f90, 110) [2] % 85.9% ysweep (adi2: adi2.f90, 90) [3] % 93.4% xsweep (adi2: adi2.f90, 70) [4] % 96.2% irand_ (libftn.so: rand_.c, 62) [5] % 98.4% adi2 (adi2: adi2.f90, 1) [6] % 99.9% rand_ (libftn.so: rand_.c, 67) [7] % 100.0% _write (libc.so.1: writeSCI.c, 27)

33 4- F. application : ADI résultats de perfex -a -y -x :
Typical Minimum Maximum Event Counter Name Counter Value Time (sec) Time (sec) Time (sec) =============================================================================================================== 0 Cycles 16 Cycles 26 Secondary data cache misses 23 TLB misses 7 Quadwords written back from scache 25 Primary data cache misses 22 Quadwords written back from primary data cache 21 Graduated floating point instructions 9 Primary instruction cache misses 10 Secondary instruction cache misses Statistics ===================================================================================== Graduated instructions/cycle Graduated floating point instructions/cycle Graduated loads & stores/cycle Graduated loads & stores/floating point instruction L1 Cache Line Reuse L2 Cache Line Reuse L1 Data Cache Hit Rate L2 Data Cache Hit Rate Time accessing memory/Total time L1--L2 bandwidth used (MB/s, average per process) Memory bandwidth used (MB/s, average per process) MFLOPS (average per process)

34 4- F. application : ADI résultats de perfex -e 23 :
Summary for execution of ./adi2 0 Cycles 23 TLB misses résultats de perfex -e 26 : 0 Cycles 26 Secondary data cache misses exécution ssrun -hwc : #!/bin/csh setenv _SPEEDSHOP_HWC_COUNTER_NUMBER 23 setenv _SPEEDSHOP_HWC_COOUNTER_OVERFLOW 2053 ssrun -prof_hwc ./adi2 setenv _SPEEDSHOP_HWC_COUNTER_NUMBER 26 setenv _SPEEDSHOP_HWC_COUNTER_OVERFLOW 2053

35 4- F. application : ADI résultats de ssrun -hwc (23) par prof -heavy :
Summary of perf. counter overflow PC sampling data (prof_hwc)-- 2816: Total samples TLB misses (23): Counter name (number) 2053: Counter overflow value : Total counts Function list, in descending order by counts [index] counts % cum.% samples function (dso: file, line) [1] % 100.0% zsweep (adi2: adi2.f90, 110) % 100.0% TOTAL Line list, in descending order by counts counts % cum.% samples function (dso: file, line) zsweep (adi2: adi2.f90, 120) zsweep (adi2: adi2.f90, 124) zsweep (adi2: adi2.f90, 110)

36 4- F. application : ADI résultats de ssrun -hwc (26) par prof -heavy :
Summary of perf. counter overflow PC sampling data (prof_hwc)-- 3545: Total samples Secondary cache D misses (26): Counter name (number) 2053: Counter overflow value : Total counts Function list, in descending order by counts [index] counts % cum.% samples function (dso: file, line) [1] % 91.9% zsweep (adi2: adi2.f90, 110) [2] % 95.2% xsweep (adi2: adi2.f90, 70) [3] % 98.5% ysweep (adi2: adi2.f90, 90) [4] % 100.0% adi2 (adi2: adi2.f90, 1) % 100.0% **OTHER** (includes excluded DSOs, rld, etc.) % 100.0% TOTAL Line list, in descending order by counts counts % cum.% samples function (dso: file, line) zsweep (adi2: adi2.f90, 120) zsweep (adi2: adi2.f90, 124) xsweep (adi2: adi2.f90, 80) ysweep (adi2: adi2.f90, 100)

37 4- F. application : ADI Analyse : Solution :
=> problème de cache thrashing. - les adresses de stockage de données dans le cache sont calculées par modulo à partir des adresses mémoire; - taille du cache en 2^p, dimensions des tableaux en 2^q; - écrasement des données dans les caches car modulos identiques; Solution : => modifier les premières dimensions des tableaux pour décaler les adresses de stockage dans les caches. integer, parameter :: ldx = 129 integer, parameter :: ldy = 129 integer, parameter :: ldz = 128 integer, parameter :: nx = 128 integer, parameter :: ny = 128 integer, parameter :: nz = 128 real(rp), dimension(ldx, ldy, ldz) :: data

38 4- F. application : ADI démarche :
6) analyser les évènements avec perfex -a -y -x; 7) affiner les valeurs des principaux compteurs avec perfex -e e0; 8) localiser les lignes du source responsables avec ssrun -hwc.

39 4- F. application : ADI résultat de perfex -a -y -x
Typical Minimum Maximum Event Counter Name Counter Value Time (sec) Time (sec) Time (sec) =============================================================================================================== 0 Cycles 16 Cycles 23 TLB misses 26 Secondary data cache misses 7 Quadwords written back from scache 25 Primary data cache misses 21 Graduated floating point instructions 22 Quadwords written back from primary data cache 9 Primary instruction cache misses 10 Secondary instruction cache misses Statistics ===================================================================================== Graduated instructions/cycle Graduated floating point instructions/cycle Graduated loads & stores/cycle Graduated loads & stores/floating point instruction L1 Cache Line Reuse L2 Cache Line Reuse L1 Data Cache Hit Rate L2 Data Cache Hit Rate Time accessing memory/Total time L1--L2 bandwidth used (MB/s, average per process) Memory bandwidth used (MB/s, average per process) MFLOPS (average per process)

40 4- F. application : ADI résultat de perfex -e 23 :
Summary for execution of ./adi5 0 Cycles 23 TLB misses résultat de perfex -e 26 : 0 Cycles 26 Secondary data cache misses résultat de ssrun -hwc (23) par prof -heavy Function list, in descending order by counts [index] counts % cum.% samples function (dso: file, line) [1] % 100.0% zsweep (adi5: adi5.f90, 110) [2] % 100.0% fake_adi (adi5: adi5.f90, 1) Line list, in descending order by counts counts % cum.% samples function (dso: file, line) zsweep (adi5: adi5.f90, 120) zsweep (adi5: adi5.f90, 124)

41 4- F. application : ADI Analyse : Solution :
=> problème de TLB thrashing. - chaque entrée dans cette table correspond à une page mémoire adressée - trop de pages différentes sont parcourues; - la table est regénérée en permanence à cause des boucles de calcul. Solution : - stocker le vecteur des données du calcul dans un vecteur temporaire; - routine de copie : do j = 1, ny call copy(data(1,j,1),ldx*ldy,temp,nx,nx,nz) do i = 1, nx call zsweep(temp(i,1),nx,nz) end do call copy(temp,nx,data(1,j,1),ldx*ldy,nx,nz)

42 4- F. application : ADI démarche :
9) analyser les évènements avec perfex -a -y -x.

43 4- F. application : ADI résultat de perfex -a -y -x
Typical Minimum Maximum Event Counter Name Counter Value Time (sec) Time (sec) Time (sec) =============================================================================================================== 0 Cycles 16 Cycles 25 Primary data cache misses 22 Quadwords written back from primary data cache 26 Secondary data cache misses 7 Quadwords written back from scache 21 Graduated floating point instructions 23 TLB misses 9 Primary instruction cache misses 10 Secondary instruction cache misses Statistics ===================================================================================== Graduated instructions/cycle Graduated floating point instructions/cycle Graduated loads & stores/cycle Graduated loads & stores/floating point instruction L1 Cache Line Reuse L2 Cache Line Reuse L1 Data Cache Hit Rate L2 Data Cache Hit Rate Time accessing memory/Total time L1--L2 bandwidth used (MB/s, average per process) Memory bandwidth used (MB/s, average per process) MFLOPS (average per process)

44 4- F. application : commentaires
La comparaison des temps ideal et réel montre une différence importante : un événement extérieur survient; pertes des données dûes au cache thrashing et au TLB thrashing; cache thrashing : les dimensions des tableaux multi-dimensionnels ne doivent pas être des puissances de 2 : => augmentation mémoire généralement légère, => augmentation des performances significative; TLB thrashing : les copies dans des tableaux temporaires peuvent résoudre les pertes de performance; => le compilateur ne sait pas le faire, => c’est du ressort du développeur.

45 5- load balancing MPI A. algorithme B. sous-domaines C. communications
D. cvbuild E. cvmake F. portage G. ssaggregate H. application I. comparaison J. conclusions

46 5- A. load balancing MPI : algorithme
problème de Poisson, différences finies 2D méthode itérative de Jacobi schéma à 5 points classique : u(i,j)(n+1)= 0.25 * { u(i+1,j )(n) + u(i-1,j )(n) + u(i ,j+1)(n) + u(i ,j-1)(n) - h*h*f(i,j) } test d’arrêt sur la convergence ou nombre max d’itérations le domaine initial est coupé en sous-domaines, chaque processus calcule sur son sous-domaine une couche de noeuds fictifs autour de chaque sous-domaines, mises à jour par des communications MPI.

47 5- B. load balancing MPI : sous-domaines
Topologie MPI : mettre une grille de processus sur la grille des sous-domaines.

48 5- C. load balancing MPI : communications
couche de noeuds fictifs (épaisseur 1 noeud) sur les 4 cotés.

49 5- D. load balancing MPI : cvbuild
outil d’analyse de dépendance pour la compilation; interrogations sur les targets : menu query.

50 5- E. load balancing MPI : cvmake
outil d’aide à la compilation; navigation dans le source, d’erreur en erreur.

51 5- F. load balancing MPI : portage
progresser dans les niveaux d’optimisation du programme en comparant les résultats avec des valeurs de référence (code séquentiel puis code parallèle sans optimisation). démarche : -O0 -g3 -DEBUG:… : pas d’optimisation, -O2 : optimisations fiables, -O3 -OPT:IEEE_arithmetic=1:roundoff=0 : optimisations aggressives, -O3 -OPT:IEEE_arithmetic=3:roundoff=3 : optimisations très aggressives. valider chaque étape.

52 5- G. load balancing MPI : ssaggregate
outil pour fusionner des fichiers de données issus du même type d’expérience. syntaxe : ssaggregate -e expfile1 expfile2 … -o outputfile analyse faite par prof ssrun sur un code MPI : mpirun -np n ssrun -fpcsampx prog [args] ssrun sur un code OpenMP : setenv OMP _NUM _THREADS n ssrun -fpcsampx prog [args]

53 5- H. load balancing MPI : application
but : étudier le load balancing des calculs sur les processus. principe : profilage du code MPI par ssrun. démarche : 1) compiler le code séquentiel et le code parallèle; 2) lancer les codes sous ssrun -fpcsampx sur le même cas test; 3) comparer les résultats entre les processus MPI; 4) faire la fusion des fichiers et comparer avec le code séquentiel; 5) faire varier la taille du maillage et le nombre de processus (2^p).

54 5- I. load balancing MPI : indications
comparer les temps des différents processus pour une même routine et leur somme avec le temps séquentiel; comparer le temps du processus le plus long avec le temps séquentiel pour évaluer l’accélération et l’efficacité; accélération : A(p) = T(1) / T(p) efficacité : E(p) = A(p) / p regarder le temps passé en communications par rapport au temps total : overhead MPI

55 5- I. load balancing MPI : ntx = 200
| ntx = 200 | p0 | p1 | 2p || 1p | | calcul | | | || | | erreur | | | || | A(2) = / = 1.99 E(2) = 100% | total | | | || | | ntx = 200 | p0 | p1 | p2 | p3 | 4p || 1p | | calcul | | | | | || | | erreur | | | | | || | A(4) = 3.37 E(4) = 84% | total | | | | | || | | ntx = 200 | p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7 | 8p || 1p | | calcul | | | | | | | | | || | | erreur | | | | | | | | | || | A(8) = 3.95 E(8) = 49% | total | | | | | | | | | || |

56 5- I. load balancing MPI : ntx = 400
| ntx = 400 | p0 | p1 | 2p || 1p | | calcul | | | || | | erreur | | | || | A(2) = 4.05 E52) = 202% | total | | | || | | ntx = 400 | p0 | p1 | p2 | p3 | 4p || 1p | | calcul | | | | | || | | erreur | | | | | || | A(4) = 6.95 E(4) = 125% | total | | | | | || | | ntx = 400 | p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7 | 8p || 1p | | calcul | | | | | | | | | || | | erreur | | | | | | | | | || | A(8) = 13.02 E(8) = 163% | total | | | | | | | | | || |

57 5- I. load balancing MPI : ntx = 800
| ntx = 800 | p0 | p1 | 2p || 1p | | calcul | | | || | | erreur | | | || | A(2) = 1.94 E(2) = 97% | total | | | || | | ntx = 800 | p0 | p1 | p2 | p3 | 4p || 1p | | calcul | | | | | || | | erreur | | | | | || | A(4) = 7.95 E(4) = 199% | total | | | | | || | | ntx = 800 | p0 | p1 | p2 | p3 | p4 | p5 | p6 | p7 | 8p || 1p | | calcul | | | | | | | | | || | | erreur | | | | | | | | | || | A(8) = 11.61 E(8) = 145% | total | | | | | | | | | || |

58 5- I. load balancing MPI : conclusions
nombre de processus doit être adapté à la masse de calcul; temps de calcul significatif pour que les imprécisions des mesures soient “petites” (charge de la machine !); temps parallèle inférieur au temps séquentiel car plusieurs processus signifient aussi : plusieurs cache L2 donc volume de cache multiplié; données distribuées sur plusieurs mémoires locales, donc accès plus courts; overhead des communications à suivre.