Outline. Calcul Réparti et Grid Computing. Outline

Transcription

1 Outline 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) Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion / 446 2/ 446 Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion 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 3/ 446 4/ 446

2 Systèmes parallèles : enfin l age adulte! 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: core per chip multi-core chips supercomputing métacomputing ( grid computing ) Besoins dans le domaine du calcul scientifique Science traditionnelle. Construire une théorie, 2. Effectuer des expériences ou construire un système. 5/ 446 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 PFlop/s! Exemples dans le domaine du calcul scientifique Contraintes de durée: prévision du climat 6/ 446 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 performance 7/ 446 8/ 446

3 Quelques exemples dans le domaine du calcul scientifique Cost constraints: wind tunnels, crash simulation,... Scale Constraints large scale: climate modelling, pollution, astrophysics tiny scale: combustion, quantum chemistry 9/ 446 0/ 446 Pourquoi des traitements parallèles? Quelques unités pour le calcul haute performance 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 4 GFlop/s (avec 2 opérations flottantes / cycle) Calculateur 20 TFlop/s 5000 processeurs calculateurs massivement parallèles Pas parce que c est le plus simple mais parce que c est nécessaire Objectif actuel (200): supercalculateur à 3 PFlop/s, 500 TBytes de mémoire? Vitesse MFlop/s Megaflop/s 0 6 opérations / seconde GFlop/s Gigaflop/s 0 9 opérations / seconde TFlop/s Teraflop/s 0 2 opérations / seconde PFlop/s Petaflop/s 0 5 opérations / seconde Mémoire kb / ko kilobyte 0 3 octets MB / Mo Megabyte 0 6 octets GB / Go Gigabyte 0 9 octets TB / To Terabyte 0 2 octets PB / Po Petabyte 0 5 octets / 446 2/ 446

4 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 Rapport (Performance réelle / performance de crête) souvent bas!! Soit P un programme :. Processeur séquentiel: unité scalaire ( GFlop/s) Temps d exécution de P : 00 s 2. Machine parallèle à 00 processeurs: Chaque processor: GFlop/s Performance crête: 00 GFlop/s 3. Si P : code séquentiel (0%) + code parallélisé (90%) Temps d exécution de P : = 0.9 s Performance réelle : 9.2 GFlop/s 4. Performance réelle Performance de crête = 0. 3/ 446 4/ 446 Loi d Amdahl fs fraction d une application qui ne peut pas être parallélisée fp = fs fraction du code parallélisé N: nombre de processeurs Loi d Amdahl: tn ( fp N + fs)t fst Speed-up: S = t tn Sequential fs+ fp N t = fst fs Parallel t3 t2 t Calculateur procs LINPACK LINPACK Perf. n = 00 n = 000 crête Intel WoodCrest ( core, 3GHz) HP ProLiant ( core, 3.8GHz) HP ProLiant ( core, 3.8GHz) IBM eserver(.9ghz, Power5) IBM eserver(.9ghz, Power5) Fujitsu Intel Xeon (3.2GHz) Fujitsu Intel Xeon (3.2GHz) SGI Altix (.5GHz Itanium2) NEC SX-8 (2 GHz) Cray T ( proc.) Hitachi S-3800/ ( proc.) Table: Performance (MFlop/s) sur la résolution d un système d équations linéaires (d après LINPACK Benchmark Dongarra [07]) 5/ 446 6/ 446

5 Machine Problème de Problème de petite taille grande taille PFlop/s computer - 36 secondes TFlop/s computer 2 secondes 0 heures CM2 64K 30 minutes an CRAY-YMP-8 4 heures 0 ans ALLIANT FX/80 5 jours 250 ans SUN 4/60 mois 500 ans VAX /780 9 mois 4,000 ans IBM AT 9 ans 70,000 ans APPLE MAC 23 ans 450,000 ans Table: Vitesse de certains calculateurs sur un problème Grand Challenge en 995 (d après J.J. Dongarra) Machine Problème de Problème de petite taille grande taille PFlop/s computer - 36 secondes TFlop/s computer 2 secondes 0 heures CM2 64K 30 minutes an CRAY-YMP-8 4 heures 0 ans ALLIANT FX/80 5 jours 250 ans SUN 4/60 mois 500 ans VAX /780 9 mois 4,000 ans IBM AT 9 ans 70,000 ans APPLE MAC 23 ans 450,000 ans Table: Vitesse de certains calculateurs sur un problème Grand Challenge en 995 (d après J.J. Dongarra) Depuis, les problèmes Grand Challenge ont grossi! 7/ 446 7/ 446 Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion Evolutions architecturales: historique Pour,000 $ : calculateur personnel plus performant, avec plus de mémoire et plus de disque qu un calculateur des années 70 avec,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 : % 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 8/ 446 9/ 446

6 Evolutions architecturales: historique Deux changements sur le marché facilitent l introduction de nouvelles architectures :. 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) 9/ 446 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: nanoseconde = temps pour qu un signal parcourt 30 cm de cable Temps de cycle nanosecond 2 GFlop/s (avec 2 opérations flottantes par cycle) Moore s law Gordon Moore (co-fondateur d Intel) a prédit en 965 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 8 mois nombre de transistors performance Seule solution: le parallélisme 20/ 446 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) 2/ / 446

7 Unités centrales haute-performance Exemple pour des opérations diadiques (suite) 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) : T. Séparer mantisse et exposant T2. Multiplier mantisses T3. Additionner les exposants T4. Normaliser le résultat T5. Ajouter signe au résultat Supposition: l opération a b c s effectue en 5 traitements élémentaires T,T2,...,T5 d un cycle chacun. Quel est le nombre de cycles processeur pour la boucle suivante? Pour i = à N A(i) = B(i) * C(i) Fin Pour Traitement non pipeliné: N * 5 cycles Traitement pipeliné (à la chaine): N + 5 cycles er cycle: T() 2ème cycle: T(2), T2() 3ème cycle: T(3), T2(2), T3()... kème cycle: T(k), T2(k-), T3(k-2), T4(k-3), T5(k-4)... 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 23/ / 446 Processeurs RISC Processeurs RISC : introduits sur le marché vers 990 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 à Jeu d instructions simple Hardware simplifié Temps de cycle plus faible 24/ / 446

8 Architectures multi-cœurs Idées maîtresses dans la conception des RISC : Instructions décodées en 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 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 Processeur Cell La PS3 est basée sur un processeur Cell (Sony,Toshiba,IBM) Cell= un Power PC + 8 SPE (Synergetic Process. Elem.) SPE = processeur vectoriel SIMD + DMA = 25.6 GFlop/s 204 GFlop/s de performance crête en arithmétique 32 bits (4.6 GFlop/s en 64 bits) 27/ 446 D où regain d intérêt pour le calcul en 32 bits Mélange d arithmétiques simple et double précision (voir [5]) 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 28/ 446 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) 30/ 446

9 Année Calculateur MFlop/s CDC CDC IBM 370/95 ILLIAC IV CRAY-, XMP, CRAY CDC CYBER 205 FUJITSU VP400 NEC SX CRAY-YMP, C ,000 ETA-0 NEC SX-3 FUJITSU VP CRAY T3E.2 TFlop/s INTEL.8 TFlop/s IBM SP 6 TFlop/s HP 20 TFlop/s NEC 40 TFlop/s IBM Blue Gene 80 TFlop/s Roadrunner PFlop/s Table: Evolutions des performances par décennie 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 33/ 446 Problèmes On est souvent (en pratique) à 0% 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 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 + vector store + 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 32/ 446 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 34/ 446

10 Size 28 KB 256 KB 6 MB 0 GB Average access time (# cycles) hit/miss Registers < Cache level # 2 / 8 66 Cache level #2 6 5 / Main memory 0 00 Remote memory Disks 700,000 / 6,000,000 Figure: Exemple de hiérarchie mémoire. 35/ 446 Conception mémoire pour nombre important de processeurs? Comment 00 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 36/ 446 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 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 entre les processeurs via la mémoire partagée Mémoire logiquement distribuée Plusieurs espaces d adressage privés Communications explicites (messages) 37/ / 446

11 Terminologie Architecture SMP (Symmetric Multi Processor) Mémoire partagée (physiquement et logiquement) Temps d accès identique à la mémoire Similaire du point de vue applicatif aux architectures multi-cœurs ( cœur = 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 localisation de la donnée Accès locaux plus rapides qu accès distants hardware permet la cohérence des caches (ccnuma) Classification de Flynn 39/ 446 Outline Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion 40/ 446 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 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,... 4/ / 446

12 Modes de programmation SIMD et MIMD Outline 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) Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion 43/ / 446 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 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. 45/ / 446

13 HPC Spectrum (d après J.Dongarra) Peer to peer 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 - 0% - 20% overhead is OK - Resources drive applications - Completion time not critical - Time-shared - Heterogeneous Outline Massively // Systems - Bounded set of resources - Apps grow to consume all cycles - Application manages resources - 5% overhead is maximum - Apps drive purchase of equipment - Real-time constraints - Space-shared - Homogeneous 47/ 446 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 2007 Conclusion Introduction 48/ 446 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 2007 Conclusion 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,... 49/ / 446

14 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 2007 Conclusion 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 =, n a(i) = b(i) + c(i) enddo 5/ / 446 Code correspondant : i = boucle : load b(i) dans registre # load c(i) dans registre #2 registre #3 = registre # + registre #2 store registre #3 dans a(i) i = i + et test fin de boucle Exploitation du pipeline déroulage de boucle do i =, n, 4 a(i ) = b(i ) + c(i ) a(i+) = b(i+) + c(i+) a(i+2) = b(i+2) + c(i+2) a(i+3) = b(i+3) + c(i+3) enddo Sur processeur vectoriel : do i =, n a(i) = b(i) + c(i) enddo load vector b dans registre # load vector c dans registre #2 register #3 = register # + register #2 store registre #3 dans vecteur a Stripmining : si n > nb (taille registres vectoriels) do i =, n, nb ib = min( nb, n-i+ ) do ii = i, i + ib - a(ii) = b(ii) + c(ii) enddo enddo 53/ / 446

15 Problèmes dans la conception des pipelines Problèmes des dépendences de données 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 Exemple : do i = 2, n a(i) = a(i-) + enddo a(i) initialisés à. Exécution scalaire : Etape : a(2) = a() + = + = 2 Etape 2 : a(3) = a(2) + = 2 + = 3 Etape 3 : a(4) = a(3) + = 3 + = / 446 Exécution vectorielle : pipeline à p étages p éléments dans le pipeline Etages du pipe Temps p sortie t0 a() t0 + dt a(2) a() t0 + 2dt a(3) a(2) a()... t0 + pdt a(p+) a(p)... a(2) a() D où : a(2) = a() + = + = 2 a(3) = a(2) + = + = 2... car on utilise la valeur initiale de a(2). Résultat exécution vectorielle exécution scalaire 57/ 446 Overlapping (recouvrement) Utiliser des unités fonctionnelles en parallèle sur des opérations indépendantes. Exemple: do i =, n A(i) = B(i) * C(i) D(i) = E(i) + F(i) enddo Pipelined multiplier B A C 56/ 446 E D F Pipelined adder Time overlapping = max{startupmul, Startupadd + dt} + n dt Time no overlap. = {Startupmul +n dt}+{startupadd +n dt} Avantages: parallélisme entre les unités fonctionnelles indépendantes et plus de flops par cycle 58/ 446

16 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 =, n A(i) = ( B(i) * C(i) ) + D(i) enddo Pipelined multiplier Pipelined adder D Timechaining = Startupmul + Startupadd + n dt Timenochaining = {Startupmul +n dt} + {Startupadd +n dt} Avantages : plus de flops par cyle, exploitation de la localité des données, économie de stockage intermédiaire Locality of references A 59/ 446 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 2007 Conclusion Concept of memory hierarchy - 60/ 446 Programs tend to reuse data and instructions recently used Often program spends 90% of its time in only 0% 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. 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. 6/ / 446

17 Concept of memory hierarchy - 2 Typical memory hierarchy 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 access bandwidth Level Size time MB/s technology manag. Registers KB 2-5 ns ,000 (BI)CMOS compiler Cache 4MB 3-0 ns 800-5,000 CMOS SRAM hardware Main memory 4GB ns 400-2,000 CMOS DRAM OS Disk GB ns 4-32 magnetic disk OS/user Memory hierarchy 63/ / 446 Memory interleaving Effect of bank cycle time Memory Interleaving "The memory is subdivided into several independent memory modules (banks)" Two basic ways of distributing the addresses Example: Memory size 2 0 =024 Words divided into 8 banks High order interleaving Low order interleaving Real a(256) Banks Banks a(), a(2),..., a(28) a(), a(9),..., a(249) 2 a(29),..., a(256) 2 a(2), a(0),..., a(250) 3 3 a(3),a(),..., a(25) 4 4 a(4), a(5), a(6), a(7),..., a(255) 8 8 a(8), a(6),..., a(256) 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=,2 Do i=,4 Do i=,4 Do j=,2... = a(i,j)... = a(i,j) Enddo Enddo Enddo Enddo Bank Bank a(,) a(,2) a(,) a(,2) a(2,) a(2,2) a(2,) a(2,2) 2 2 a(3,) a(3,2) a(3,) a(3,2) 3 3 a(4,) a(4,2) a(4,) a(4,2) 4 4 CP 0 Clock Period time 8 Clock Period Bank Conflict: Consecutive accesses to the same bank in less than bank cycle time. "well adapted to pipelining memory access" Stride: Memory address interval between successive elements 65/ / 446

18 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 2007 Conclusion Organisation interne et performance des processeurs vectoriels (d après J. Dongarra) Soit l opération vectorielle triadique : do i =, n y(i) = alpha * ( x(i) + y(i) ) enddo On a 6 opérations :. Load vecteur x 2. Load vecteur y 3. Addition x + y 4. Multiplication alpha ( x + y ) 5. Store dans vecteur y 67/ / 446 Sequential Machine Organization a load x Organisations de processeur considérées :. 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 a memory path busy Chained Arithmetic a load x a load y load y b b add. add. c mult. c mult. d store memory path busy d store 69/ / 446

19 Chained Load and Arithmetic a load x a load y b add. Overlapped Load with Chained Operations a load x memory path busy c mult. d store a load y b add. c mult. Chained Load, Arithmetic and Store d store a load x memory path busy a load y memory path 2 busy b add. memory path 3 busy c mult. memory path busy d store 7/ / 446 Outline Organisation des processeurs RISC 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 2007 Conclusion 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 [3]) 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 73/ / 446

20 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... 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 ILP: Dynamic scheduling Hardware rearranges the instruction execution to reduce the stalls. 75/ 446 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 ILP: Dynamic scheduling 76/ 446 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 78/ / 446

21 ILP: Dynamic scheduling Other approach : Tomasulo s approach (register renaming) Suppose compiler has issued: F0 <- F2 x F2 F2 <- F0 + F6 Rename F2 to F8 in the second instruction (assuming F8 is not used) F0 <- F2 x F2 F8 <- F0 + F6 Can be used in conjunction with scoreboarding Impact of ILP : example This example is from J.L. Hennessy and D.A. Patterson (996) [3]. Original Fortran code do i = 000, x(i) = x(i) + temp enddo Pseudo-assembler code R <- address(x(000)) load temp -> F2 Loop : load x(i) -> F0 F4 = F0 + F2 store F4 -> x(i) R = R - #8 % decrement pointer BNEZ R, Loop % branch until end of loop Architecture Integer Unit stage FP add 4 stages IF ID MEM WB FP mult 4 stages Divide not pipelined 79/ 446 Example of pipelined processor (DLX processor, Hennessy and Patterson, 96 [3]) 8/ / 446 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 Loads FP add 3 FP mult 3 FP divide 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 Load double store double 0 Latency between instructions Latency FP op to store double : forwarding hardware passes result from ALU directly to memory input. 82/ 446

22 Straightforward code #cycle Loop : load x(i) -> F0 load lat. = stall 2 F4 = F0 + F2 3 stall 4 FP op -> store = 2 stall 5 store F4 -> x(i) 6 R = R - #8 7 BNEZ R, Loop 8 stall 9 delayed branch 9 cycles per iteration Cost of calculation 9,000 cycles Peak performance : flop/cycle Effective performance : 9 of peak With a better scheduling #cycle Loop : load x(i) -> F0 load lat. = stall 2 F4 = F0 + F2 3 R = R - #8 4 Try keep int. unit busy BNEZ R, Loop 5 store F4 -> x(i) 6 Hide delayed branching by store 6 cycles per iteration Cost of calculation 6,000 cycles Effective performance : 6 of peak Using loop unrolling (depth = 4) do i = 000,, -4 x(i ) = x(i ) + temp x(i-) = x(i-) + temp x(i-2) = x(i-2) + temp x(i-3) = x(i-3) + temp enddo 83/ 446 Pseudo-assembler code (loop unrolling, depth=4): #cycle Loop : load x(i) -> F0 stall F4 = F0 + F2 3 2 stalls store F4 -> x(i) 6 load x(i-) -> F6 7 stall F8 = F6 + F2 9 2 stalls store F8 -> x(i-) 2 load x(i-2) -> F0 3 stall F2= F0+ F2 5 2 stalls store F2-> x(i-2) 8 load x(i-3) -> F4 9 stall F6= F4+ F2 2 2 stalls store F6-> x(i-3) 24 R = R - #32 25 BNEZ R, Loop 26 stall cycles per iteration Cost of calculation = 6750 cycles 4 84/ 446 Effective performance : = 5% of peak 86/ / 446

23 Outline = 29% of peak Using loop unrolling (depth = 4) and scheduling #cycle Loop : load x(i) -> F0 load x(i-) -> F6 2 load x(i-2) -> F0 3 load x(i-3) -> F4 4 F4 = F0 + F2 5 F8 = F6 + F2 6 F2= F0+ F2 7 F6= F4+ F2 8 store F4 -> x(i) 9 store F8 -> x(i-) 0 store F2-> x(i-2) R = R - #32 2 BNEZ R, Loop 3 store F6-> x(i-3) 4 4 cycles per iteration Cost of calculation = 3500 cycles Effective performance : / 446 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 load x(i-)-> F6 2 load x(i-2)-> F0 F4 =F0 +F2 3 load x(i-3)-> F4 F8 =F6 +F2 4 load x(i-4)-> F8 F2=F0+F2 5 store F4 ->x(i) F6=F4+F2 6 store F8 ->x(i-) F20=F8+F2 7 store F2->x(i-2) 8 store F6->x(i-3) 9 R = R - #40 0 BNEZ R, Loop store F20->x(i-4) 2 2 cycles per iteration Cost of calculation cycles 5 = 2400 Effective performance : = 42% of peak Performance limited by balance between int. and float. instr. 88/ 446 Réutilisation des données (dans les registres) 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 2007 Conclusion 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 89/ / 446

24 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 =, N do i =, N... DOT do i =, N do j =, N... Réutilisation de x(j) : déroulage à une profondeur 2 * Cleanup odd iteration i = MOD(N,2) if ( i >= ) then do j =, N y(i) = y(i) + x(j)*a(j,i) enddo end if * Main loop imin = i + do i = imin, N, 2 temp = 0. temp2 = 0. do j =, N temp = temp + A( j,i-) * x(j) temp2 = temp2 + A( j,i ) * x(j) enddo y(i-) = y(i-) + temp y(i ) = y(i ) + temp2 enddo 9/ / 446 DOT variant Processeurs RISC mieux adaptés à DOT que AXPY do i =, N temp = 0. do j =, N temp = temp + x(j)*a(j,i) enddo y(i) = y(i) + temp enddo Stride = 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 = load A(j,i-) load x(j) perform A(j, i- ) * x(j) + temp 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 2k Déroulage à une profondeur k: k+ 92/ / 446

25 45 Performance of y = At x on HP 75/64 50 Performance of y = At x on CRAY T3D 40 Rolled 45 Rolled Unrolled 2 Unrolled 4 Unrolled Unrolled 2 Unrolled 4 Unrolled 8 MFlops MFlops Size Size Figure: Effect of loop unrolling on HP 75/64 Figure: Effect of loop unrolling on CRAY T3D 95/ / 446 AXPY variant Habituellement préférée sur processeurs vectoriels do j =, N do i =, N y(i) = y(i) + x(j)*a(j,i) enddo enddo Stride > 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) Réutilisation de y(i) : déroulage à profondeur 2 * Cleanup odd iteration j = MOD(N,2) if ( j.ge. ) then do i =, N y(i) = y(i) + x(j)*a(j,i) enddo end if * Main loop jmin = j + do j = jmin, N, 2 do i =, N y(i) = y(i)+a(j-,i)*x(j-)+a(j,i)*x(j) enddo enddo Ratio Flops/références mémoire = / 446

26 Outline load y(i) load A(j-,i) perform A(j-,i ) * x(j-) + 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 = Déroulage à profondeur 4 Ratio = 4 3 Déroulage à profondeur p Ratio = 2p 2+p 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 2007 Conclusion 99/ / 446 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 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 = : cache fully associative K = : cache direct mapped 0/ / 446

27 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 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 line 2 line 3 line 4 cache line main memory Fully associative Pas de correspondance a priori Recherche de données dans cache coûteuse main memory 03/ / 446 Gestion des caches Cache coherency problem Processor # Processor # 2 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 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 05/ / 446

28 Cache coherency problem Outline Processor # cache X Y Processor # 2 cache 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 06/ 446 Processor Line size Level Size Organization miss Access / cycle DEC B 8 KB Direct-mapped 2 C KB 3-way ass. 8 C MB Direct-mapped 2 C 2 IBM Power2 28 B / 28 KB / 4-way-ass. 8 C B 256 KB MIPS R B 6 KB Direct-mapped 7 C 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 Réutilisation des données (dans les caches) 07/ 446 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 2007 Conclusion Example cache 0 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. tmiss Average cost: (similar to Amdahl s law) 08/ / 446

29 Réutilisation des données (dans les caches) Réutilisation des données (dans les caches) Example cache 0 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. tmiss Average cost: 90%(0. tmiss) + 0% tmiss tmiss 00% gain = = 90% (0. tmiss )+0% tmiss (0.9 0.)+0. = 0.9 = 5.3 (similar to Amdahl s law) 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 = 00%). Tmin temps correspondant. Lecture de donnée dans le cache par une instruction et exécution : thit = cycle Temps d accès à une donnée lors d un défaut de cache : tmiss = 0 ou 20 cycles (exécution instruction tmiss + thit) Ttotal = %hits.thit + %misses (tmiss + thit) Topt = 00% thit Perf = Topt Ttotal Tmiss %hits Tps hits Tps misses Ttotal Perf. 00% % 0 99% % 20 99% % 0 95% % 20 95% % 09/ 446 Table: Effet des défauts de cache sur la performance d un code (exprimés en pourcentages vs pas de défaut de cache). 0/ 446 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= Example from D. Gannon and F. Bodin : do i=,n do j=,n a(j) = a(j) + b(i) enddo enddo. Compute the cache hit ratio (assume n much larger than CS). 2. Propose a modification to improve the cache hit ratio. / 446 2/ 446

30 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=,n a(j) = a(j) + b(i) enddo Each iteration reads a(j) and b(i), and writes a(j) For i= access to a(:n) For i=2 access to a(:n) As n >> CS, a(j) no longer in cache when accessed again, therefore: each read of a(j) miss each write of a(j) hit each read of b(i) hit (except the first one) # of hits Hit ratio = Mem.Refs = 2 3 = 66% 3/ 446 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(:n). do j=,n,nb jb = min(nb,n-j+)! nb may not divide n do i=,n do jj=j,j+jb- a(jj) = a(jj) + b(i) enddo enddo enddo 4/ 446 To clarify we load the cache explicitely; it is managed as a D array : CA(0:nb) do j=,n,nb jb = min(nb,n-j+) CA(:jb) = a(j:j+jb-) do i=,n CA(0) = b(i) do jj=j,j+jb- CA(jj-j+) = CA(jj-j+) + CA(0) enddo enddo a(j:j+jb-) = CA(:jb) enddo Total memory references = 3n 2 Total misses: load a = n nb nb load b = n nb n Total = n + n2 nb Total hits = 3n 2 n n2 nb = (3 nb ) n2 n Hit ratio = hits Mem.Refs 3nb 00% if nb is large enough. Each load into cache is a miss, each store to cache is a hit. 5/ 446 6/ 446

31 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 2007 Conclusion Mémoire virtuelle Mémoire réelle : code et données doivent être logés en mémoire centrale (CRAY) 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: 024 entrées Défaut de TLB : 36 C environ AIX offre la possibilité d augmenter la taille des pages (jusqu à 6 MB) pour limiter les défauts de TLB. Outline 7/ 446 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 2007 Conclusion 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) page mémoire = 2Mmots = 00 colonnes de A, B, ou C ( mot = 8 bytes) défaut de page 0 4 secondes Stockage de A, B, et C : 3 400Mmots = GB = 9.6 GB 8/ 446 capacité mémoire : 28 pages soit: 28 2Mmots = 256Mmots = 2GB A, B, C ne peuvent être stockées totalement 9/ / 446

32 Variante () : ijk Variante () : ijk do i =, n do j =, n do k =, n Cij <- Cij + Aik * Bkj enddo enddo enddo. 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? do i =, n do j =, n do k =, n Cij <- Cij + Aik * Bkj enddo enddo enddo Si accès en séquence aux colonnes d une matrice, défaut de page toutes les 00 colonnes. Accès à une ligne de A n 00 = 200 défauts de page. D où = defauts de page défauts de page 0 4 sec. = 8 Msec 28 jours de calcul Variante (2) : jki do j =, n do k =, n do i =, 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 défauts de page Temps d exécution sec = 400 sec 2/ / / 446 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 =, n, nb jb = min(n-j+,nb) do k =, n, nb sectioning loops kb = min(n-k+,nb) * Multiplication sur les sous-matrices * C:n,j:j+jb- <- C:n,j:j+jb- * + A:n,k:k+kb- * Bk:k+kb-,j:j+jb- do jj = j, j+jb- do kk = k, k+kb- do i =, n Cijj <- Cijj + Aikk * Bkkjj enddo enddo enddo enddo enddo

33 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 0 4 défauts de page Temps de chargement mémoire = 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,... ) 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 2007 Conclusion 25/ / 446 Interconnexion des processeurs Anneau Proc 0 Proc Proc 2 Proc n 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 Grille Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Utilisé sur Intel DELTA et PARAGON,... 27/ / 446

34 Shuffle Exchange : Perfect Shuffle avec en plus Proc # i connecté à Proc # (i+) N-cube ou hypercube : Proc #i connecté au Proc # j si i et j diffèrent d un seul bit Grand classique utilisé sur hypercubes Intel (ipsc/, ipsc/2, ipsc/860), machines NCUBE, CM2,... Figure: 4-Cube in space. 29/ 446 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 2 ), w = 2 N 2 (N 2 ) Tore 2D (grille avec rebouclage sur les bords) : d = N 2, w = 2 N Proc Proc Proc Proc Proc Proc Proc Proc 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,... ) 30/ 446 Proc Proc Proc Proc Proc Proc Proc Proc Hypercube ou p-cube : d = p, w = N p 2 3/ / 446

35 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 2007 Conclusion Statistiques Top 500 (voir 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 0 dernières années la performance a augmenté plus vite que la loi de Moore: 997: # =. TFlop/s #500 = 7.7 GFlop/s 2007: # = 280 TFlop/s #500 = 4 TFlop/s 2008: Roadrunner # = PFlop/s (026 TFlop/s) #500 = 4 TFlop/s Quelques remarques générales (Juin 2007) Architectures IBM Blue Gene dominent dans le top 0. 33/ 446 NEC Earth simulator supercomputer (36 Tflop/s, 520 processeurs vectoriels) est aujourd hui numéro 20. Est resté en tête de Juin 2002 à Juin Il faut 56 Tflop/s pour entrer dans le Top 0 (contre 5 TFlop/s en juin 2005) Somme accumulée: 4.95 PFlop/s (contre.69 PFlop/s en juin 2005) Le 500 ième (4 Tflop/s) aurait été 26 ème il y a 6 mois. 35/ 446 Remarques générales (Juin 2007 suite) Domaine d activité 34/ 446 Recherche 25%, Accadémie 8%, Industrie 53% Par contre 00% du TOP0 pour recherche et accadémie. France (0/500) dont 8 pour l industrie. Processeurs 289 systèmes basés sur de l Intel (dont sur le Xeon Woodcrest, bi-cœur) 07 sur des AMD (dont 90 : bi-cœurs Opteron) 85 sur de l IBM Power 3, 4 ou 5 0 sur des HP PA-RISC 4 sur des NEC (vectoriels) 3 sur des Sparc 2 sur des CRAY (vectoriels) 6/500 (8/500 en 2005) basés sur des processeurs vectoriels. Architecture 07 MPP (Cray SX, IBM SP, NEC SX, SGI ALTIX, Hitatchi SR) pour 393 Clusters 36/ 446

36 Analyse des sites - Definitions Rang: Position dans le top 500. Rpeak: Performance crête de la machine en nombre d opérations flottantes par secondes. Rmax: Performance maximum obtenue sur le test LINPACK. Nmax: Taille du problème ayant servi à obtenir Rmax. Power: Watts consommés (voir aussi Plus/moins performant du top 500: 480 Mflops/Watt et 4 Mflops/Watt Juin 2008, # Top500: 437 Mflops/Watt est 3ieme au green500 (#2 : 205 Mflops/Watt) Gain de 3 Mflops/watt par rapport à Novembre 2007 (utilisation du processeur Cell, voir Section 2 Introduction) Gain de 0.4Mflops (entre Juin 2007 et 2008) seulement sur le bas du classement Top 0 mondial (Juin 2007) Rang-Configuration Implantation #proc. Rmax Rpeak Year TFlops TFlops -IBM eserver BlueGene DOE/NNSA/LLNL Cray XT4/XT3 Oak Ridge Nationl Lab Cray RedStorm 2 NNSA/Sandia Lab IBM eserver BlueGene IBM TJWatson Res. Ctr IBM eserver BlueGene New York Ctr. in CS IBM eserver pseries 3 DOE/NNSA/LLNL IBM eserver Blue Gene Nonotechnology DELL PowerEdge 5 Nat.Ctr. Supercomp. Appl IBM cluster 6 Barcelona Supercomp. Ctr SGI Altix GHz Leibniz Rechenzentrum Tera-0 Novascale 7 CEA Opteron 2.6Hz dual core 2 Opteron 2.4Hz dual core 3 p5.9ghz 4 Rensselaer Polytech. Inst. (nanotech.) GHz-Infinib. 6 PPC-2.3GHz-Myri. 7 Ita2-.6GHz-Quadrics 37/ / 446 Top 7 mondial (Juin 2005) Rang-Configuration Implantation #proc. Rmax Rpeak Nmax TFlops TFlops 0 3 -IBM eserver BlueGene Solution DOE/NNSA/LLNL IBM eserver BlueGene Solution IBM TJWatson Res. Ctr SGI Altix.5GHz NASA/Ames Res.Ctr./NAS NEC Earth simulator Earth Simul. Center IBM cluster, PPC-2.2GHz-Myri. Barcelona Supercomp. Ctr IBM eserver BlueGene Solution ASTRON/Univ. Groningen NOW Itanium2-.4GHz-Quadrix Los Alamos Nat. Lab Stockage du problème de taille 0 6 = 8 Terabytes Constructeur Nombre Pourcent. Rmax Rpeak Procs (TFlop/s) (TFlop/s) IBM HP Dell Cray Inc SGI NEC Self-made Sun Fujitsu All Statistiques constructeurs Top 500, nombre de systèmes installés. 39/ 446

37 Analyse des sites français Juin 2007 Rang-Configuration Implantation #proc. Rmax Rpeak GFlops GFlops 2-NovaScale CEA NovaScale CEA IBM Blue Gene L EDF R&D HP Cluster 0 HP HP Cluster Industrie alim HP Cluster 2 IT Service Prov IBM BladeCenter 3 Finance IBM Cluster 4 PSA Peugeot IBM eserver 5 Total SA HP Cluster Xeon 6 Industrie alim NEC SX8R (2.2 Ghz) Meteo-France Ita2,.6GHz, Infiniband 9 Ita2,.6GHz, Quadrics 0 Xeon-3GHz, Infiniband Xeon-3GHz, GigEthernet 2 Xeon-3GHz, GigEthernet Analyse des sites français Juin 2005 Rang-Configuration Implantation #proc. Rmax Rpeak Nmax GFlops GFlops HP AlphaServer SC45, GHz CEA HP Cluster P4 Xeon-2.4GHz Finance IBM Cluster Xeon2.4GHz-Gig-E Total HP Cluster P4 Xeon-2.4GHz Caylon HP Cluster P4 Xeon-2.4GHz Caylon IBM Cluster Xeon2.4GHz-Gig-E Soc.Gen IBM eserver (.7GHz Power4+) CNRS-IDRIS SGI Altix.5GHz CEG Gramat (armement) 384-HP Superdome 875MHz France Telec. 445-HP Cluster Xeon 3.2 GHz Soc.Gen Opteron-2.2 GHz 4 Opteron-2.6 GHz, Infiniband 5 pseries.9ghz Myrinet GHz, GigEthernet 4/ / 446 Répartition géographique Analyse des plates-formes à usage académique Afrique: Océanie : 5 Amérique: 295 Europe: 27 Brésil 2 Allemagne 24 Canada 0 France 3 Mexique 2 Italie 5 USA 28 RU 42 Espagne 6 Russie 5 Asie : 72 Chine 3 India 8 Japon 23 S. Arabia 2 Amérique: 44 Europe: 33 Canada 4 Allemagne 6 Etats-Unis 39 Belgique Mexique Espagne 3 Océanie : 2 Finlande 2 Australie France 0 Nouvelle Zélande Italie Asie : Norvège Japon 8 Pays-Bas 2 Chine Royaume Uni 7 Taiwan Russie 4 Corée du Sud Suède 4 Turquie Suisse 43/ / 446

38 Type de processeurs Evolution de la performance 45/ / 446 Exemples d architecture de supercalculateurs MPP IBM SP NERSC-LBNL Noeud Noeud 46 Machines de type scalaire MPP IBM SP (NERSC-LBNL, IDRIS (France)) CRAY XT3/4 (Oak Ridge National Lab) Cluster DELL (NCSA) Non-Uniform Memory Access (NUMA) computer SGI Altix (Nasa Ames) IBM Blue Gene Machines de type vectoriel NEC (Earth Simulator Center, Japon) CRAY X (Oak Ridge Nat. Lab.) Machine à base de processeur Cell Roadrunner (Los Alamos National Lab (LANL)) P P6 P P6 2Gbytes 46 Noeuds de 6 processeurs 375MHz processeur (.5Gflops) Mémoire: 4.9 Terabytes Réseau 2Gbytes 6656 processeurs (Rpeak=9.9Teraflops) Remarque: Machine pécédente (en 2000) Cray T3E (696 procs à 900MFlops et 256Mbytes) Supercalculateur du Lawrence Berkeley National Lab. (installé en 200) 47/ / 446

39 MPP IBM SP CNRS-IDRIS Cluster DELL Abe (NCSA, Illinois) Noeud Noeud 2 P 28Gbytes P32 2 Noeuds de 32 processeurs.3ghz processeur (5.2Gflops) Mémoire:.5 Terabytes + X noeuds de 4 procs Réseau Supercalculateur de l IDRIS (installé en 2004) P 28Gbytes P processeurs (Rpeak=2.6Tflops) Performance: Rpeak=94 TFlop/s peak, Rmax=62.7 TFlop/s Architecture (9600 cores): 200 nœuds (bi-xeon) à 2.33 GHz Chaque Xeon : 4 cœurs 4 flops/cycle/cœur (9.33 GFlop/s) Mémoire: 90 TB ( GB par cœur) Infiniband applications GigEthernet système+monitoring IO: 70 TB at 7.5 GB/s 49/ 446 Non Uniform Memory Access Computer SGI Altix 4.Tbytes de mémoire globalement adressable C Brick C Brick 28 Noeud Noeud Noeud Noeud 2 2 P P2 P P2 P P2 P P2 6Gb 6Gb 6Gb 6Gb 50/ 446 NEC Earth Simulator Center (charactéristiques) 640 NEC/SX6 nodes 520 CPU (8 GFlops) > 40 TFlops 2 $ Billions, 7 MWatts. Réseau 28 C Bricks de 2 Noeuds de 2 procs.5ghz Itanium 2 (6Gflops/proc) Mémoire: 4. Terabytes Remarque: NUMA et latence 52 processeurs (Rpeak=3.Teraflops) Noeud (45nsec); C Brick (290ns); Entre C Bricks(+ 50 à 400ns); Supercalculateur SGI Altix (installé à NASA-Ames en 2004) 2007: #0=Altix, 63 TFlop/s, 9728 cœurs, 39 TB, Allemagne 5/ / 446

40 NEC Earth Simulator Center (architecture) Cray X d Oak Ridge National Lab. Noeud Arithm. Proc Arith. Proc. 8 Noeud 640 Arithm. Proc Arith. Proc. 8 Vector Scalar Vector Scalar Vector Scalar Vector Scalar Unit unit Unit unit Unit unit Unit unit Registers cache Registers cache Registers cache Registers cache Mémoire partagée (6Gbytes) Mémoire partagée (6Gbytes) Réseau (Crossbar complet) Performance: 6.4 Tflop/s, 2Terabytes, Rmax(5.9 TFlop/s) Architecture 504 Multi Stream processeurs (MSP): 26 Noeuds Chaque Noeud a 4 MSP et 6Gbytes de mémoire flat. Chaque MSP a 4 Single Stream Processors (SSP) Chaque SSP a une unité vectorielle et une unité superscalaire, total 3.2Gflops. 640 Noeuds (8 Arith. Proc.) > 40Tflops Mémoire totale 0TBytes Vector unit (500MHz): 8 ens. de pipes (8*2*.5= 8Glops) (Rpeak > 6 flops // par AP) Supercalculateur NEC (installé à Tockyo en 2002) 53/ / 446 Cray X node Blue Gene L (65536 dual-procs, 360 TFlops peak) Système d exploitation minimal (non threadé) Consommation limitée: 32 TB mais seulement 52 MB de mémoire par noeud! un noeud = 2 PowerPC à 700 MHz (2x2.8 GFlop/s) 2.8 GFlop/s ou 5.6 GFlop/s crête par noeud Plusieurs réseaux rapides avec redondances 55/ / 446

41 Blue gene: efficace aussi en Mflops/watt Clusters à base de processeurs Cell rack QS20 = 2 processeurs Cell (52 MB / processeur) racks connectés entre eux par switchs GigEthernet Chaque Cell=205 GFlop/s (32 bits) Installation au CINES (Montpellier): 2 racks IBM QS20 performance crête: 820 GFlop/s mémoire: seulement 2 GB! reste très expérimental et difficile à programmer 57/ / 446 Pour entrer dans l ère du Petacale : Roadrunner Roadrunner (suite) Los Alamos National Lab et IBM 8 clusters de 70 noeuds de calcul Par noeud : 2 dual-core AMD Opteron et 4 IBM PowerXCell 8i proc (Machine complète : 2240 PowerCell) Performance IBM PowerXCell 8i : 0 Glops (64 bits flottant) cores et 98 Terabytes Rmax=026 Teraflops; Rpeak 376 Teraflops; 2.3 MWatts Différence Cell BroadBand Engine (CBE) et IBM PowerXCell 8i Amélioration significative de la performance des calculs 64bits (00Gflops/5Gflops) Mémoire plus rapide Programmation du Roadrunner 3 compilateurs : Opteron, PowerPC et Cell SPE jeu d instructions Gestion explicite des données et programmes entre Opteron, PowerPC et Cell. 59/ / 446

42 Programmes nationaux d équipement USA: Advanced Simulation and Computing Program (formerly Accelerated Strategic Initiative) Début du projet : 995 DOE (Dept. Of Energy) Objectifs : PetaFlop/s France: le projet Grid 5000 (en plus des centres de calcul CNRS: IDRIS et CINES) Début du projet : 2004 (Ministère de la Recherche) Objectifs : réseau de 5000 machines sur 8 sites répartis (Bordeaux, Grenoble, Lille, Lyon, Nice, Rennes, Toulouse) Prévisions BlueGeneL et ses successeurs: 3 PFlop/s en 200 Projet japonnais (0 Pflops en 20). Juin 2008: Architectures à base de noeuds hybrides incluant des processeurs vectoriels/cell Outline 6/ 446 Conclusion 62/ 446 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 2007 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? 63/ / 446

43 Ecriture de code efficace (I) : MFLOPS ou MIPS? Ecriture de code efficace (II) 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). 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) Notion de calcul potentiellement efficace 65/ 446 Proposition: Soient x et y des vecteurs et A, B, C des matrices d ordre n; le noyau de calcul () 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. 66/ 446 Le 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()... si on utilise des bibliothèques optimisées! 67/ / 446

44 Limites de l optimisation de code et de la vectorisation/parallélisation automatiques C α A B + βc (DGEMM du BLAS) DO 40 j =, N... DO 30 l =, K IF ( B( l, j ).NE. ZERO ) THEN TEMP = ALPHA * B( l, j ) DO 20 i =, 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 69/ 446 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!!) Table: Performance de versions différentes de GEMM sur processeurs RISC avec des matrices Calculateur standard optimisé perf. de crête DEC 3000/300 AXP HP 75/ IBM RS6000/ Pentium 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!! Utilisation d une bibliothèque optimisée Noyaux de calcul matricexmatrice optimisés existent : ATLAS - Automatic Tuned Linear Algebra Software. Goto from Univ. Texas at Austin 70/ 446 7/ 446 Figure: Comparaison de la performance de noyaux de calcul en algèbre

45 Outline 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 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 73/ / 446 Contexte informatique Multiprocesseur à mémoire distribuée ou réseau de stations de travail network # computer # computer #2 cluster network #2 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) multiprocessor Exemple de réseau de calculateurs. 75/ / 446

46 Outline Le modèle de programmation par transfert de messages 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 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 échange de données explicite prise en compte possible d un réseau hétérogènes de calculateurs avec gestion des pannes. 77/ / 446 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) Hypothèse d exécution Machine complètement connectée Routeur automatique de messages Machine Machine 2 Processus P P22 P2 P2 P3 Machine 3 les deux hypothèses ci-dessus ne sont pas toujours vraies (Transputers) 79/ / 446

47 Bibliotèques portables pour la programmation d applications parallèles distribuées Outline 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 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 8/ / 446 Envoi et réception de messages Environnement d exécution des communications Un arbre qui cache la forêt 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:. le numéro de l émetteur 2. le numéro du récepteur 3. le label du message 4. la taille du message / / 446

48 Types de communication classiques Communications point à point (quelques questions) 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 Envoi et réception de messages Processus Source Dest Send (Dest, data) data Temps Recv(Source, data) data Questions: Synchronisation entre l envoi et la réception? Quand peut-on réutiliser la donnée envoyée? Bufferisation des communications? 85/ / 446 Outline Choisir un mode de communication (Communications Synchrones/ Asynchrones) 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 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!! 87/ / 446

49 8.9s Process Facto_L 4 5 Process Facto_L 4 Process Process Process Process Process Process L 8.95s 9.0s Process 0 Process Process Process 3 Process 4 Process Process Process s 9.3s 9.32s Trace d éxecution(8 proc. CRAY T3E) Algorithme Asynchrone Algorithme Synchrone (Algorithmes de factorisation LU de matrices creuses développés à l ENSEEIHT (asynchrone) et au NERSC, Berkeley (synchrone) ) 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 ) Envoi asynchrone : bloquant et non-bloquant 89/ 446 Réceptions bloquantes asynchrones 90/ 446 Réception non bloquante simple Réception non bloquante générale Envoi asynchrone bloquant Envoi asyncrhone non bloquant Recv (Dest, data,ireq) 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 Send (Dest, data) Recv(Source, data, Recu) Si ( Recu ) alors traiter data Fin Si Send (Dest, data) Temps Test (Ireq) Wait (Ireq) ATTENTE Recv(Source, data) Temps Recv(Source, data) (indépendant du mode d envoi) 9/ / 446

50 Où va l information envoyée? Source Destination Send (Dest, data) Buffer envoi Réseau Buffer réception 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 Recv(Dest, data) Send (Dest, data) Send (Source, data) Le(s) buffer(s) sont soit internes à la couche système soit gérés par l utilisateur. Propriétés des communications 93/ 446 Diffusion des messages ordonnancée FIFO : les messages issus de Proc sont reçus dans l ordre par Proc2. Proc Temps Proc 2 Par contre PAS d ordonnancement causal Temps Proc Proc 2 Proc 3 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. 94/ 446 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 95/ / 446

51 Communications non symétriques Examples d opérations collectives PUT(data) : écriture directe dans la mémoire d un autre processus GET(data) : lecture dans la mémoire d un autre processeur Proc Put (data) Proc 2 Mémoire locale Proc2 ne fait pas de réception Proc Proc 2 Mémoire locale Proc ne fait pas d envoi Attention aux problèmes de cohérence de données!! Get (data) 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. 97/ 446 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 / écriture dans le buffer interne des données envoyées. 2/ le processus envoyeur continue son travail (si envoi asynchrone) Protocole pour messages longs / 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 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 Temps Proc. Source Asynch. Non bloquant (isend) 98/ 446 Proc. Destination Asynch. Non bloquant irecv(user_buf, Ireq) User_buf Attente message wait(ireq) Message déjà dans User_buf 99/ / 446

52 Communications asynchrones et surcoût MPI Communications asynchrones et performance Illustration sur un code de factorization de matrices creuses (code disponible sous mumps.enseeiht.fr/) recv standard Application MPI VT_API recv asynchrone 20% 40% 60% 80% Temps pour la factorisation LU (Matrice creuse d ordre avec 7Mega entrées, 8 procs d un Cray T3E): MPI buffer size (bytes) type de réception 0 52 K 4K 64K 52K 2Mega standard asynchrone Valeur par défaut sur le Cray T3E. Remarques sur la taille des buffers systèmes 20/ 446 Qu est-ce qui influence les performances? 202/ 446 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. 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) 203/ / 446

53 Outline Description des standards pour la programmation en mode message Description des standards pour la programmation en mode message Distributed and heterogeneous computing using PVM 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 MPI : le standard pour le transfert de message Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes Exercice: Recouvrir calcul et communications 205/ / 446 Outline Distributed and heterogeneous computing using PVM Description des standards pour la programmation en mode message Distributed and heterogeneous computing using PVM 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 MPI : le standard pour le transfert de message Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes Exercice: Recouvrir calcul et communications 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. 207/ / 446

54 Overview of the PVM computing environment Workstation Workstation Fast network Workstation PVM (Parallel Virtual Machine) : Public domain software available on netlib Workstation 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. Workstation Slow Network Mini Comp Super Comp Figure: Example of virtual machine 209/ / 446 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). 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. 2/ / 446

55 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. We focus on the main procedures of the PVM user library. Complete version of PVM3 user library [9] available on netlib. 23/ / 446 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. 26/ 446

56 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. 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 -, tids( ), info ) endif... 27/ / 446 Interprocess communication Memory/data pvmfpack Send buffer 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 : Sending Process pvmfsend. 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). Memory/data Receive buffer pvmfunpack Receiving Process pvmfrecv Figure: Illustration of send/receive main steps 29/ / 446

57 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. 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. Management of buffers 22/ 446 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 No encoding, native format of the host node. PvmInPlace 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. 223/ 446 Packing/unpacking data 222/ 446 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, BYTE, INTEGER2, INTEGER4 REAL4, REAL8, COMPLEX8, COMPLEX6 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. 224/ 446

58 Sending messages Receiving 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) Blocking receive call pvmfrecv( tid, mstag, bufid ) Non Blocking Receive call pvmfnrecv( tid, mstag, bufid ) ( bufid = 0 message not received ) Wildcards tid = - any message message tag mstag. mstag = - any message message from tid. tid = - and mstag = - any message. 225/ / 446 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. Sequential code Do It = Ibeg, Ifin Update image Print image Enddo (4) () (3) (2) Slave task ( i ) Do It = Ibeg, Ifin ( Update image ( i ); Pack in active buffer ) call pvmfsend(tid_master, It, info) Enddo Parallel Approach () (2) (subdive the image) (3) (4) () (2) (3) (4) Master task ( Build a complete image at each iteration ) Do It = Ibeg, Ifin Do Idummy=, Nb_slaves call pvmfrecv (, It, bufid) ( bufinfo > tids (Islave) ) ( Unpack and Assemble image Islave ) Enddo ( Print full image ) Enddo 227/ 446

59 * 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-, tids( ), info ) * multicast tids array to children call pvmfinitsend( PVMDEFAULT, info ) call pvmfpack( INTEGER4, tids( ), NPROC-,, info ) call pvmfmcast(nproc-,tids(),msgt0,info) else * receive the tids of brothers and identify call pvmfrecv( tids( 0 ), msgt0, info ) call pvmfunpack( INTEGER4, tids(),nproc-,,info) do i =, NPROC- if( mytid.eq. tids( i ) ) me = i enddo endif call dowork(me,tids,nproc ) call pvmfexit( info ) stop end 229/ 446 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. 23/ 446 subroutine dowork ( me, tids, nproc ) i n c l u d e??/ 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, stride, msgtag count = ; s t r i d e = ; 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 ( tids ( me + ), msgtag, info ) c a l l pvmf recv ( tids ( nproc ), msgtag, info ) e l s e c a l l pvmf recv ( tids ( me ), msgtag, info ) c a l l pvmf unpack (INTEGER4, token, count, stride, info 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, stride, info ) dest = t i d s ( me + ) i f ( me. eq. nproc ) dest = tids ( 0 ) c a l l { pvmfsend }( dest, msgtag, i n f o ) e n d i f return 230/ 446 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 =, m y ( i ) = 0. 0D0 do j =, n y ( i ) = y ( i ) + A( i, j ) x ( j ) enddo enddo 232/ 446

60 In the parallel implementation, first_row() first_row(2) first_row(3) A x master slave slave 2 slave 3 Figure: Static parallelization of the matrix vector product: A partitioned into block of rows distributed on the slave processes. x x x x 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 Codes for master and slave processes Master s code: 233/ 446 * * 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 235/ 446 nb_of_processes = nb_of_slaves + do j=,n do i =,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() = first_row(nb_of_processes+) = m+ j = (m / nb_of_processes) if (nb_of_slaves.gt.0) then do i=2,nb_of_processes first_row(i) = j*(i-) + enddo * work balancing j = mod(m,nb_of_processes) do i=, j- first_row(nb_of_processes-i+) = & first_row(nb_of_processes-i+) +j -i enddo 234/ / 446

61 * broadcast n and x type = 0 call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (INTEGER4, n,,, info) call pvmfpack (REAL8, x, n,, info) call pvmfmcast (nb_of_slaves, inst, type, info) * send its sub-matrix data to each slave process type = do no_slave =, nb_of_processes- * number of components computed by the slave no_slave j = first_row(no_slave+2) - first_row(no_slave+) call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (INTEGER4, j,,, info) call pvmfsend (inst(no_slave), type, info) do i=, n call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (REAL8, & a(first_row(no_slave+),i),j,,info) call pvmfsend (inst(no_slave), type, info) enddo enddo * * compute its part of the work * * perform y <-- one*ax + zero*y * where A is an matrix of order (first_row()-) x n. incx = call dgemv( N,first_row()-,n,one,a,lda,x, & incx,zero,y,incx) * * collect results * type = 2 do no_slave =, nb_of_slaves * j holds number of rows computed by no_slave j = first_row(no_slave+2) - first_row(no_slave+) call pvmfrecv (inst(no_slave), type, bufidr) call pvmfunpack (REAL8, & y(first_row(no_slave+)),j,,info) enddo call pvmfexit(retcode) stop end 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,,, info) call pvmfunpack (REAL8, x, n,, info) * receive my block of rows type = call pvmfrecv (p_id, type, bufidr) call pvmfunpack (INTEGER4, m,,, info) do 0, i=,n call pvmfrecv (p_id, type, bufidr) call pvmfunpack (REAL8, a(,i), m,, info) 0 continue 237/ 446 * perform matrix-vector on my block of rows incx = 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,, info) call pvmfsend (p_id, type, info) * leave PVM environment call pvmfexit (info) stop end 238/ / / 446

62 Makefile for Compilation - Link Configuration of the virtual machine 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 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. 24/ / 446 Example pie> cat hostfile # comments pie pinson goeland aigle pie> pvmd3 hostfile & pie> pvm > conf 4 hosts, data format HOST DTID ARCH SPEED pie HPPA 000 pinson SUN4 000 goeland c0000 RS6K 000 aigle SUN4 000 pie> pvm pvm> conf host, data format HOST DTID ARCH SPEED pie HPPA 000 pvm> add pinson goeland aigle 3 successful HOST DTID pinson goeland c aigle 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. 243/ / 446

63 Outline Figure: XPVM trace of the static parallelisation of the matrix-vector product Description des standards pour la programmation en mode message Distributed and heterogeneous computing using PVM 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 MPI : le standard pour le transfert de message Notions basiques Les modes de communication point à point Exercices: communications point à point Communications globales Communications persistantes Exercice: Recouvrir calcul et communications Note that the fastest computer (sharon) is idle most of the time. 245/ / 446 MPI : le standard pour le transfert de message. Effort de définition d un standard de transfert de message pour les utilisateurs de développeurs 2. Juin 94 Version.0 issue du forum MPI Message Passing Interface [7, 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 : or Versions publiques disponibles: LAM (Univ. Notre Dame), MPICH (Argonne Nat. Lab.), OpenMPI ( 247/ 446 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, 25 fonctions dont 6 de base : MPI Init, MPI Finalize, MPI Comm size, MPI Comm rank, MPI Send, MPI Recv 248/ 446

64 Environnement Example : Hello world enregistrement : call MPI Init( info ) terminaison : call MPI Finalize contexte par défaut : MPI COMM WORLD : tâches numérotées 0,..., N- création de nouveaux contextes : définir des nouveaux groupes de processus et un nouveau contexte #i n c l u d e mpi. h #i n c l u d e <s t d i o. h> i n t main ( argc, argv ) i n t argc ; char argv ; { i n t rank, s i z e MPI Init ( &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. 249/ / 446 Envoi / réception message : opérations de base Les modes de communication point à point 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 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 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 25/ / 446

65 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). Sémantique des communications point à point 253/ 446 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). 253/ 446 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). Sémantique des communications point à point 253/ 446 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). 253/ 446

66 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). Exercice : communications point à point 253/ 446 En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes:. MPI IRsend (..., Ireq,... ) 2. MPI ISsend (..., Ireq,... ) 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. Exercice : communications point à point 254/ 446 En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes:. 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,... ) 3. MPI IBsend (..., Ireq,... ) 3. MPI IBsend (..., Ireq,... ) 255/ / 446

67 Exercice : communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes:. 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,... ) 3. MPI IBsend (..., Ireq,... ) Exercice : communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes:. 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. Rien ne garantit que la communication soit finie. 3. MPI IBsend (..., Ireq,... ) Exercice : communications point à point 255/ 446 En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes:. 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. Rien ne garantit que la communication soit finie. 3. MPI IBsend (..., Ireq,... ) Exercice : communications point à point 255/ 446 En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes:. 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. 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). 255/ / 446

68 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 = IF ( rank.eq.0) THEN d e s t = 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 ) 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 = IF ( rank.eq.0) THEN d e s t = 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 Exercice 2: Communications point à point 256/ 446 Commenter le comportement du programme suivant (exécuté sur 2 processus): CALL MPI COMM RANK(comm, rank, i e r r ) tag = IF ( rank.eq.0) THEN d e s t = 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 Communication glogales 256/ 446 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 256/ / 446

69 Communications persistantes-illustration Cas de communications effectuées en boucle dans un programme. Initialisation(s) d envoi(s)/réception(s): MPI xsend Init (..., Req ) / MPI xrecv Init ( Req ) Possbilité 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) 258/ 446 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 Calcul ( 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 Calcul ( 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, 50, 50)sec.. 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? 260/ 446 Exercice: Recouvrir calcul et communications Soit le programme suivant: CALL MPI COMM RANK(comm, rank, i e r r ) p r e v = rank ; n e x t = rank+ IF ( rank.eq. Nprocs ) next = 0 IF ( rank.eq. 0 ) prev = nprocs IF ( rank.eq.0) THEN CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL Calcul ( 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 Calcul ( rank )! Rdata and Sdata not used i n C a l c u l ENDIF Hypothèses : Solution (I) 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. 259/ 446 IF ( rank.eq.0) THEN CALL MPI Send ( SData, count, MPI REAL, next, tag, comm, i e r r ) CALL Calcul ( 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 Calcul ( rank )! Rdata and Sdata not used i n C a l c u l ENDIF. MPI Send: Temps = Max( , , ( ) = 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 = = 650 sec; On a en plus perdu le recouvrement entre le calcul de PO et de P!! 26/ 446

70 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 MPI Irecv ( RData, count, MPI REAL, prec, tag, comm, Ireq, ierr ) CALL Calcul ( 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 Calcul ( rank )! Rdata not used i n C a l c u l ENDIF Influence du type d envoi: MPI send: Temps= max( , , ) = 300sec MPI Isend: Temps = = 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 262/ 446 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- 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). 263/ 446 Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Profiling automatique Modélisation de Hockney et Jesshope Traces d exécution d un code parallèle Les modèles utilisés 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 Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur Task mapping and scheduling Definitions Postorderings and memory usage Influence of scheduling on the makespan Analyse de performance et modélisation des algorithmes. Evaluation des performances d un algorithme = l utilisation de modèles pour :. 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 264/ / 446

71 . 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. 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. L analyse des performances réelles Permet la validation des modèles précédents. Souvent difficile pour un code parallèle :. 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. Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Profiling automatique Modélisation de Hockney et Jesshope Traces d exécution d un code parallèle Les modèles utilisés 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 Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur Task mapping and scheduling Definitions Postorderings and memory usage Influence of scheduling on the makespan 266/ 446 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(0 6 ), Gflops(0 9 ), Teraflops(0 2 )) Mips: Millions d instructions élémentaires par secondes. ( flops k instruc. de base) Temps d exécution séquentielle: T(N) = Ts(N) + Tpar (N) Temps d exécution parallèle: Tp(N, p) Temps de surcoût parallèle Tsc(N, p) (communication, synchronisation...) Tp(N, p) = Ts(N) + Tpar (N) + Tsc(N, p) p 267/ / / 446

72 00 Ts=Tsc=0 Accélération (speed-up): Sp(N, p) = T(N) Tp(N, p) 0 Speedup Ts>0, Tsc=0 Sp > = speed-up ; et Sp(N, p) < = speed-down Sp(N, p) > p = speed-up superlinéaire. (meilleure utilisation des hiérarchies mémoires, meilleur comportement de l algorithme parallèle) 0 00 Ts>0, Tsc> Nb Processeurs Figure: 3 comportements extrêmes 270/ / 446 Si Tsc = 0 alors Ts + Tpar Sp = Ts + Tpar p Si Tsc > 0 alors Posons, par exemple: Tsc = αp alors donc S = limp Sp = T/Ts, S = + Tpar /Ts S Sp = + p ( ) ] 2 2 p [ + p popt soit p = Tpar (N)/Ts(N) alors: 2 S Sp = ( + p /p) 2 Remarques:. p [0, ] et correspond au poids relatif de la partie // 2 (= 0 pas de //, = tout //). 2. p = p = Sp = S 2 2 p correspond au nombre de processeurs pour atteindre la 2 moitié de S. 3. Si p 4p alors 80% de S est déjà atteint / 446 où popt = Tpar /α et correspond au speed-up maximum Sopt. Exemple: Tp = + 0 p p = Sopt = 9.7 Efficacité: Sp(N, p) Ep(N, p) = p. Pour N fixé, si Tsc est une fonction croissante de p alors Ep décroit avec p 2. Pour p fixé et Ts = 0, si Tsc croît moins vite que T alors Ep augmente avec N 273/ 446

73 Scalabilité: Capacité à conserver Ep(N, p) constante lorsque p augmente. T(N) doit augmenter de façon exponentielle = le sytème est dit peu scalable. T(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 Ep = cte ou Sp croissant linéairement avec p.. On cherche le polynome d ordre m, m tel que 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. E(p, N) = E(kp, amn m an + a0) 2. Plus m est petit plus le système est scalable. 274/ 446 Loi d Amdahl pour le calcul parallèle (loi de Ware) RAPPEL Speed-up théorique avec p processeurs : Sp = De façon plus réaliste : 275/ 446 p f +( f ) p Soit le programme P. T : temps d exécution de P sur processeur f : fraction de P pouvant être exécutée sur p processeurs f : zone séquentielle de P Tp : temps d exécution de P sur p processeurs Tp = temps d exéc. Séq. + temps d exéc. Par. temps d exéc. Séq. = ( f )T temps d exéc. Par. = f T p Tp = ( f ) T + f T p et Sp = T Tp (f + ( f ) p) T Tp ou Tp = p (f + ( f ) p) T +O p O overhead prenant en compte : overheads de synchronisation transferts de données (archi. mém. distribuée) contentions mémoire... p MAIS quel que soit O : Sp f +( f )p Pour un nombre infini de processeurs : Speed-up maximum S f 276/ / 446

74 Table: A very optimistic table Number of processors p f Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Profiling automatique Modélisation de Hockney et Jesshope Traces d exécution d un code parallèle Les modèles utilisés 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 Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur Task mapping and scheduling Definitions Postorderings and memory usage Influence of scheduling on the makespan 278/ 446 Exemples d outils pour l analyse de performances Profiling automatique 279/ 446 Objectif : Etude du temps passé dans les unités de programme : en général procédures/fonctions, mais aussi parfois boucles et intructions.. exemple : gprof sous UNIX permet d étudier le temps passé par procédure.. Compilation des sources avec options appropriées (habituellement -pg ou -p).2 L exécution produit un fichier gmon.out.3 Postraitement, avec options multiples, du fichier gmon.out: gprof [options] nom executable > fichier profile 280/ / 446

75 La seconde partie du fichier profile permet d identifier l arbre d appel (parents et descendants) de chaque routine. Exemple de fichier profile obtenu : % cumulative self self total time seconds seconds calls ms/call ms/call name _matmul_ [3] _matsum_ [4] _MAIN [] _matvec_ [5]... called/total parents index %time self descendents called+self name index called/total children / _main [2] [] _MAIN [] / _matmul_ [3] /5 _matsum_ [4] / _matvec_ [5] [2] _main [2] _MAIN / [] /2 _getenv [49] / _MAIN [] [3] _matmul_ [3] /5 _MAIN [] [4] _matsum_ [4] / _MAIN [] [5] _matvec_ [5] / / 446 Analyse automatiques de la performance et des cache-hits sur CRAY T3D (code de mécanique des fluides): secs Mflops data caches time PVMFRECV:400 gradvelo: % infl3dc : % gradvel : % grad3d : % nufl3dc : % PVMFSEND: 635 SQRT : 320 vsfl3dc : % ns3dc : % implrssm: % edvialg : % shearstr: % dtvis3dc: % updpct : % heatflpg: % EXP : 53.7 Total code: 200 secs 969 ( 6.07%) work 254 (5.76%) loading instructions and data cache 206 (75.59%) waiting on PVM communication 4 ( 2.58%) uninstrumented functions 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) SM SM SM / / 446

76 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 Outline Analyse de performance et modélisation des algorithmes Terminologie Exemples d outils pour l analyse de performances Profiling automatique Modélisation de Hockney et Jesshope Traces d exécution d un code parallèle Les modèles utilisés 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 Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur Task mapping and scheduling Definitions Postorderings and memory usage Influence of scheduling on the makespan 286/ / 446 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. 2 rn : 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 2 Exemple du produit scalaire:. Sur calculateur vectoriel Cray T90, Performance de crête ( proc) =800 Mflops r = 872 Mflops et n = Sur calculateur scalaire SGI Origin 2000, Performance de crête ( proc) =360 Mflops r = 94 Mflops et n = 7 2 c est l effet du cache primaire qui est ici mesuré par n 2 3. Sur machines scalaires sans cache et sans pipeline n = 0 car 2 temps startup est nul. 288/ / 446

77 Traces d exécution d un code parallèle Outils de mise au point et d analyse de codes parallèles Approximation de la performance d une boucle de taille n : rn = r n 2 n + alors limn rn = r et rn 2 = r /2 Comment calculer r et n? 2 (pour une boucle et un calculateur donnné). Mesure de la performance pour différentes longueurs de vecteur. 2. Approximation aux moindres carrés 290/ 446 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é Figure: Trace d exécution VAMPIR d un code de factorisation de matrices creuses