High Performance Matrix Computations

Transcription

1 High Performance Matrix Computations J.-Y. L Excellent (INRIA/LIP-ENS Lyon) Office 352 Jean-Yves.L.Excellent@ens-lyon.fr prepared in collaboration with P. Amestoy, L.Giraud, M. Daydé (ENSEEIHT-IRIT) Contents 1 Introduction Introduction aux calculateurs haute-performance Evolutions architecturales Programmation Calcul Matriciel et calcul haute performance Grid computing - Internet Computing 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 Notions et techniques générales pour l algèbre linéaire Introduction Gaussian Elimination LU Factorization Vector and Matrix norms Erreur, sensibilité, conditionnement Factorisation LU avec pivotage Systèmes bande Matrices symétriques Factorisation de Cholesky Factorisation QR Gram-Schmidt Process Problèmes aux moindres carrés Problèmes aux valeurs propres Décomposition en valeurs singulières (SVD)

2 4 Efficient dense linear algebra libraries Use of scientific libraries Level 1 BLAS and LINPACK BLAS LU Factorization LAPACK Linear algebra for distributed memory architectures BLACS (Basic Linear Algebra Communication Subprograms) PBLAS : parallel BLAS for distributed memory machines ScaLAPACK Recursive algorithms

3 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 : enfin l age adulte! Les machines les plus puissantes sont à haut degré de parallélisme Le rapport prix / performance est attractif Plus que quelques constructeurs dans la course Systèmes plus stables Logiciels applicatifs et librairies disponibles Exploitation industrielle et commerciale : plus uniquement laboratoires de recherche Mais : travail algorithmique important et validation/maintenance difficile. Nouvelles évolutions: 1 core per chip multi-core chips 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,...) Gains importants possibles avec rapport coût-performance intéressant

4 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,... 2

5 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 3

6 Temps de cycle 0.5 nanoseconde 4 GFlop/s (avec 2 opérations flottantes / cycle) Calculateur 20 TFlop/s 5000 processeurs calculateurs massivement parallèles Pas parce que c est le plus simple mais parce que c est nécessaire Objectif actuel (2010): supercalculateur à 3 PFlop/s, 500 TBytes de mémoire? 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 Mémoire 1 kb / 1 ko 1 kilobyte 10 3 octets 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 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 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 4

7 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 Parallel t = f s t 1 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]) 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 problèmes Grand Challenge ont grossi! 5

8 1 TB 100 GB 10GB 1 GB Vehicule Signature 72-Hour Weather Structural Biology Pharmaceutical Design Global Change Human Genome Fkuid Turbulence Vehical Dynamics Ocean Circulation Viscous Fluid Dynamics Superconductor Modelling Structural Biology Quantum Chromodynamics Vision 100MB 48-Hour Weather 3D Plasma Modelling 10MB 2D airfoil Oil Reservoir Chemical Dynamics Modelling and beyond 100 MFlops 1 GFlops 10 GFlops 100 GFlops 1 TFlops Figure 1: Grand challenge problems (1995). 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 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 : plus de puissance : Performance d un PC > CRAY C90 (95) 6

9 Moore s law 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) 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: 1 nanoseconde = temps pour qu un signal parcoure 30 cm de cable Temps de cycle 1 nanosecond 2 GFlop/s (avec 2 opérations flottantes par cycle) 7

10 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) 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)... 8

11 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 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 9

12 Calculateur procs LINPACK LINPACK Performance n = 100 n = 1000 crête Intel WoodCrest (1 core, 3GHz) HP ProLiant (1 core, 3.8GHz) IBM eserver(1.9ghz, Power5) SGI Altix (1.6GHz Itanium2) AMD Opteron (2.19GHz) Fujitsu Intel Xeon (3.2GHz) AMD Athlon (1GHz) Compaq ES45 (1GHz) Performance actuelle d un processeur vectoriel NEC SX-8 (2 GHz) NEC SX-8 (2 GHz) Table 3: Performance des processseurs RISC (LINPACK Benchmark Dongarra [07]) 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 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 [?]) Typiquement: 32-bit pour le gros des calculs, 64 bits pour améliorer la précision Pas seulement sur processeur CELL 10

13 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 ???? 3 PFlop/s? Table 4: Evolutions des performances par décennie 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 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 : organisation mémoire, communication inter-processeurs Hardware plus complexe : pipe, technologie, réseau,... 11

14 Logiciel plus complexe : compilateur, système d exploitation, langages de programmation, gestion du parallélisme,... applications Vitesse mémoire vs vitesse processeur Il devient plus difficile de programmer efficacement Performance processeur: + 60% par an Mémoire DRAM: + 9% par an Ratio performance processeur temps acces memoire augmente d environ 50% par an!! Problèmes de débit mémoire L accés aux données est un problème crucial dans les calculateurs modernes Accroîssement de la vitesse de calcul sans accroître le débit mémoire goulet d étranglement MFlop/s plus faciles que MB/s pour débit mémoire Temps de cyle processeurs 2 GHz (.5 ns) Temps de cycle mémoire 20 ns SRAM 50 ns DRAM Comment obtenir de hauts débits mémoire? Plusieurs chemins d accès entre mémoire et processeurs CRAY XMP et YMP : 2 vector load + 1 vector store + 1 I/O utilisés pour accéder des vecteurs distincts NEC SX : chemins d accès multiples peuvent être aussi utilisés pour charger un vecteur (améliore le débit, mais pas la latence!) Plusieurs modules mémoire accédés simultanément (entrelaçage) Accès mémoire pipelinés Mémoire organisée hiérarchiquement La façon d accéder aux données peut affecter la performance: Minimiser les défauts de cache Minimiser la pagination mémoire Localité: améliorer le rapport références à des mémoires locales/ références à des mémoires à distance 12

15 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 2: Exemple de hiérarchie mémoire. Conception mémoire pour nombre important de processeurs? Comment 100 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 Architecture des multiprocesseurs Nombre élevé de processeurs mémoire physiquement distribuée Organisation Organisation physique logique Partagée (32 procs max) Distribuée Partagée multiprocesseurs espace d adressage global à mémoire partagée (hard/soft) au dessus de messages mémoire partagée virtuelle Distribuée émulation de messages échange de messages (buffers) Table 5: Organisation des processeurs Remarque: standards de programmation Organisation logique partagée: threads, OpenMP Organisation logique distribuée: PVM, MPI, sockets 13

16 Shared Memory Interconnection Network P1 P2 P3 P4... Pn Figure 3: Exemple d architecture à mémoire partagée. Interconnection Network LM LM LM LM LM... P1 P2 P3 P4... Pn Figure 4: Exemple d architecture à mémoire distribuée. 14

17 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 identique à 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) Exemples Mémoire physiquement et logiquement partagée (SMP): la plupart des supercalculateurs à faible nombre de processeurs: stations de travail multi-processeurs (SUN: jusqu à 64 processeurs,... ), NEC, SGI Power Challenge,... Mémoire physiquement et logiquement distribuée: grappes de PC monoprocesseurs, IBM SP2, T3D, T3E,... Mémoire physiquement distribuée et logiquement partagée (NUMA): BBN, KSR, SGI Origin, SGI Altix,... 15

18 Clusters de multi-processeurs Plusieurs niveaux de mémoire et de réseaux d interconnexion temps d accès non uniforme Mémoire commune partagée par un faible nombre de processeurs (noeud SMP) Eventuellement des outils de programmation distincts (transferts de message entre les clusters,... ) Exemples: grappes de bi- ou quadri-processeurs, IBM SP (CINES, IDRIS): plusieurs nœuds de 4 à 32 Power4+... Network SMP node Memory Memory Network Network LM LM LM LM Proc Proc Proc Proc Figure 5: Exemple d architecture clusterisée. Réseaux de Calculateurs Evolution du calcul centralisé vers un calcul distribué sur des réseaux de calculateurs Puissance croissante des stations de travail Intéressant du point de vue coût Processeurs identiques sur stations de travail et MPP Calcul parallèle et calcul distribué peuvent converger : modèle de programmation environnement logiciel : PVM, MPI,... Performance effective peut varier énormément sur une application Hétérogène / homogène Plutôt orienté vers un parallélisme gros grain (tâches indépendentes,... ) Performance très dépendante des communications (débit et latence) Charge du réseau et des calculateurs variable pdt l exécution Equilibrage des traitements? 16

19 computer #2 network #1 cluster computer #1 network #2 multiprocessor Figure 6: Exemple de réseau de calculateurs. Multiprocesseurs vs réseaux de machines Systèmes distribués (réseaux de machines) : indépendants communications relativement lentes et systèmes Systèmes parallèles (architectures multiprocesseur) : communications plus rapides (réseau d interconnexion plus rapide) et systèmes plus homogènes Il y a convergence entre ces deux classes d architectures et la frontière est floue : clusters et clusters de clusters des systèmes d exploitation répartis (ex: MACH et CHORUS OS) savent gérer les deux versions de UNIX multiprocesseur souvent mêmes environnements de développement 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, 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 17

20 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: mémoire partagée: OpenMP, threads POSIX mémoire distribuée: PVM, MPI (depuis C/C++/Fortran) 1.4 Calcul Matriciel et calcul haute performance Calcul Matriciel et calcul haute performance Démarche générale pour le calcul scientifique: 1. Problème de simulation (problème continu) 2. Application de lois phyisques (Equations aux dérivées partielles) 3. Discrétisation, mise en équations en dimension finie 4. Résolution de systèmes linéaires (Ax = b) 5. (Etude des résultats, remise en cause éventuelle du modèle ou de la méthode) Résolution de systèmes linéaires=noyau algorithmique fondamental. compte: Paramètres à prendre en Propriétés du système (symétrie, défini positif, conditionnement, sur-déterminé,... ) Structure: dense ou creux, Taille: plusieurs millions d équations? Equations aux dérivées partielles Modélisation d un phénomène physique Equaltions différentielles impliquant: forces moments températures 18

21 vitesses énergies temps Solutions analytiques rarement disponibles Exemples d équations aux dérivées partielles Trouver le potentiel électrique pour une distribution de charge donnée: 2 ϕ = f ϕ = f, or 2 x 2 ϕ(x, y, z) + 2 y 2 ϕ(x, y, z) + 2 z 2 ϕ(x, y, z) = f(x, y, z) Equation de la chaleur (ou équation de Fourier): 2 u x u y u z 2 = 1 u α t avec u = u(x, y, z, t): température, α: diffusivité thermique du milieu. Equations de propagation d ondes, équation de Schrödinger, Navier-Stokes,... Discrétisation (étape qui suit la modélisation physique) Travail du numéricien: Réalisation d un maillage Choix des méthodes de résolution et étude de leur comportement Etude de la perte d information due au passage à la dimension finie Principales techniques de discrétisation Différences finies Eléments finis Volumes finis Discretization with finite differences (1D) Basic approximation (ok if h is small enough): ( ) du u(x + h) u(x h) (x) dx h Results from Taylor s formula Replacing h by h: u(x + h) = u(x) + h du dx + h2 d 2 u 2 dx 2 + h3 d 3 u 6 dx 3 + O(h4 ) u(x h) = u(x) h du dx + h2 d 2 u 2 dx 2 h3 d 3 u 6 dx 3 + O(h4 ) Thus: d 2 u u(x + h) 2u(x) + u(x h) = dx2 h 2 + O(h 2 ) 19

22 Discretization with finite differences (1D) d 2 u u(x + h) 2u(x) + u(x h) = dx2 h 2 + O(h 2 ) 3-point stencil for the centered difference approximation to the second order derivative:

23 Finite Differences for the Laplacian Operator (2D) Assuming same mesh size h in x and y directions, u(x) u(x h, y) 2u(x, y) + u(x + h), y u(x, y h) 2u(x, y) + u(x, y + h) + h 2 h 2 u(x) 1 (u(x h, y) + u(x + h, y) + u(x, y h) + u(x, y + h) 4u(x, y)) h point stencils for the centered difference approximation to the Laplacian operator (left) standard (right) skewed 27-point stencil used for 3D geophysical applications (collaboration S.Operto and J.Virieux, Geoazur). 1D example { u Consider the problem (x) = f(x) for x (0, 1) u(0) = u(1) = 0 x i = i h, i = 0,..., n + 1, f(x i ) = f i, u(x i ) = u i h = 1/(n + 1) 21

24 Centered difference approximation: u i 1 + 2u i u i+1 = h 2 f i (u 0 = u n+1 = 0), We obtain a linear system Au = f or (for n = 6): 1 h u 1 u 2 u 3 u 4 u 5 u 6 = f 1 f 2 f 3 f 4 f 5 f 6 Slightly more complicated (2D) Consider an elliptic PDE: u (a(x, y) x ) x u (b(x, y) y ) + c(x, y) u y = g(x, y) sur Ω u(x, y) = 0 sur Ω 0 x, y 1 a(x, y) > 0 b(x, y) > 0 c(x, y) 0 Case of a regular 2D mesh: discretization step: h = 1 n+1, n = 4 5-point finite difference scheme: (a(x, y) u x ) ij x = a i+ 1 2,j (u i+1,j u i,j ) h 2 a i 1 2,j (u i,j u i 1,j ) h 2 + O(h 2 ) Similarly: (b(x, y) u y ) ij y = b i,j+ 1 2 (u i,j+1 u i,j ) h 2 b i,j 1 2 (u i,j u i,j 1 ) h 2 + O(h 2 ) a i+ 1 2,j, b i+ 1 2,j, c ij,... known. With the ordering of unknows of the example, we obtain a linear system of the form: where x 1 u 1,1 = u( 1 n+1, 1 n+1 ) x 2 u 2,1 = u( 2 n+1, 1 n+1 ) Ax = b, 22

25 x 3 u 3,1 x 4 u 4,1 x 5 u 1,2,... and A is n 2 by n 2, b is of size n 2, with the following structure: x x x 1 g11 x x x x 2 g21 x x x x 3 g31 x x 0 x 4 g41 x 0 x x x 5 g12 x x x x x 6 g22 x x x x x 7 g32 A= x x x 0 x 8 b= g42 x 0 x x x 9 g13 x x x x x 10 g23 x x x x x 11 g33 x x x 0 x 12 g43 x 0 x x 13 g14 x x x x 14 g24 x x x x 15 g34 x x x 16 g44 Solution of the linear system Often the most costly part in a numerical simulation code Direct methods: L U factorization followed by triangular substitutions parallelism depends highly on the structure of the matrix Iterative methods: usually rely on sparse matrix-vector products (can be done in parallel) algebraic preconditioner useful Evolution of a complex phenomenon Examples: Need for high-performance linear algebra kernels climate modeling, evolution of radioactive waste,... { u(x, y, z, t) = u(x,y,z,t) heat equation: t u(x, y, z, t 0 ) = u 0 (x, y, z) Discrétization in both space and time (1D case): Explicit approaches: u n+1 j u n j t n+1 t n = un j+1 2un j +un j 1 h 2. 23

26 Implicit approaches: u n+1 j u n j t n+1 t n = un+1 j+1 2un+1 j +u n+1 j 1 h. 2 Implicit approaches are preferred (more stable, larger timestep possible) but are more numerically intensive: a sparse linear system must be solved at each iteration. Discretization with Finite elements Need for high performance linear algebra kernels Consider a partial differential equation of the form (Poisson Equation): { u = 2 u x 2 u = 0 on Ω + 2 u y 2 we can show (using Green s formula) that the previous problem is equivalent to: a(u, v) = f v dx dy v such that v = 0 on Ω where a(u, v) = Ω ( u v x x + u v y y Ω ) dxdy Finite element scheme: 1D Poisson Equation = f u = 2 u x 2 Equivalent to = f, u = 0 on Ω a(u, v) = g(v) for all v (v Ω = 0) where a(u, v) = Ω u v x x and g(v) = Ω f(x)v(x)dx (1D: similar to integration by parts) Idea: we search u of the form = k α kφ k (x) (Φ k ) k=1,n basis of functions such that Φ k is linear on all E i, and Φ k (x i ) = δ ik = 1 if k = i, 0 otherwise. Φ k 1 Φ k Φ k+1 x k E k E k+1 Ω Finite Element Scheme: 1D Poisson Equation Φ k 1 Φ k Φ k+1 x k E k E k+1 Ω 24

27 We rewrite a(u, v) = g(v) for all Φ k : a(u, Φ k ) = g(φ k ) for all k i α ia(φ i, Φ k ) = g(φ k ) a(φ i, Φ k ) = Φ i Φ k Ω x x = 0 when i k 2 k th equation associated with Φ k α k 1 a(φ k 1, Φ k ) + α k a(φ k, Φ k ) + x k+1 a(φ k+1, Φ k ) = g(φ k ) a(φ k 1, Φ k ) = E k a(φ k+1, Φ k ) = E k +1 a(φ k, Φ k ) = E k Φ k x Φ k 1 x Φ k+1 x Φ k x Φ k x Φ k x + Φ k Φ k E k x x Finite Element Scheme: 1D Poisson Equation From the point of view of E k, we have a 2x2 contribution matrix: ( Ek Ek Φk 1 Φk 1 x x Φk 1 Φk x x Ek Ek Φk 1 Φk x x Φk Φk x x ) ( IEk (Φ = k 1, Φ k 1 ) I Ek I Ek (Φ k, Φ k 1 ) I Ek Φ 1 Φ 2 Φ Ω E 1 E 2 I E1 (Φ 1, Φ 1) + I E2 (Φ 1, Φ 1) I E2 (Φ 1, Φ 2) I E2 (Φ 2, Φ 1) I E2 (Φ 2, Φ 2) + I E3 (Φ 2, Φ 2) I E3 (Φ 2, Φ 3) I E3 (Φ 2, Φ 3) I E3 (Φ 3, Φ 3) + I E4 (Φ 3, Φ 3) Finite Element Scheme in Higher Dimension E 3 E 4 1 A α 1 α 2 α 3 = g(φ 1) g(φ 2 ) g(φ 3 ) i Can be used for higher dimensions Mesh can be irregular Φ i can be a higher degree polynomial Matrix pattern depends on mesh connectivity/ordering Set of elements (tetrahedras, triangles) to assemble: j T k C(T ) = a T i,i a T i,j a T i,k a T j,i a T j,j a T j,k a T k,i a T k,j a T k,k 25

28 Needs for the parallel case Assemble the sparse matrix A = i C(T i): graph coloring algorithms Parallelization domain by domain: graph partitioning Solution of Ax = b: high performance matrix computation kernels Other example: linear least squares mathematical model + approximate measures estimate parameters of the model m experiments + n parameters x i : min Ax b avec: A R m n, m n: data matrix b R m : vector of observations x R n : parameters of the model Solving the problem: Factorisation sous la forme A = QR, avec Q orthogonale, R triangulaire Ax b = Q T Ax Q T b = Q T QRx Q T b = Rx Q T b Problems can be large (meteorological data,... ), sparse or not Again, we need high performance algorithms Software aspects, parallelization of industrial simulation codes Distinction between Porting codes and optimizing them on SMP machines Local changes in the code No major change in the global resolution method Possible substitution of computational kernels Development of a parallel code for distributed memory machines different algorithms needed Development of optimized parallel libraries (ex: solvers for linear systems) where portability and efficiency are essential How to take the characteristics of a parallel machine into account? Some of the most efficient sequential algorithms cannot be parallelized Some algorithms suboptimal in sequential are very good in parallel Major problem: How to reuse existing codes? 1.5 Grid computing - Internet Computing Grid computing - Internet Computing Internet peut servir de support à l exécution d applications réparties en plus de sa fonction d accès à l information. Intérêt Interface familière Disponibilité d outils de base : 26

29 Espace universel de désignation (URL) Protocole de transfert de l information (HTTP) Gestion d information sous format standard (HTML-XML) Web = système d exploitation primitif pour applications réparties? Problèmes Où et comment sont exécutés les programmes? Sur le site serveur scripts CGI, servlets,... Sur le site client scripts dans extension du navigateur (plugin) ou applets,... Comment assurer la sécurité? Problème majeur pas complètement résolu Traçabilité Protection des sites Encryptage de l information Restrictions sur les conditions d exécution Mais finalement qui bénéficie du résultat de l exécution du service? Grid Computing Rendre accessibles de façon transparente des ressources sur le Net : capacités de traitement, logiciels d expertise, bases de données,... 3 types de grilles: partage d information, stockage, calcul Problèmes : Localiser et renvoyer les solutions - ou logiciels - sous forme directement exploitable et usuelle à l utilisateur Exemples : NetSolve, DIET, Globus, NEOS, Ninf, Legion,... Mécanismes mis en œuvre : Sockets, RPC, client-serveur, HTTP, Corba, scripts CGI, Java,... Appels à partir de codes C ou Fortran Eventuellement interfaces plus interactives : consoles Java, pages HTML,... Initiatives américaines, européennes : EuroGrid (CERN + ESA +... ), GRID 5000,... Grilles de calcul : tentative de classification (T. Priol, INRIA) Multiplicité de termes : P2P Computing, Metacomputing, Virtual Supercomputing, Desktop Grid, Pervasive Computing, Utility Computing, Mobile Computing, Internet Computing, PC Grid Computing, On Demand Computing,... Virtual Supercomputing : grilles de supercalculateurs ; Desktop Grid, Internet Computing : grille composée d un très grand nombre de PC (10,000-1,000,000); Metacomputing: association de serveurs applicatifs; P2P Computing : infrastructure de calcul Pair-à-Pair: client ou serveur. chaque entité peut être alternativement 27

30 Vision de la grille aux USA. Peer-to-Peer : SETI@home Total Last 24 Hours Users new users Results received Total CPU time years years Flops e e ,000 PCs à la recherche d intelligence extra-terrestre Analyse du signal Pair récupère un jeu de données depuis le radio-téléscope d Arecibo Pair analyse les données (300 kb, 3TFlops, 10 hours) quand ils sont inactifs Les résultats sont transmis à l équipe SETI 35 TFlop/s en moyenne Source d inspiration pour de nombreuses entreprises Google (d après J. Dongarra) 2600 requêtes par seconde ( par jour) 100 pays documents indexés 450,000 systèmes Linux dans plusieurs centres de données Consommation électrique 20 MW (2 millions de $ par mois) Ordre d apparence des pages valeurs propres d une matrice de probabilité de transition (1 entre page i et j signifie l existence d un lien de i vers j) 28

31 RPC et Grid Computing : Grid RPC (F. Desprez, INRIA) Idée simple: Construire le modèle de programmation RPC sur la grille utiliser les ressources (données+services) disponibles sur le réseau Parallélisme mixte : guidé par les données au niveau du serveur et par les tâches entre les serveurs. Fonctionnalités requises: 1. Equilibrage de charge (localisation services, évaluation de performance, séquencement) 2. IDL (Interface Definition Language) 3. Mécanismes pour gérer la persistence et la dupplication des données. 4. Sécurité, Tolérance aux pannes, Interopérabilité entre intergiciels (gridrpc) RPC et Grid Computing : Grid RPC (suite) Exemples: Netsolve (Univ. Tennessee) (le plus ancien, basé sur des sockets) DIET: Equipe Graal (LIP) Outil récent largement utilisé Travaux importants sur l ordonnancement des tâches, le déploiement, la gestion des données. 1.6 Conclusion Evolutions du Calcul Haute-Performance Mémoire virtuellement partagée : clusters Hiérarchie mémoire plus étendue Clusters de machines Souvent à base de PCs (Pentium ou Dec Alpha, NT ou LINUX) Programmation parallèle (mémoire partagée, transfert de message, data parallèle) : Efforts de définition de standards : Open MP et threads POSIX, MPI, HPF,... MPPs et clusters représentent l avenir pour le calcul haute-performance rapport puissance communications souvent faible par rapport aux 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 : 29

32 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. Résolution de problèmes issus du calcul scientifique Calcul parallèle nécessaire pour résoudre des problèmes de tailles raisonnables Calculs impliquant des matrices souvent les plus critiques en mémoire/en temps Besoins: méthodes numériques parallèles, algèbre linéaire dense et creuse, algorithmes de traitement de graphes Les algorithmes doivent s adapter: aux architectures parallèles aux modèles de programmation portabilité et efficacité? la meilleure façon d obtenir un programme parallèle est de concevoir un algorithme parallèle!!!! HPC Spectrum (d après J.Dongarra) Peer to peer (SETI@home) Network of ws Grid based computing Beowulf cluster Clusters w/ special interconnect Parallel dist mem TFlop machines Distributed Systems - Gather (unused) resources - Steal cycles - System software manages resources - 10% - 20% overhead is OK - Resources drive applications - Completion time not critical - Time-shared - Heterogeneous 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 30

33 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,... Utilisation des architectures Besoins toujours croissants en volume mémoire : x par an pour un code moyen (soit 1 bit d adresse tous les 1-2 ans) 25 dernières années remplacement assembleur par langages de haut niveau compilateurs / optimisation de code Evolution technologique Circuits intégrés (CPU) : densité + 50 % par an Semi-conducteurs DRAM (mémoire) : CPU performance CP U time = Densité + 60 % par an Temps de cycle : -30 % tous les 10 ans Taille : multipliée par 4 tous les 3 ans #P rogramcycles ClockRate #P rogramcycles = #P rograminstructions avg.#cyclesperinstruction Thus performance (CP U time ) depends on three factors : 1. clock cycle time 2. #cycles per instruction 3. number of instructions But those factors are inter-dependent: ClockRate depends on hardware technology and processor organization #cyclesperinstruction depends on organization and instruction set architecture #instructions depends on instruction set and compiler 31

34 2.2 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 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 32

35 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 : 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). Résultat exécution vectorielle exécution scalaire 33

36 Overlapping (recouvrement) Utiliser des unités fonctionnelles en parallèle sur des opérations indépendantes. Exemple: do i = 1, n A(i) = B(i) * C(i) D(i) = E(i) + F(i) enddo 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 : 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. 34

37 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 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 Speed of computation relies on high bandwith Speed of computation High memory bandwidth Example: X <--- Y + Z Memory Flow requirement Data Intruction Intruction Y Adder X Z 1 Word = 8 Bytes NI = Nb. Instructions/cycle LI = Nb. Words/Instruction NO = Nb. Operations/cycle Bandwidth required: (NI*LI+3*NO) (in Words/sec) cycle time NI LI NO Cycle time (in nsec) Bandwidth Required 1 CPU NEC SX3/ GW/sec 1 CPU CRAY-C GW/sec Digital α / GW/sec Intel i860 XP 2 1/2 3/ GW/sec 35

38 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 : 1. Load vecteur x 2. Load vecteur y 3. Addition x + y 4. Multiplication alpha ( x + y ) 5. Store dans vecteur y 36

39 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 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 37

40 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 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 [?]) Pipeline increases the instruction throughput Pipeline hazards: prevents the next instruction from executing Structural hazards: arising from hardware resource conflicts Data hazards: due to dependencies between instructions Control hazards: branches for example Instruction Level Parallelism (ILP) Pipelining: overlap execution of independent operations Instruction Level Parallelism Techniques for increasing amount of parallelism among instructions: reduce the impact of data and control hazards increase the ability of processor to exploit parallelism compiler techniques to increase ILP Main techniques loop unrolling basic and dynamic pipeline scheduling dynamic branch prediction Issuing multiple instructions per cycle compiler dependence analysis software pipelining trace scheduling / speculation... 38

41 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 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 39

42 ILP : Multiple issue CPI cannot be less than one except if more than one instruction issued each cycle multiple-issue processors (CPI: average nb of cycles per instruction) Two types : superscalar processors VLIW processors (Very Long Instruction Word) Superscalar processors issue varying number of instructions per cycle either statically scheduled by compiler or dynamically (e.g. using scoreboarding). Typically 1-8 instructions per cycle with some constraints. VLIW issue a fixed number of instructions formatted either as one large instruction or as a fixed instruction packet : inherently statically scheduled by compiler Impact of ILP : example This example is from J.L. Hennessy and D.A. Patterson (1996) [?]. 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 [?]) 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 40

43 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 41

44 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 42

45 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. Survol des processeurs RISC Processeur RISC pipeliné: exemple pipeline d exécution à 4 étages stage #1 stage #2 stage #3 stage #4 fetch decode execute write result Processeur RISC superscalaire : plusieurs pipelines plusieurs instructions chargées + décodées + exécutées simultanément stage #1 stage #2 stage #3 stage #4 fetch decode execute write result pipeline #1 fetch decode execute write result pipeline #2 fetch decode execute write result pipeline #3 fetch decode execute write result pipeline #4 souvent opération entière / opérations flottante / load mémoire problème : dépendances largement utilisés : DEC, HP, IBM, Intel, SGI, Sparc,... Processeur RISC superpipeline : plus d une instruction initialisée par temps de cycle pipeline plus rapide que l horloge système exemple : sur MIPS R4000 horloge interne du pipeline est 2 (ou 4) fois plus rapide que horloge système externe Superscalaire + superpipeline : non existant Exemples de processeurs RISC Exec. pipe D-cache I-cache inst./ Peak Processor MHz #stages (KB) (KB) cycle Perf. DEC / DEC / MB HP PA MB ext HP PA MB ext IBM Power IBM Power MIPS R / MB ext MIPS R MB ext MIPS R MB ext Pentium Pro ext. 200 UltraSPARC I KB ext UltraSPARC II MB ext

46 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 do... do... y(i) = y(i) + x(j)*a(j,i) enddo enddo 2 variantes : 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 Ratio Flops/références mémoire = 2 2 = 1 Réutilisation de x(j) : déroulage à une profondeur 2 44

47 * 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 7: Effect of loop unrolling on HP 715/64 AXPY variant Habituellement préférée sur processeurs vectoriels 45

48 50 Performance of y = At x on CRAY T3D Rolled Unrolled 2 Unrolled 4 Unrolled 8 MFlops Size Figure 8: Effect of loop unrolling on CRAY T3D 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) load A(j,i) perform A(j,i) * x(j) + y(i) store result in y(i) 46

49 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 47

50 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 48

51 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) 49

52 Tmiss %hits Tps hits Tps misses Ttotal Perf. 100% % 10 99% % 20 99% % 10 95% % 20 95% % Table 6: 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. 50

53 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 [?])) 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? 51

54 Analyse de performance: blocage dans les trois directions C=A B+ C ( C1,1 C 1,2 C 2,2 C 2,2 ) ( A1,1 A = 1,2 A 2,1 A 2,2 ) ( B1,1 B 1,2 B 2,1 B 2,2 ) ( C1,1 C + 1,2 C 2,1 C 2,2 ) C 1,1 = C 1,1 + A 1,1 B 1,1 + A 1,2 B 2,1 C 2,1 = C 2,1 + A 2,1 B 1,1 + A 2,2 B 2,1 C 1,2 = C 1,2 + A 1,1 B 1,2 + A 1,2 B 2,2 C 2,2 = C 2,2 + A 2,1 B 1,2 + A 2,2 B 2,2 Multiplication de matrices C C + A B DO j = 1, n DO k = 1, n DO i = 1, n C(i,j) = C(i,j) + A(i,k) * B(k,j) Enddo Enddo Enddo Architecture avec caches : A, B, C découpées en sous-matrices DO i = 1, n, nb1 I = i:i+nb1-1 DO k = 1, n, nb2 K=k:k+nb2-1 DO j = 1, n, nb3 J=j:j+nb3-1 C(I,J) = C(I,J) + A(I,K) * B(K,J) Multiplication sur les sous-matrices : C(I,J) : nb1xnb3 A(I,K) : nb1xnb2 B(K,J) : nb2xnb3 Multiplication sur les sous-matrices pour processeur vectoriel C Perform C(I,J) = C(I,J) + A(I,K) * B(K,J) DO jj = j, j+nb3-1 DO kk = k, k+nb2-1 DO ii = i, i+nb1-1 C(ii,jj) = C(ii,jj) + A(ii,kk) * B(kk,jj) Utilise chainage multiplieur, additionneur, et Loads/Stores. Optimisation supplémentaire en déroulant la boucle sur k. nb1 : multiple de la longueur des registres vectoriels nb2 : assez grand pour assurer une performance maximale La boucle extérieure peut être distribuée sur plusieurs processeurs (nb3 fonction du nombre de procs.) 52

55 6 Blocking : C = C + A.B on HP 714/ No blocking Blocking MFlops Size Figure 9: Effect of blocking on HP 715/64 Multiplication sur les sous-matrices pour processeur RISC C Perform C(I,J) = C(I,J) + A(I,K) * B(K,J) DO jj = j, j+nb3-1 DO ii = i, i+nb1-1 DO kk = k, k+nb2-1 C(ii,jj) = C(ii,jj) + A(ii,kk) * B(kk,jj) Opération de réduction (produit scalaire) dans la boucle interne préférable. Déroulage sur les boucles j et i (par exemple 2x2 ou 4x2). nb1, nb2, et nb3 choisis en fonction de la hiérarchie mémoire et des processeurs : nb1=nb2=nb3=nb. nb choisi tel que les sous-matrices tiennent dans le cache. Soit 3 nb 2 prec < taille du cache avec prec = 8 octets en double précision et 4 octets en simple Réutilisation de la sous-matrice de A : C boucle externe DO k = 1, n, nb2 K=k:k+nb2-1 DO i = 1, n, nb1 I = i:i+nb1-1 DO j = 1, n, nb3 J=j:j+nb3-1 C(I,J) = C(I,J) + A(I,K) * B(K,J) avec A(I,K) sous-matrice qui reste dans le cache pour la boucle interne Blocked Matrix-matrix multiplication: copying 53

56 15 14 Blocking : C = C + A.B on CRAY T3D No blocking Blocking MFlops Size Figure 10: Effect of blocking on CRAY T3D C C do ll = 1, n, nb lb = min(n-ll+1,nb) do ii = 1, m, nb ib = min(m-ii+1,nb) Copy submatrix of A into array work do i = ii, ii+ib-1 do k = ll, ll+lb-1 work(k-ll+1,i-ii+1) = A(i,k) enddo enddo do jj = 1, n, nb jb = min(n-jj+1,nb) do j = jj, jj+jb-1 do i = ii, ii+ib-1 do k = ll, ll+lb-1 C(i,j)=C(i,j)+work(k-ll+1,i-ii+1)*B(k,j) enddo enddo enddo enddo enddo enddo Effet des Strides Un stride 1 peut avoir un impact critique sur la performance par accroissement des défauts de cache cache initialement vide politique de remplacement : LRU 1 ligne cache = 4 réels a(1) rangé au début d une ligne de cache real a(*)... do i = 1, n, 4 54

57 8.5 Blocking : C = C + A.B on HP 715/ Blocking Blocking and copying MFlops Size Figure 11: Comparison blocking vs blocking and copying on HP 715/64. a(i) = a(i) + 1 enddo chaque lecture de a(i) provoque un défaut de cache Stride critique!!!!! Exemple tiré d un code d aérodynamique In the most time consuming routines: real*8 dvel((n1+4)*(n2+4)*(n3+4),1:9)... do n = dvel(n,1) = dvel(n,1) +... dvel(n,2) = dvel(n,2) dvel(n,9) = dvel(n,9) enddo Very efficient on vector processors (up to 450 MFlops on CRAY C90) Dramatic performance decrease when using n1, n2, n3 = 12, 20, 12 block size on IBM SP2 dvel(n,*) not in the same cache line stride = (n1+4)*(n2+4)*(n3+4) If (n1+4)*(n2+4)*(n3+4) multiple of 1024 contention since dvel(n,*) are mapped into the same set and only 4 blocks available!! This is the case using 12 x 20 x 12 block size on IBM SP2 real*8 dvel(1:9,(n1+4)*(n2+4)*(n3+4))... do n =... Solution: modify the data storage for dvel!!! 55

58 line 1 line 2 line M E M O R Y C A C H E block 1 block 2 block 3 block 3 set #1 set #2 set #3 set #256 Figure 12: Cache on IBM SP2 thin node : 4-way set-associative, 64KB, 256 sets, cache line=64 bytes.... dvel(1,n) = dvel(1,n) +... dvel(2,n) = dvel(2,n) dvel(9,n) = dvel(9,n) enddo Performance obtenue sur SP2 Stockage initial: dvel( (n1+4)*(n2+4)*(n3+4), 1:9 ) Stockage modifié: dvel( 1:9, (n1+4)*(n2+4)*(n3+4) ) Gain sur IBM SP2: facteur 9! Note: versions distinctes pour processeur RISC et pour processeur vectoriel 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 56

59 0 1 2 o o o o o o o o o o o o 3 o o o o o Réseau Crossbar 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. Utilisé sur calculateurs à mémoire partagée : Alliant, Cray, Convex,... 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 13: Exemple de réseau multi-étage avec p=3. Réseaux birectionnels ou doublement du réseau. 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, permutation sur des vecteurs de 2 p éléments. 57

60 Le réseau Omega reproduit à chaque étage un Perfect Shuffle. Autorise la distribution d une entrée sur toutes les sorties ( broadcast ) A B C D E F G H I J K L Réseau Omega 8 8. Autre topologie possible (réseau Butterfly, BBN, Meiko CS2) A B C D E F G H I J K L 58

61 Réseaux mono-étage Réalisent un nombre fini de permutations entre les entrées et les sorties, chacune de ces permutations faisant l objet d une connexion physique (en général canal bidirectionnel). Généralement statique. Proc 1 Proc 2 Proc 3 Proc 4 Proc 5 Proc 6 Très utilisé dans les architectures à mémoire locale Exemples : Bus partagé Proc #0 B U S Cache Local Memory Main Memory Proc #n Cache Local Memory Anneau Largement utilisé sur SMP (SGI, SUN, DEC,... ) Proc 0 Proc 1 Proc 2 Proc n Grille 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,... 59

62 Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc 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,... )

63 Figure 14: 4-Cube in space. Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc 2.12 Les supercalculateurs du top 500 en Juin 2007 Statistiques Top 500 (voir Liste des 500 machines les plus puissantes au monde Mesure: GFlops/s pour pour la résolution de où A est une matrice dense. Ax = b Mis à 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: 1997: 2007: #1 = 1.1 TFlop/s #500 = 7.7 GFlop/s #1 = 280 TFlop/s #500 = 4 TFlop/s Quelques remarques générales Architectures IBM Blue Gene dominent dans le top 10. NEC Earth simulator supercomputer (36 Tflop/s, 5120 processeurs vectoriels) est aujourd hui numéro 20. Est resté en tête de Juin 2002 à Juin

64 Il faut 56 Tflop/s pour entrer dans le Top 10 (contre 15 TFlop/s en juin 2005) Somme accumulée: 4.95 PFlop/s (contre 1.69 PFlop/s en juin 2005) Le 500 ième (4 Tflop/s) aurait été 216 ème il y a 6 mois. Remarques générales (suite) Domaine d activité Recherche 25%, Accadémie 18%, Industrie 53% Par contre 100% du TOP10 pour recherche et accadémie. France (10/500) dont 8 pour l industrie. Processeurs 289 systèmes basés sur de l Intel (dont sur le Xeon Woodcrest, bi-cœur) 107 sur des AMD (dont 90 : bi-cœurs Opteron) 85 sur de l IBM Power 3, 4 ou 5 10 sur des HP PA-RISC 4 sur des NEC (vectoriels) 3 sur des Sparc 2 sur des CRAY (vectoriels) 6/500 (18/500 en 2005) basés sur des processeurs vectoriels. Architecture 107 MPP (Cray SX1, IBM SP, NEC SX, SGI ALTIX, Hitatchi SR) pour 393 Clusters Analyse des sites - Definitions Rang: Position dans le top 500 en Juin Rpeak: Performance crête de la machine en nombre d opérations flottantes par secondes. Rmax: Performance maximum obtenue sur le test LINPACK. Nmax: Taille du problème ayant servi à obtenir Rmax. Top 10 mondial (Juin 2007) Rang-Configuration Implantation #proc. Rmax Rpeak Year TFlops TFlops 1-IBM eserver BlueGene DOE/NNSA/LLNL Cray XT4/XT3 1 Oak Ridge Nationl Lab Cray RedStorm 2 NNSA/Sandia Lab IBM eserver BlueGene IBM TJWatson Res. Ctr IBM eserver BlueGene New York Ctr. in CS IBM eserver pseries 3 DOE/NNSA/LLNL IBM eserver Blue Gene Nonotechnology DELL PowerEdge 5 Nat.Ctr. Supercomp. Appl IBM cluster 6 Barcelona Supercomp. Ctr SGI Altix GHz Leibniz Rechenzentrum Tera-10 Novascale 7 CEA

65 Top 7 mondial (Juin 2005) Rang-Configuration Implantation #proc. Rmax Rpeak Nmax TFlops TFlops IBM eserver BlueGene Solution DOE/NNSA/LLNL IBM eserver BlueGene Solution IBM TJWatson Res. Ctr SGI Altix 1.5GHz NASA/Ames Res.Ctr./NAS NEC Earth simulator Earth Simul. Center IBM cluster, PPC-2.2GHz-Myri. Barcelona Supercomp. Ctr IBM eserver BlueGene Solution ASTRON/Univ. Groningen NOW Itanium2-1.4GHz-Quadrix Los Alamos Nat. Lab de taille 10 6 = 8 Terabytes Stockage du problème Constructeur Nombre Pourcent. P Rmax P Rpeak P P rocs (TFlop/s) (TFlop/s) IBM HP Dell Cray Inc SGI NEC Self-made Sun Fujitsu All Statistiques constructeurs Top 500, nombre de systèmes installés. Analyse des sites français Juin 2007 Rang-Configuration Implantation #proc. Rmax Rpeak GFlops GFlops 12-NovaScale CEA NovaScale CEA IBM Blue Gene L EDF R&D HP Cluster 10 HP HP Cluster 11 Industrie alim HP Cluster 12 IT Service Prov IBM BladeCenter 13 Finance IBM Cluster 14 PSA Peugeot IBM eserver 15 Total SA HP Cluster Xeon 16 Industrie alim NEC SX8R (2.2 Ghz) Meteo-France Analyse des sites français Juin 2005 Rang-Configuration Implantation #proc. Rmax Rpeak Nmax GFlops GFlops HP AlphaServer SC45, 1GHz CEA HP Cluster P4 Xeon-2.4GHz Finance IBM Cluster Xeon2.4GHz-Gig- Total E E 281-IBM eserver (1.7GHz Power4+) 359-SGI Altix 1.5GHz 257-HP Cluster P4 Xeon-2.4GHz Caylon HP Cluster P4 Xeon-2.4GHz Caylon IBM Cluster Xeon2.4GHz-Gig- Soc.Gen CNRS- IDRIS CEG Gramat (armement) HP Superdome 875MHz France Telec. 445-HP Cluster Xeon 3.2 GHz Soc.Gen Répartition géographique 63

66 Afrique: 1 Océanie : 5 Amérique: 295 Europe: 127 Brésil 2 Allemagne 24 Canada 10 France 13 Mexique 2 Italie 5 USA 281 RU 42 Espagne 6 Russie 5 Asie : 72 Chine 13 India 8 Japon 23 S. Arabia 2 Analyse des plates-formes à usage académique Processor Types Amérique: 44 Europe: 33 Canada 4 Allemagne 6 Etats-Unis 39 Belgique 1 Mexique 1 Espagne 3 Océanie : 2 Finlande 2 Australie 1 France 0 Nouvelle Zélande 1 Italie 1 Asie : 11 Norvège 1 Japon 8 Pays-Bas 2 Chine 1 Royaume Uni 7 Taiwan 1 Russie 4 Corée du Sud 1 Suède 4 Turquie 1 Suisse 1 Performance evolution 64

67 Exemples d architecture de supercalculateurs Machines de type scalaire MPP IBM SP (NERSC-LBNL, IDRIS (France)) CRAY XT3/4 (Oak Ridge National Lab) Cluster DELL (NCSA) Non-Uniform Memory Access (NUMA) computer SGI Altix (Nasa Ames) IBM Blue Gene Machines de type vectoriel NEC (Earth Simulator Center, Japon) CRAY X1 (Oak Ridge Nat. Lab.) MPP IBM SP NERSC-LBNL Noeud 1 Noeud 416 P1 P16 P1 P16 12Gbytes 12Gbytes Réseau 416 Noeuds de 16 processeurs 6656 processeurs (Rpeak=9.9Teraflops) 375MHz processeur (1.5Gflops) Mémoire: 4.9 Terabytes Remarque: Machine pécédente (en 2000) Cray T3E (696 procs à 900MFlops et 256Mbytes) Supercalculateur du Lawrence Berkeley National Lab. (installé en 2001) MPP IBM SP CNRS-IDRIS 65

68 Noeud 1 Noeud 12 P1 P32 P1 P32 128Gbytes 128Gbytes Réseau 12 Noeuds de 32 processeurs 1.3GHz processeur (5.2Gflops) Mémoire: 1.5 Terabytes + X noeuds de 4 procs Supercalculateur de l IDRIS (installé en 2004) 384 processeurs (Rpeak=2.61Tflops) Cluster DELL Abe (NCSA, Illinois) Performance: Rpeak=94 TFlop/s peak, Rmax=62.7 TFlop/s Architecture (9600 cores): 1200 nœuds (bi-xeon) à 2.33 GHz Chaque Xeon : 4 cœurs 4 flops/cycle/cœur (9.33 GFlop/s) Mémoire: 90 TB (1 GB par cœur) Infiniband applications GigEthernet système+monitoring IO: 170 TB at 7.5 GB/s Non Uniform Memory Access Computer SGI Altix 4.1Tbytes de mémoire globalement adressable C Brick 1 Noeud 1 Noeud 2 P1 P2 P1 P2 C Brick 128 Noeud 1 Noeud 2 P1 P2 P1 P2 16Gb 16Gb 16Gb 16Gb Réseau 128 C Bricks de 2 Noeuds de 2 procs 512 processeurs (Rpeak=3.1Teraflops) 1.5GHz Itanium 2 (6Gflops/proc) Mémoire: 4.1 Terabytes Remarque: NUMA et latence Noeud (145nsec); C Brick (290ns); Entre C Bricks(+ 150 à 400ns); Supercalculateur SGI Altix (installé à NASA-Ames en 2004) 2007: #10=Altix, 63 TFlop/s, 9728 cœurs, 39 TB, Allemagne NEC Earth Simulator Center (charactéristiques) 640 NEC/SX6 nodes 5120 CPU (8 GFlops) > 40 TFlops 2 $ Billions, 7 MWatts. 66

69 NEC Earth Simulator Center (architecture) Arithm. Proc 1 Arith. Proc. 8 Arithm. Proc 1 Arith. Proc. 8 Vector Scalar Vector Scalar Vector Scalar Vector Unit unit Unit unit Unit unit Unit Registers cache Noeud 1 Registers cache Registers cache Noeud 640 Scalar unit Registers cache Mémoire partagée (16Gbytes) Mémoire partagée (16Gbytes) Réseau (Crossbar complet) 640 Noeuds (8 Arith. Proc.) > 40Tflops Mémoire totale 10TBytes Vector unit (500MHz): 8 ens. de pipes (8*2*.5= 8Glops) (Rpeak > 16 flops // par AP) Supercalculateur NEC (installé à Tockyo en 2002) Cray X1 d Oak Ridge National Lab. Performance: 6.4 Tflop/s, 2Terabytes, Rmax(5.9 TFlop/s) Architecture 504 Muti Stream processeurs (MSP): 126 Noeuds Chaque Noeud a 4 MSP et 16Gbytes de mémoire flat. Chaque MSP a 4 Single Stream Processors (SSP) Chaque SSP a une unité vectorielle et une unité superscalaire, total 3.2Gflops. Cray X1 node 67

70 Blue Gene L (65536 dual-procs, 360 TFlops peak) 68

71 Système d exploitation minimal (non threadé) Consommation limitée: 32 TB mais seulement 512 MB de mémoire par noeud! un noeud = 2 PowerPC à 700 MHz (2x2.8 GFlop/s) 2.8 GFlop/s ou 5.6 GFlop/s crête par noeud Plusieurs réseaux rapides avec redondances 69

72 Clusters à base de processeurs CELL rack QS20 = 2 processeurs CELL (512 MB / processeur) racks connectés entre eux par switchs GigEthernet Chaque CELL=205 GFlop/s (32 bits) Installation au CINES (Montpellier): 2 racks IBM QS20 performance crête: 820 GFlop/s mémoire: seulement 2 GB! reste très expérimental et difficile à programmer Machines auxquelles on a accès depuis le LIP Calculateurs des centres nationaux (pas dans le top 500) IDRIS: 1024 processeurs Power4 IBM, 3 noeuds NEC SX8 CINES: 9 noeuds de 32 Power4 IBM, SGI Origin 3800 (768 processeurs),... Calculateurs régionaux/locaux: icluster2 à Grenoble: 100 bi-processeurs itanium (en cours de renouvellement) clusters de la fédération lyonnaise de calcul haute performance Grid 5000 (node in Lyon: 127 bi-processeurs opteron, 1 core/proc) Programmes nationaux d équipement USA: Advanced Simulation and Computing Program (formerly Accelerated Strategic Initiative) Début du projet : 1995 DOE (Dept. Of Energy) Objectifs : 1 PetaFlop/s France: le projet Grid 5000 (en plus des centres de calcul CNRS: IDRIS et CINES) Début du projet : 2004 (Ministère de la Recherche) Objectifs : réseau de 5000 machines sur 8 sites répartis Nice, Rennes, Toulouse) (Bordeaux, Grenoble, Lille, Lyon, Prévisions BlueGeneL et ses successeurs: 3 PFlop/s en 2010 Fujitsu prévoit de construire une machine au moins aussi puissante (3 PFlop/s) d ici

73 2.13 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 Ecriture de code efficace Comment exploiter efficacement l architecture? 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 Explique pourquoi il est préférable d annoncer la performance d un processeur RISC en MIPS plutôt qu en MFlops... mais il y a autre chose que les calculs flottants en informatique... 71