Calcul Réparti et Grid Computing

Calcul Réparti et Grid Computing Patrick Amestoy et Michel Daydé (ENSEEIHT-IRIT) préparé en collaboration avec J.-Y. L Excellent (INRIA/LIP-ENS Lyon) 2014-2015 1 / 396

Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion Overview of the PVM computing environment The PVM3 user library Illustrative Example: a dot version of the matrix vector product Performance analysis and graphical interface 2 / 396

Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion Overview of the PVM computing environment The PVM3 user library Illustrative Example: a dot version of the matrix vector product Performance analysis and graphical interface 3 / 396

Intérêts du Calcul Haute-Performance Applications temps-critique Cas de calcul plus gros Diminution du temps de réponse Minimisation des coûts de calcul Difficultés Accès aux données : hiérarchie mémoire complexe Exploiter la localité des références aux données Identification et gestion du parallélisme dans une application Approche algorithmique 4 / 396

Systèmes parallèles: Les machines les plus puissantes sont à haut degré de parallélisme Le rapport prix / performance est attractif Plus que quelques constructeurs dans la course Systèmes plus stables Logiciels applicatifs et librairies disponibles Exploitation industrielle et commerciale : plus uniquement laboratoires de recherche Mais: travail algorithmique important et validation/maintenance difficile. Nouvelles évolutions: 1 core per chip multi-core chips Graphycal Processing units (GPU) supercomputing métacomputing ( grid computing ) 5 / 396

Classes de calculateurs Serveurs de calcul : Utilisables sur une large gamme d applications Multiprogrammation et temps partagé Stations de travail, serveurs départementaux, centre de calcul Calculateurs plus spécifiques : Efficaces sur une classe plus limitée de problèmes (haut degré de parallélisme) A cause de leur architecture ou de limitations du logiciel Par exemple architectures massivement parallèles (MPP, clusters de PC,...) Gains importants possibles avec rapport coût-performance intéressant Calculateurs spécialisés : Résolution d un problème (image processing, crash test,... ) Hardware et logiciels conçus pour cette application-cible Gains très importants possibles avec un rapport coût-performance très intéressant Par exemple, la machine MDGRAPE-3 (dynamique moléculaire) installée au Japon atteint 1 PFlop/s! 6 / 396

Besoins dans le domaine du calcul scientifique Science traditionnelle 1. Construire une théorie, 2. Effectuer des expériences ou construire un système. trop difficile (ex: souffleries de grandes tailles) trop cher (fabriquer un avion juste pour quelques expérimentations) trop lent (attente de l évolution du climat / de l univers) trop dangereux (armes, médicaments, expérimentations sur le climat) Calcul scientifique simuler le comportement de systèmes complexes grâce à la simulation numérique. lois physiques + algorithmes numériques + calculateurs haute 7 / 396

Exemples dans le domaine du calcul scientifique Contraintes de durée: prévision du climat 8 / 396

Quelques exemples dans le domaine du calcul scientifique Cost constraints: wind tunnels, crash simulation,... 9 / 396

Scale Constraints large scale: climate modelling, pollution, astrophysics tiny scale: combustion, quantum chemistry 10 / 396

Pourquoi des traitements parallèles? Besoins de calcul non satisfaits dans beaucoup de disciplines (pour résoudre des problèmes significatifs) Performance uniprocesseur proche des limites physiques Temps de cycle 0.5 nanoseconde (fréq: 2GH) 8 GFlop/s (avec 4 opérations flottantes / cycle) Calculateur 40 TFlop/s 5000 coeurs calculateurs massivement parallèles Pas parce que c est le plus simple mais parce que c est nécessaire Puissance actuelle (cf http://www.top500.org): Juin 2010, Cray XT5, Oak Ridge Natl Lab, 1.7Pflops, 300Tbytes, 224K coeurs Juin 2013, TH-IVB cluster, NUDT (Chine), 33.8Pflops, 1PetaByte, 3M coeurs 11 / 396

Quelques unités pour le calcul haute performance Vitesse 1 MFlop/s 1 Megaflop/s 10 6 opérations / seconde 1 GFlop/s 1 Gigaflop/s 10 9 opérations / seconde 1 TFlop/s 1 Teraflop/s 10 12 opérations / seconde 1 PFlop/s 1 Petaflop/s 10 15 opérations / seconde 1 EFlop/s 1 Exaflop/s 10 18 opérations / seconde Mémoire 1 MB / 1 Mo 1 Megabyte 10 6 octets 1 GB / 1 Go 1 Gigabyte 10 9 octets 1 TB / 1 To 1 Terabyte 10 12 octets 1 PB / 1 Po 1 Petabyte 10 15 octets 1 EB / 1 Eo 1 Exabyte 10 18 octets Origines grecques des préfixes : kilo (mille); Mega (grand); Giga (géant); Tera (monstre); Peta (cinq); Exa (six) 12 / 396

Mesures de performance Nombre d opérations flottantes par seconde (pas MIPS) Performance crête : Ce qui figure sur la publicité des constructeurs Suppose que toutes les unités de traitement sont actives On est sûr de ne pas aller plus vite : #unités fonctionnelles Performance crête = clock (sec.) Performance réelle : Habituellement très inférieure à la précédente Malheureusement 13 / 396

Rapport (Performance réelle / performance de crête) souvent bas!! Soit P un programme : 1. Processeur séquentiel: 1 unité scalaire (1 GFlop/s) Temps d exécution de P : 100 s 2. Machine parallèle à 100 processeurs: Chaque processor: 1 GFlop/s Performance crête: 100 GFlop/s 3. Si P : code séquentiel (10%) + code parallélisé (90%) Temps d exécution de P : 0.9 + 10 = 10.9 s Performance réelle : 9.2 GFlop/s 4. Performance réelle Performance de crête = 0.1 14 / 396

Loi d Amdahl f s fraction d une application qui ne peut pas être parallélisée f p = 1 f s fraction du code parallélisé N: nombre de processeurs Loi d Amdahl: t N ( fp N + f s)t 1 f s t 1 Speed-up: S = t 1 t N 1 f s+ fp N 1 f s Sequential Parallel t = f s t 1 t 3 t 2 t 1 15 / 396

Calculateur procs LINPACK LINPACK Perf. n = 100 n = 1000 crête Intel WoodCrest (1 core, 3GHz) 1 3018 6542 12000 HP ProLiant (1 core, 3.8GHz) 1 1852 4851 7400 HP ProLiant (1 core, 3.8GHz) 2 8197 14800 IBM eserver(1.9ghz, Power5) 1 1776 5872 7600 IBM eserver(1.9ghz, Power5) 8 34570 60800 Fujitsu Intel Xeon (3.2GHz) 1 1679 3148 12800 Fujitsu Intel Xeon (3.2GHz) 2 5151 6400 SGI Altix (1.5GHz Itanium2) 1 1659 5400 6000 NEC SX-8 (2 GHz) 1 2177 14960 16000 Cray T932 32 1129 (1 proc.) 29360 57600 Hitachi S-3800/480 4 408 (1 proc.) 20640 32000 Table: Performance (MFlop/s) sur la résolution d un système d équations linéaires (d après LINPACK Benchmark Dongarra [07]) 16 / 396

Machine Problème de Problème de petite taille grande taille PFlop/s computer - 36 secondes TFlop/s computer 2 secondes 10 heures CM2 64K 30 minutes 1 an CRAY-YMP-8 4 heures 10 ans ALLIANT FX/80 5 jours 250 ans SUN 4/60 1 mois 1500 ans VAX 11/780 9 mois 14,000 ans IBM AT 9 ans 170,000 ans APPLE MAC 23 ans 450,000 ans Table: Vitesse de certains calculateurs sur un problème Grand Challenge en 1995 (d après J.J. Dongarra) 17 / 396

Machine Problème de Problème de petite taille grande taille PFlop/s computer - 36 secondes TFlop/s computer 2 secondes 10 heures CM2 64K 30 minutes 1 an CRAY-YMP-8 4 heures 10 ans ALLIANT FX/80 5 jours 250 ans SUN 4/60 1 mois 1500 ans VAX 11/780 9 mois 14,000 ans IBM AT 9 ans 170,000 ans APPLE MAC 23 ans 450,000 ans Table: Vitesse de certains calculateurs sur un problème Grand Challenge en 1995 (d après J.J. Dongarra) Depuis, les problèmes Grand Challenge ont grossi! 18 / 396

Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion Overview of the PVM computing environment The PVM3 user library Illustrative Example: a dot version of the matrix vector product Performance analysis and graphical interface 19 / 396

Evolutions architecturales: historique Pour 1,000 $ : calculateur personnel plus performant, avec plus de mémoire et plus de disque qu un calculateur des années 70 avec 1,000,000 $ technologie et conception! Durant les 25 premières années de l informatique progrès : technologie et architecture Depuis les années 70 : conception basée sur les circuits intégrés performance : +25-30% par an pour les mainframes et minis qui dominaient l industrie Depuis la fin des années 70 : émergence du microprocesseur meilleure exploitation des avancées dans l intégration que pour les mainframes et les minis (intégration moindre) progression et avantage de coût (production de masse) : de plus en plus de machines sont basées sur les microprocesseurs possibilité de pourcentage d amélioration plus rapide = 35% par an 20 / 396

Evolutions architecturales: historique Deux changements sur le marché facilitent l introduction de nouvelles architectures : 1. utilisation décroissante de l assembleur (compatibilité binaire moins importante) 2. systèmes d exploitation standards, indépendants des architectures (e.g. UNIX) développement d un nouvel ensemble d architectures : RISC à partir de 85 performance : + 50% par an!!! Conséquences : plus de puissance : Performance d un PC > CRAY C90 (95) Prix très infèrieur Domination des microprocesseurs PC, stations de travail Minis remplacés par des serveurs à base de microprocesseurs Mainframes remplacés par des multiprocesseurs à faible nombre de processeurs RISC (SMP) Supercalculateurs à base de processeurs RISC (essentiellement MPP) 21 / 396

Moore s law Gordon Moore (co-fondateur d Intel) a prédit en 1965 que la densité en transitors des circuits intégrés doublerait tous les 24 mois. A aussi servi de but à atteindre pour les fabriquants. A été déformé: 24 18 mois nombre de transistors performance 22 / 396

Comment accroître la vitesse de calcul? Accélérer la fréquence avec des technologies plus rapides On atteint les limites: Conception des puces Consommation électrique et chaleur dissipée Refroidissement problème d espace On peut encore miniaturiser, mais: pas indéfiniment résistance des conducteurs (R = ρ l s ) augmente et.. la résistance est responsable de la dissipation d énergie (effet Joule). effets de capacités difficiles à maîtriser Remarque: 0.5 nanoseconde = temps pour qu un signal parcourt 15 cm de cable Temps de cycle 0.5 nanosecond 8 GFlop/s (avec 4 opérations flottantes par cycle) 23 / 396

Seule solution: le parallélisme parallélisme: exécution simultanée de plusieurs instructions à l intérieur d un programme A l intérieur d un processeur : micro-instructions traitement pipeliné recouvrement d instructions exécutées par des unités distinctes transparent pour le programmeur (géré par le compilateur ou durant l exécution) Entre des processeurs ou cœurs distincts: suites d instructions différentes exécutées synchronisations implicites (compilateur, parallélisation automatique) ou explicites (utilisateur) 24 / 396

Unités centrales haute-performance Concept clé: Traitement pipeliné : L exécution d une opération (arithmétique) est décomposée en plusieurs sous-opérations Chaque sous-opération est exécutée par une unité fonctionnelle dédiée = étage (travail à la chaine) Exemple pour une opérations diadique (a b c) : T1. Séparer mantisse et exposant T2. Multiplier mantisses T3. Additionner les exposants T4. Normaliser le résultat T5. Ajouter signe au résultat 25 / 396

Exemple pour des opérations diadiques (suite) Supposition: l opération a b c s effectue en 5 traitements élémentaires T1,T2,...,T5 d un cycle chacun. Quel est le nombre de cycles processeur pour la boucle suivante? Pour i = 1 à N A(i) = B(i) * C(i) Fin Pour Traitement non pipeliné: N * 5 cycles Traitement pipeliné (à la chaine): N + 5 cycles 1er cycle: T1(1) 2ème cycle: T1(2), T2(1) 3ème cycle: T1(3), T2(2), T3(1)... kème cycle: T1(k), T2(k-1), T3(k-2), T4(k-3), T5(k-4)... 26 / 396

Impact de l approche CRAY L approche CRAY (années 80) a eu un grand impact sur la conception des supercalculateurs : horloge la plus rapide possible unité vectorielle pipelinée sophistiquée registres vectoriels mémoire très haute performance multiprocesseurs à mémoire partagée processeurs vectoriels exploitent la régularité des traitements sur les éléments d un vecteur traitement pipeliné couramment utilisés sur les supercalculateurs vectorisation par le compilateur 27 / 396

Processeurs RISC Processeurs RISC : introduits sur le marché vers 1990 the attack of the killer micros pipeline sur les opérations scalaires performance proche de celle des processeurs vectoriels à fréquence égale plus efficaces sur des problèmes scalaires CISC (Complex Instruction Set Computer) Efficacité par un meilleur encodage des instructions RISC (Reduced Instruction Set Computer) Concept étudié fin des années 70 Décroître le nombre de cycles par instruction à 1 Jeu d instructions simple Hardware simplifié Temps de cycle plus faible 28 / 396

Idées maîtresses dans la conception des RISC : Instructions décodées en 1 cycle Uniquement l essentiel réalisé au niveau du hardware Interface load/store avec la mémoire Utilise intensivement le principe du pipeline pour obtenir un résultat par cycle même pour les opérations complexes Hiérarchie mémoire haute-performance Format d instructions simple RISC super scalaires ou superpipelines: plusieurs unités fonctionnelles 29 / 396

Architectures multi-cœurs Constats La quantité de composants / puce va continuer à augmenter La fréquence ne peut plus augmenter beaucoup (chaleur/refroidissement) Il est difficile de trouver suffisamment de parallélisme dans le flot d instructions d un processus Multi-cœurs plusieurs cœurs à l intérieur d un même processeur vus comme plusieurs processeurs logiques par l utilisateur Mais: multi-threading nécessaire au niveau de l application 30 / 396

Processeur Cell La PS3 est basée sur un processeur Cell (Sony,Toshiba,IBM) 1 Cell= un Power PC + 8 SPE (Synergetic Process. Elem.) 1 SPE = processeur vectoriel SIMD + DMA = 25.6 GFlop/s 204 GFlop/s de performance crête en arithmétique 32 bits (14.6 GFlop/s en 64 bits) D où regain d intérêt pour le calcul en 32 bits Mélange d arithmétiques simple et double précision (voir [13]) Typiquement: 32-bit pour le gros des calculs, 64 bits pour améliorer la précision Pas seulement sur processeur Cell

Example of mixed-precision arithmetic Solve Ax = b, A sparse with the sparse direct solver MUMPS Compare single precision + iterative refinement to double precision run (Number of steps of iterative refinements indicated on Figure). Speed-up obtained wrt double precision (Results from A. Buttari et.al., 2007) 32 / 396

Année Calculateur MFlop/s 1955-65 CDC 6600 1-10 1965-75 CDC 7600 10-100 IBM 370/195 ILLIAC IV 1975-85 CRAY-1, XMP, CRAY 2 100-1000 CDC CYBER 205 FUJITSU VP400 NEC SX-2 1985-1995 CRAY-YMP, C90 1000-100,000 ETA-10 NEC SX-3 FUJITSU VP2600 1995-2005 CRAY T3E 1.2 TFlop/s INTEL 1.8 TFlop/s IBM SP 16 TFlop/s HP 20 TFlop/s NEC 40 TFlop/s IBM Blue Gene 180 TFlop/s 2008 - Roadrunner 1 PFlop/s Table: Evolutions des performances par décennie

Problèmes On est souvent (en pratique) à 10% de la performance crête Processeurs plus rapides accès aux données plus rapide : organisation mémoire, communication inter-processeurs Hardware plus complexe : pipe, technologie, réseau,... Logiciel plus complexe : compilateur, système d exploitation, langages de programmation, gestion du parallélisme,... applications Il devient plus difficile de programmer efficacement 34 / 396

Problèmes de débit mémoire L accès aux données est un problème crucial dans les calculateurs modernes Accroîssement de la vitesse de calcul sans accroître le débit mémoire goulet d étranglement MFlop/s plus faciles que MB/s pour débit mémoire Temps de cyle processeurs 2 GHz (.5 ns) Temps de cycle mémoire 20 ns SRAM 50 ns DRAM 35 / 396

Comment obtenir de hauts débits mémoire? Plusieurs chemins d accès entre mémoire et processeurs CRAY XMP et YMP : 2 vector load + 1 vector store + 1 I/O utilisés pour accéder des vecteurs distincts NEC SX : chemins d accès multiples peuvent être aussi utilisés pour charger un vecteur (améliore le débit, mais pas la latence!) Plusieurs modules mémoire accédés simultanément (entrelaçage) Accès mémoire pipelinés Mémoire organisée hiérarchiquement La façon d accéder aux données peut affecter la performance: Minimiser les défauts de cache Minimiser la pagination mémoire Localité: améliorer le rapport références à des mémoires locales/ références à des mémoires à distance 36 / 396

Size Average access time (# cycles) hit/miss Registers < 1 1 128 KB Cache level #1 1 2 / 8 66 256 KB 16 MB Cache level #2 6 15 / 30 200 1 10 GB Main memory 10 100 Remote memory 500 5000 Disks 700,000 / 6,000,000 Figure: Exemple de hiérarchie mémoire. 37 / 396

Conception mémoire pour nombre important de processeurs? Comment 500 processeurs peuvent-ils avoir accès à des données rangées dans une mémoire partagée (technologie, interconnexion, prix?) Solution à coût raisonnable : mémoire physiquement distribuée (chaque processeur a sa propre mémoire locale) 2 solutions : mémoires locales globalement adressables : Calulateurs à mémoire partagée virtuelle transferts explicites des données entre processeurs avec échanges de messages Scalibité impose : augmentation linéaire débit mémoire / vitesse du processeur augmentation du débit des communications / nombre de processeurs Rapport coût/performance mémoire distribuée et bon rapport coût/performance sur les processeurs 38 / 396

Architecture des multiprocesseurs Nombre élevé de processeurs mémoire physiquement distribuée Organisation Organisation physique logique Partagée (32 procs max) Distribuée Partagée multiprocesseurs espace d adressage global à mémoire partagée (hard/soft) au dessus de messages mémoire partagée virtuelle Distribuée émulation de messages échange de messages (buffers) Table: Organisation des processeurs Remarque: standards de programmation Organisation logique partagée: threads, OpenMP Organisation logique distribuée: PVM, MPI, sockets 39 / 396

Remarques Mémoire physiquement partagée Temps d accès uniforme à toute la mémoire Mémoire physiquement distribuée Temps d accès dépend de la localisation de la donnée Mémoire logiquement partagée Espace d adressage unique Communications implicites via la mémoire partagée Mémoire logiquement distribuée Plusieurs espaces d adressage privés Communications explicites (messages)

Terminologie Architecture SMP (Symmetric Multi Processor) Mémoire partagée (physiquement et logiquement) et temps d accès uniforme à la mémoire Similaire du point de vue applicatif aux architectures multi-cœurs (1 cœur = 1 processeur logique) Mais communications bcp plus rapides dans les multi-cœurs (latence < 3ns, bande passantee > 20 GB/s) que dans les SMP (latence 60ns, bande passantee 2 GB/s) Architecture NUMA (Non Uniform Memory Access) Mémoire physiquement distribuée et logiquement partagée (plus facile d augmenter le nombre de procs qu en SMP) Temps d accès dépend de la localité (accès locaux plus rapides ; hardware assure cohérence des caches (ccnuma)) 41 / 396

Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion Overview of the PVM computing environment The PVM3 user library Illustrative Example: a dot version of the matrix vector product Performance analysis and graphical interface 42 / 396

Classification de Flynn S.I.S.D. : Single Instruction Single Data stream architecture monoprocesseur calculateur von Neumann conventionnel exemples : SUN, PC S.I.M.D. : Single Instruction Multiple Data stream processeurs exécutent de façon synchrone la même instruction sur des données différentes (e.g. éléments d un vecteur, d une matrice, d une image) une unité de contrôle diffuse les instructions processeurs identiques Exemples : CM-2, DAP, MasPar,... plus récemment: chacun des 8 SPE du processeur CELL se comporte comme un système SIMD 43 / 396

M.I.S.D. : n existe pas M.I.M.D. : Multiple Instructions Multiple Data stream processeurs exécutent de façon asynchrone des instructions différentes sur des données différentes processeurs éventuellement hétérogènes chaque processeur a sa propre unité de contrôle exemples : ALLIANT, CONVEX, CRAYs, IBM SP, clusters BEOWULF, serveurs multi-processeurs, réseaux de stations de travail,... 44 / 396

Modes de programmation SIMD et MIMD Avantages du SIMD : Facilité de programmation et de débogage Processeurs synchronisés coûts de synchronisation minimaux Une seule copie du programme Décodage des instructions simple Avantages du MIMD : Plus flexible, beaucoup plus général Exemples: mémoire partagée: OpenMP, threads POSIX mémoire distribuée: PVM, MPI (depuis C/C++/Fortran) 45 / 396

Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion Overview of the PVM computing environment The PVM3 user library Illustrative Example: a dot version of the matrix vector product Performance analysis and graphical interface 46 / 396

Evolutions du Calcul Haute-Performance Mémoire virtuellement partagée : clusters Hiérarchie mémoire plus étendue Clusters de machines Souvent à base de PCs (Pentium ou Dec Alpha, NT ou LINUX) Programmation parallèle (mémoire partagée, transfert de message, data parallèle) : Efforts de définition de standards : Open MP et threads POSIX, MPI, HPF,... MPPs et clusters représentent l avenir pour le calcul haute-performance rapport puissance communications souvent faible par rapport aux de calcul multiprocesseurs à mémoire partagée intégration dans l ensemble des moyens de calcul d une entreprise de plus en plus courante 47 / 396

Environnements de programmation On n évitera pas le calcul parallèle Logiciels ont toujours un temps de retard / aux architectures Système d exploitation Parallélisation automatique Logiciels applicatifs et librairies scientifiques Pour des architectures massivement parallèles : Standard de programmation : MPI ou MPI + threads (POSIX/OpenMP) Langages: le plus souvent C ou Fortran Besoins d outils de dévelopement (débogueurs, compilateurs, analyseurs de performance, librairies,... ) Développements/maintenance difficiles et difficultés d utilisation des outils de mise au point. 48 / 396

HPC Spectrum (d après J.Dongarra) Peer to peer (SETI@home) Network of ws Grid based computing Beowulf cluster Clusters w/ special interconnect Parallel dist mem TFlop machines Distributed Systems - Gather (unused) resources - Steal cycles - System software manages resources - 10% - 20% overhead is OK - Resources drive applications - Completion time not critical - Time-shared - Heterogeneous 49 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 50 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 51 / 396

Introduction Conception d un supercalculateur Déterminer quelles caractéristiques sont importantes (domaine d application) Maximum de performance en respectant les contraintes de coût (achat, maintenance,consommation) Conception d un processeur : Jeu d instructions Organisation fonctionnelle et logique Implantation (intégration, alimentation,... ) Exemples de contraintes fonctionnelles vs domaine d application Machine généraliste : performance équilibrée sur un large ensemble de traitements Calcul scientifique : arithmétique flottante performante Gestion : base de données, transactionnel,... 52 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 53 / 396

Pipeline Pipeline = principe du travail à la chaîne un traitement est découpé en un certain nombre de sous-traitements réalisés par des unités différentes (étages du pipeline) les étages fonctionnent simultanément sur des opérandes différents (éléments de vecteurs par exemple) après amorçage du pipeline, on obtient un résultat par temps de cyle de base Processeur RISC : Pipeline sur des opérations scalaires indépendantes : a = b + c d = e + f Code exécutable plus complexe sur RISC : do i = 1, n a(i) = b(i) + c(i) enddo 54 / 396

Code correspondant : i = 1 boucle : load b(i) dans registre #1 load c(i) dans registre #2 registre #3 = registre #1 + registre #2 store registre #3 dans a(i) i = i + 1 et test fin de boucle Exploitation du pipeline déroulage de boucle do i = 1, n, 4 a(i ) = b(i ) + c(i ) a(i+1) = b(i+1) + c(i+1) a(i+2) = b(i+2) + c(i+2) a(i+3) = b(i+3) + c(i+3) enddo 55 / 396

Sur processeur vectoriel : do i = 1, n a(i) = b(i) + c(i) enddo load vector b dans registre #1 load vector c dans registre #2 register #3 = register #1 + register #2 store registre #3 dans vecteur a Stripmining : si n > nb (taille registres vectoriels) do i = 1, n, nb ib = min( nb, n-i+1 ) do ii = i, i + ib - 1 a(ii) = b(ii) + c(ii) enddo enddo 56 / 396

Problèmes dans la conception des pipelines Beaucoup d étages: coût d amorçage plus élévé performances plus sensibles à la capacité de nourrir le pipeline permet de réduire le temps de cycle Moins d étages sous-instructions plus complexes plus difficile de décroître le temps de cycle 57 / 396

Problèmes des dépendences de données Exemple : do i = 2, n a(i) = a(i-1) + 1 enddo a(i) initialisés à 1. Exécution scalaire : Etape 1 : a(2) = a(1) + 1 = 1 + 1 = 2 Etape 2 : a(3) = a(2) + 1 = 2 + 1 = 3 Etape 3 : a(4) = a(3) + 1 = 3 + 1 = 4... 58 / 396

Exécution vectorielle : pipeline à p étages p éléments dans le pipeline Etages du pipe ------------------------------------------- Temps 1 2 3... p sortie ------------------------------------------------------- t0 a(1) t0 + dt a(2) a(1) t0 + 2dt a(3) a(2) a(1)... t0 + pdt a(p+1) a(p)... a(2) a(1) ------------------------------------------------------- D où : a(2) = a(1) + 1 = 1 + 1 = 2 a(3) = a(2) + 1 = 1 + 1 = 2... car on utilise la valeur initiale de a(2). Résultat exécution vectorielle exécution scalaire 59 / 396

Overlapping (recouvrement) Utiliser des unités fonctionnelles en parallèle sur des opérations indépendantes. Exemple: do i = 1, n A(i) = B(i) * C(i) D(i) = E(i) + F(i) enddo Pipelined multiplier B A C E F Pipelined adder Time overlapping = max{startup mul, Startup add + dt} + n dt Time no overlap. = {Startup mul + n dt} + {Startup add + n dt} Avantages: parallélisme entre les unités fonctionnelles indépendantes et plus de flops par cycle D 60 / 396

Chaining (chaînage) La sortie d une unité fonctionnelle est dirigée directement vers l entrée d une autre unité fonctionnelle Exemple : B C do i = 1, n A(i) = ( B(i) * C(i) ) + D(i) enddo Pipelined multiplier Pipelined adder A D Time chaining = Startup mul + Startup add + n dt Time nochaining = {Startup mul + n dt} + {Startup add + n dt} Avantages : plus de flops par cyle, exploitation de la localité des données, économie de stockage intermédiaire 61 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 62 / 396

Locality of references Programs tend to reuse data and instructions recently used Often program spends 90% of its time in only 10% of code. Also applies - not as strongly - to data accesses : temporal locality : recently accessed items are likely to be accessed in the future spatial locality : items whose addresses are near one another tend to be referenced close together in time. 63 / 396

Concept of memory hierarchy - 1 Example : In hardware : smaller is faster On a high-performance computer using same technology (pipelining, overlapping,... ) for memory: signal propagation is a major cause of delay thus larger memories more signal delay and more levels to decode addresses. smaller memories are faster because designer can use more power per memory cell. 64 / 396

Concept of memory hierarchy - 2 Make use of principle of locality of references Data most recently used - or nearby data - are very likely to be accessed again in the future Try to have recently accessed data in the fastest memory Because smaller is faster use smaller memories to hold most recently used items close to CPU and successively larger memories farther away from CPU Memory hierarchy 65 / 396

Typical memory hierarchy access bandwidth Level Size time MB/s technology manag. Registers 1KB 2-5 ns 400-32,000 (BI)CMOS compiler Cache 4MB 3-10 ns 800-5,000 CMOS SRAM hardware Main memory 4GB 80-400 ns 400-2,000 CMOS DRAM OS Disk 1GB 5 10 6 ns 4-32 magnetic disk OS/user 66 / 396

Memory interleaving Memory Interleaving "The memory is subdivided into several independent memory modules (banks)" Two basic ways of distributing the addresses Example: Memory size 2 10 =1024 Words divided into 8 banks High order interleaving Real a(256) Low order interleaving Banks Banks 1 2 3 4 5 6 7 8 a(1), a(2),..., a(128) a(129),..., a(256) 1 2 3 4 5 6 7 8 a(1), a(9),..., a(249) a(2), a(10),..., a(250) a(3),a(11),..., a(251) a(4),... a(5),... a(6),... a(7),..., a(255) a(8), a(16),..., a(256) "well adapted to pipelining memory access" 67 / 396

Effect of bank cycle time Bank cycle time: Time interval during which the bank cannot be referenced again Example Low order interleaved memory, 4 banks, bank cycle time 3CP. % column access %row access Real a(4,2) Real a(4,2) Do j=1,2 Do i=1,4 Do i=1,4 Do j=1,2... = a(i,j)... = a(i,j) Enddo Enddo Enddo Enddo Bank Bank 1 a(1,1) a(1,2) 1 a(1,1) a(1,2) a(2,1) a(2,2) a(2,1) a(2,2) 2 2 3 a(3,1) a(3,2) 3 a(3,1) a(3,2) 4 a(4,1) a(4,2) 4 a(4,1) a(4,2) 1 CP 10 Clock Period time 18 Clock Period Bank Conflict: Consecutive accesses to the same bank in less than bank cycle time. Stride: Memory address interval between successive elements 68 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 69 / 396

Organisation interne et performance des processeurs vectoriels (d après J. Dongarra) Soit l opération vectorielle triadique : do i = 1, n y(i) = alpha * ( x(i) + y(i) ) enddo On a 6 opérations : 1. Load vecteur x 2. Load vecteur y 3. Addition x + y 4. Multiplication alpha ( x + y ) 5. Store dans vecteur y 70 / 396

Organisations de processeur considérées : 1. Séquentielle 2. Arithmétique chaînée 3. Load mémoire et arithmétique chaînées 4. Load mémoire, arithmétique et store mémoire chaînés 5. Recouvrement des loads mémoire et opérations chaînées Notations : a : startup pour load mémoire b : startup pour addition c : startup pour multiplication d : startup pour store mémoire 71 / 396

Sequential Machine Organization a load x a load y memory path busy b add. c mult. d store Chained Arithmetic a load x a load y b add. memory path busy c mult. d store 72 / 396

Chained Load and Arithmetic a load x a load y b add. c mult. memory path busy d store Chained Load, Arithmetic and Store a load x a load y memory path busy b c add. mult. d store 73 / 396

Overlapped Load with Chained Operations a load x a b load y add. c mult. d store memory path 1 busy memory path 2 busy memory path 3 busy 74 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 75 / 396

Organisation des processeurs RISC The execution pipeline Instruction Fetch Instruction Decode Execution Memory access and branch completion Write back (write results in register file) Example (DLX processor, Hennessy and Patterson, 96 [11]) Pipeline increases the instruction throughput Pipeline hazards: prevents the next instruction from executing Structural hazards: arising from hardware resource conflicts Data hazards: due to dependencies between instructions Control hazards: branches for example 76 / 396

Instruction Level Parallelism (ILP) Pipelining: overlap execution of independent operations Instruction Level Parallelism Techniques for increasing amount of parallelism among instructions: reduce the impact of data and control hazards increase the ability of processor to exploit parallelism compiler techniques to increase ILP Main techniques loop unrolling basic and dynamic pipeline scheduling dynamic branch prediction Issuing multiple instructions per cycle compiler dependence analysis software pipelining trace scheduling / speculation... 77 / 396

Instruction Level Parallelism (ILP) Simple and common way to increase amount of parallelism is to exploit parallelism among iterations of a loop : Loop Level Parallelism Several techniques : Unrolling a loop statically by compiler or dynamically by the hardware Use of vector instructions 78 / 396

ILP: Dynamic scheduling Hardware rearranges the instruction execution to reduce the stalls. Advantage: handle cases where dependences are unknown at compile time and simplifies the compiler But: significant increase in hardware complexity Idea: execute instructions as soon as their data are available Out-of-order execution Handling exceptions becomes tricky 79 / 396

ILP: Dynamic scheduling Scoreboarding: technique allowing instruction out-of-order execution when resources are sufficient and when no data dependences full responsability for instruction issue and execution goal : try to maintain an execution rate of one instruction / clock by executing instructions as early as possible requires multiple instructions to be in the EX stage simultaneously multiple functional units and/or pipelined units Scoreboard table record/update data dependences + status of functional units Limits: amount of parallelism available between instructions number of scoreboard entries: set of instructions examined (window) number and type of functional units 80 / 396

ILP: Dynamic scheduling Other approach : Tomasulo s approach (register renaming) Suppose compiler has issued: F10 <- F2 x F2 F2 <- F0 + F6 Rename F2 to F8 in the second instruction (assuming F8 is not used) F10 <- F2 x F2 F8 <- F0 + F6 Can be used in conjunction with scoreboarding 81 / 396

Impact of ILP : example This example is from J.L. Hennessy and D.A. Patterson (1996) [11]. Original Fortran code do i = 1000, 1 x(i) = x(i) + temp enddo Pseudo-assembler code R1 <- address(x(1000)) load temp -> F2 Loop : load x(i) -> F0 F4 = F0 + F2 store F4 -> x(i) R1 = R1 - #8 % decrement pointer BNEZ R1, Loop % branch until end of loop 82 / 396

Architecture Integer Unit 1 stage FP add 4 stages IF ID MEM WB FP mult 4 stages Divide not pipelined Example of pipelined processor (DLX processor, Hennessy and Patterson, 96 [11]) 83 / 396

Latency: # cycles between instruction that produces result and instruction that uses result Initiation interval : # cycles between issuing 2 instructions of same type Latency = 0 means results can be used next cycle Functional unit Latency Initiation interval Integer ALU 0 1 Loads 1 1 FP add 3 1 FP mult 3 1 FP divide 24 24 Characteristics of the processor Inst. producing result Inst. using result Latency FP op FP op 3 FP op store double 2 Load double FP op 1 Load double store double 0 Latency between instructions Latency FP op to store double : forwarding hardware passes result from ALU directly to memory input. 84 / 396

Straightforward code #cycle Loop : load x(i) -> F0 1 load lat. = 1 stall 2 F4 = F0 + F2 3 stall 4 FP op -> store = 2 stall 5 store F4 -> x(i) 6 R1 = R1 - #8 7 BNEZ R1, Loop 8 stall 9 delayed branch 1 9 cycles per iteration Cost of calculation 9,000 cycles Peak performance : 1 flop/cycle Effective performance : 1 9 of peak 85 / 396

With a better scheduling #cycle Loop : load x(i) -> F0 1 load lat. = 1 stall 2 F4 = F0 + F2 3 R1 = R1 - #8 4 Try keep int. unit busy BNEZ R1, Loop 5 store F4 -> x(i) 6 Hide delayed branching by store 6 cycles per iteration Cost of calculation 6,000 cycles Effective performance : 1 6 of peak 86 / 396

Using loop unrolling (depth = 4) do i = 1000, 1, -4 x(i ) = x(i ) + temp x(i-1) = x(i-1) + temp x(i-2) = x(i-2) + temp x(i-3) = x(i-3) + temp enddo 87 / 396

Pseudo-assembler code (loop unrolling, depth=4): #cycle Loop : load x(i) -> F0 1 1 stall F4 = F0 + F2 3 2 stalls store F4 -> x(i) 6 load x(i-1) -> F6 7 1 stall F8 = F6 + F2 9 2 stalls store F8 -> x(i-1) 12 load x(i-2) -> F10 13 1 stall F12= F10+ F2 15 2 stalls store F12-> x(i-2) 18 load x(i-3) -> F14 19 1 stall F16= F14+ F2 21 2 stalls store F16-> x(i-3) 24 R1 = R1 - #32 25 BNEZ R1, Loop 26 stall 27 27 cycles per iteration Cost of calculation 1000 4 27 = 6750 cycles Effective performance : 1000 6750 = 15% of peak 88 / 396

Using loop unrolling (depth = 4) and scheduling #cycle Loop : load x(i) -> F0 1 load x(i-1) -> F6 2 load x(i-2) -> F10 3 load x(i-3) -> F14 4 F4 = F0 + F2 5 F8 = F6 + F2 6 F12= F10+ F2 7 F16= F14+ F2 8 store F4 -> x(i) 9 store F8 -> x(i-1) 10 store F12-> x(i-2) 11 R1 = R1 - #32 12 BNEZ R1, Loop 13 store F16-> x(i-3) 14 14 cycles per iteration Cost of calculation 1000 4 14 = 3500 cycles Effective performance : 1000 3500 = 29% of peak 89 / 396

Now assume superscalar pipeline : integer and floating point operations can be issued simultaneously Using loop unrolling with depth = 5 Integer inst. Float.inst. #cycle Loop: load x(i) -> F0 1 load x(i-1)-> F6 2 load x(i-2)-> F10 F4 =F0 +F2 3 load x(i-3)-> F14 F8 =F6 +F2 4 load x(i-4)-> F18 F12=F10+F2 5 store F4 ->x(i) F16=F14+F2 6 store F8 ->x(i-1) F20=F18+F2 7 store F12->x(i-2) 8 store F16->x(i-3) 9 R1 = R1 - #40 10 BNEZ R1, Loop 11 store F20->x(i-4) 12 12 cycles per iteration Cost of calculation 1000 5 12 = 2400 cycles Effective performance : 1000 2400 = 42% of peak Performance limited by balance between int. and float. instr. 90 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 91 / 396

Réutilisation des données (dans les registres) Améliorer l accès aux données et exploiter la localité spatiale et temporelle des références mémoire Déroulage de boucles : réduit le nombre d accès mémoire en utilisant le plus de registres possible Utiliser des scalaires temporaires Distribution de boucles : si nombre de données réutilisables > nombre de registres : substituer plusieurs boucles à une seule 92 / 396

Déroulage de boucle Objectif : réduire nombre d accès mémoire et améliorer pipeline opérations flottantes. Produit matrice-vecteur : y y + A t x 2 variantes : do... do... y(i) = y(i) + x(j)*a(j,i) enddo enddo AXPY : do j = 1, N do i = 1, N... DOT do i = 1, N do j = 1, N... 93 / 396

DOT variant Processeurs RISC mieux adaptés à DOT que AXPY do i = 1, N temp = 0. do j = 1, N temp = temp + x(j)*a(j,i) enddo y(i) = y(i) + temp enddo Stride = 1 dans boucle la plus interne load A(j,i) load x(j) perform x(j)*a(j,i) + temp Ratio Flops/références mémoire = 2 2 = 1 94 / 396

Réutilisation de x(j) : déroulage à une profondeur 2 * Cleanup odd iteration i = MOD(N,2) if ( i >= 1 ) then do j = 1, N y(i) = y(i) + x(j)*a(j,i) enddo end if * Main loop imin = i + 1 do i = imin, N, 2 temp1 = 0. temp2 = 0. do j = 1, N temp1 = temp1 + A( j,i-1) * x(j) temp2 = temp2 + A( j,i ) * x(j) enddo y(i-1) = y(i-1) + temp1 y(i ) = y(i ) + temp2 enddo 95 / 396

load A(j,i-1) load x(j) perform A(j, i-1 ) * x(j) + temp1 load A(j,i) perform A(j,i ) * x(j) + temp2 Ratio Flops/références mémoire = 4 3 Déroulage à une profondeur de 4 : 8 5 Déroulage à une profondeur k: 2k k+1 96 / 396

45 Performance of y = At x on HP 715/64 40 35 Rolled Unrolled 2 Unrolled 4 Unrolled 8 30 MFlops 25 20 15 10 5 0 200 400 600 800 1000 1200 Size Figure: Effect of loop unrolling on HP 715/64 97 / 396

50 Performance of y = At x on CRAY T3D 45 40 35 Rolled Unrolled 2 Unrolled 4 Unrolled 8 MFlops 30 25 20 15 10 5 0 200 400 600 800 1000 1200 Size Figure: Effect of loop unrolling on CRAY T3D 98 / 396

AXPY variant Habituellement préférée sur processeurs vectoriels do j = 1, N do i = 1, N y(i) = y(i) + x(j)*a(j,i) enddo enddo Stride > 1 dans la boucle la plus interne load A(j,i) load y(i) perform x(j)*a(j,i) + y(i) store result in y(i) Ratio Flops/références mémoire = 2 3 99 / 396

Réutilisation de y(i) : déroulage à profondeur 2 * Cleanup odd iteration j = MOD(N,2) if ( j.ge. 1 ) then do i = 1, N y(i) = y(i) + x(j)*a(j,i) enddo end if * Main loop jmin = j + 1 do j = jmin, N, 2 do i = 1, N y(i) = y(i)+a(j-1,i)*x(j-1)+a(j,i)*x(j) enddo enddo

load y(i) load A(j-1,i) perform A(j-1,i ) * x(j-1) + y(i) load A(j,i) perform A(j,i) * x(j) + y(i) store result in y(i) Ratio Flops/références mémoire = 1 Déroulage à profondeur 4 Ratio = 4 3 Déroulage à profondeur p Ratio = 2p 2+p 101 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 102 / 396

Organisation d une mémoire cache Cache Buffer rapide entre les registres et la mémoire principale Divisé en lignes de cache Ligne de cache Unité de transfert entre cache et mémoire principale Défaut de cache Référence à une donnée non présente dans le cache Stratégie de choix d une ligne à remplacer (LRU parmi les éligibles) Une ligne de cache contenant la donnée est chargée de la mémoire principale dans le cache Problème de la cohérence de cache sur les multiprocesseurs à mémoire partagée Rangement des données dans les caches correspondance mémoire emplacements dans le cache 103 / 396

Stratégies les plus courantes : direct mapping fully associative set associative Conception des caches : L octets par ligne de cache K lignes par ensemble (K est le degré d associativité) N ensembles Correspondance simple entre l adresse en mémoire et un ensemble : N = 1 : cache fully associative K = 1 : cache direct mapped 104 / 396

Direct mapping Chaque bloc en mémoire un placement unique dans le cache Recherche de données dans cache peu coûteuse (mais remplacement coûteux) Problème de contention entre les blocs line cache Fully associative Pas de correspondance a priori Recherche de données dans cache coûteuse main memory 105 / 396

Set associative Cache divisé en plusieurs ensembles Chaque bloc en mémoire peut être dans l une des lignes de l ensemble 4-way set associative : 4 lignes par ensemble cache set #k line 1 line 2 line 3 line 4 line main memory 106 / 396

Gestion des caches Coût d un défaut de cache : entre 2 et 50 C (temps de cycle) Copyback Pas de m-à-j lorsqu une ligne de cache est modifiée, excepté lors d un cache flush ou d un défaut de cache Mémoire pas toujours à jour. Pas de problème de cohérence si les processeurs modifient des lignes de cache indépendantes Writethrough Donnée écrite en mémoire chaque fois qu elle est modifiée Données toujours à jour. Pas de problème de cohérence si les processeurs modifient des données indépendantes 107 / 396

Cache coherency problem Processor # 1 Processor # 2 cache cache cache line X Y Cache coherency mechanisms to: avoid processors accessing old copies of data (copyback and writethrough) update memory by forcing copyback invalidate old cache lines 108 / 396

Cache coherency problem Processor # 1 Processor # 2 cache cache X Y cache line Cache coherency mechanisms to: avoid processors accessing old copies of data (copyback and writethrough) update memory by forcing copyback invalidate old cache lines Example of mechanism (snooping): assume writethrough policy Each processor observes the memory accesses from others If a write operation occurs that corresponds to a local cacheline, invalidate local cacheline 109 / 396

Processor Line size Level Size Organization miss Access / cycle DEC 21164 32 B 1 8 KB Direct-mapped 2 C 2 2 96 KB 3-way ass. 8 C 2 3 1-64 MB Direct-mapped 12 C 2 IBM Power2 128 B / 1 128 KB / 4-way-ass. 8 C 2 256 B 256 KB MIPS R8000 16 B 1 16 KB Direct-mapped 7 C 2 2 4-16 MB 4-way-ass. 50 C 2 Cache configurations on some computers. : data + instruction cache Current trends: Large caches of several MBytes Several levels of cache 110 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 111 / 396

Réutilisation des données (dans les caches) Example cache 10 times faster than memory, hits 90% of the time. What is the gain from using the cache? Cost cache miss: tmiss Cost cache hit: thit = 0.1 t miss Average cost: 112 / 396

Réutilisation des données (dans les caches) Example cache 10 times faster than memory, hits 90% of the time. What is the gain from using the cache? Cost cache miss: tmiss Cost cache hit: thit = 0.1 t miss Average cost: 90%(0.1 t miss ) + 10% t miss t gain = miss 100% 1 90% (0.1 t miss )+10% t miss = (0.9 0.1)+0.1 = 1 0.19 = 5.3 (similar to Amdahl s law) 113 / 396

Réutilisation des données (dans les caches) Il est critique d utiliser au maximum les données dans le cache améliorer le % de succès de cache Exemple : effet du % de défauts de cache sur un code donné Pmax performance lorsque toutes les données tiennent dans le cache (hit ratio = 100%). T min temps correspondant. Lecture de donnée dans le cache par une instruction et exécution : t hit = 1 cycle Temps d accès à une donnée lors d un défaut de cache : tmiss = 10 ou 20 cycles (exécution instruction t miss + t hit ) T total = %hits.t hit + %misses (t miss + t hit ) T opt = 100% t hit Perf = Topt T total 114 / 396

Tmiss %hits Tps hits Tps misses Ttotal Perf. 100% 1.00 0.00 1.00 100% 10 99% 0.99 0.11 1.10 91% 20 99% 0.99 0.21 1.20 83% 10 95% 0.95 0.55 1.50 66% 20 95% 0.95 1.05 2.00 50% Table: Effet des défauts de cache sur la performance d un code (exprimés en pourcentages vs pas de défaut de cache). 115 / 396

Efficient cache utilization: Exercise Reuse as much as possible data held in cache Improve cache hit ratio Cache : single block of CS (cache size) words When cache is full: LRU line returned to memory Copy-back: memory updated only when a modified block removed from cache For simplicity, we assume cache line size L=1 Example from D. Gannon and F. Bodin : do i=1,n do j=1,n a(j) = a(j) + b(i) enddo enddo 1. Compute the cache hit ratio (assume n much larger than CS). 2. Propose a modification to improve the cache hit ratio. 116 / 396

Total number of memory references = 3 n 2 i.e. n 2 loads for a, n 2 stores for a, and n 2 loads for b (assuming the compiler is stupid). Total number of flops = n 2 Cache empty at beginning of calculations. Inner loop: do j=1,n a(j) = a(j) + b(i) enddo Each iteration reads a(j) and b(i), and writes a(j) For i=1 access to a(1:n) For i=2 access to a(1:n) As n >> CS, a(j) no longer in cache when accessed again, therefore: each read of a(j) 1 miss each write of a(j) 1 hit each read of b(i) 1 hit (except the first one) # of hits Hit ratio = Mem.Refs = 2 3 = 66% 117 / 396

blocked version The inner loop is blocked into blocks of size nb < CS so that nb elements of a can be kept in cache and entirely updated with b(1:n). do j=1,n,nb jb = min(nb,n-j+1)! nb may not divide n do i=1,n do jj=j,j+jb-1 a(jj) = a(jj) + b(i) enddo enddo enddo 118 / 396

To clarify we load the cache explicitely; it is managed as a 1D array : CA(0:nb) do j=1,n,nb jb = min(nb,n-j+1) CA(1:jb) = a(j:j+jb-1) do i=1,n CA(0) = b(i) do jj=j,j+jb-1 CA(jj-j+1) = CA(jj-j+1) + CA(0) enddo enddo a(j:j+jb-1) = CA(1:jb) enddo Each load into cache is a miss, each store to cache is a hit. 119 / 396

Total memory references = 3n 2 Total misses: load a = n nb nb load b = n nb n Total = n + n 2 nb Total hits = 3n 2 n n2 nb = (3 1 nb ) n2 n Hit ratio = hits Mem.Refs 1 1 3nb 100% if nb is large enough. 120 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 121 / 396

Mémoire virtuelle Mémoire réelle : code et données doivent être logés en mémoire centrale Mémoire virtuelle : mécanisme de pagination entre la mémoire et les disques Une pagination mémoire excessive peut avoir des conséquences dramatiques sur la performance!!!! TLB : Translation Lookaside Buffer : correspondance entre l adresse virtuelle et l adresse réelle d une page en mémoire TLB sur IBM Power4/5: 1024 entrées Défaut de TLB : 36 C environ AIX offre la possibilité d augmenter la taille des pages (jusqu à 16 MB) pour limiter les défauts de TLB. 122 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 123 / 396

Exercice sur la réutilisation des données (en mémoire) (inspiré de (Dongarra, Duff, Sorensen, van der Vorst [7])) C C + A B A, B, C : matrices n n, n = 20000, stockées par colonnes Calculateur vectoriel (Performance de crête 50 GFlop/s) Mémoire virtuelle (remplacement page : LRU) 1 page mémoire = 2Mmots = 100 colonnes de A, B, ou C (1 mot = 8 bytes) 1 défaut de page 10 4 secondes Stockage de A, B, et C : 3 400Mmots = 3 3.2 GB = 9.6 GB capacité mémoire : 128 pages soit: 128 2Mmots = 256Mmots = 2GB A, B, C ne peuvent être stockées totalement 124 / 396

Variante (1) : ijk do i = 1, n do j = 1, n do k = 1, n Cij <- Cij + Aik * Bkj enddo enddo enddo 1. Quel est le nombre de défauts de pages et le temps de calcul de cette variante (ijk)? 2. Quel est le nombre de défauts de pages et le temps de calcul de la variante (jki)? 3. Quel est le nombre de défauts de pages et le temps de calcul de la variante (jki) avec blocage sur j et k par blocs de taille 4 pages mémoire? 125 / 396

Variante (1) : ijk do i = 1, n do j = 1, n do k = 1, n Cij <- Cij + Aik * Bkj enddo enddo enddo Si accès en séquence aux colonnes d une matrice, 1 défaut de page toutes les 100 colonnes. Accès à une ligne de A n 100 = 200 défauts de page. D où 200 20000 2 = 8 10 10 defauts de page. 8 10 10 défauts de page 10 4 sec. = 8 Msec 128 jours de calcul 126 / 396

Variante (2) : jki do j = 1, n do k = 1, n do i = 1, n Cij <- Cij + Aik * Bkj enddo enddo enddo Pour chaque j : toutes colonnes de A accédées : n*200 défauts de page accés aux colonnes de B et C : 200 défauts de page total 4 10 6 défauts de page Temps d exécution 4 10 6 10 4 sec = 400 sec 127 / 396

Variante (3) : jki bloqué Les matrices sont partitionées en blocs de colonnes tq bloc-colonne (nb = 400 colonnes) = 4 pages mémoire. Réutilisation maximale des sous-matrices en mémoire. * Organisation des calculs sur des sous-matrices do j = 1, n, nb jb = min(n-j+1,nb) do k = 1, n, nb sectioning loops kb = min(n-k+1,nb) * Multiplication sur les sous-matrices * C1:n,j:j+jb-1 <- C1:n,j:j+jb-1 * + A1:n,k:k+kb-1 * Bk:k+kb-1,j:j+jb-1 do jj = j, j+jb-1 do kk = k, k+kb-1 do i = 1, n Cijj <- Cijj + Aikk * Bkkjj enddo enddo enddo enddo enddo

Défauts de page : nb = 400 colonnes (4 pages mémoire) accès à B et C, défauts de page lors de la boucle en j: 200 défauts de page n/nb accès (boucle en j) à A par blocs de colonnes, pour chaque indice k: 200, soit n/nb 200 au total. Total ( n nb + 2) 200 défauts de page nb = 400 donc n nb = 50 et donc 10 4 défauts de page Temps de chargement mémoire = 1 sec Attention : le temps de calcul n est plus négligeable!! Temps = 2 n 3 /vitesse 320 secondes Idées identiques au blocage pour cache Blocage : très efficace pour exploiter au mieux une hiérarchie mémoire (cache, mémoire virtuelle,... ) 129 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 130 / 396

Interconnexion des processeurs Réseaux constitués d un certain nombre de boîtes de connexion et de liens Commutation de circuits : chemin créé physiquement pour toute la durée d un transfert (idéal pour un gros transfert) Commutation de paquets : des paquets formés de données + contrôle trouvent eux-même leur chemin Commutation intégrée : autorise les deux commutations précédentes Deux familles de réseaux distincts par leur conception et leur usage : Réseaux mono-étage Réseaux multi-étages 131 / 396

Réseau Crossbar 0 1 2 o o o o o o o o o o o o 3 o o o o o 1 2 3 Toute entrée peut être connectée à toute sortie sans blocage. Théoriquement, le plus rapide des réseaux mais concevable seulement pour un faible nombre d Entrées/Sortie. 132 / 396

Réseaux multi-étages Constitués de plus d un étage de boitiers de connexion. Système de communication permettant le plus grand nombre possible de permutations entre un nombre fixe d entrées et de sorties. A chaque entrée (ou sortie) est associée une unité fonctionnelle. Nombre d entrées = nombre de sorties = 2 p. 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 Figure: Exemple de réseau multi-étage avec p=3. Réseaux birectionnels ou doublement du réseau. 133 / 396

Boîte de connexion élémentaire Elément de base dans la construction d un réseau : connexion entre deux entrées et deux sorties Boîte à deux fonctions (B2F) permettant les connexions directe et croisée contrôlée par un bit Boîte à quatre fonctions (B4F) permettant les connexions directe, croisée,à distribution basse et haute contrôlée par deux bits. 134 / 396

Topologie : mode d assemblage des boîtes de connexion pour former un réseau de N = 2 p entrées / N sorties. La plupart des réseaux sont composés de p étages de N 2 boîtes. Exemple : Réseau Omega Topologie basée sur le Perfect Shuffle (décalage à gauche des bits plus boucle) permutation sur des vecteurs de 2 p éléments. 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 Le réseau Omega reproduit à chaque étage un Perfect Shuffle. Autorise la distribution d une entrée sur toutes les sorties ( broadcast ). 7 135 / 396

0 1 2 4 0 3 5 6 1 2 3 4 5 6 7 7 0 1 2 3 4 5 6 7 0 1 2 4 5 6 7 3 A B C D E F G H I J K L Réseau Omega 8 8. 136 / 396

Anneau Proc 0 Proc 1 Proc 2 Proc n Grille Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Utilisé sur Intel DELTA et PARAGON,... 137 / 396

Shuffle Exchange : Perfect Shuffle avec en plus Proc # i connecté à Proc # (i+1) 0 1 2 3 4 5 6 7 N-cube ou hypercube : Proc #i connecté au Proc # j si i et j diffèrent d un seul bit. 0 1 2 3 4 5 6 7 Grand classique utilisé sur hypercubes Intel (ipsc/1, ipsc/2, ipsc/860), machines NCUBE, CM2, SGI... 138 / 396

Figure: 4-Cube in space. 139 / 396

Topologies usuelles pour les architectures distribuées Notations : # procs = N = 2 p diamètre = d (chemin critique entre 2 procs) # liens = w Anneau : d = N 2, w = N Grille 2D : d = 2 (N 1 2 1), w = 2 N 1 2 (N 1 2 1) Tore 2D (grille avec rebouclage sur les bords) : d = N 1 2, w = 2 N Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Hypercube ou p-cube : d = p, w = N p 2 140 / 396

Remarques Tendance actuelle: Réseaux hiérarchiques/multi-étages Beaucoup de redondances (bande passante, connections simultanées) Conséquence sur les calculateurs haute performance: Peu de différence de coût selon sources/destinations La conception des algorithmes parallèles ne prend plus en compte la topologie des réseaux (anneaux,... ) 141 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 142 / 396

Statistiques Top 500 (voir www.top500.org) Liste des 500 machines les plus puissantes au monde Mesure: GFlops/s pour pour la résolution de Ax = b, A matrice dense. Mises à jour 2 fois par an (Juin/ISC, Novembre/SC). Sur les 10 dernières années la performance a augmenté plus vite que la loi de Moore: 143 / 396

Analyse des sites - Definitions Rang (noté # par la suite): Position dans le top 500. Rpeak (Gflop/s): Performance crête de la machine en nombre d opérations flottantes par secondes. Rmax (Gflop/s): Performance maximum obtenue sur le test LINPACK Nmax: Taille du problème ayant servi à obtenir Rmax. Power (MWatt/s) : Watt/s consommés (voir aussi www.green500.org) L efficacité énergétique s améliore Les calculateurs à efficacité energétique la plus forte possédent des processeurs cell Green500.org: #1: 3208 Mflops/Watt, CINECA (Bologne) Top500 performance #1: 1900 Mflops/Watt, Tianhe-2 (Chine) (#1 en 2010 : 253 Mflops/Watt!!!) 144 / 396

Top 500: évolution des performances (RMAX) June 1997: ASCI Red, Sandia NL #1 = 1.1 TFlop/s (effectif) #500 = 7.7 GFlop/s June 2007:IBM Blue gene, Livermore NL #1 = 280 TFlop/s #500 = 4 TFlop/s June 2008: Roadrunner, LosAlamos NL #1 = 1 PFlop/s (1026 TFlop/s) #500 = 4 TFlop/s June 2010: Jaguar, OakRidge NL #1 = 1,75 PFlop/s (1026 TFlop/s) #500 = 25 TFlop/s June 2013: #1 Tianhe-2 (MilkyWay-2) National Univ. of Def. Tech., Chine, 33.8 Pflops (> 3 Millions coeurs) #500 = 100 Tera 145 / 396

Evolution des performances energétiques des Top #1 Entre 2002 et 2005 : NEC earth simulator (40 Tflop/s) : 6 MFlops/Watt Entre 2005 et 2007 : IBM Bleu gene L (280 Tflop/s) : 205 Mflops/Watt 2008 : Roadrunner Blade center ( 1 Pflop/s) : 444 Mflops/Watt 2010 : Jaguar, Cray XT5 Opteron 6 core (1.7 Pflop/s) : 253 Mflops/Watt 2013 : Tianhe-2, Cray XT5 Opteron 6 core (33.8 Pflop/s) : 1900 Mflops/Watt 146 / 396

Evolution des performances (RMAX) 147 / 396

Top 5 (Juin 2013) 148 / 396

Distribution géographique 149 / 396

Répartition par segment d activité 150 / 396

Statistiques constructeurs 151 / 396

Analyse des familles de processeurs 152 / 396

Analyse des familles de processeurs 153 / 396

Analyse des sites français Juin 2013 (23 dans Top 500) Rang Site Système Cores Rmax Power (x1000) (Tflops) (Mw) 11 Total SGI ICE X, Xeon, 8C, 2.6GH 110K 2098 2,1 15 CEA/TGCC Bullx, Xeon, 8C 2.7GH 77K 1359 2,2 25 CEA Bullx, super-node 136K 1050 4,5 37 CNRS/IDRIS BlueGene/Q, Power BQC, 1.6GH 65K 716 0.33 38 EDF R&D BlueGene/Q, Power BQC, 1.6GH 65K 716 0.33 54 Météo France Bullx 26K 500 401 123 Airbus HP POD - Cluster Platform 25,8 243 Autres domaines concernés (Institution financieres (4), Service, Automobile, Simulation (EADS, CNES)) Meteo France, Espace Clément Ader (Toulouse), 1 Petaflops en 2014 et 5 Petaflops en 2016 154 / 396

Outline Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des processeurs vectoriels Organisation des processeurs RISC Réutilisation des données (dans les registres) Mémoire cache Réutilisation des données (dans les caches) Mémoire virtuelle Réutilisation des données (en mémoire) Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2013 Conclusion Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes 155 / 396

Conclusion Performance : Horloge rapide Parallélisme interne au processeur Traitement pipeliné Recouvrement, chaînage des unités fonctionnelles Parallélisme entre processeurs Mais : Accès aux données : Organisation mémoire Communications entre processeurs Complexité du hardware Techniques de compilation : pipeline / vectorisation / parallélisation Comment exploiter efficacement l architecture? 156 / 396

Ecriture de code efficace (I) : MFLOPS ou MIPS? MFLOPS: floating point operations /sec. Ne dépend pas du calculateur MIPS: instructions de bas-niveau Dépend du calculateur Watt: code efficace sur des machines a faible consommation en Watt par proc. (Exemple des proc. Cell). Précision des calculs: travail partiel en précision numérique affaiblie (plus efficace). 157 / 396

Ecriture de code efficace (II) Facteurs architecturaux influençant la performance : débit et latence mémoire coûts des communications et de synchronisation temps d amorçage des unités vectorielles besoins en entrées/sorties Facteurs dépendant de l application : parallélisme (dépend des algorithmes retenus) régularité des traitements équilibrage des traitements volume de communications (localité) granularité - scalabilité Localité des données (spatiale et temporelle) encore plus critique sur les architectures Cell et GPU (Graphical Proc Unit) 158 / 396

Notion de calcul potentiellement efficace Proposition: Soient x et y des vecteurs et A, B, C des matrices d ordre n; le noyau de calcul (1) x = x + αy est potentiellement moins efficace que le noyau (2) y = A x + y qui est potentiellement moins efficace que le noyau (3) C = C + A B Exercice : justifier la proposition précédente. 159 / 396

La mesure du rapport entre le nombre d opérations flottantes et de réferences mémoire pour chacun des noyaux de calcul explique le potentiel. x = x + αy 3n références mémoire 2n opérations flottantes rapport Flops/Ref = 2/3 y = A x + y n 2 références mémoire 2n 2 opérations flottantes rapport Flops/Ref = 2 C = C + A B 4n 2 références mémoire 2n 3 opérations flottantes rapport Flops/Ref = n/2 Typiquement Vitesse (3) = 5 vitesse(2) et vitesse(2) = 3 vitesse(1)... si on utilise des bibliothèques optimisées! 160 / 396

Limites de l optimisation de code et de la vectorisation/parallélisation automatiques C α A B + βc (DGEMM du BLAS) DO 40 j = 1, N... DO 30 l = 1, K IF ( B( l, j ).NE. ZERO ) THEN TEMP = ALPHA * B( l, j ) DO 20 i = 1, M C( i, j ) = C( i, j ) + TEMP * A( i, l ) 20 CONTINUE END IF 30 CONTINUE 40 CONTINUE Plupart des compilateurs : parallélisent la boucle d indice j et optimisent / vectorisent la boucle d indice i 161 / 396

Table: Performance de versions différentes de GEMM sur processeurs RISC avec des matrices 128 128. Calculateur standard optimisé perf. de crête DEC 3000/300 AXP 23.1 48.4 150.0 HP 715/64 16.9 38.4 128.0 IBM RS6000/750 25.2 96.1 125.0 Pentium 4 113 975 3600 Plupart des optimisations réalisées par les compilateurs sur la boucle interne En théorie très bon potentiel grâce au rapport entre opérations flottantes et références mémoire : ( 4n 2 références mémoire, 2n 3 opérations flottantes) i.e. n 2 mais les compilateurs ne savent pas l exploiter!! 162 / 396

Optimisation de code : Améliorer l accès aux données et exploiter la localité spatiale et temporelle des références mémoire Déroulage de boucles : réduit le nombre d accés mémoire en améliorant la réutilisation des registres, permet aussi une meilleure exploitation du parallélisme interne aux processeurs Blocage pour une utilisation efficace du cache : améliore la localité spatiale et temporelle Copie des données dans des tableaux de travail pour forcer la localité et éviter des strides critiques (pas toujours possibles car parfois trop coûteux) prefetch des données Utilisation de l assembleur (cas désespéré!!) Utilisation de bibliothèques optimisées (cas ideal!!) 163 / 396

Figure: Comparaison de la performance de noyaux de calcul en algèbre Utilisation d une bibliothèque optimisée Noyaux de calcul matricexmatrice optimisés existent : ATLAS - Automatic Tuned Linear Algebra Software. http://netlib.enseeiht.fr/atlas/ Goto from Univ. Texas at Austin http://www.cs.utexas.edu/users/flame/goto/

Outline La programmation par mode message Contexte informatique, objectifs et besoins Le modèle de programmation par transfert de messages Envoi et réception de messages Choisir un mode de communication Traces d exécution d un code parallèle 165 / 396

Outline La programmation par mode message Contexte informatique, objectifs et besoins Le modèle de programmation par transfert de messages Envoi et réception de messages Choisir un mode de communication Traces d exécution d un code parallèle 166 / 396

Contexte informatique Multiprocesseur à mémoire distribuée ou réseau de stations de travail computer #2 network #1 computer #1 cluster network #2 multiprocessor Exemple de réseau de calculateurs. 167 / 396

Objectifs et besoins But : répartir/gérer des calculs sur la machine cible Outils nécessaires : ( minimum ) Sécurité et droits d accés (machines et données) Création de processus distants Communication entre processus Synchronisation entre processus Gestion de la cohérence des donnés et des traitements Séquenceur des tâches réparties Gestion dynamiques des processeurs et des processus (gestion des pannes, gestion de points de reprises) 168 / 396

Outline La programmation par mode message Contexte informatique, objectifs et besoins Le modèle de programmation par transfert de messages Envoi et réception de messages Choisir un mode de communication Traces d exécution d un code parallèle 169 / 396

Le modèle de programmation par transfert de messages Permet d exprimer la communication et la synchronisation C est le modèle le plus répandu en calcul réparti mais ce n est pas le seul (voir par ex. LINDA ) Il n apporte pas de solution à tous les problèmes posés. Caractéristiques : expression du parallélisme à la charge du programmeur distribution des données à la charge du programmeur l échange de données est explicite prise en compte possible d un réseau hétérogènes de calculateurs avec gestion des pannes. 170 / 396

Modèle pelure d oignon pour l échange de message Chaque niveau peut-être construit au dessus du précédent Niveau le plus bas : adressage au niveau canal procédures pour transférer des paquets sur des liens Adressage au niveau processus éventuellement plus d un processus par processeur échange de message en donnant l adresse d un processus Exemples : Nx sur ipsc, Vertex sur ncube, Express, PARMACS, PVM, MPI,... Niveau plus élevé d abstraction : mémoire partagée virtuelle, LINDA, espace de tuples partagé ou réparti) 171 / 396

Hypothèse d exécution Machine complètement connectée Routeur automatique de messages Machine 1 Machine 2 Processus P22 P11 P12 P21 P31 Machine 3 les deux hypothèses ci-dessus ne sont pas toujours vraies (Transputers) 172 / 396

Bibliotèques portables pour la programmation d applications parallèles distribuées P4 de l Argonne National Laboratory offre à la fois les modèles mémoire partagée et transfert de message communications entre processus disponible et optimisé sur une large gamme de calculateurs (et réseaux de calculateurs) PICL de l Oak Ridge National Laboratory portable sur une large gamme de multiprocesseurs à mémoire distribuée PVM : Univ. Tennessee, Univ. Emory, Oak Ridge Nat. Lab.,... pour réseaux hétérogènes de calculateurs aussi disponible sur multiprocesseurs MPI : le standard pour le transfert de message 173 / 396

Outline La programmation par mode message Contexte informatique, objectifs et besoins Le modèle de programmation par transfert de messages Envoi et réception de messages Choisir un mode de communication Traces d exécution d un code parallèle 174 / 396

Envoi et réception de messages Un arbre qui cache la forêt 175 / 396

Environnement d exécution des communications Chaque processus est identifié par un numéro d instance (rang dans un groupe ou communicateur) L enveloppe d un message doit permettre la caractérisation et le traitement du message. Elle contient: 1. le numéro de l émetteur 2. le numéro du récepteur 3. le label du message 4. la taille du message 5.... 176 / 396

Types de communication classiques communications point à point (one-to-one) : échange d information entre 2 processus communications collectives ( dans groupe / communicateur ) : one-to-many (broadcast, fan-out) : d un processus vers un ensemble de processus many-to-one (collect, fan-in) : un processus collecte des informations issues d un ensemble de processus many-to-many : échange global d informations entre plusieurs processus 177 / 396

Communications point à point (quelques questions) Envoi et réception de messages Processus Source Send (Dest, data) Dest data Recv(Source, data) data Temps Questions: Synchronisation entre l envoi et la réception? Quand peut-on réutiliser la donnée envoyée? Bufferisation des communications? 178 / 396

Outline La programmation par mode message Contexte informatique, objectifs et besoins Le modèle de programmation par transfert de messages Envoi et réception de messages Choisir un mode de communication Traces d exécution d un code parallèle 179 / 396

Choisir un mode de communication (Communications Synchrones/ Asynchrones) Envoi/réception synchrones: Le premier arrivé attend l autre (notion de rendez-vous). Envoi/Réception asynchrones: L émetteur et le récepteur ne s attendent pas. Un envoi asynchrone peut cependant être bloqué par la non consommation du message par le récepteur (ceci sera détaillé par la suite) L èmetteur et le récepteur n ont pas à être tous les deux synchrones/asynchrones!! 180 / 396

Trace d éxecution(8 proc. CRAY T3E) Algorithme Asynchrone 8.9s 8.95s 9.0s Algorithme Synchrone Process 0 5 5 5 5 4 4 5 108 5 5 5 5 5 5 5 Facto_L1 4 5 Process 1 108 4 4 108 5 108 5 5 5 5 5 5 5 Facto_L1 4 Process 0 9.28s 9.3s 9.32s Process 2 108 4 4 108 5 5 5 5 5 5 5 5 108 5 108 5 Process 1 80 80 80 80 80 80 80 80 Process 3 5 5 5 4 108 5 5 4108 5 5 5 5 5 5 4 108 5 5 Process 2 80 80 80 80 80 80 80 80 80 Process 4 4 108 5 5 4 5 5 5 5 5 5 108 5 108 5 Process 3 Process 4 Process 5 4 4 4 5 5 4 108 5 5 5 5 5 5 5 5 2 2 2 2 Process 5 80 80 80 80 80 80 80 80 80 Process 6 4 4 108 108 5 108 5 5 5 5 5 5 5 108 5 5 Process 6 80 80 80 80 80 80 80 80 80 Process 7 108 4 4 108 2 2 2 2 2 2 2 2 4 108 5 5 Process 7 L (Algorithmes de factorisation LU de matrices creuses développés à l ENSEEIHT (asynchrone) et au NERSC, Berkeley (synchrone) ) 181 / 396

Envoi/Réception bloquants ou non bloquants Envoi/Réception bloquants: La ressource est disponible en retour de la procédure. Réception non-bloquante simple un paramètre de retour indique si l information est disponible. Envoi/Réception non-bloquants généraux : -Retour de la procédure sans garantir que la donnée ait été envoyée/reçue. -L utilisateur ne peut pas réutiliser l espace mémoire associé (au risque de changer ce qui sera envoyé). -Il faut donc pouvoir tester/attendre la libération (si envoi) ou la réception effective de la donnée. Send/Recv ( Dest/Source, data, Ireq) renvoie aussi un numéro de requête Test ( Ireq ) et Wait ( Ireq ) 182 / 396

Envoi asynchrone : bloquant et non-bloquant Envoi asynchrone bloquant Envoi asyncrhone non bloquant Send (Dest, data) Attente (par ex. copie dans buffer interne) Actif data modifiable (pas tjrs recue) Send (Dest, data,ireq) Test (Ireq) Wait (Ireq) data modifiable (pas tjrs recue) Actif Recv(Source, data) Temps Recv(Source, data) 183 / 396

Réceptions bloquantes asynchrones Réception non bloquante simple Réception non bloquante générale Recv (Dest, data,ireq) Recv(Source, data, Recu) Test (Ireq) Send (Dest, data) Si ( Recu ) alors traiter data Fin Si Send (Dest, data) Wait (Ireq) ATTENTE Temps (indépendant du mode d envoi) 184 / 396

Où va l information envoyée? Source Destination Send (Dest, data) Buffer envoi Réseau Buffer réception Recv(Dest, data) Le(s) buffer(s) sont soit internes à la couche système soit gérés par l utilisateur. 185 / 396

Proprietés de la communication bufférisée Buffer(s) implique(ent) copies multiples (coût mémoire et temps) Même dans un mode bloquant l envoyeur peut être libre immédiatement Si Taille(buffer d envoi) Taille (message) alors ( envoi asynchrone bloquant envoi non-bloquant ) Attention à gérer la saturation des buffers (deadlock possible!!! ) Source Destination Send (Dest, data) Send (Source, data) Buffer envoi Réseau Buffer envoi si l envoi est asynchrone (bloquant) l envoi peut être bloqué jusqu au lancement de la réception correspondante. 186 / 396

Propriétés des communications Diffusion des messages ordonnancée FIFO : les messages issus de Proc1 sont reçus dans l ordre par Proc2. Proc 1 Temps Proc 2 Par contre PAS d ordonnancement causal Temps Proc 1 Proc 2 Proc 3 187 / 396

Exemples (PVM et MPI) de communications point à point Envoi/réception standard pvm send/pvm recv: asynchrone bloquant (pvm Nrecv : réception non-bloquante simple) mpi send/mpi recv: bloquant (synchronisme dépend de l implémentation) (mpi Isend/mpi Irecv : communication non-bloquante générale) Envoi synchrone: Bloquant : mpi Ssend Non-bloquant : mpi ISsend Envoi bufferisé: bloquant : mpi Bsend et non-bloquant : mpi IBsend 188 / 396

Communications non symétriques PUT(data) : écriture directe dans la mémoire d un autre processus GET(data) : lecture dans la mémoire d un autre processeur Proc 1 Proc 2 Proc 1 Proc 2 Put (data) Mémoire locale Mémoire locale Get (data) Proc2 ne fait pas de réception Proc1 ne fait pas d envoi Attention aux problèmes de cohérence de données!! 189 / 396

Examples d opérations collectives Communications au sein d un groupe de processus ou d un communicateur Les appels collectifs sont bloquants mais ne constituent pas un point de synchronisation fiable (comparable à une barrière). Diffusion dans un groupe: Broadcast (data, label, Groupe) Somme des données distribuées sur un groupe de procs: Reduce (SUM, ValeurSum, ValeurLoc, Groupe, Dest) ValeurSum n est disponible que sur le processus Dest. Maximum de valeurs distibuées disponible sur chaque processus AllReduce(MAX, ValeurMax, ValeurLoc, Groupe) ValeurMax est disponible sur tous les processus du Groupe. 190 / 396

Commentaires sur les protocoles de communications un protocole différent est souvent utilisé pour les messages courts et les messages longs (ex. Cray T3E, SGI origin) Protocole pour messages courts 1/ écriture dans le buffer interne des données envoyées. 2/ le processus envoyeur continue son travail (si envoi asynchrone) Protocole pour messages longs 1/ envoi d une requête d envoi au destinataire 2/ attente d un message prêt à recevoir 3/ envoi effectif des données rangées dans l espace utilisateur du récepteur 191 / 396

Influence de la taille des buffers sur les Communications asynchrones A/ Taille (Message) < Buf_interne B/ Taille(Message) > Buf_interne Proc. Source Asynch. Non bloquant (isend) Proc. Destination buf_interne Réception bloquante recv (User_buf) Transfer (User_buf) Local copy Proc. Source Asynch. Non bloquant (isend) Temps Proc. Destination Asynch. Non bloquant irecv(user_buf, Ireq) User_buf Attente message wait(ireq) Message déjà dans User_buf 192 / 396

Communications asynchrones et surcoût MPI Illustration sur un code de factorization de matrices creuses (code disponible sous mumps.enseeiht.fr/) recv standard recv asynchrone Application MPI VT_API 20% 40% 60% 80% 193 / 396

Communications asynchrones et performance Temps pour la factorisation LU (Matrice creuse d ordre 64838 avec 7Mega entrées, 8 procs d un Cray T3E): MPI buffer size (bytes) type de réception 0 512 1K 4K 64K 512K 2Mega standard 37.0 37.4 38.3 37.6 32.8 28.3 26.4 asynchrone 27.3 26.5 26.6 26.4 26.2 26.2 26.4 Valeur par défaut sur le Cray T3E. 194 / 396

Remarques sur la taille des buffers systèmes Changer la taille des buffers peut donc conduire à Une modification de la performance (temps attente, nombre de copies internes...) Des résultats faux (causalité mal gérée) De nouvelles situations d interblocage (codes basés sur des communications standards (mpi send et mpi recv) ) tous les cas d erreur correspondent à des programmes/algo. erronés 195 / 396

Qu est-ce qui influence les performances? La distribution des données L équilibrage du travail sur les processus Recouvrement des communications par les calculs L optimisation des communications : choix du mode de communication ( point à point? symétrique? synchrone? bufferisé? bloquante... ) Optimisation algorithmiques: pipelining - blocage - envoi au plus tôt - prefetch... exploitation des protocoles d implémentation des communications (et taille des buffers internes) exploiter l architecture du réseau (topologie, connexions bidirectionnelles, fonctionnement de plusieurs canaux simultanés) 196 / 396

Outline Description des standards pour la programmation en mode message Distributed and heterogeneous computing using PVM MPI : le standard pour le transfert de message Modélisation de l architecture Modes du routage et modèles associés Modèles de programme Modèles d exécution Placement statique et/ou dynamique 197 / 396

Description des standards pour la programmation en mode message 198 / 396

Outline Description des standards pour la programmation en mode message Distributed and heterogeneous computing using PVM MPI : le standard pour le transfert de message Modélisation de l architecture Modes du routage et modèles associés Modèles de programme Modèles d exécution Placement statique et/ou dynamique 199 / 396

Distributed and heterogeneous computing using PVM Short overview of the PVM computing environment. Simple example. XPVM tracing tool used for illustration Complete description of PVM : [3, 9, 4]. Many of the examples we use are coming from these references. 200 / 396

Overview of the PVM computing environment PVM (Parallel Virtual Machine) : Public domain software available on netlib Developed by the Oak Ridge National Laboratory, the University of Tennessee, the University of Carnegie Mellon, the Pittsburgh Supercomputing Center and the Emory University of Atlanta. Allows to use a network of heterogeneous UNIX computers (either serial or parallel) as a unique computing resource referred to as a virtual machine. 201 / 396

Workstation Workstation Fast network Workstation Workstation Slow Network Workstation Mini Comp Super Comp Figure: Example of virtual machine 202 / 396

Daemon on each node of the virtual machine coordinates work distributed on the virtual machine. Host file : contains the list of computers and allows to automatically activate the UNIX daemons and build the parallel virtual machine at start-up. Application viewed as a set of parallel processes (MIMD programing mode) being executed on the processors of the virtual machine Communication and synchronization using message passing Processes can be organized into groups (a process can belong to several groups and groups can change at any time during computation). 203 / 396

From the user point of view, the PVM package is composed of two parts : daemon process pvmd3: resides on each computer of the parallel virtual machine. Can be started interactively or automatically. When user wants to run an application in the PVM environment: pvmd3 starts a daemon on each node of a virtual machine described in host file. The application can then be started from any node. pvm starts the PVM console used to interactively control and modify the virtual machine both in terms of host nodes and processes. pvm may be started and stopped multiple times on any of the hosts. 204 / 396

set of library procedures: communication and synchronization procedures used from C or FORTRAN. Facilities to create and terminate processes, to communicate between processes, to synchronize processes, to modify the parallel virtual machine, and to manipulate process groups. 205 / 396

We focus on the main procedures of the PVM user library. Complete version of PVM3 user library [9] available on netlib. 206 / 396

The PVM3 user library Notations: tid integer : identifier of the PVM process ntask integer : number of processes tids() integer array : array of PVM process identifiers bufid integer : identifier of a buffer msgtag integer : message label encoding integer : message coding bytes integer : length of a message in bytes info integer : erro message task character : name of an executable file group character : group identifier size integer : size of the group xp what : data array stride integer : stride between two elements nitem integer : number of elements

Control of processes Enroll a process in PVM call pvmfmytid(tid) At its first call, the pvmfmytid() procedure creates a PVM process. pvmfmytid() returns the process identifier tid and may be called several times. If the host node does not belong to the parallel virtual machine then an error message is returned. Leave PVM call pvmfexit(info) pvmfexit indicates to the local daemon (pvmd3) that the process leaves the PVM environment. The process is not killed but it cannot communicate (via PVM) with other PVM processes. Kill another PVM process: call pvmfkill(tid, info) pvmfkill kills the PVM process identified by tid. 208 / 396

Activation of processes Starting other processes on the virtual machine call pvmfspawn(task, flag, where, ntask, tids, numt) Starts ntask copies of executable file task. flag allows to control the type of computer on which will be activated the processes. Predefined values of flag : PvmDefault PVM chooses the computers PvmArch where defines a target architecture. PvmHost where specifies a target computer. PvmDebug processes are activated in debugging mode. numt # processes actually activated. Task identifiers first numt positions of tids(ntask). Error codes (neg. values) last ntask-numt positions of tids(). Get tid of father: call pvmfparent(tid) On exit tid tid of parent process, otherwise tid set to negative value PvmNoParent. 209 / 396

Fortran Example SPMD programming mode... * Enroll task in PVM system call pvmftid( mytid ) * Find out if I am parent or child - * All child processes have parents call pvmfparent( tids( 0 ) ) if( tids( 0 ).lt. 0 ) then tids( 0 ) = mytid me = 0 * Start up child tasks ( copies of parent task ) call pvmfspawn( spmd, PVMDEFAULT, *, & NPROC - 1, tids( 1 ), info ) endif... 210 / 396

Interprocess communication Communication between PVM processes based on message-passing. PVM provides asynchronous send, blocking receive, and nonblocking receive facilities. Sending a message is done in three steps : 1. initialization of a send buffer and choice of an encoding format to send data; (pvmfinitsend) 2. packing of data to be sent into the send buffer (pvmfpack); 3. actual send/broadcast of the message stored in the send buffer to destination(s) process(es) (pvmfsend, pvmfcast). 211 / 396

Memory/data pvmfpack Send buffer Sending Process pvmfsend Memory/data pvmfunpack Receive buffer pvmfrecv Receiving Process Figure: Illustration of send/receive main steps 212 / 396

Main advantage of this strategy : user can compose his message out of various pieces of data and therefore decrease the number of messages effectively sent. With the broadcast option, only one send buffer has to be filled. If one large array of only a given data type needs to be sent (pvmfpsend) has been designed to pack and send data in one call to improve performance. 213 / 396

Reception is symmetric to the three step sending procedure After reception of message into the active buffer, data are unpacked into the destination arrays. Various options to receive data are provided: pvmfrecv : blocking receive pvmftrecv : timeout receive pvmfnrecv : nonblocking receive pvmprecv : combines blocking receive and unpacking. 214 / 396

Management of buffers Clear/initialize send buffer call pvmfinitsend( encoding, bufid) clears the send buffer and prepare it for packing a new message. Encoding scheme used during data packing defined by encoding. Predefined values of encoding in FORTRAN: PvmDefault The XDR encoding used (heterogeneous network of computers). PvmRaw PvmInPlace No encoding, native format of the host node. Data are not copied into the buffer which only contains the size and pointers to the data. Several buffers can be used simultaneously, but only one is active buffer for sending/receiving data. Procedures to create/release buffers (pvmfmkbuf, pvmffreebuf) to get/set the active send/receive buffer (pvmfgetrbuf, pvmfgetsbuf, pvmfsetsbuf, pvmfsetrbuf) are designed for this purpose. 215 / 396

Packing/unpacking data call pvmfpack(what, xp, nitem, stride, info) pvmfpack packs an array of data of a given type into the active send buffer. A message containing data of different types may be built using successive calls to pvmfpack. nitem elements chosen each stride elements of the linear array xp of type what are packed into the buffer. Predefined values of what : STRING, BYTE1, INTEGER2, INTEGER4 REAL4, REAL8, COMPLEX8, COMPLEX16 call pvmfunpack(what, xp, nitem, stride, info) Similarly, pvmfunpack is used to unpack informations held into the active receive buffer. The unpacked data are then stored into the array xp. 216 / 396

Sending messages Send : call pvmfsend(tid, msgtag, info) pvmfsend sets the message label to msgtag then sends it to the pvm process of number tid. Broadcast : call pvmfmcast(ntask, tids, msgtag, info) pvmfmcast broadcast the message to ntask processes specified into the integer array tids. Pack and send : call pvmfpsend (tid, msgtag, xp, nitem, type, info) 217 / 396

Receiving Messages Blocking receive call pvmfrecv( tid, mstag, bufid ) Non Blocking Receive call pvmfnrecv( tid, mstag, bufid ) ( bufid = 0 message not received ) Wildcards tid = -1 any message message tag mstag. mstag = -1 any message message from tid. tid = -1 and mstag = -1 any message. 218 / 396

Receive and unpack call pvmfprecv(tid,msgtag,xp,nitem,type,rtid,rtag,ritem,info) Check for arrived messages call pvmfprobe(tid, msgtag, bufid) If the message is not arrived then bufid =0, otherwise a buffer number is returned but the message is not received. A posteriori verification call pvmfbufinfo(bufid, bytes, msgtag, tid, info) pvmfbufinfo returns the characteristics of the message stored in bufid: label msgtag, sending process tid, length in bytes bytes. pvmfbufinfo is particularly useful in conjunction with pvmfprobe or when the label or the source of the message to be received have not been specified. 219 / 396

Sequential code Do It = Ibeg, Ifin Update image Print image Enddo Parallel Approach (subdive the image) (1) (2) (3) (4) (1) (2) (1) (4) (3) (2) Slave task ( i ) Do It = Ibeg, Ifin ( Update image ( i ); Pack in active buffer ) call pvmfsend(tid_master, It, info) Enddo (3) (4) Master task ( Build a complete image at each iteration ) Do It = Ibeg, Ifin Do Idummy= 1, Nb_slaves call pvmfrecv ( 1, It, bufid) ( bufinfo > tids (Islave) ) ( Unpack and Assemble image Islave ) Enddo ( Print full image ) Enddo

* SPMD Fortran example using PVM 3 * Enroll in pvm call pvmfmytid( mytid ) call pvmfparent( tids( 0 ) ) if( tids( 0 ).lt. 0 ) then tids( 0 ) = mytid; me = 0 call pvmfspawn( spmd,pvmdefault, *,NPROC-1, tids( 1 ), info ) * multicast tids array to children call pvmfinitsend( PVMDEFAULT, info ) call pvmfpack( INTEGER4, tids( 1 ), NPROC-1, 1, info ) call pvmfmcast(nproc-1,tids(1),msgt0,info) else * receive the tids of brothers and identify call pvmfrecv( tids( 0 ), msgt0, info ) call pvmfunpack( INTEGER4, tids(1),nproc-1,1,info) do i = 1, NPROC-1 if( mytid.eq. tids( i ) ) me = i enddo endif call dowork(me,tids,nproc ) call pvmfexit( info ) stop end 221 / 396

subroutine dowork ( me, t i d s, nproc ) i n c l ude??/ i n c l u d e /fpvm3. h Simple subroutine to p a s s a token around a r i n g i n t e g e r me, nproc, t i d s ( 0 : nproc ) i n t e g e r token, dest, count, s t r i d e, msgtag count = 1 ; s t r i d e = 1 ; msgtag = 4 i f ( me. eq. 0 ) then token = t i d s ( 0 ) c a l l pvmf i n i t s e n d ( PVMDEFAULT, i n f o ) c a l l pvmf pack ( INTEGER4, token, count, s t r i d e, i n f o ) c a l l pvmf send ( t i d s ( me + 1 ), msgtag, i n f o ) c a l l pvmf r e c v ( t i d s ( nproc 1 ), msgtag, i n f o ) e l s e c a l l pvmf r e c v ( t i d s ( me 1 ), msgtag, i n f o ) c a l l pvmf unpack (INTEGER4, token, count, s t r i d e, i n f o ) c a l l pvmf i n i t s e n d ( PVMDEFAULT, i n f o ) c a l l pvmf pack (INTEGER4, token, count, s t r i d e, i n f o ) d e s t = t i d s ( me + 1 ) i f ( me. eq. nproc 1 ) d e s t = t i d s ( 0 ) c a l l { pvmfsend }( dest, msgtag, i n f o ) e n d i f return 222 / 396

Management of process groups Procedures to manage process groups form a layer on top of the PVM layer (library libgpvm3.a). Main characteristics of PVM groups: Any PVM process can join pvmfjoingroup and pvmfleave a group; A process can belong to several groups; A message can be broadcasted to a PVM group from any PVM process pvmfbcast Synchronization within a group can be performed using barriers pvmfbarrier. Useful procedures: pvmfgettid, pvmfgetinst pvmfgsize,... PVM 3.3 provides collective communication routines such as pvmfreduce() that performs a global arithmetic operations (e.g. global maximum or global sum) across a group. Must be called by all processes in the group, final result is sent to a member specified as root. There is also a way of managing with system signals. 223 / 396

Illustrative Example: a dot version of the matrix vector product Straightforward static parallelization of the matrix-vector product, y = A x where A is a (m n) matrix, x an n-vector, and y an m-vector. Master-slave paradigm: Each process is in charge of computing one block y. Additionally master process broadcasts the data to the slaves and collects the final results. The sequential FORTRAN code is: do i = 1, m y ( i ) = 0. 0D0 do j = 1, n y ( i ) = y ( i ) + A( i, j ) x ( j ) enddo enddo 224 / 396

In the parallel implementation, first_row(1) first_row(2) first_row(3) A x master slave 1 slave 2 x x x slave 3 x Figure: Static parallelization of the matrix vector product: A partitioned into block of rows distributed on the slave processes. 225 / 396

Master process Slave process (the master holds A and x) enroll into PVM enroll into PVM create slaves send data to slaves recv data from master compute part of y compute my block of y receive results send back results leave PVM application leave PVM application Computation of one block of y is performed using GEMV from the Level 2 BLAS (see [6]) which performs: y = α A x + βy 226 / 396

Codes for master and slave processes Master s code: * * Enroll this program in Pvm call pvmfmytid (my_id) if (my_id.lt. 0) then write(*,*) failure in enrolling on host stop endif write(*,*) How many slave worstations will you used read(*,*) nb_of_slaves * Initiate nb_of_slaves instances of slave program call pvmfspawn ( slave,pvmdefault, *, & nb_of_slaves,inst,numt) * Check if everything is Ok if (numt.ne. nb_of_slaves) stop 227 / 396

nb_of_processes = nb_of_slaves +1 do j=1,n do i = 1,m a(i,j) = DBLE(i+j)/DBLE(m+n) + one enddo x(j) = one + DBLE(j)/DBLE(n) enddo * compute the index of the first row * performed by each process first_row(1) = 1 first_row(nb_of_processes+1) = m+1 j = (m / nb_of_processes) if (nb_of_slaves.gt.0) then do i=2,nb_of_processes first_row(i) = j*(i-1) +1 enddo * work balancing j = mod(m,nb_of_processes) do i=1, j-1 first_row(nb_of_processes-i+1) = & first_row(nb_of_processes-i+1) +j -i enddo 228 / 396

* broadcast n and x type = 0 call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (INTEGER4, n, 1, 1, info) call pvmfpack (REAL8, x, n, 1, info) call pvmfmcast (nb_of_slaves, inst, type, info) * send its sub-matrix data to each slave process type = 1 do no_slave = 1, nb_of_processes-1 * number of components computed by the slave no_slave j = first_row(no_slave+2) - first_row(no_slave+1) call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (INTEGER4, j, 1, 1, info) call pvmfsend (inst(no_slave), type, info) do i=1, n call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (REAL8, & a(first_row(no_slave+1),i),j,1,info) enddo enddo call pvmfsend (inst(no_slave), type, info) 229 / 396

* ------------------------------------ * compute its part of the work * ------------------------------------ * perform y <-- one*ax + zero*y * where A is an matrix of order (first_row(1)-1) x n. incx = 1 call dgemv( N,first_row(1)-1,n,one,a,lda,x, & incx,zero,y,incx) * ---------------------- * collect results * ---------------------- type = 2 do no_slave = 1, nb_of_slaves * j holds number of rows computed by no_slave j = first_row(no_slave+2) - first_row(no_slave+1) call pvmfrecv (inst(no_slave), type, bufidr) call pvmfunpack (REAL8, & enddo call pvmfexit(retcode) stop end y(first_row(no_slave+1)),j,1,info) 230 / 396

Slave s code: PROGRAM slave... double precision a(lda,lda),x(lda),y(lda),one,zero * Enroll this program in PVM 3 call pvmfmytid (my_id) * Get the tid of the master s task id call pvmfparent (p_id) * receive broadcasted data type = 0 call pvmfrecv (p_id, type, bufid) call pvmfunpack (INTEGER4, n, 1, 1, info) call pvmfunpack (REAL8, x, n, 1, info) * receive my block of rows type = 1 call pvmfrecv (p_id, type, bufidr) call pvmfunpack (INTEGER4, m, 1, 1, info) do 10, i=1,n call pvmfrecv (p_id, type, bufidr) call pvmfunpack (REAL8, a(1,i), m, 1, info) 10 continue 231 / 396

* perform matrix-vector on my block of rows incx = 1 call dgemv( N,m,n,one,a,lda,x,incx,zero,y,incx) * send back results to master process type = 2 call pvmfinitsend (PVMDATADEFAULT, bufid) call pvmfpack (REAL8, y, m, 1, info) call pvmfsend (p_id, type, info) * leave PVM environment call pvmfexit (info) stop end 232 / 396

Makefile for Compilation - Link PvmArch and PvmDir correspond respectively to target computer and to location of the PVM library. F77 = /usr/lang/f77 FOPTS = -O -u # Specification of the target computer PvmArch = SUN4 # Location of PVM libraries PvmDir = /usr/local/pvm3/lib # PVM libraries (C, FORTRAN, Group) PVMLIB_C = $(PvmDir)/$(PvmArch)/libpvm3.a PVMLIB_F = $(PvmDir)/$(PvmArch)/libfpvm3.a PVMLIB_G = $(PvmDir)/$(PvmArch)/libgpvm3.a LIBS = $(PVMLIB_F) $(PVMLIB_C) $(PVMLIB_G) # Location of the executable files IDIR = $(HOME)/pvm3/bin/$(PvmArch) all : dotmatvec slave dotmatvec : master.o $(BLAS) $(TIMING) $(F77) -o dotmatvec master.o $(LIBS) -lblas mv dotmatvec $(IDIR) slave : slave.o $(BLAS) $(F77) -o slave slave.o $(LIBS) -lblas mv slave $(IDIR).f.o : $(F77) $(FOPTS) -c $*.f clean : /bin/rm *.o 233 / 396

Configuration of the virtual machine Configuration file describe the list of computers used. Used to start the pvmd3 daemon on each computer listed. Parallel Virtual Machine can be controled using the pvm console. Other solution use directly the pvm console to build the virtual machine. Both solutions illustrated in the following example : a parallel virtual machine of 4 RISC workstations (HP, IBM and two SUN) is build. The HP workstation, pie, is our host computer. 234 / 396

Example pie> cat hostfile # comments pie pinson goeland aigle pie> pvmd3 hostfile & pie> pvm > conf 4 hosts, 1 data format HOST DTID ARCH SPEED pie 40000 HPPA 1000 pinson 80000 SUN4 1000 goeland c0000 RS6K 1000 aigle 100000 SUN4 1000 pie> pvm pvm> conf 1 host, 1 data format HOST DTID ARCH SPEED pie 40000 HPPA 1000 pvm> add pinson goeland aigle 3 successful HOST DTID pinson 80000 goeland c0000 aigle 100000 235 / 396

Performance analysis and graphical interface Analysis of the efficiency of the parallel execution of a program complex problem by itself. Time measures and speed-up estimations often not sufficient to understand the behaviour of a parallel application. Automatic tracing of parallel execution indispensable tool both to visualize the parallel behaviour and to debug. PVM allows to control which events are generated and where messages will be sent quite complex to use. XPVM: tracing tool exploiting automatically features of PVM. PVM s tracing facilities generate extra traffic in the network will perturb program execution. We show traces obtained during parallel execution of matrix-vector product. Target vitual machine = heterogeneous set of 4 RISC workstations. Master process located on computer node rosanna. 236 / 396

Figure: XPVM trace of the static parallelisation of the matrix-vector product Note that the fastest computer (sharon) is idle most of the time. 237 / 396

Outline Description des standards pour la programmation en mode message Distributed and heterogeneous computing using PVM MPI : le standard pour le transfert de message Modélisation de l architecture Modes du routage et modèles associés Modèles de programme Modèles d exécution Placement statique et/ou dynamique 238 / 396

MPI : le standard pour le transfert de message 1. Effort de définition d un standard de transfert de message pour les utilisateurs de développeurs 2. Juin 94 Version 1.0 issue du forum MPI Message Passing Interface [15, 8] 3. Objectifs : portabilité, simplicité utilisation plus large du calcul distribué implantation par les constructeurs 4. Pour multiprocesseurs, clusters et réseaux de calculateurs Accessible sur le site netlib ou sur le Web, voir par exemple : http://www.enseeiht.fr or http://www.netlib.org Versions publiques disponibles: LAM (Univ. Notre Dame), MPICH (Argonne Nat. Lab.), OpenMPI (www.open-mpi.org). 239 / 396

Notions basiques Groupe de processus MPI Contexte : pour définir des flots de messages indépendants. Communicateur: permet de définir un contexte de communication au sein d un groupe de processus. Message : contexte et un numéro de message/contexte 4 modes de communication : bloquants, non-bloquants, synchrones, bufferisés. Communication collectives et définition de sous-groupes Modèle de programmation SPMD, 125 fonctions dont 6 de base : MPI Init, MPI Finalize, MPI Comm size, MPI Comm rank, MPI Send, MPI Recv 240 / 396

Environnement enregistrement : call MPI Init( info ) terminaison : call MPI Finalize contexte par défaut : MPI COMM WORLD : tâches numérotées 0,..., N-1 création de nouveaux contextes : définir des nouveaux groupes de processus et un nouveau contexte 241 / 396

Example : Hello world #i n c l u de mpi. h #i n c l u de <s t d i o. h> i n t main ( argc, argv ) i n t a r g c ; char argv ; { i n t rank, s i z e M P I I n i t ( &argc, &argv ) ; MPI Comm rank ( MPI COMM WORLD, &rank ) ; MPI Comm size ( MPI COMM WORLD, &s i z e ) ; p r i n t f ( H e l l o world! I m %d o f %d\n, rank, s i z e ) ; M P I F i n a l i z e ( ) ; return 0 : } Exécution sous MPICH avec : mpirun -np 2 hello printf exécuté par 2 processus. 242 / 396

Envoi / réception message : opérations de base Envoi/Réception de données de type datatype rangées à @ : call MPI Send ( @, nb, datatype, dest, mess id, comm,info) call MPI Recv ( @, nb, datatype, source, mess id, comm, status, info ) Diffusion: toutes les tâches émettent la requète; les données sont envoyées par le processus root: call MPI Bcast ( @,nb,datatype,root,mess id,context,info) Opération collective: Le processus root reçoit les résultats: call MPI Reduce ( @, results, nb, datatype, operation, root, context, info ) datatype peut être prédéfini (MPI real) ou défini par l utilisateur; context définit le groupe de tâches et le contexte 243 / 396

Les modes de communication point à point Bloquant L émetteur est bloqué jusqu à ce que la donnée envoyée puisse être réutilisée en toute sécurité. Synchrone Le retour d un envoi synchrone indique que la donnée envoyée a commencé à etre reçue par le récepteur. Bufferisé Le retour d un envoi bufferisé indique que la donnée a été copiée dans le buffer. Ready L envoi n est possible que si le destinataire a déjà posté une reception 244 / 396

Sémantique des communications point à point MPI Send et MPI Recv: Asynchrone et Bloquant; L émetteur est bloqué jusqu à ce que la donnée envoyée puisse être réutilisée en toute sécurité. 245 / 396

Sémantique des communications point à point MPI Send et MPI Recv: Asynchrone et Bloquant; L émetteur est bloqué jusqu à ce que la donnée envoyée puisse être réutilisée en toute sécurité. MPI Bsend: Bufferisé, Asynchrone, et Bloquant; L utilisateur définit un buffer (MPI Buffer Attach/Detach(buffer, size). L envoyeur est bloqué jusqu a ce que la donnée envoyée ait été copiée dans le buffer (erreur si buffer plein/petit). 246 / 396

Sémantique des communications point à point MPI Send et MPI Recv: Asynchrone et Bloquant; L émetteur est bloqué jusqu à ce que la donnée envoyée puisse être réutilisée en toute sécurité. MPI Bsend: Bufferisé, Asynchrone, et Bloquant; L utilisateur définit un buffer (MPI Buffer Attach/Detach(buffer, size). L envoyeur est bloqué jusqu a ce que la donnée envoyée ait été copiée dans le buffer (erreur si buffer plein/petit). MPI Isend, MPI Irecv: Asynchrone et Non bloquant; En retour, la donnée envoyée ne doit pas être modifiée. MPI Wait, MPI Test pour gérer les données. 247 / 396

Sémantique des communications point à point MPI Send et MPI Recv: Asynchrone et Bloquant; L émetteur est bloqué jusqu à ce que la donnée envoyée puisse être réutilisée en toute sécurité. MPI Bsend: Bufferisé, Asynchrone, et Bloquant; L utilisateur définit un buffer (MPI Buffer Attach/Detach(buffer, size). L envoyeur est bloqué jusqu a ce que la donnée envoyée ait été copiée dans le buffer (erreur si buffer plein/petit). MPI Isend, MPI Irecv: Asynchrone et Non bloquant; En retour, la donnée envoyée ne doit pas être modifiée. MPI Wait, MPI Test pour gérer les données. MPI Ssend, MPI Srecv : Synchrone (rendez-vous); Le retour de MPI Ssend indique que la donnée envoyée est réutilisable ET que le recepteur a commencé à recevoir. 248 / 396

Sémantique des communications point à point MPI Send et MPI Recv: Asynchrone et Bloquant; L émetteur est bloqué jusqu à ce que la donnée envoyée puisse être réutilisée en toute sécurité. MPI Bsend: Bufferisé, Asynchrone, et Bloquant; L utilisateur définit un buffer (MPI Buffer Attach/Detach(buffer, size). L envoyeur est bloqué jusqu a ce que la donnée envoyée ait été copiée dans le buffer (erreur si buffer plein/petit). MPI Isend, MPI Irecv: Asynchrone et Non bloquant; En retour, la donnée envoyée ne doit pas être modifiée. MPI Wait, MPI Test pour gérer les données. MPI Ssend, MPI Srecv : Synchrone (rendez-vous); Le retour de MPI Ssend indique que la donnée envoyée est réutilisable ET que le recepteur a commencé à recevoir. MPI Rsend : Ready et bloquant; L envoi bloquant n est possible que si le destinataire a déjà posté une reception (sinon erreur). 249 / 396

Attente ou test de messages MPI Probe (Source, label, comm, status): Attend l arrivée d un message (source,label) mais ne le reçoit pas. MPI IProbe (Source, label, comm, status): Regarde si message disponible MPI Any Source,MPI Any Tag : n importe quel source ou label Associé à une requête non bloquante (par ex MPI ISend/MPI IRecv): MPI Wait (Request) : Attente MPI Test (Request) : Test MPI Cancel (Request) : Nettoyage, utilisation parfois délicate. 250 / 396

Exercice 1: communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes: 1. MPI IRsend (..., Ireq,... ) 251 / 396

Exercice 1: communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes: 1. MPI IRsend (..., Ireq,... ) Retour immédiat si le destinataire a déjà posté une réception sinon erreur de retour (pour le reste idem MPI Isend). 252 / 396

Exercice 1: communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes: 1. MPI IRsend (..., Ireq,... ) Retour immédiat si le destinataire a déjà posté une réception sinon erreur de retour (pour le reste idem MPI Isend). 2. MPI ISsend (..., Ireq,... ) 253 / 396

Exercice 1: communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes: 1. MPI IRsend (..., Ireq,... ) Retour immédiat si le destinataire a déjà posté une réception sinon erreur de retour (pour le reste idem MPI Isend). 2. MPI ISsend (..., Ireq,... ) Retour immédiat. Le S de ISsend : la fin de l envoi (obtenue par ex. après un MPI Wait(Ireq)) garantit que le récepteur est en train de recevoir l information. Ce n est pas le cas avec un MPI wait consécutif à un MPI ISend. Par contre rien ne garantit que la communication soit finie. 254 / 396

Exercice 1: communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes: 1. MPI IRsend (..., Ireq,... ) Retour immédiat si le destinataire a déjà posté une réception sinon erreur de retour (pour le reste idem MPI Isend). 2. MPI ISsend (..., Ireq,... ) Retour immédiat. Le S de ISsend : la fin de l envoi (obtenue par ex. après un MPI Wait(Ireq)) garantit que le récepteur est en train de recevoir l information. Ce n est pas le cas avec un MPI wait consécutif à un MPI ISend. Par contre rien ne garantit que la communication soit finie. 3. MPI IBsend (..., Ireq,... ) 255 / 396

Exercice 1: communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes: 1. MPI IRsend (..., Ireq,... ) Retour immédiat si le destinataire a déjà posté une réception sinon erreur de retour (pour le reste idem MPI Isend). 2. MPI ISsend (..., Ireq,... ) Retour immédiat. Le S de ISsend : la fin de l envoi (obtenue par ex. après un MPI Wait(Ireq)) garantit que le récepteur est en train de recevoir l information. Ce n est pas le cas avec un MPI wait consécutif à un MPI ISend. Par contre rien ne garantit que la communication soit finie. 3. MPI IBsend (..., Ireq,... ) Retour immédiat. Le B de IBsend : la fin de l envoi (obtenue par ex. après un MPI Wait(Ireq)) garantit que le message est bufferisé mais ne garantit pas qu il ait été envoyé. (cas d erreur: le buffer est trop petit). 256 / 396

Exercice 2: Communications point à point Commenter le comportement du programme suivant (exécuté sur 2 processus): CALL MPI COMM RANK(comm, rank, i e r r ) tag = 1 IF ( rank.eq. 0 ) THEN d e s t = 1 ELSE d e s t = 0 ENDIF CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) 257 / 396

Exercice 2: Communications point à point Commenter le comportement du programme suivant (exécuté sur 2 processus): CALL MPI COMM RANK(comm, rank, i e r r ) tag = 1 IF ( rank.eq. 0 ) THEN d e s t = 1 ELSE d e s t = 0 ENDIF CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) Le message envoyé doit être copié pour que l envoi se débloque. Le programme ne peut donc se finir que si au moins un des deux messages est copié dans un buffer interne local 258 / 396

Exercice 2: Communications point à point Commenter le comportement du programme suivant (exécuté sur 2 processus): CALL MPI COMM RANK(comm, rank, i e r r ) tag = 1 IF ( rank.eq. 0 ) THEN d e s t = 1 ELSE d e s t = 0 ENDIF CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) Le message envoyé doit être copié pour que l envoi se débloque. Le programme ne peut donc se finir que si au moins un des deux messages est copié dans un buffer interne local Pour des messages de grande taille cela peut donc entraîner un interblocage des processus 259 / 396

Communication glogales Barrières MPI Barrier (communicateur) : bloque l appelant jusqu à ce que tous les proc membres du communicateur aient effectués l appel. Broadcast MPI Bcast réduction disponible sur un proc ou sur tous MPI Reduce/MPI Allreduce: max global, somme globale,... scatter / gather, all to all 260 / 396

Communications persistantes-illustration Cas de communications effectuées en boucle dans un programme 1. Initialisation(s) d envoi(s)/réception(s): MPI xsend Init (..., Req ) / MPI xrecv Init ( Req ) Possibilité de faire de multiples initialisations 2. Lancement effectif dans la boucle MPI Start ( Req ) 3. Attente de requêtes (multiples) dans la boucle: MPI Wait, MPI Wait All, MPI Wait Some MPI Test, MPI Test All, MPI Test Some All = attente fin de toutes les requêtes mentionnées à l appel Some = au moins une a fini (out: liste des requêtes finies) Any = attendre la fin d une requête choisie parmi toutes celles finies (out: une requête finie) (utilisable bien sûr aussi avec des requêtes non bloquantes classiques) 261 / 396

Exercice: Recouvrir calcul et communications Soit le programme suivant: CALL MPI COMM RANK(comm, rank, i e r r ) p r e v = rank 1; n e x t = rank+1 IF ( rank.eq. Nprocs ) n e x t = 0 IF ( rank.eq. 0 ) p r e v = nprocs 1 IF ( rank.eq. 0 ) THEN CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL C a l c u l ( rank )! Rdata and Sdata not used i n C a l c u l CALL MPI Recv ( RData, count, MPI REAL, prec, tag, comm, i e r r ) ELSE CALL MPI Recv ( RData, count, MPI REAL, prec, tag, comm, i e r r ) CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL C a l c u l ( rank )! Rdata and Sdata not used i n C a l c u l ENDIF Hypothèses : Protocole long (synchrone) pour messages longs. Si l émetteur est occupé (sans appel MPI) la communication ne peut démarrer. Un timeout (MPI) est souvent associé à la notion de calcul non interruptible. 262 / 396

Exercice: Recouvrir calcul et communications (suite) IF ( rank.eq. 0 ) THEN CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL C a l c u l ( rank )! Rdata not used i n C a l c u l CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) ELSE CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL C a l c u l ( rank )! Rdata not used i n C a l c u l ENDIF On suppose Nprocs=3; Sdata de grande taille (temps de comm 50sec); Temps de Calcul(rank)= (200, 150, 150)sec. 1. Calculer le temps d exécution. 2. Pour recouvrir calcul et communications on propose de remplacer MPI Send par un appel non-bloquant MPI ISend. Calculer le temps d exécution. 3. Comment réduire le temps d exécution? 263 / 396

Solution (I) IF ( rank.eq. 0 ) THEN CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL C a l c u l ( rank )! Rdata and Sdata not used i n c a l c u l CALL MPI Recv ( RData, count, MPI REAL, prec, tag, comm, i e r r ) ELSE CALL MPI Recv ( RData, count, MPI REAL, prec, tag, comm, i e r r ) CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL C a l c u l ( rank )! Rdata and Sdata not used i n C a l c u l ENDIF 1. MPI Send: Temps = Max(50+200+50, 50+150+50, (100+150+50+150) = 450 sec Le fait que la reception n ait pas été postée plus tôt par P0 est une catastrophe! 2. MPI ISend: Temps = 200 + 50 + 150 + 50 + 150 + 50 = 650 sec; On a en plus perdu le recouvrement entre le calcul de PO et de P1!! 264 / 396

Solution (II) avec modification Recv sur proc0 IF ( rank.eq. 0 ) THEN CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL M P I I r e c v ( RData, count, MPI REAL, prec, tag, comm, I r e q, i e r r ) CALL C a l c u l ( rank )! Rdata not used i n c a l c u l CALL MPI Wait ( I r e q ) ELSE CALL MPI Recv ( RData, count, MPI REAL, prec, tag, comm, i e r r ) CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL C a l c u l ( rank )! Rdata not used i n C a l c u l ENDIF Influence du type d envoi: MPI send: Temps= max(50 + 200, 100 + 150, 150 + 150) = 300sec MPI Isend: Temps = 200 + 50 + 150 + 50 + 150 = 600 sec!!! MPI Ssend Temps= 300 sec (plus robuste que MPI Send) MPI ISsend: Idem MPI Isend MPI ISsend(Ireq)+MPI Wait(Ireq): Idem MPI Ssend Bricole: Ajouter des MPI Bidon dans calcul ou réduire le paramètre MPI du timeout 265 / 396

MPI: remarques conclusives Très grande richesse pour exprimer la communication (point à point, collective) La sémantique de MPI Send/Recv doit être respectée (risque d interblocage) Ajouts de MPI-2 vis à vis de MPI-1 Gestion dynamique des proc (MPI Comm Spawn, idem PVM) plus extensions pour fusionner les communicateurs ((MPI Intercomm Merge). IO parallèle (bloquante ou non, collective ou non) Communications mémoire à mémoire (PUT/GET) Interaction avec threads Disponibles dans OpenMPI et LAM mais pas encore chez tous les constructeurs (dont IBM). 266 / 396

Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Modélisation de Hockney et Jesshope Les modèles utilisés Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur 267 / 396

Analyse de performance et modélisation des algorithmes 1. Evaluation des performances d un algorithme = l utilisation de modèles pour : 1.1 Caractériser la machine cible Le processeur (Unités de calcul et d accès mémoire, fréquence d horloge, degré de parallélisme interne... ) Hiérarchie mémoire (registres, cache, mémoire locale, globale, disque...) Réseau d interconnection entre modules mémoires et processeurs. Temps d accès aux couches mémoires (incluant les Entrées/Sorties sur disque) Coûts de communication/synchronisation 268 / 396

1. l algorithme Objectif : représenter le parallélisme intrinsèque de l algorithme, Graphes de dépendance des calculs, Graphe de flot de données, Ces graphes peuvent être valués et orientés. 2. l exécution du programme Objectif : Analyse et classification a priori d un algorithme. Comment : simuler l exécution du programme (de son modèle) sur la machine cible (un modèle simplifié). Un modèle d exécution est donc caractérisé par les hypothèses effectuées: 2.1 nombre borné ou infini de processeurs. 2.2 mémoire (globale, distribuée, infinie..) 2.3 stratégie d allocation des tâches sur les processeurs. 269 / 396

L analyse des performances réelles Permet la validation des modèles précédents. Souvent difficile pour un code parallèle : 1. Choix de l unité de mesure? 2. influence de la taille du problème, architecture, charge du système sur la mesure? Utilisation d analyseurs automatiques de traces d exécution souvent indispensable. 270 / 396

Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Modélisation de Hockney et Jesshope Les modèles utilisés Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur 271 / 396

Terminologie Problème: taille N exécuté sur p processeurs. Vitesse: Nombre d opérations par secondes Flops: Opérations en virgule flottante par secondes (Mflops(10 6 ), Gflops(10 9 ), Teraflops(10 12 )) Mips: Millions d instructions élémentaires par secondes. (1 flops k instruc. de base) Temps d exécution séquentielle: T 1 (N) = T s (N) + T par (N) Temps d exécution parallèle: T p (N, p) Temps de surcoût parallèle T sc (N, p) (communication, synchronisation...) T p (N, p) = T s (N) + T par (N) p + T sc (N, p) 272 / 396

Accélération (speed-up): S p (N, p) = T 1(N) T p (N, p) Sp > 1 = speed-up ; et S p (N, p) < 1 = speed-down S p (N, p) > p = speed-up superlinéaire. (meilleure utilisation des hiérarchies mémoires, meilleur comportement de l algorithme parallèle) 273 / 396

100 Ts=Tsc=0 Ts>0, Tsc=0 10 Speedup Ts>0, Tsc>0 1 1 10 100 Nb Processeurs 1000 10000 Figure: 3 comportements extrêmes 274 / 396

Si Tsc = 0 alors S p = T s + T par T s + Tpar p donc S = lim p S p = T 1 /T s, soit p 1 2 = T par (N)/T s (N) alors: S = 1 + T par /T s S p = S (1 + p 1 2 /p) Remarques: 1. p 1 [0, ] et correspond au poids relatif de la partie // 2 (= 0 pas de //, = tout //). 2. p = p 1 = S p = S 2 2 p 1 correspond au nombre de processeurs pour atteindre la moitié 2 de S. 3. Si p 4p 1 alors 80% de S est déjà atteint. 2 275 / 396

Si Tsc > 0 alors Posons, par exemple: T sc = αp alors S p = S 1 + p ( ) ] 1 2 2 p [1 + p p opt où p opt = T par /α et correspond au speed-up maximum S opt. Exemple: T p = 1 + 10 p + 0.001p = S opt = 9.17 Efficacité: E p (N, p) = S p(n, p) p 1. Pour N fixé, si T sc est une fonction croissante de p alors E p décroit avec p 2. Pour p fixé et T s = 0, si T sc croît moins vite que T 1 alors E p augmente avec N 276 / 396

Scalabilité: Capacité à conserver E p (N, p) constante lorsque p augmente. T 1 (N) doit augmenter de façon exponentielle = le sytème est dit peu scalable. T 1 (N) doit augmenter linéairement = le sytème est scalable. Isoefficacité: Mesure de scalabilité d un algorithme parallèle, elle relie la taille du problème au nombre de processeurs nécessaires pour maintenir E p = cte ou S p croissant linéairement avec p. 1. On cherche le polynome d ordre m, m 1 tel que E(p, N) = E(kp, a m N m +... + a 1 N + a0) 2. Plus m est petit plus le système est scalable. 277 / 396

Granularité: Designe le volume de calcul effectué entre deux points de synchronisation. Equilibrage ou load balancing Un calcul parallèle est équilibré si chaque processeur a à peu près la même quantité de travail à effectuer. 278 / 396

Loi d Amdahl pour le calcul parallèle (loi de Ware) RAPPEL Soit le programme P. T 1 : temps d exécution de P sur 1 processeur f : fraction de P pouvant être exécutée sur p processeurs 1 f : zone séquentielle de P T p : temps d exécution de P sur p processeurs T p = temps d exéc. Séq. + temps d exéc. Par. temps d exéc. Séq. = (1 f )T 1 temps d exéc. Par. = f T 1 p T p = (1 f ) T 1 + f T 1 p et S p = T 1 T p 279 / 396

Speed-up théorique avec p processeurs : Sp = De façon plus réaliste : p f +(1 f ) p Tp (f + (1 f ) p) T 1 p ou T p = (f + (1 f ) p) T 1 +O p O overhead prenant en compte : overheads de synchronisation transferts de données (archi. mém. distribuée) contentions mémoire... MAIS quel que soit O : S p p f +(1 f )p Pour un nombre infini de processeurs : Speed-up maximum S 1 1 f 280 / 396

Table: A very optimistic table Number of processors p f 2 3 4 8 16 32 64 1.00 2 3 4 8 16 32 64 0.99 1.98 2.94 3.88 7.48 13.91 24.43 39.26 100 0.98 1.96 2.88 3.77 7.02 12.31 19.75 28.32 50 0.96 1.92 2.78 3.57 6.25 10.00 14.29 18.18 25 0.92 1.85 2.59 3.23 5.13 7.27 9.19 10.60 12.50 0.90 1.82 2.50 3.08 4.71 6.40 7.80 8.77 10.00 0.80 1.67 2.14 2.50 3.33 4.00 4.44 4.71 5.00 0.70 1.54 1.88 2.11 2.58 2.91 3.11 3.22 3.33 281 / 396

Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Modélisation de Hockney et Jesshope Les modèles utilisés Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur 282 / 396

Exemples d outils pour l analyse de performances 283 / 396

Profiling automatique Objectif : Etude du temps passé dans les unités de programme : en général procédures/fonctions, mais aussi parfois boucles et intructions. 1. exemple : gprof sous UNIX permet d étudier le temps passé par procédure. 1.1 Compilation des sources avec options appropriées (habituellement -pg ou -p) 1.2 L exécution produit un fichier gmon.out 1.3 Postraitement, avec options multiples, du fichier gmon.out: gprof [options] nom executable > fichier profile 284 / 396

Exemple de fichier profile obtenu : % cumulative self self total time seconds seconds calls ms/call ms/call name 98.6 218.79 218.79 1 218790.00 218790.0 _matmul_ [3] 0.7 220.39 1.60 5 320.00 320.0 _matsum_ [4] 0.6 221.63 1.24 1 1240.00 221880.0 _MAIN [1] 0.1 221.87 0.24 1 240.00 240.0 _matvec_ [5]... 285 / 396

La seconde partie du fichier profile permet d identifier l arbre d appel (parents et descendants) de chaque routine. called/total parents index %time self descendents called+self name index called/total children 1.24 220.64 1/1 _main [2] [1] 100.0 1.24 220.64 1 _MAIN [1] 218.79 0.00 1/1 _matmul_ [3] 1.60 0.00 5/5 _matsum_ [4] 0.24 0.00 1/1 _matvec_ [5] ----------------------------------------------- [2] 100.0 0.00 221.88 _main [2] 1.24 220.64 1/1 _MAIN [1] 0.00 0.00 1/2 _getenv [49] ----------------------------------------------- 218.79 0.00 1/1 _MAIN [1] [3] 98.6 218.79 0.00 1 _matmul_ [3] ----------------------------------------------- 1.60 0.00 5/5 _MAIN [1] [4] 0.7 1.60 0.00 5 _matsum_ [4] ----------------------------------------------- 0.24 0.00 1/1 _MAIN [1] [5] 0.1 0.24 0.00 1 _matvec_ [5] -----------------------------------------------... 286 / 396

Analyse automatiques de la performance et des cache-hits sur CRAY T3D (code de mécanique des fluides): secs Mflops data caches time PVMFRECV:11400 gradvelo: 672 7.58 82.89% infl3dc : 602 5.03 76.71% gradvel : 202 8.31 81.29% grad3d : 322 5.94 76.06% nufl3dc : 414 5.82 55.76% PVMFSEND: 635 SQRT : 320 vsfl3dc : 217 9.09 80.07% ns3dc : 256 2.50 81.91% implrssm: 177 7.59 57.58% edvialg : 139 3.86 49.22% shearstr: 52 15.89 78.34% dtvis3dc: 127 6.79 68.03% updpct : 83.5 6.55 84.15% heatflpg: 45.0 6.39 70.70% EXP : 53.7 Total code: 12100 secs 969 ( 6.07%) work 2514 (15.76%) loading instructions and data cache 12061 (75.59%) waiting on PVM communication 411 ( 2.58%) uninstrumented functions 287 / 396

Analyse de performance des boucles Traces obtenues sur CONVEX analyse beaucoup plus fine. Première partie: analyse du temps Optimization Times teration Count CPU Time Line NL Report Exec Min Max Avg (less inner loops) ---- --- ----------- -------- ----- ------ ----- ---------------- 129 0 SM 200 3078 3078 3078 0.916022 164 0 SM 201 3078 3078 3078 0.917755 200 0 SM 401 1977 1977 1977 0.369021 288 / 396

Deuxième partie: analyse du comportement. On peut par exemple calculer le rapport Nb flops sur Nb ref mémoire (i.e. Vector flops / Chime count). Static Profile Estimated Mflops Vector Vector Chime (less inner loops) (plus inner loops) Line NL Spills Flops Count Avg Peak Avg Peak ---- --- ------ ------- ------- --------- --------- ------- ------ 129 0 0 28 36 18.817 19.444 18.817 19.444 164 0 0 28 36 18.875 19.444 18.875 19.444 200 0 0 6 8 12.890 18.750 12.890 18.750 289 / 396

Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Modélisation de Hockney et Jesshope Les modèles utilisés Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur 290 / 396

Modélisation de Hockney et Jesshope Mesurer l efficacité d un algorithme dans l utilisation d un processeur possédant des unités pipelinées (unités de calcul ou accès mémoire). Nombres r et n 1. 2 r n : performance (en Mflops) sur des vecteurs de taille n r : performance (en Mflops) obtenue sur de vecteurs de taille infinie. but : étudier la différence entre performance réelle et théorique : taille minimum de vecteur pour atteindre r /2 but : étudier les surcoûts venant des temps d amorçage des pipelines (de calculs ou d accès mémoire) n 1 2 291 / 396

Exemple du produit scalaire: 1. Sur calculateur vectoriel Cray T90, Performance de crête (1 proc) =1800 Mflops r = 872 Mflops et n 1 2 = 304 2. Sur calculateur scalaire SGI Origin 2000, Performance de crête (1 proc) =360 Mflops r = 194 Mflops et n 1 2 = 7 c est l effet du cache primaire qui est ici mesuré par n 1 2 3. Sur machines scalaires sans cache et sans pipeline n 1 temps startup est nul. 2 = 0 car 292 / 396

Approximation de la performance d une boucle de taille n : r n = r n 12 n + 1 alors lim n r n = r et r n 12 = r /2 Comment calculer r et n 1? 2 (pour une boucle et un calculateur donnné) 1. Mesure de la performance pour différentes longueurs de vecteur. 2. Approximation aux moindres carrés 293 / 396

Traces d exécution d un code parallèle Outils de mise au point et d analyse de codes parallèles Figure: Trace d exécution VAMPIR d un code de factorisation de matrices creuses

L instrumentation (par exemple avec l outil VAMPIR) permet une analyse fine sur une partie de la trace d exécution. Figure: Trace d exécution VAMPIR d un code de factorisation de matrices creuses

L utilisation de camemberts permet alors de visualiser le poids relatif d un type d activité