Calcul Réparti et Grid Computing

Transcription

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

2 Contents 1 Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Conclusion 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 Conclusion Ecriture de code efficace 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 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 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

3 5.5 Exemple d analyse de performance d algorithmes : Produit Matrice-Vecteur Informatique distribuée et Grid Computing Informatique distribuée et système Applications distribuées Répartition des calculs Représentation d un calcul réparti Abstractions de niveau plus élevé Grid computing - Internet Computing Classification et exemples de grilles de calcul GridRPC - les projets DIET et Netsolve Exemple d utilisation de la grille : projet Grid-TLSE

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

5 Gains importants possibles avec rapport coût-performance intéressant Calculateurs spécialisés : Résolution d un problème (image processing, crash test,... ) Hardware et logiciels conçus pour cette application-cible Gains très importants possibles avec un rapport coût-performance très intéressant Par exemple, la machine MDGRAPE-3 (dynamique moléculaire) installée au Japon atteint 1 PFlop/s! Besoins dans le domaine du calcul scientifique Science traditionnelle 1. Construire une théorie, 2. Effectuer des expériences ou construire un système. trop difficile (ex: souffleries de grandes tailles) trop cher (fabriquer un avion juste pour quelques expérimentations) trop lent (attente de l évolution du climat / de l univers) trop dangereux (armes, médicaments, expérimentations sur le climat) Calcul scientifique simuler le comportement de systèmes complexes grâce à la simulation numérique. lois physiques + algorithmes numériques + calculateurs haute performance Exemples dans le domaine du calcul scientifique Contraintes de durée: prévision du climat Quelques exemples dans le domaine du calcul scientifique Cost constraints: wind tunnels, crash simulation,... 5

6 Scale Constraints large scale: climate modelling, pollution, astrophysics tiny scale: combustion, quantum chemistry Pourquoi des traitements parallèles? Besoins de calcul non satisfaits dans beaucoup de disciplines (pour résoudre des problèmes significatifs) Performance uniprocesseur proche des limites physiques 6

7 Temps de cycle 0.5 nanoseconde (fréq: 2GH) 8 GFlop/s (avec 4 opérations flottantes / cycle) Calculateur 40 TFlop/s 5000 coeurs calculateurs massivement parallèles Pas parce que c est le plus simple mais parce que c est nécessaire Puissance actuelle (cf http: // www. top500. org ): Juin 2010, Cray XT5, Oak Ridge Natl Lab, 1.7Pflops, 300Tbytes, 224K coeurs Juin 2013, TH-IVB cluster, NUDT (Chine), 33.8Pflops, 1PetaByte, 3M coeurs Quelques unités pour le calcul haute performance Vitesse 1 MFlop/s 1 Megaflop/s 10 6 opérations / seconde 1 GFlop/s 1 Gigaflop/s 10 9 opérations / seconde 1 TFlop/s 1 Teraflop/s opérations / seconde 1 PFlop/s 1 Petaflop/s opérations / seconde 1 EFlop/s 1 Exaflop/s opérations / seconde Mémoire 1 MB / 1 Mo 1 Megabyte 10 6 octets 1 GB / 1 Go 1 Gigabyte 10 9 octets 1 TB / 1 To 1 Terabyte octets 1 PB / 1 Po 1 Petabyte octets 1 EB / 1 Eo 1 Exabyte octets Origines grecques des préfixes : kilo (mille); Mega (grand); Giga (géant); Tera (monstre); Peta (cinq); Exa (six) 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 : 1. Processeur séquentiel: 1 unité scalaire (1 GFlop/s) Temps d exécution de P : 100 s 2. Machine parallèle à 100 processeurs: Chaque processor: 1 GFlop/s 7

8 Performance crête: 100 GFlop/s 3. Si P : code séquentiel (10%) + code parallélisé (90%) Temps d exécution de P : = 10.9 s Performance réelle : 9.2 GFlop/s 4. Performance réelle Performance de crête = 0.1 Loi d Amdahl f s fraction d une application qui ne peut pas être parallélisée f p = 1 f s fraction du code parallélisé N: nombre de processeurs Loi d Amdahl: t N ( fp N + f s)t 1 f s t 1 Speed-up: S = t1 t N 1 f s+ fp N 1 f s Sequential t = f s t 1 Parallel t 3 t 2 t 1 Calculateur procs LINPACK LINPACK Perf. n = 100 n = 1000 crête Intel WoodCrest (1 core, 3GHz) HP ProLiant (1 core, 3.8GHz) HP ProLiant (1 core, 3.8GHz) IBM eserver(1.9ghz, Power5) IBM eserver(1.9ghz, Power5) Fujitsu Intel Xeon (3.2GHz) Fujitsu Intel Xeon (3.2GHz) SGI Altix (1.5GHz Itanium2) NEC SX-8 (2 GHz) Cray T (1 proc.) Hitachi S-3800/ (1 proc.) Table 1: Performance (MFlop/s) sur la résolution d un système d équations linéaires (d après LINPACK Benchmark Dongarra [07]) Depuis, les problèmes Grand Challenge ont grossi! 1.2 Evolutions architecturales Evolutions architecturales: historique Pour 1,000 $ : calculateur personnel plus performant, avec plus de mémoire et plus de disque qu un calculateur des années 70 avec 1,000,000 $ technologie et conception! Durant les 25 premières années de l informatique progrès : technologie et architecture 8

9 Machine Problème de Problème de petite taille grande taille PFlop/s computer - 36 secondes TFlop/s computer 2 secondes 10 heures CM2 64K 30 minutes 1 an CRAY-YMP-8 4 heures 10 ans ALLIANT FX/80 5 jours 250 ans SUN 4/60 1 mois 1500 ans VAX 11/780 9 mois 14,000 ans IBM AT 9 ans 170,000 ans APPLE MAC 23 ans 450,000 ans Table 2: Vitesse de certains calculateurs sur un problème Grand Challenge en 1995 (d après J.J. Dongarra) 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 Deux changements sur le marché facilitent l introduction de nouvelles architectures : 1. utilisation décroissante de l assembleur (compatibilité binaire moins importante) 2. systèmes d exploitation standards, indépendants des architectures (e.g. UNIX) développement d un nouvel ensemble d architectures : RISC à partir de 85 performance : + 50% par an!!! Conséquences : Moore s law 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

10 Gordon Moore (co-fondateur d Intel) a prédit en 1965 que la densité en transitors des circuits intégrés doublerait tous les 24 mois. A aussi servi de but à atteindre pour les fabriquants. A été déformé: mois nombre de transistors performance Comment accroître la vitesse de calcul? Accélérer la fréquence avec des technologies plus rapides On atteint les limites: Conception des puces Consommation électrique et chaleur dissipée Refroidissement problème d espace On peut encore miniaturiser, mais: pas indéfiniment résistance des conducteurs (R = ρ l s ) augmente et.. la résistance est responsable de la dissipation d énergie (effet Joule). effets de capacités difficiles à maîtriser Remarque: 0.5 nanoseconde = temps pour qu un signal parcourt 15 cm de cable Temps de cycle 0.5 nanosecond 8 GFlop/s (avec 4 opérations flottantes par cycle) Seule solution: le parallélisme parallélisme: exécution simultanée de plusieurs instructions à l intérieur d un programme A l intérieur d un processeur : micro-instructions traitement pipeliné recouvrement d instructions exécutées par des unités distinctes transparent pour le programmeur (géré par le compilateur ou durant l exécution) Entre des processeurs ou cœurs distincts: suites d instructions différentes exécutées synchronisations implicites (compilateur, parallélisation automatique) ou explicites (utilisateur) 10

11 Unités centrales haute-performance Concept clé: Traitement pipeliné : L exécution d une opération (arithmétique) est décomposée en plusieurs sous-opérations Chaque sous-opération est exécutée par une unité fonctionnelle dédiée = étage (travail à la chaine) Exemple pour une opérations diadique (a b c) : T1. Séparer mantisse et exposant T2. Multiplier mantisses T3. Additionner les exposants T4. Normaliser le résultat T5. Ajouter signe au résultat Exemple pour des opérations diadiques (suite) Supposition: l opération a b c s effectue en 5 traitements élémentaires T1,T2,...,T5 d un cycle chacun. Quel est le nombre de cycles processeur pour la boucle suivante? Pour i = 1 à N A(i) = B(i) * C(i) Fin Pour Traitement non pipeliné: N * 5 cycles Traitement pipeliné (à la chaine): N + 5 cycles 1er cycle: T1(1) 2ème cycle: T1(2), T2(1) 3ème cycle: T1(3), T2(2), T3(1)... kème cycle: T1(k), T2(k-1), T3(k-2), T4(k-3), T5(k-4)... 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 11

12 Processeurs RISC Processeurs RISC : introduits sur le marché vers 1990 the attack of the killer micros pipeline sur les opérations scalaires performance proche de celle des processeurs vectoriels à fréquence égale plus efficaces sur des problèmes scalaires CISC (Complex Instruction Set Computer) Efficacité par un meilleur encodage des instructions RISC (Reduced Instruction Set Computer) Concept étudié fin des années 70 Décroître le nombre de cycles par instruction à 1 Jeu d instructions simple Hardware simplifié Temps de cycle plus faible Idées maîtresses dans la conception des RISC : Instructions décodées en 1 cycle Uniquement l essentiel réalisé au niveau du hardware Interface load/store avec la mémoire Utilise intensivement le principe du pipeline pour obtenir un résultat par cycle même pour les opérations complexes Hiérarchie mémoire haute-performance Format d instructions simple RISC super scalaires ou superpipelines: plusieurs unités fonctionnelles Architectures multi-cœurs Constats La quantité de composants / puce va continuer à augmenter La fréquence ne peut plus augmenter beaucoup (chaleur/refroidissement) Il est difficile de trouver suffisamment de parallélisme dans le flot d instructions d un processus Multi-cœurs plusieurs cœurs à l intérieur d un même processeur vus comme plusieurs processeurs logiques par l utilisateur Mais: multi-threading nécessaire au niveau de l application 12

13 Processeur Cell La PS3 est basée sur un processeur Cell (Sony,Toshiba,IBM) 1 Cell= un Power PC + 8 SPE (Synergetic Process. Elem.) 1 SPE = processeur vectoriel SIMD + DMA = 25.6 GFlop/s 204 GFlop/s de performance crête en arithmétique 32 bits (14.6 GFlop/s en 64 bits) D où regain d intérêt pour le calcul en 32 bits Mélange d arithmétiques simple et double précision (voir [13]) Typiquement: 32-bit pour le gros des calculs, 64 bits pour améliorer la précision Pas seulement sur processeur Cell Example of mixed-precision arithmetic Solve Ax = b, A sparse with the sparse direct solver MUMPS Compare single precision + iterative refinement to double precision run (Number of steps of iterative refinements indicated on Figure). Speed-up obtained wrt double precision (Results from A. Buttari et.al., 2007) Problèmes On est souvent (en pratique) à 10% de la performance crête Processeurs plus rapides accès aux données plus rapide : 13

14 Année Calculateur MFlop/s CDC CDC IBM 370/195 ILLIAC IV CRAY-1, XMP, CRAY CDC CYBER 205 FUJITSU VP400 NEC SX CRAY-YMP, C ,000 ETA-10 NEC SX-3 FUJITSU VP CRAY T3E 1.2 TFlop/s INTEL 1.8 TFlop/s IBM SP 16 TFlop/s HP 20 TFlop/s NEC 40 TFlop/s IBM Blue Gene 180 TFlop/s Roadrunner 1 PFlop/s Table 3: Evolutions des performances par décennie 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 Problèmes de débit mémoire Il devient plus difficile de programmer efficacement 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 Comment obtenir de hauts débits mémoire? Plusieurs chemins d accès entre mémoire et processeurs CRAY XMP et YMP : 2 vector load + 1 vector store + 1 I/O utilisés pour accéder des vecteurs distincts NEC SX : 14

15 chemins d accès multiples peuvent être aussi utilisés pour charger un vecteur (améliore le débit, mais pas la latence!) Plusieurs modules mémoire accédés simultanément (entrelaçage) Accès mémoire pipelinés Mémoire organisée hiérarchiquement La façon d accéder aux données peut affecter la performance: Minimiser les défauts de cache Minimiser la pagination mémoire Localité: améliorer le rapport références à des mémoires locales/ références à des mémoires à distance Size Average access time (# cycles) hit/miss Registers < KB Cache level #1 1 2 / KB 16 MB Cache level # / GB Main memory Remote memory Disks 700,000 / 6,000,000 Figure 1: Exemple de hiérarchie mémoire. Conception mémoire pour nombre important de processeurs? Comment 500 processeurs peuvent-ils avoir accès à des données rangées dans une mémoire partagée (technologie, interconnexion, prix?) Solution à coût raisonnable : mémoire physiquement distribuée (chaque processeur a sa propre mémoire locale) 2 solutions : mémoires locales globalement adressables : Calulateurs à mémoire partagée virtuelle transferts explicites des données entre processeurs avec échanges de messages Scalibité impose : augmentation linéaire débit mémoire / vitesse du processeur augmentation du débit des communications / nombre de processeurs Rapport coût/performance mémoire distribuée et bon rapport coût/performance sur les processeurs 15

16 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 4: Organisation des processeurs Architecture des multiprocesseurs Nombre élevé de processeurs mémoire physiquement distribuée 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) Terminologie Architecture SMP (Symmetric Multi Processor) Mémoire partagée (physiquement et logiquement) Temps d accès uniforme à la mémoire Similaire du point de vue applicatif aux architectures multi-cœurs (1 cœur = 1 processeur logique) Mais communications bcp plus rapides dans les multi-cœurs (latence < 3ns, bande passantee > 20 GB/s) que dans les SMP (latence 60ns, bande passantee 2 GB/s) Architecture NUMA (Non Uniform Memory Access) Mémoire physiquement distribuée et logiquement partagée Plus facile d augmenter le nombre de procs qu en SMP Temps d accès dépend de la localisation de la donnée Accès locaux plus rapides qu accès distants hardware permet la cohérence des caches (ccnuma) 16

17 1.3 Programmation Classification de Flynn S.I.S.D. : Single Instruction Single Data stream architecture monoprocesseur calculateur von Neumann conventionnel exemples : SUN, PC S.I.M.D. : Single Instruction Multiple Data stream processeurs exécutent de façon synchrone la même instruction sur des données différentes (e.g. éléments d un vecteur, d une matrice, d une image) une unité de contrôle diffuse les instructions processeurs identiques Exemples : CM-2, DAP, MasPar,... plus récemment: chacun des 8 SPE du processeur CELL se comporte comme un système SIMD 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 multiprocesseurs, réseaux de stations de travail,... Modes de programmation SIMD et MIMD Avantages du SIMD : Facilité de programmation et de débogage Processeurs synchronisés coûts de synchronisation minimaux Une seule copie du programme Décodage des instructions simple Avantages du MIMD : Plus flexible, beaucoup plus général Exemples: 1.4 Conclusion mémoire partagée: OpenMP, threads POSIX mémoire distribuée: PVM, MPI (depuis C/C++/Fortran) Evolutions du Calcul Haute-Performance Mémoire virtuellement partagée : clusters Hiérarchie mémoire plus étendue Clusters de machines 17

18 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 multiprocesseurs à mémoire partagée de calcul 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. HPC Spectrum (d après J.Dongarra) Peer to peer (SETI@home) Grid based computing Network of ws Beowulf cluster Clusters w/ special interconnect Parallel dist mem TFlop machines Distributed Systems - Gather (unused) resources - Steal cycles - System software manages resources - 10% - 20% overhead is OK - Resources drive applications - Completion time not critical - Time-shared - Heterogeneous 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 18

19 2 Calculateurs haute-performance: concepts généraux 2.1 Introduction Introduction Conception d un supercalculateur Déterminer quelles caractéristiques sont importantes (domaine d application) Maximum de performance en respectant les contraintes de coût (achat, maintenance,consommation) Conception d un processeur : Jeu d instructions Organisation fonctionnelle et logique Implantation (intégration, alimentation,... ) Exemples de contraintes fonctionnelles vs domaine d application Machine généraliste : performance équilibrée sur un large ensemble de traitements Calcul scientifique : arithmétique flottante performante Gestion : base de données, transactionnel, Organisation des processeurs 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 : Code correspondant : do i = 1, n a(i) = b(i) + c(i) enddo i = 1 boucle : load b(i) dans registre #1 load c(i) dans registre #2 registre #3 = registre #1 + registre #2 store registre #3 dans a(i) i = i + 1 et test fin de boucle Exploitation du pipeline déroulage de boucle 19

20 do i = 1, n, 4 a(i ) = b(i ) + c(i ) a(i+1) = b(i+1) + c(i+1) a(i+2) = b(i+2) + c(i+2) a(i+3) = b(i+3) + c(i+3) enddo Sur processeur vectoriel : do i = 1, n a(i) = b(i) + c(i) enddo load vector b dans registre #1 load vector c dans registre #2 register #3 = register #1 + register #2 store registre #3 dans vecteur a Stripmining : si n > nb (taille registres vectoriels) do i = 1, n, nb ib = min( nb, n-i+1 ) do ii = i, i + ib - 1 a(ii) = b(ii) + c(ii) enddo enddo Problèmes dans la conception des pipelines Beaucoup d étages: coût d amorçage plus élévé performances plus sensibles à la capacité de nourrir le pipeline permet de réduire le temps de cycle Moins d étages sous-instructions plus complexes plus difficile de décroître le temps de cycle Problèmes des dépendences de données Exemple : do i = 2, n a(i) = a(i-1) + 1 enddo a(i) initialisés à 1. Exécution scalaire : 20

21 Etape 1 : a(2) = a(1) + 1 = = 2 Etape 2 : a(3) = a(2) + 1 = = 3 Etape 3 : a(4) = a(3) + 1 = = 4... Exécution vectorielle : pipeline à p étages p éléments dans le pipeline Etages du pipe Temps p sortie t0 a(1) t0 + dt a(2) a(1) t0 + 2dt a(3) a(2) a(1)... t0 + pdt a(p+1) a(p)... a(2) a(1) D où : a(2) = a(1) + 1 = = 2 a(3) = a(2) + 1 = = 2... car on utilise la valeur initiale de a(2). Overlapping (recouvrement) Résultat exécution vectorielle exécution scalaire Utiliser des unités fonctionnelles en parallèle sur des opérations indépendantes. Exemple: do i = 1, n A(i) = B(i) * C(i) D(i) = E(i) + F(i) enddo B C Pipelined multiplier A E F Pipelined adder T ime overlapping = max{startup mul, Startup add + dt} + n dt T ime no overlap. = {Startup mul + n dt} + {Startup add + n dt} D Avantages: parallélisme entre les unités fonctionnelles indépendantes et plus de flops par cycle Chaining (chaînage) La sortie d une unité fonctionnelle est dirigée directement vers l entrée d une autre unité fonctionnelle Exemple : 21

22 do i = 1, n A(i) = ( B(i) * C(i) ) + D(i) enddo B C Pipelined multiplier Pipelined adder A T ime chaining = Startup mul + Startup add + n dt T ime nochaining = {Startup mul + n dt} + {Startup add + n dt} D Avantages : plus de flops par cyle, exploitation de la localité des données, économie de stockage intermédiaire 2.3 Organisation mémoire Locality of references Programs tend to reuse data and instructions recently used Often program spends 90% of its time in only 10% of code. Also applies - not as strongly - to data accesses : temporal locality : recently accessed items are likely to be accessed in the future spatial locality : items whose addresses are near one another tend to be referenced close together in time. Concept of memory hierarchy - 1 Example : In hardware : smaller is faster On a high-performance computer using same technology (pipelining, overlapping,... ) for memory: signal propagation is a major cause of delay thus larger memories more signal delay and more levels to decode addresses. smaller memories are faster because designer can use more power per memory cell. Concept of memory hierarchy - 2 Make use of principle of locality of references Data most recently used - or nearby data - are very likely to be accessed again in the future Try to have recently accessed data in the fastest memory Because smaller is faster use smaller memories to hold most recently used items close to CPU and successively larger memories farther away from CPU Typical memory hierarchy Memory hierarchy 22

23 access bandwidth Level Size time MB/s technology manag. Registers 1KB 2-5 ns ,000 (BI)CMOS compiler Cache 4MB 3-10 ns 800-5,000 CMOS SRAM hardware Main memory 4GB ns 400-2,000 CMOS DRAM OS Disk 1GB ns 4-32 magnetic disk OS/user Memory interleaving Memory Interleaving "The memory is subdivided into several independent memory modules (banks)" Two basic ways of distributing the addresses Example: Memory size 2 10 =1024 Words divided into 8 banks High order interleaving Real a(256) Low order interleaving Banks a(1), a(2),..., a(128) a(129),..., a(256) Banks a(1), a(9),..., a(249) a(2), a(10),..., a(250) a(3),a(11),..., a(251) a(4),... a(5),... a(6),... a(7),..., a(255) a(8), a(16),..., a(256) "well adapted to pipelining memory access" Effect of bank cycle time Bank cycle time: Time interval during which the bank cannot be referenced again Example Low order interleaved memory, 4 banks, bank cycle time 3CP. % column access %row access Real a(4,2) Real a(4,2) Do j=1,2 Do i=1,4 Do i=1,4 Do j=1,2... = a(i,j)... = a(i,j) Enddo Enddo Enddo Enddo Bank Bank 1 a(1,1) a(1,2) 1 a(1,1) a(1,2) a(2,1) a(2,2) a(2,1) a(2,2) a(3,1) a(3,2) 3 a(3,1) a(3,2) 4 a(4,1) a(4,2) 4 a(4,1) a(4,2) 1 CP 10 Clock Period time 18 Clock Period Bank Conflict: Consecutive accesses to the same bank in less than bank cycle time. Stride: Memory address interval between successive elements 2.4 Organisation interne et performance des processeurs vectoriels Organisation interne et performance des processeurs vectoriels (d après J. Dongarra) Soit l opération vectorielle triadique : do i = 1, n y(i) = alpha * ( x(i) + y(i) ) enddo On a 6 opérations : 23

24 1. Load vecteur x 2. Load vecteur y 3. Addition x + y 4. Multiplication alpha ( x + y ) 5. Store dans vecteur y Organisations de processeur considérées : 1. Séquentielle 2. Arithmétique chaînée 3. Load mémoire et arithmétique chaînées 4. Load mémoire, arithmétique et store mémoire chaînés 5. Recouvrement des loads mémoire et opérations chaînées Notations : a : startup pour load mémoire b : startup pour addition c : startup pour multiplication d : startup pour store mémoire Sequential Machine Organization a load x a load y memory path busy b add. c mult. d store Chained Arithmetic a load x a load y b add. memory path busy c mult. d store 2.5 Organisation des processeurs RISC Organisation des processeurs RISC The execution pipeline Instruction Fetch Instruction Decode Execution Memory access and branch completion Write back (write results in register file) Example (DLX processor, Hennessy and Patterson, 96 [11]) Pipeline increases the instruction throughput 24

25 Chained Load and Arithmetic a load x a load y b add. c mult. memory path busy d store Chained Load, Arithmetic and Store a load x a load y memory path busy b c add. mult. d store Overlapped Load with Chained Operations a load x a load y b add. c mult. d store memory path 1 busy memory path 2 busy memory path 3 busy 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 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 25

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

27 ILP: Dynamic scheduling Other approach : Tomasulo s approach (register renaming) Suppose compiler has issued: F10 <- F2 x F2 F2 <- F0 + F6 Rename F2 to F8 in the second instruction (assuming F8 is not used) F10 <- F2 x F2 F8 <- F0 + F6 Can be used in conjunction with scoreboarding Impact of ILP : example This example is from J.L. Hennessy and D.A. Patterson (1996) [11]. Original Fortran code do i = 1000, 1 x(i) = x(i) + temp enddo Pseudo-assembler code R1 <- address(x(1000)) load temp -> F2 Loop : load x(i) -> F0 F4 = F0 + F2 store F4 -> x(i) R1 = R1 - #8 % decrement pointer BNEZ R1, Loop % branch until end of loop Architecture Integer Unit 1 stage FP add 4 stages IF ID MEM WB FP mult 4 stages Divide not pipelined Example of pipelined processor (DLX processor, Hennessy and Patterson, 96 [11]) Latency: # cycles between instruction that produces result and instruction that uses result Initiation interval : # cycles between issuing 2 instructions of same type Latency = 0 means results can be used next cycle Functional unit Latency Initiation interval Integer ALU 0 1 Loads 1 1 FP add 3 1 FP mult 3 1 FP divide Characteristics of the processor 27

28 Inst. producing result Inst. using result Latency FP op FP op 3 FP op store double 2 Load double FP op 1 Load double store double 0 Latency between instructions Latency FP op to store double : forwarding hardware passes result from ALU directly to memory input. Straightforward code #cycle Loop : load x(i) -> F0 1 load lat. = 1 stall 2 F4 = F0 + F2 3 stall 4 FP op -> store = 2 stall 5 store F4 -> x(i) 6 R1 = R1 - #8 7 BNEZ R1, Loop 8 stall 9 delayed branch 1 9 cycles per iteration Cost of calculation 9,000 cycles Peak performance : 1 flop/cycle Effective performance : 1 9 With a better scheduling of peak #cycle Loop : load x(i) -> F0 1 load lat. = 1 stall 2 F4 = F0 + F2 3 R1 = R1 - #8 4 Try keep int. unit busy BNEZ R1, Loop 5 store F4 -> x(i) 6 Hide delayed branching by store 6 cycles per iteration Cost of calculation 6,000 cycles Effective performance : 1 6 of peak Using loop unrolling (depth = 4) do i = 1000, 1, -4 x(i ) = x(i ) + temp x(i-1) = x(i-1) + temp x(i-2) = x(i-2) + temp x(i-3) = x(i-3) + temp enddo Pseudo-assembler code (loop unrolling, depth=4): #cycle Loop : load x(i) -> F0 1 1 stall F4 = F0 + F2 3 2 stalls store F4 -> x(i) 6 28

29 load x(i-1) -> F6 7 1 stall F8 = F6 + F2 9 2 stalls store F8 -> x(i-1) 12 load x(i-2) -> F stall F12= F10+ F stalls store F12-> x(i-2) 18 load x(i-3) -> F stall F16= F14+ F stalls store F16-> x(i-3) 24 R1 = R1 - #32 25 BNEZ R1, Loop 26 stall cycles per iteration Cost of calculation = 6750 cycles 1000 Effective performance : 6750 = 15% of peak Using loop unrolling (depth = 4) and scheduling #cycle Loop : load x(i) -> F0 1 load x(i-1) -> F6 2 load x(i-2) -> F10 3 load x(i-3) -> F14 4 F4 = F0 + F2 5 F8 = F6 + F2 6 F12= F10+ F2 7 F16= F14+ F2 8 store F4 -> x(i) 9 store F8 -> x(i-1) 10 store F12-> x(i-2) 11 R1 = R1 - #32 12 BNEZ R1, Loop 13 store F16-> x(i-3) cycles per iteration Cost of calculation = 3500 cycles 1000 Effective performance : 3500 = 29% of peak Now assume superscalar pipeline : integer and floating point operations can be issued simultaneously Using loop unrolling with depth = 5 Integer inst. Float.inst. #cycle Loop: load x(i) -> F0 1 load x(i-1)-> F6 2 load x(i-2)-> F10 F4 =F0 +F2 3 load x(i-3)-> F14 F8 =F6 +F2 4 load x(i-4)-> F18 F12=F10+F2 5 store F4 ->x(i) F16=F14+F2 6 store F8 ->x(i-1) F20=F18+F2 7 store F12->x(i-2) 8 store F16->x(i-3) 9 R1 = R1 - #40 10 BNEZ R1, Loop 11 store F20->x(i-4) 12 29

30 12 cycles per iteration Cost of calculation = 2400 cycles 1000 Effective performance : 2400 = 42% of peak Performance limited by balance between int. and float. instr. 2.6 Réutilisation des données (dans les registres) Réutilisation des données (dans les registres) Améliorer l accès aux données et exploiter la localité spatiale et temporelle des références mémoire Déroulage de boucles : réduit le nombre d accès mémoire en utilisant le plus de registres possible Utiliser des scalaires temporaires Distribution de boucles : si nombre de données réutilisables > nombre de registres : substituer plusieurs boucles à une seule 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 : DOT do j = 1, N do i = 1, N... do i = 1, N do j = 1, N... DOT variant Processeurs RISC mieux adaptés à DOT que AXPY do i = 1, N temp = 0. do j = 1, N temp = temp + x(j)*a(j,i) enddo y(i) = y(i) + temp enddo Stride = 1 dans boucle la plus interne load A(j,i) load x(j) perform x(j)*a(j,i) + temp 30

31 Ratio Flops/références mémoire = 2 2 = 1 Réutilisation de x(j) : déroulage à une profondeur 2 * Cleanup odd iteration i = MOD(N,2) if ( i >= 1 ) then do j = 1, N y(i) = y(i) + x(j)*a(j,i) enddo end if * Main loop imin = i + 1 do i = imin, N, 2 temp1 = 0. temp2 = 0. do j = 1, N temp1 = temp1 + A( j,i-1) * x(j) temp2 = temp2 + A( j,i ) * x(j) enddo y(i-1) = y(i-1) + temp1 y(i ) = y(i ) + temp2 enddo load A(j,i-1) load x(j) perform A(j, i-1 ) * x(j) + temp1 load A(j,i) perform A(j,i ) * x(j) + temp2 Ratio Flops/références mémoire = 4 3 Déroulage à une profondeur de 4 : 8 5 Déroulage à une profondeur k: 2k k+1 45 Performance of y = At x on HP 715/ Rolled Unrolled 2 Unrolled 4 Unrolled 8 30 MFlops Size Figure 2: Effect of loop unrolling on HP 715/64 31

32 50 Performance of y = At x on CRAY T3D Rolled Unrolled 2 Unrolled 4 Unrolled 8 MFlops Size Figure 3: Effect of loop unrolling on CRAY T3D AXPY variant Habituellement préférée sur processeurs vectoriels do j = 1, N do i = 1, N y(i) = y(i) + x(j)*a(j,i) enddo enddo Stride > 1 dans la boucle la plus interne load A(j,i) load y(i) perform x(j)*a(j,i) + y(i) store result in y(i) Ratio Flops/références mémoire = 2 3 Réutilisation de y(i) : déroulage à profondeur 2 * Cleanup odd iteration j = MOD(N,2) if ( j.ge. 1 ) then do i = 1, N y(i) = y(i) + x(j)*a(j,i) enddo end if * Main loop jmin = j + 1 do j = jmin, N, 2 do i = 1, N y(i) = y(i)+a(j-1,i)*x(j-1)+a(j,i)*x(j) enddo enddo load y(i) load A(j-1,i) perform A(j-1,i ) * x(j-1) + y(i) 32

33 load A(j,i) perform A(j,i) * x(j) + y(i) store result in y(i) Ratio Flops/références mémoire = 1 Déroulage à profondeur 4 Ratio = 4 3 Déroulage à profondeur p Ratio = 2.7 Mémoire cache Organisation d une mémoire cache Cache 2p 2+p 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 = 1 : cache fully associative K = 1 : cache direct mapped 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 33

34 line cache main memory Fully associative Pas de correspondance a priori Recherche de données dans cache coûteuse Set associative Cache divisé en plusieurs ensembles Chaque bloc en mémoire peut être dans l une des lignes de l ensemble 4-way set associative : 4 lignes par ensemble cache set #k line 1 line 2 line 3 line 4 line main memory Gestion des caches Coût d un défaut de cache : entre 2 et 50 C (temps de cycle) Copyback Pas de m-à-j lorsqu une ligne de cache est modifiée, excepté lors d un cache flush ou d un défaut de cache Mémoire pas toujours à jour. Pas de problème de cohérence si les processeurs modifient des lignes de cache indépendantes Writethrough Donnée écrite en mémoire chaque fois qu elle est modifiée Données toujours à jour. Pas de problème de cohérence si les processeurs modifient des données indépendantes 34

35 Cache coherency problem Processor # 1 Processor # 2 cache cache cache line X Y Cache coherency mechanisms to: avoid processors accessing old copies of data (copyback and writethrough) update memory by forcing copyback invalidate old cache lines 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 Processor Line size Level Size Organization miss Access / cycle DEC B 1 8 KB Direct-mapped 2 C KB 3-way ass. 8 C MB Direct-mapped 12 C 2 IBM Power2 128 B / KB / 4-way-ass. 8 C B 256 KB MIPS R B 1 16 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 2.8 Réutilisation des données (dans les caches) Réutilisation des données (dans les caches) Example cache 10 times faster than memory, hits 90% of the time. What is the gain from using the cache? Cost cache miss: t miss Cost cache hit: t hit = 0.1 t miss Average cost: 90%(0.1 t miss ) + 10% t miss t gain = miss 100% 1 90% (0.1 t miss)+10% t miss = ( )+0.1 = = 5.3 (similar to Amdahl s law) 35

36 Tmiss %hits Tps hits Tps misses Ttotal Perf. 100% % 10 99% % 20 99% % 10 95% % 20 95% % Table 5: Effet des défauts de cache sur la performance d un code (exprimés en pourcentages vs pas de défaut de cache). Réutilisation des données (dans les caches) Il est critique d utiliser au maximum les données dans le cache améliorer le % de succès de cache Exemple : effet du % de défauts de cache sur un code donné P max performance lorsque toutes les données tiennent dans le cache (hit ratio = 100%). T min temps correspondant. Lecture de donnée dans le cache par une instruction et exécution : t hit = 1 cycle Temps d accès à une donnée lors d un défaut de cache : t miss = 10 ou 20 cycles (exécution instruction t miss + t hit ) T total = %hits.t hit + %misses (t miss + t hit ) T opt = 100% t hit P erf = Topt T total Efficient cache utilization: Exercise Reuse as much as possible data held in cache Improve cache hit ratio Cache : single block of CS (cache size) words When cache is full: LRU line returned to memory Copy-back: memory updated only when a modified block removed from cache For simplicity, we assume cache line size L=1 Example from D. Gannon and F. Bodin : do i=1,n do j=1,n a(j) = a(j) + b(i) enddo enddo 1. Compute the cache hit ratio (assume n much larger than CS). 2. Propose a modification to improve the cache hit ratio. 36

37 2.9 Mémoire virtuelle 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: 1024 entrées Défaut de TLB : 36 C environ AIX offre la possibilité d augmenter la taille des pages (jusqu à 16 MB) pour limiter les défauts de TLB Réutilisation des données (en mémoire) Exercice sur la réutilisation des données (en mémoire) (inspiré de (Dongarra, Duff, Sorensen, van der Vorst [7])) C C + A B A, B, C : matrices n n, n = 20000, stockées par colonnes Calculateur vectoriel (Performance de crête 50 GFlop/s) Mémoire virtuelle (remplacement page : LRU) 1 page mémoire = 2Mmots = 100 colonnes de A, B, ou C (1 mot = 8 bytes) 1 défaut de page 10 4 secondes Stockage de A, B, et C : 3 400Mmots = GB = 9.6 GB capacité mémoire : 128 pages soit: 128 2Mmots = 256Mmots = 2GB A, B, C ne peuvent être stockées totalement Variante (1) : ijk do i = 1, n do j = 1, n do k = 1, n Cij <- Cij + Aik * Bkj enddo enddo enddo 1. Quel est le nombre de défauts de pages et le temps de calcul de cette variante (ijk)? 2. Quel est le nombre de défauts de pages et le temps de calcul de la variante (jki)? 3. Quel est le nombre de défauts de pages et le temps de calcul de la variante (jki) avec blocage sur j et k par blocs de taille 4 pages mémoire? 37

38 2.11 Interconnexion des processeurs Interconnexion des processeurs Réseaux constitués d un certain nombre de boîtes de connexion et de liens Commutation de circuits : chemin créé physiquement pour toute la durée d un transfert (idéal pour un gros transfert) Commutation de paquets : des paquets formés de données + contrôle trouvent eux-même leur chemin Commutation intégrée : autorise les deux commutations précédentes Deux familles de réseaux distincts par leur conception et leur usage : Réseaux mono-étage Réseaux multi-étages Réseau Crossbar o o o o o o o o o o o o 3 o o o o o Toute entrée peut être connectée à toute sortie sans blocage. Théoriquement, le plus rapide des réseaux mais concevable seulement pour un faible nombre d Entrées/Sortie. Réseaux multi-étages Constitués de plus d un étage de boitiers de connexion. Système de communication permettant le plus grand nombre possible de permutations entre un nombre fixe d entrées et de sorties. A chaque entrée (ou sortie) est associée une unité fonctionnelle. Nombre d entrées = nombre de sorties = 2 p Figure 4: Exemple de réseau multi-étage avec p=3. Réseaux birectionnels ou doublement du réseau. 38

39 Boîte de connexion élémentaire Elément de base dans la construction d un réseau : connexion entre deux entrées et deux sorties Boîte à deux fonctions (B2F) permettant les connexions directe et croisée contrôlée par un bit Boîte à quatre fonctions (B4F) permettant les connexions directe, croisée,à distribution basse et haute contrôlée par deux bits. Topologie : mode d assemblage des boîtes de connexion pour former un réseau de N = 2 p entrées / N sorties. La plupart des réseaux sont composés de p étages de N 2 boîtes. Exemple : Réseau Omega Topologie basée sur le Perfect Shuffle (décalage à gauche des bits plus boucle) permutation sur des vecteurs de 2 p éléments Le réseau Omega reproduit à chaque étage un Perfect Shuffle. Autorise la distribution d une entrée sur toutes les sorties ( broadcast ). 7 39

40 0 1 A E I B F J C G K D H 7 Réseau Omega 8 8. L 6 7 Anneau Proc 0 Proc 1 Proc 2 Proc n Grille Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Utilisé sur Intel DELTA et PARAGON,... Shuffle Exchange : Perfect Shuffle avec en plus Proc # i connecté à Proc # (i+1) 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/1, ipsc/2, ipsc/860), machines NCUBE, CM2,... 40

41 Topologies usuelles pour les architectures distribuées Notations : # procs = N = 2 p diamètre = d (chemin critique entre 2 procs) # liens = w Anneau : d = N 2, w = N Grille 2D : d = 2 (N 1 2 1), w = 2 N 1 2 (N 1 2 1) Tore 2D (grille avec rebouclage sur les bords) : d = N 1 2, w = 2 N Hypercube ou p-cube : d = p, w = N p 2 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,... ) 41

42 Figure 5: 4-Cube in space. Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc 42

43 2.12 Les supercalculateurs du top 500 en Juin 2013 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 10 dernières années la performance a augmenté plus vite que la loi de Moore: Analyse des sites - Definitions Rang (noté # par la suite): Position dans le top 500. Rpeak (Gflop/s): Performance crête de la machine en nombre d opérations flottantes par secondes. Rmax (Gflop/s): Performance maximum obtenue sur le test LINPACK Nmax: Taille du problème ayant servi à obtenir Rmax. Power (MWatt/s) : Watt/s consommés (voir aussi L efficacité énergétique s améliore Les calculateurs à efficacité energétique la plus forte possédent des processeurs cell Green500.org: #1: 3208 Mflops/Watt, CINECA (Bologne) Top500 performance #1: 1900 Mflops/Watt, Tianhe-2 (Chine) (#1 en 2010 : 253 Mflops/Watt!!!) Top 500: évolution des performances (RMAX) June 1997: ASCI Red, Sandia NL #1 = 1.1 TFlop/s (effectif) #500 = 7.7 GFlop/s June 2007:IBM Blue gene, Livermore NL #1 = 280 TFlop/s #500 = 4 TFlop/s June 2008: Roadrunner, LosAlamos NL #1 = 1 PFlop/s (1026 TFlop/s) #500 = 4 TFlop/s June 2010: Jaguar, OakRidge NL #1 = 1,75 PFlop/s (1026 TFlop/s) #500 = 25 TFlop/s June 2013: #1 Tianhe-2 (MilkyWay-2) National Univ. of Def. Tech., Chine, 54 Pflops (> 3 Millions coeurs) #500 = 100 Tera 43

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

45 Distribution géographique Répartition par segment d activité Statistiques constructeurs 45

46 Analyse des familles de processeurs Analyse des familles de processeurs 46

47 Analyse des sites français Juin 2013 (23 dans Top 500) Rang Site Système Cores Rmax Power (x1000) (Tflops) (Mw) 11 Total SGI ICE X, Xeon, 8C, 2.6GH 110K ,1 15 CEA/TGCC Bullx, Xeon, 8C 2.7GH 77K ,2 25 CEA Bullx, super-node 136K ,5 37 CNRS/IDRIS BlueGene/Q, Power BQC, 1.6GH 65K EDF R&D BlueGene/Q, Power BQC, 1.6GH 65K Météo France Bullx 26K Airbus HP POD - Cluster Platform 25,8 243 Autres domaines concernés (Institution financieres (4), Service, Automobile, Simulation (EADS, CNES)) Meteo France, Espace Clément Ader (Toulouse), 1 Petaflops en 2014 et 5 Petaflops en Conclusion Conclusion Performance : Mais : Horloge rapide Parallélisme interne au processeur Traitement pipeliné Recouvrement, chaînage des unités fonctionnelles Parallélisme entre processeurs 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? 47

48 Ecriture de code efficace Ecriture de code efficace (I) : MFLOPS ou MIPS? MFLOPS: floating point operations /sec. Ne dépend pas du calculateur MIPS: instructions de bas-niveau Dépend du calculateur Watt: code efficace sur des machines a faible consommation en Watt par proc. (Exemple des proc. Cell). Précision des calculs: travail partiel en précision numérique affaiblie (plus efficace). Ecriture de code efficace (II) Facteurs architecturaux influençant la performance : débit et latence mémoire coûts des communications et de synchronisation temps d amorçage des unités vectorielles besoins en entrées/sorties Facteurs dépendant de l application : parallélisme (dépend des algorithmes retenus) régularité des traitements équilibrage des traitements volume de communications (localité) granularité - scalabilité Localité des données (spatiale et temporelle) encore plus critique sur les architectures Cell et GPU (Graphical Proc Unit) Notion de calcul potentiellement efficace Proposition: Soient x et y des vecteurs et A, B, C des matrices d ordre n; le noyau de calcul (1) x = x+αy est potentiellement moins efficace que le noyau (2) y = A x+y qui est potentiellement moins efficace que le noyau (3) C = C + A B Exercice : justifier la proposition précédente. Limites de l optimisation de code et de la vectorisation/parallélisation automatiques C α A B + βc (DGEMM du BLAS) DO 40 j = 1, N... DO 30 l = 1, K IF ( B( l, j ).NE. ZERO ) THEN TEMP = ALPHA * B( l, j ) DO 20 i = 1, M C( i, j ) = C( i, j ) + TEMP * A( i, l ) 20 CONTINUE END IF 30 CONTINUE 40 CONTINUE 48

49 Table 6: 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 715/ IBM RS6000/ Pentium Plupart des compilateurs : parallélisent la boucle d indice j et optimisent / vectorisent la boucle d indice i Plupart des optimisations réalisées par les compilateurs sur la boucle interne En théorie très bon potentiel mais les compilateurs ne savent pas l exploiter 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!!) 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 Figure 6: Comparaison de la performance de noyaux de calcul en algèbre linéaire (BLAS) (J. Dongarra) 49

50 3 La programmation par mode message 3.1 Contexte informatique, objectifs et besoins Contexte informatique Multiprocesseur à mémoire distribuée ou réseau de stations de travail computer #2 network #1 computer #1 cluster network #2 multiprocessor Objectifs et besoins Exemple de réseau de calculateurs. 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) 3.2 Le modèle de programmation par transfert de messages Le modèle de programmation par transfert de messages Permet d exprimer la communication et la synchronisation C est le modèle le plus répandu en calcul réparti mais ce n est pas le seul (voir par ex. LINDA ) Il n apporte pas de solution à tous les problèmes posés. Caractéristiques : expression du parallélisme à la charge du programmeur distribution des données à la charge du programmeur l échange de données est explicite prise en compte possible d un réseau hétérogènes de calculateurs avec gestion des pannes. 50

51 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 1 Machine 2 P11 P12 Processus P21 P22 P31 Machine 3 les deux hypothèses ci-dessus ne sont pas toujours vraies (Transputers) Bibliotèques portables pour la programmation d applications parallèles distribuées P4 de l Argonne National Laboratory offre à la fois les modèles mémoire partagée et transfert de message communications entre processus disponible et optimisé sur une large gamme de calculateurs (et réseaux de calculateurs) PICL de l Oak Ridge National Laboratory portable sur une large gamme de multiprocesseurs à mémoire distribuée PVM : Univ. Tennessee, Univ. Emory, Oak Ridge Nat. Lab.,... pour réseaux hétérogènes de calculateurs aussi disponible sur multiprocesseurs MPI : le standard pour le transfert de message 3.3 Envoi et réception de messages Envoi et réception de messages Un arbre qui cache la forêt 51

52 Environnement d exécution des communications Chaque processus est identifié par un numéro d instance (rang dans un groupe ou communicateur) L enveloppe d un message doit permettre la caractérisation et le traitement du message. Elle contient: 1. le numéro de l émetteur 2. le numéro du récepteur 3. le label du message 4. la taille du message Types de communication classiques communications point à point (one-to-one) : échange d information entre 2 processus communications collectives ( dans groupe / communicateur ) : one-to-many (broadcast, fan-out) : d un processus vers un ensemble de processus many-to-one (collect, fan-in) : un processus collecte des informations issues d un ensemble de processus many-to-many : échange global d informations entre plusieurs processus Communications point à point (quelques questions) Source Processus Dest Send (Dest, data) data Recv(Source, data) data Envoi et réception de messages Temps Questions: Synchronisation entre l envoi et la réception? Quand peut-on réutiliser la donnée envoyée? Bufferisation des communications? 3.4 Choisir un mode de communication Choisir un mode de communication (Communications Synchrones/ Asynchrones) Envoi/réception synchrones: Envoi/Réception asynchrones: Le premier arrivé attend l autre (notion de rendez-vous). 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!! 52

53 Trace d éxecution(8 proc. CRAY T3E) Algorithme Asynchrone 8.9s 8.95s 9.0s Algorithme Synchrone Process Facto_L s 9.3s 9.32s Process Facto_L1 4 Process 0 Process Process Process Process Process Process 3 Process 4 Process Process Process Process Process Process 7 L (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 ) Exemples de communications Envoi asynchrone : bloquant et non-bloquant Envoi asynchrone bloquant Envoi asyncrhone non bloquant Send (Dest, data) Attente (par ex. copie dans buffer interne) Actif data modifiable (pas tjrs recue) Send (Dest, data,ireq) Test (Ireq) Wait (Ireq) data modifiable (pas tjrs recue) Actif Recv(Source, data) Temps Recv(Source, data) Réceptions bloquantes asynchrones Réception non bloquante simple Réception non bloquante générale Recv (Dest, data,ireq) Recv(Source, data, Recu) Test (Ireq) Send (Dest, data) Si ( Recu ) alors traiter data Fin Si Send (Dest, data) Wait (Ireq) ATTENTE Temps (indépendant du mode d envoi) 53

54 Où va l information envoyée? Source Destination Send (Dest, data) Buffer envoi Réseau Buffer réception Recv(Dest, data) Le(s) buffer(s) sont soit internes à la couche système soit gérés par l utilisateur. Proprietés de la communication bufférisée Buffer(s) implique(ent) copies multiples (coût mémoire et temps) Même dans un mode bloquant l envoyeur peut être libre immédiatement Si Taille(buffer d envoi) Taille (message) alors ( envoi asynchrone bloquant envoi non-bloquant ) Attention à gérer la saturation des buffers (deadlock possible!!! ) Source Destination Send (Dest, data) Send (Source, data) Buffer envoi Réseau Buffer envoi si l envoi est asynchrone (bloquant) l envoi peut être bloqué jusqu au lancement de la réception correspondante. Propriétés des communications Diffusion des messages ordonnancée FIFO : les messages issus de Proc1 sont reçus dans l ordre par Proc2. Temps Proc 1 Proc 2 Par contre PAS d ordonnancement causal 54

55 Proc 1 Temps Proc 2 Proc 3 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 Communications non symétriques PUT(data) : écriture directe dans la mémoire d un autre processus GET(data) : lecture dans la mémoire d un autre processeur Proc 1 Proc 2 Proc 1 Proc 2 Put (data) Mémoire locale Mémoire locale Get (data) Proc2 ne fait pas de réception Proc1 ne fait pas d envoi Examples d opérations collectives Attention aux problèmes de cohérence de données!! 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, Valeur- Loc, 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. 55

56 Commentaires sur les protocoles de communications un protocole différent est souvent utilisé pour les messages courts et les messages longs (ex. Cray T3E, SGI origin) Protocole pour messages courts 1/ écriture dans le buffer interne des données envoyées. 2/ le processus envoyeur continue son travail (si envoi asynchrone) Protocole pour messages longs 1/ envoi d une requête d envoi au destinataire 2/ attente d un message prêt à recevoir 3/ envoi effectif des données rangées dans l espace utilisateur du récepteur Influence de la taille des buffers sur les Communications asynchrones A/ Taille (Message) < Buf_interne B/ Taille(Message) > Buf_interne Proc. Source Asynch. Non bloquant (isend) Proc. Destination buf_interne Réception bloquante recv (User_buf) Transfer (User_buf) Local copy Proc. Source Asynch. Non bloquant (isend) Temps Proc. Destination Asynch. Non bloquant irecv(user_buf, Ireq) User_buf Attente message wait(ireq) Message déjà dans User_buf Communications asynchrones et surcoût MPI Illustration sur un code de factorization de matrices creuses (code disponible sous mumps.enseeiht.fr/) recv standard Application MPI recv asynchrone VT_API 20% 40% 60% 80% Communications asynchrones et performance 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 K 4K 64K 512K 2Mega standard asynchrone Valeur par défaut sur le Cray T3E. Remarques sur la taille des buffers systèmes Changer la taille des buffers peut donc conduire à Une modification de la performance (temps attente, nombre de copies internes...) Des résultats faux (causalité mal gérée) De nouvelles situations d interblocage (codes basés sur des communications standards (mpi send et mpi recv) ) tous les cas d erreur correspondent à des programmes/algo. erronés 56

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

58 4 Description des standards pour la programmation en mode message 4.1 Distributed and heterogeneous computing using PVM Distributed and heterogeneous computing using PVM Short overview of the PVM computing environment. Simple example. XPVM tracing tool used for illustration Complete description of PVM : [3, 9, 4]. Many of the examples we use are coming from these references Overview of the PVM computing environment Overview of the PVM computing environment PVM (Parallel Virtual Machine) : Public domain software available on netlib Developed by the Oak Ridge National Laboratory, the University of Tennessee, the University of Carnegie Mellon, the Pittsburgh Supercomputing Center and the Emory University of Atlanta. Allows to use a network of heterogeneous UNIX computers (either serial or parallel) as a unique computing resource referred to as a virtual machine. Workstation Workstation Fast network Workstation Workstation Slow Network Workstation Mini Comp Super Comp Figure 7: Example of virtual machine 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 58

59 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. set of library procedures: 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 The PVM3 user library The PVM3 user library Notations: Control of processes communication and synchronization procedures used from C or 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 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: tid. call pvmfkill(tid, info) pvmfkill kills the PVM process identified by 59

60 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 PvmArch PvmHost PvmDebug PVM chooses the computers where defines a target architecture. where specifies a target computer. 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 - 1, tids( 1 ), info ) endif... Interprocess communication Communication between PVM processes based on message-passing. send, blocking receive, and nonblocking receive facilities. Sending a message is done in three steps : PVM provides asynchronous 1. initialization of a send buffer and choice of an encoding format to send data; (pvmfinitsend) 2. packing of data to be sent into the send buffer (pvmfpack); 3. actual send/broadcast of the message stored in the send buffer to destination(s) process(es) (pvmfsend, pvmfcast). 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. 60

61 Memory/data pvmfpack Send buffer Sending Process pvmfsend Memory/data pvmfunpack Receive buffer pvmfrecv Receiving Process Figure 8: Illustration of send/receive main steps 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 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. Packing/unpacking data call pvmfpack(what, xp, nitem, stride, info) pvmfpack packs an array of data of a given type into the active send buffer. A message containing data of different types may be built using successive calls to pvmfpack. nitem elements chosen each stride elements of the linear array xp of type what are packed into the buffer. Predefined values of what : STRING, BYTE1, INTEGER2, INTEGER4 REAL4, REAL8, COMPLEX8, COMPLEX16 call pvmfunpack(what, xp, nitem, stride, info) Similarly, pvmfunpack is used to unpack informations held into the active receive buffer. unpacked data are then stored into the array xp. The 61

62 Sending messages Send : call pvmfsend(tid, msgtag, info) pvmfsend sets the message label to msgtag then sends it to the pvm process of number tid. Broadcast : call pvmfmcast(ntask, tids, msgtag, info) pvmfmcast broadcast the message to ntask processes specified into the integer array tids. Pack and send : call pvmfpsend (tid, msgtag, xp, nitem, type, info) Receiving Messages Blocking receive call pvmfrecv( tid, mstag, bufid ) Non Blocking Receive call pvmfnrecv( tid, mstag, bufid ) ( bufid = 0 message not received ) Wildcards tid = -1 any message message tag mstag. mstag = -1 any message message from tid. tid = -1 and mstag = -1 any message. 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 Parallel Approach (subdive the image) (1) (2) (3) (4) (1) (2) (1) (4) (3) (2) Slave task ( i ) Do It = Ibeg, Ifin ( Update image ( i ); Pack in active buffer ) call pvmfsend(tid_master, It, info) Enddo (3) (4) Master task ( Build a complete image at each iteration ) Do It = Ibeg, Ifin Do Idummy= 1, Nb_slaves call pvmfrecv ( 1, It, bufid) ( bufinfo > tids (Islave) ) ( Unpack and Assemble image Islave ) Enddo ( Print full image ) Enddo 62

63 * SPMD Fortran example using PVM 3 * Enroll in pvm call pvmfmytid( mytid ) call pvmfparent( tids( 0 ) ) if( tids( 0 ).lt. 0 ) then tids( 0 ) = mytid; me = 0 call pvmfspawn( spmd,pvmdefault, *,NPROC-1, tids( 1 ), info ) * multicast tids array to children call pvmfinitsend( PVMDEFAULT, info ) call pvmfpack( INTEGER4, tids( 1 ), NPROC-1, 1, info ) call pvmfmcast(nproc-1,tids(1),msgt0,info) else * receive the tids of brothers and identify call pvmfrecv( tids( 0 ), msgt0, info ) call pvmfunpack( INTEGER4, tids(1),nproc-1,1,info) do i = 1, NPROC-1 if( mytid.eq. tids( i ) ) me = i enddo endif call dowork(me,tids,nproc ) call pvmfexit( info ) stop end subroutine dowork ( me, t i d s, nproc ) include??/ i n c l u d e /fpvm3. h Simple subroutine to p a s s a token around a r i n g integer me, nproc, t i d s ( 0 : nproc ) integer token, dest, count, s t r i d e, msgtag count = 1 ; s t r i d e = 1 ; msgtag = 4 i f ( me. eq. 0 ) then token = t i d s ( 0 ) c a l l pvmf i n i t s e n d ( PVMDEFAULT, i n f o ) c a l l pvmf pack ( INTEGER4, token, count, s t r i d e, i n f o ) c a l l pvmf send ( t i d s ( me + 1 ), msgtag, i n f o ) c a l l pvmf recv ( t i d s ( nproc 1 ), msgtag, i n f o ) else c a l l pvmf recv ( t i d s ( me 1 ), msgtag, i n f o ) c a l l pvmf unpack (INTEGER4, token, count, s t r i d e, i n f o ) c a l l pvmf i n i t s e n d ( PVMDEFAULT, i n f o ) c a l l pvmf pack (INTEGER4, token, count, s t r i d e, i n f o ) d e s t = t i d s ( me + 1 ) i f ( me. eq. nproc 1 ) d e s t = t i d s ( 0 ) c a l l {pvmfsend }( dest, msgtag, i n f o ) endif return 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,... 63

64 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 Illustrative Example: a dot version of the matrix vector product Illustrative Example: a dot version of the matrix vector product Straightforward static parallelization of the matrix-vector product, y = A x where A is a (m n) matrix, x an n-vector, and y an m-vector. Master-slave paradigm: Each process is in charge of computing one block y. Additionally master process broadcasts the data to the slaves and collects the final results. The sequential FORTRAN code is: do i = 1, m y ( i ) = 0. 0D0 do j = 1, n y ( i ) = y ( i ) + A( i, j ) x ( j ) enddo enddo In the parallel implementation, first_row(1) first_row(2) first_row(3) A x master slave 1 slave 2 x x x slave 3 x Figure 9: Static parallelization of the matrix vector product: A partitioned into block of rows distributed on the slave processes. 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 performs: y = α A x + βy GEMV from the Level 2 BLAS (see [6]) which 64

65 Codes for master and slave processes Master s code: * * Enroll this program in Pvm call pvmfmytid (my_id) if (my_id.lt. 0) then write(*,*) failure in enrolling on host stop endif write(*,*) How many slave worstations will you used read(*,*) nb_of_slaves * Initiate nb_of_slaves instances of slave program call pvmfspawn ( slave,pvmdefault, *, & nb_of_slaves,inst,numt) * Check if everything is Ok if (numt.ne. nb_of_slaves) stop nb_of_processes = nb_of_slaves +1 do j=1,n do i = 1,m a(i,j) = DBLE(i+j)/DBLE(m+n) + one enddo x(j) = one + DBLE(j)/DBLE(n) enddo * compute the index of the first row * performed by each process first_row(1) = 1 first_row(nb_of_processes+1) = m+1 j = (m / nb_of_processes) if (nb_of_slaves.gt.0) then do i=2,nb_of_processes first_row(i) = j*(i-1) +1 enddo * work balancing j = mod(m,nb_of_processes) do i=1, j-1 first_row(nb_of_processes-i+1) = & first_row(nb_of_processes-i+1) +j -i enddo * broadcast n and x type = 0 call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (INTEGER4, n, 1, 1, info) call pvmfpack (REAL8, x, n, 1, info) call pvmfmcast (nb_of_slaves, inst, type, info) * send its sub-matrix data to each slave process type = 1 do no_slave = 1, nb_of_processes-1 * number of components computed by the slave no_slave j = first_row(no_slave+2) - first_row(no_slave+1) call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (INTEGER4, j, 1, 1, info) call pvmfsend (inst(no_slave), type, info) do i=1, n call pvmfinitsend ( PVMDATADEFAULT, bufids) call pvmfpack (REAL8, & a(first_row(no_slave+1),i),j,1,info) enddo enddo call pvmfsend (inst(no_slave), type, info) 65

66 * * compute its part of the work * * perform y <-- one*ax + zero*y * where A is an matrix of order (first_row(1)-1) x n. incx = 1 call dgemv( N,first_row(1)-1,n,one,a,lda,x, & incx,zero,y,incx) * * collect results * type = 2 do no_slave = 1, nb_of_slaves * j holds number of rows computed by no_slave j = first_row(no_slave+2) - first_row(no_slave+1) call pvmfrecv (inst(no_slave), type, bufidr) call pvmfunpack (REAL8, & enddo call pvmfexit(retcode) stop end Slave s code: y(first_row(no_slave+1)),j,1,info) PROGRAM slave... double precision a(lda,lda),x(lda),y(lda),one,zero * Enroll this program in PVM 3 call pvmfmytid (my_id) * Get the tid of the master s task id call pvmfparent (p_id) * receive broadcasted data type = 0 call pvmfrecv (p_id, type, bufid) call pvmfunpack (INTEGER4, n, 1, 1, info) call pvmfunpack (REAL8, x, n, 1, info) * receive my block of rows type = 1 call pvmfrecv (p_id, type, bufidr) call pvmfunpack (INTEGER4, m, 1, 1, info) do 10, i=1,n call pvmfrecv (p_id, type, bufidr) call pvmfunpack (REAL8, a(1,i), m, 1, info) 10 continue * perform matrix-vector on my block of rows incx = 1 call dgemv( N,m,n,one,a,lda,x,incx,zero,y,incx) * send back results to master process type = 2 call pvmfinitsend (PVMDATADEFAULT, bufid) call pvmfpack (REAL8, y, m, 1, info) call pvmfsend (p_id, type, info) * leave PVM environment call pvmfexit (info) stop end Makefile for Compilation - Link PvmArch and PvmDir correspond respectively to target computer and to location of the PVM library. F77 = /usr/lang/f77 FOPTS = -O -u # Specification of the target computer PvmArch = SUN4 # Location of PVM libraries 66

67 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 of the virtual machine Configuration file describe the list of computers used. Used to start the pvmd3 daemon on each computer listed. Parallel Virtual Machine can be controled using the pvm console. Other solution use directly the pvm console to build the virtual machine. Both solutions illustrated in the following example : a parallel virtual machine of 4 RISC workstations (HP, IBM and two SUN) is build. The HP workstation, pie, is our host computer. Example pie> cat hostfile # comments pie pinson goeland aigle pie> pvmd3 hostfile & pie> pvm > conf 4 hosts, 1 data format HOST DTID ARCH SPEED pie HPPA 1000 pinson SUN goeland c0000 RS6K 1000 aigle SUN pie> pvm pvm> conf 1 host, 1 data format HOST DTID ARCH SPEED pie HPPA 1000 pvm> add pinson goeland aigle 3 successful HOST DTID pinson goeland c0000 aigle Performance analysis and graphical interface 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. 67

68 4.2 MPI : le standard pour le transfert de message MPI : le standard pour le transfert de message 1. Effort de définition d un standard de transfert de message pour les utilisateurs de développeurs 2. Juin 94 Version 1.0 issue du forum MPI Message Passing Interface [15, 8] 3. Objectifs : portabilité, simplicité utilisation plus large du calcul distribué implantation par les constructeurs 4. Pour multiprocesseurs, clusters et réseaux de calculateurs Accessible sur le site netlib ou sur le Web, voir par exemple : or Versions publiques disponibles: LAM (Univ. Notre Dame), MPICH (Argonne Nat. Lab.), OpenMPI ( Notions basiques Notions basiques Groupe de processus MPI Contexte : pour définir des flots de messages indépendants. Communicateur: permet de définir un contexte de communication au sein d un groupe de processus. Message : contexte et un numéro de message/contexte 4 modes de communication : bloquants, non-bloquants, synchrones, bufferisés. Communication collectives et définition de sous-groupes Modèle de programmation SPMD, 125 fonctions dont 6 de base : MPI Init, MPI Finalize, MPI Comm size, MPI Comm rank, MPI Send, MPI Recv Environnement enregistrement : call MPI Init( info ) terminaison : call MPI Finalize contexte par défaut : MPI COMM WORLD : tâches numérotées 0,..., N-1 création de nouveaux contextes : définir des nouveaux groupes de processus et un nouveau contexte 68

69 Example : Hello world #include mpi. h #include <s t d i o. h> int main ( argc, argv ) int argc ; char argv ; { int 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 ) ; MPI Finalize ( ) ; return 0 : } Exécution sous MPICH avec : mpirun -np 2 hello printf exécuté par 2 processus. Envoi / réception message : opérations de base Envoi/Réception de données de type datatype rangées : call MPI Send nb, datatype, dest, mess id, comm,info) call MPI Recv nb, datatype, source, mess id, comm, status, info ) Diffusion: toutes les tâches émettent la requète; les données sont envoyées par le processus root: call MPI Bcast 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 Les modes de communication point à point Les modes de communication point à point Bloquant L émetteur est bloqué jusqu à ce que la donnée envoyée puisse être réutilisée en toute sécurité. Synchrone Le retour d un envoi synchrone indique que la donnée envoyée a commencé à etre reçue par le récepteur. Bufferisé Le retour d un envoi bufferisé indique que la donnée a été copiée dans le buffer. Ready L envoi n est possible que si le destinataire a déjà posté une reception 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). 69

70 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 Exercices: communications point à point Exercice 1: communications point à point En supposant que I = non-bloquant, S=synchrone, R=ReadyMode, déduire la sémantique des primitives MPI suivantes: 1. MPI IRsend (..., Ireq,... ) 2. MPI ISsend (..., Ireq,... ) 3. MPI IBsend (..., Ireq,... ) Exercice 2: Communications point à point Commenter le comportement du programme suivant (exécuté sur 2 processus): CALL MPI COMM RANK(comm, rank, i e r r ) tag = 1 IF ( rank.eq. 0 ) THEN d e s t = 1 ELSE d e s t = 0 ENDIF CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) Communications globales Communication glogales Barrières MPI Barrier (communicateur) : bloque l appelant jusqu à ce que tous les proc membres du communicateur aient effectués l appel. Broadcast MPI Bcast réduction disponible sur un proc ou sur tous MPI Reduce/MPI Allreduce: max global, somme globale,... scatter / gather, all to all 70

71 4.2.5 Communications persistantes Communications persistantes-illustration Cas de communications effectuées en boucle dans un programme 1. Initialisation(s) d envoi(s)/réception(s): MPI xsend Init (..., Req ) / MPI xrecv Init ( Req ) Possibilité de faire de multiples initialisations 2. Lancement effectif dans la boucle MPI Start ( Req ) 3. Attente de requêtes (multiples) dans la boucle: MPI Wait, MPI Wait All, MPI Wait Some MPI Test, MPI Test All, MPI Test Some All = attente fin de toutes les requêtes mentionnées à l appel Some = au moins une a fini (out: liste des requêtes finies) Any = attendre la fin d une requête choisie parmi toutes celles finies (out: une requête finie) (utilisable bien sûr aussi avec des requêtes non bloquantes classiques) Exercice: Recouvrir calcul et communications Exercice: Recouvrir calcul et communications Soit le programme suivant: CALL MPI COMM RANK(comm, rank, i e r r ) prev = rank 1; next = rank+1 IF ( rank.eq. Nprocs ) next = 0 IF ( rank.eq. 0 ) prev = nprocs 1 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 in 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 in C a l c u l ENDIF Hypothèses : Protocole long (synchrone) pour messages longs. Si l émetteur est occupé (sans appel MPI) la communication ne peut démarrer. Un timeout (MPI) est souvent associé à la notion de calcul non interruptible. Exercice: Recouvrir calcul et communications (suite) IF ( rank.eq. 0 ) THEN CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL C a lcul ( rank )! Rdata not used in C a l c u l CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) ELSE CALL MPI Recv ( RData, count, MPI REAL, dest, tag, comm, i e r r ) CALL MPI Send ( SData, count, MPI REAL, dest, tag, comm, i e r r ) CALL C a lcul ( rank )! Rdata not used in C a l c u l ENDIF On suppose Nprocs=3; Sdata de grande taille (temps de comm 50sec); Temps de Calcul(rank)= (200, 150, 150)sec. 1. Calculer le temps d exécution. 2. Pour recouvrir calcul et communications on propose de remplacer MPI Send par un appel nonbloquant MPI ISend. Calculer le temps d exécution. 3. Comment réduire le temps d exécution? 71

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

73 5 Analyse de performance et modélisation des algorithmes Analyse de performance et modélisation des algorithmes 1. Evaluation des performances d un algorithme = l utilisation de modèles pour : 1. Caractériser la machine cible 1. l algorithme 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 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: 1. nombre borné ou infini de processeurs. 2. mémoire (globale, distribuée, infinie..) 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 : 1. Choix de l unité de mesure? 2. influence de la taille du problème, architecture, charge du système sur la mesure? Utilisation d analyseurs automatiques de traces d exécution souvent indispensable. 5.1 Terminologie Terminologie Problème: taille N exécuté sur p processeurs. Vitesse: Nombre d opérations par secondes Flops: Opérations en virgule flottante par secondes (Mflops(10 6 ), Gflops(10 9 ), Teraflops(10 12 )) Mips: Millions d instructions élémentaires par secondes. (1 flops k instruc. de base) Temps d exécution séquentielle: T 1 (N) = T s (N) + T par (N) Temps d exécution parallèle: T p (N, p) 73

74 Temps de surcoût parallèle T sc (N, p) (communication, synchronisation...) Accélération (speed-up): T p (N, p) = T s (N) + T par(n) p S p (N, p) = T 1(N) T p (N, p) S p > 1 = speed-up ; et S p (N, p) < 1 = speed-down + T sc (N, p) S p (N, p) > p = speed-up superlinéaire. (meilleure utilisation des hiérarchies mémoires, meilleur comportement de l algorithme parallèle) 100 Ts=Tsc=0 10 Speedup Ts>0, Tsc=0 Ts>0, Tsc> Nb Processeurs Figure 10: 3 comportements extrêmes Si T sc = 0 alors donc S = lim p S p = T 1 /T s, soit p 1 2 = T par(n)/t s (N) alors: Remarques: S p = T s + T par T s + Tpar p S = 1 + T par /T s S p = S (1 + p 1 2 /p) 1. p 1 [0, ] et correspond au poids relatif de la partie // (= 0 pas de //, = tout //) p = p 1 = S p = S 2 2 p 1 correspond au nombre de processeurs pour atteindre la moitié 2 de S. 3. Si p 4p 1 alors 80% de S est déjà atteint. 2 Si T sc > 0 alors Posons, par exemple: T sc = αp alors S p = S 1 + p ( ) ] p [1 + p p opt où p opt = T par /α et correspond au speed-up maximum S opt. Exemple: T p = p p = S opt =

75 Efficacité: E p (N, p) = S p(n, p) p 1. Pour N fixé, si T sc est une fonction croissante de p alors E p décroit avec p 2. Pour p fixé et T s = 0, si T sc croît moins vite que T 1 alors E p augmente avec N Scalabilité: Capacité à conserver E p (N, p) constante lorsque p augmente. T 1 (N) doit augmenter de façon exponentielle = le sytème est dit peu scalable. T 1 (N) doit augmenter linéairement = le sytème est scalable. Isoefficacité: Mesure de scalabilité d un algorithme parallèle, elle relie la taille du problème au nombre de processeurs nécessaires pour maintenir E p = cte ou S p croissant linéairement avec p. 1. On cherche le polynome d ordre m, m 1 tel que 2. Plus m est petit plus le système est scalable. Granularité: E(p, N) = E(kp, a m N m a 1 N + a0) 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. Loi d Amdahl pour le calcul parallèle (loi de Ware) RAPPEL Soit le programme P. T 1 : temps d exécution de P sur 1 processeur f : fraction de P pouvant être exécutée sur p processeurs 1 f : zone séquentielle de P T p : temps d exécution de P sur p processeurs T p = temps d exéc. Séq. + temps d exéc. Par. temps d exéc. Séq. = (1 f)t 1 temps d exéc. Par. = f T1 p T p = (1 f) T 1 + f T1 p et S p = T1 T p Speed-up théorique avec p processeurs : Sp = De façon plus réaliste : T p (f + (1 f) p) T 1 p O overhead prenant en compte : p f+(1 f) p overheads de synchronisation transferts de données (archi. mém. distribuée) contentions mémoire... MAIS quel que soit O : S p p f+(1 f)p Pour un nombre infini de processeurs : Speed-up maximum ou T p = (f + (1 f) p) T 1 p S 1 1 f + O 75

76 Table 7: A very optimistic table Number of processors p f Exemples d outils pour l analyse de performances Exemples d outils pour l analyse de performances Profiling automatique Profiling automatique Objectif : Etude du temps passé dans les unités de programme : en général procédures/fonctions, mais aussi parfois boucles et intructions. 1. exemple : gprof sous UNIX permet d étudier le temps passé par procédure. 1. 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 Exemple de fichier profile obtenu : % cumulative self self total time seconds seconds calls ms/call ms/call name _matmul_ [3] _matsum_ [4] _MAIN [1] _matvec_ [5]... La seconde partie du fichier profile permet d identifier l arbre d appel (parents et descendants) de chaque routine. called/total parents index %time self descendents called+self name index called/total children /1 _main [2] [1] _MAIN [1] /1 _matmul_ [3] /5 _matsum_ [4] /1 _matvec_ [5] [2] _main [2] /1 _MAIN [1] /2 _getenv [49] /1 _MAIN [1] [3] _matmul_ [3] /5 _MAIN [1] [4] _matsum_ [4] /1 _MAIN [1] [5] _matvec_ [5] Analyse automatiques de la performance et des cache-hits sur CRAY T3D (code de mécanique des fluides): 76

77 secs Mflops data caches time PVMFRECV:11400 gradvelo: % infl3dc : % gradvel : % grad3d : % nufl3dc : % PVMFSEND: 635 SQRT : 320 vsfl3dc : % ns3dc : % implrssm: % edvialg : % shearstr: % dtvis3dc: % updpct : % heatflpg: % EXP : 53.7 Total code: secs 969 ( 6.07%) work 2514 (15.76%) loading instructions and data cache (75.59%) waiting on PVM communication 411 ( 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 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 Modélisation de Hockney et Jesshope Modélisation de Hockney et Jesshope Mesurer l efficacité d un algorithme dans l utilisation d un processeur possédant des unités pipelinées (unités de calcul ou accès mémoire). Nombres r et n 1 2. r n : performance (en Mflops) sur des vecteurs de taille n r : performance (en Mflops) obtenue sur de vecteurs de taille infinie. but : étudier la différence entre performance réelle et théorique n 1 2 : 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) Exemple du produit scalaire: 1. Sur calculateur vectoriel Cray T90, Performance de crête (1 proc) =1800 Mflops r = 872 Mflops et n Sur calculateur scalaire SGI Origin 2000, Performance de crête (1 proc) =360 Mflops r = 194 Mflops et n 1 2 = 7 c est l effet du cache primaire qui est ici mesuré par n

78 3. Sur machines scalaires sans cache et sans pipeline n 1 = 0 car temps startup est nul. 2 Approximation de la performance d une boucle de taille n : alors lim n r n = r et r n 12 = r /2 r n = r n 12 n + 1 Comment calculer r et n 1 2? (pour une boucle et un calculateur donnné) 1. Mesure de la performance pour différentes longueurs de vecteur. 2. Approximation aux moindres carrés Traces d exécution d un code parallèle Traces d exécution d un code parallèle Outils de mise au point et d analyse de codes parallèles Figure 11: Trace d exécution VAMPIR d un code de factorisation de matrices creuses L instrumentation (par exemple avec l outil VAMPIR) permet une analyse fine sur une partie de la trace d exécution. L utilisation de camemberts permet alors de visualiser le poids relatif d un type d activité 5.4 Les modèles utilisés Les modèles utilisés Présentation des modèles utilisés pour représenter 1. l architecture de la machine cible 2. l algorithme 3. l exécution La simulation de l exécution du modèle de programme sur le modèle de machine cible permet d estimer la performance réelle et de faire une analyse de complexité de l agorithme. 78

79 Figure 12: Trace d exécution VAMPIR d un code de factorisation de matrices creuses Modélisation de l architecture Modélisation de l architecture 1. Le temps d exécution d une opération dépend de la vitesse théorique du processeur et de la localisation des données dans la hiérarchie mémoire 2. Une modélisation fine de l architecture doit prendre en compte: le nombre (et la taille) des registres, la taille et la stratégie de gestion de la mémoire cache le coût d un accès au cache et d un défaut de cache. la taille et le temps d accés à la mémoire locale. 1. Sur architectures parallèles à mémoire physiquement distribuée, le temps d accès aux données distantes est critique et il dépend: du réseau (topologie, vitesse, nb liens/nœud) et des stratégies de routages de messages 2. Le rapport (Vitesse processeur/bande passante mémoire) est une mesure de l équilibrage globale d une machine. Rapport plus petit = Machine plus équilibrée (flop = 3 opérandes) Modes du routage et modèles associés Modes du routage et modèles associés Définitions/rappels Les machines parallèles disposent de composants matériels dédiés au routage (les routeurs). message: entité que l application souhaite transmettre mode de commutation : façon dont sont acheminés les messages de la source vers la destination. fonction de routage : manière dont est calculée la route des messages (indépendant du mode de commutation). On parle de routage statique si la fonction est injective (un seul choix possible) sinon de routage dynamique ou adaptatif. 79

80 Figure 13: Trace d exécution VAMPIR d un code de factorisation de matrices creuses congestion : d un lien (ou nœud) est le nombre de routes passant par ce lien (ou nœud). paquet : l interface réseau peut éventuellement découper le message en paquets. conséquences des paquets : ++ les ressources disponibles sur la route sont de taille bornée. l interface réseau doit être capable de reconstruire le message complet à partir de plusieurs paquets. Hypothèses le temps de propagation d un octet entre deux nœuds est constant. deux processeurs x et y, non voisins, souhaitent échanger un message M de taille L. Soit d(x, y) la distance entre x et y. (on ne modélisera pas la congestion). 1. Commutation de messages Chaque processeur intermédiaire sur le chemin de communication reçoit le message M complètement avant de le réémettre en direction du processus destinataire. Lorsqu un routeur reçoit un message il le stocke dans un de ses tampons avant de le retransmettre. Il le retransmet lorsqu un tampon est libre sur le routeur suivant L entête du message permet aux routeurs intermédiaires de calculer la route. Modélisation : T cm = d(x, y)(α + Lβ), où α est le temps d initialisation, et β le temps de propagation d un octet. Commutation de paquets par macro-pipeline : pour réduire le coût total on divise le message en paquets de taille fixe µ : T cm = (d(x, y) + Lµ ) 1 (α + µβ). Lα ( ) 2 opt µ opt = = Tcm = Lβ + (d(x, y) 1)α (d(x, y) 1)β 80