High Performance Matrix Computations J.-Y. L Excellent (INRIA/LIP-ENS Lyon) Office 352 Jean-Yves.L.Excellent@ens-lyon.fr 2007-2008 prepared in collaboration with P. Amestoy, L.Giraud, M. Daydé (ENSEEIHT-IRIT) Contents 1 Introduction 1 1.1 Introduction aux calculateurs haute-performance....................... 1 1.2 Evolutions architecturales.................................... 6 1.3 Programmation.......................................... 17 1.4 Calcul Matriciel et calcul haute performance......................... 18 1.5 Grid computing - Internet Computing............................. 26 1.6 Conclusion............................................ 29 2 Calculateurs haute-performance: concepts généraux 31 2.1 Introduction............................................ 31 2.2 Organisation des processeurs.................................. 32 2.3 Organisation mémoire...................................... 34 2.4 Organisation interne et performance des processeurs vectoriels................ 36 2.5 Organisation des processeurs RISC............................... 38 2.6 Réutilisation des données (dans les registres)......................... 44 2.7 Mémoire cache.......................................... 47 2.8 Réutilisation des données (dans les caches)........................... 49 2.9 Mémoire virtuelle......................................... 51 2.10 Réutilisation des données (en mémoire)............................ 51 2.11 Interconnexion des processeurs................................. 56 2.12 Les supercalculateurs du top 500 en Juin 2007......................... 61 2.13 Conclusion............................................ 71 2.13.1 Ecriture de code efficace................................. 71 3 Notions et techniques générales pour l algèbre linéaire 74 3.1 Introduction............................................ 74 3.2 Gaussian Elimination....................................... 75 3.3 LU Factorization......................................... 75 3.4 Vector and Matrix norms.................................... 79 3.5 Erreur, sensibilité, conditionnement............................... 80 3.6 Factorisation LU avec pivotage................................. 84 3.7 Systèmes bande.......................................... 85 3.8 Matrices symétriques....................................... 86 3.9 Factorisation de Cholesky.................................... 88 3.10 Factorisation QR......................................... 89 3.11 Gram-Schmidt Process...................................... 92 3.12 Problèmes aux moindres carrés................................. 93 3.13 Problèmes aux valeurs propres................................. 94 3.14 Décomposition en valeurs singulières (SVD).......................... 95 1
4 Efficient dense linear algebra libraries 96 4.1 Use of scientific libraries..................................... 96 4.2 Level 1 BLAS and LINPACK.................................. 98 4.3 BLAS............................................... 99 4.4 LU Factorization......................................... 104 4.5 LAPACK............................................. 110 4.6 Linear algebra for distributed memory architectures..................... 113 4.7 BLACS (Basic Linear Algebra Communication Subprograms)................ 113 4.8 PBLAS : parallel BLAS for distributed memory machines.................. 115 4.9 ScaLAPACK........................................... 117 4.10 Recursive algorithms....................................... 121 2
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
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
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
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 10 12 opérations / seconde 1 PFlop/s 1 Petaflop/s 10 15 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 10 12 octets 1 PB / 1 Po 1 Petabyte 10 15 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 : 0.9 + 10 = 10.9 s Performance réelle : 9.2 GFlop/s 4. Performance réelle Performance de crête = 0.1 4
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) 1 3018 6542 12000 HP ProLiant (1 core, 3.8GHz) 1 1852 4851 7400 HP ProLiant (1 core, 3.8GHz) 2 8197 14800 IBM eserver(1.9ghz, Power5) 1 1776 5872 7600 IBM eserver(1.9ghz, Power5) 8 34570 60800 Fujitsu Intel Xeon (3.2GHz) 1 1679 3148 12800 Fujitsu Intel Xeon (3.2GHz) 2 5151 6400 SGI Altix (1.5GHz Itanium2) 1 1659 5400 6000 NEC SX-8 (2 GHz) 1 2177 14960 16000 Cray T932 32 1129 (1 proc.) 29360 57600 Hitachi S-3800/480 4 408 (1 proc.) 20640 32000 Table 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
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 1980 1988 1991 1993 1995 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 : +25-30% par an pour les mainframes et minis qui dominaient l industrie Depuis la fin des années 70 : émergence du microprocesseur meilleure exploitation des avancées dans l intégration que pour les mainframes et les minis (intégration moindre) progression et avantage de coût (production de masse) : de plus en plus de machines sont basées sur les microprocesseurs possibilité de pourcentage d amélioration plus rapide = 35% par an 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
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é: 24 18 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
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
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
Calculateur procs LINPACK LINPACK Performance n = 100 n = 1000 crête Intel WoodCrest (1 core, 3GHz) 1 3018 6542 12000 HP ProLiant (1 core, 3.8GHz) 1 1852 4851 7400 IBM eserver(1.9ghz, Power5) 1 1776 5872 7600 SGI Altix (1.6GHz Itanium2) 1 1765 5943 6400 AMD Opteron (2.19GHz) 1 1253 3145 4284 Fujitsu Intel Xeon (3.2GHz) 1 1679 3148 12800 AMD Athlon (1GHz) 1 832 1705 3060 Compaq ES45 (1GHz) 1 824 1542 2000 Performance actuelle d un processeur vectoriel NEC SX-8 (2 GHz) 1 2177 14960 16000 NEC SX-8 (2 GHz) 8 75140 128000 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
Année Calculateur MFlop/s 1955-65 CDC 6600 1-10 1965-75 CDC 7600 10-100 IBM 370/195 ILLIAC IV 1975-85 CRAY-1, XMP, CRAY 2 100-1000 CDC CYBER 205 FUJITSU VP400 NEC SX-2 1985-1995 CRAY-YMP, C90 1000-100,000 ETA-10 NEC SX-3 FUJITSU VP2600 1995-2005 CRAY T3E 1.2 TFlop/s INTEL 1.8 TFlop/s IBM SP 16 TFlop/s HP 20 TFlop/s NEC 40 TFlop/s IBM Blue Gene 180 TFlop/s 2010 -???? 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
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
Size Average access time (# cycles) hit/miss Registers < 1 1 128 KB Cache level #1 1 2 / 8 66 256 KB 16 MB Cache level #2 6 15 / 30 200 1 10 GB Main memory 10 100 Remote memory 500 5000 Disks 700,000 / 6,000,000 Figure 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
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
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
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
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
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
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 2 + 2 u y 2 + 2 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
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: 1 2 1 20
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)) h2 1 1 4 1 1 1 4 1 1 1 5-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
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 2 2 1 0 0 0 0 1 2 1 0 0 0 0 1 2 1 0 0 0 0 1 2 1 0 0 0 0 1 2 1 0 0 0 0 1 2 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: 1 5 1 2 3 4 0 1 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
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: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 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
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
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 Φ 3 0 1 2 3 4 Ω 0 @ 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
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
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
Vision de la grille aux USA. Peer-to-Peer : SETI@home Total Last 24 Hours Users 5436301 0 new users Results received 2005637370 780175 Total CPU time 2378563.061 years 539.796 years Flops 7.406171e+21 3.042682e+18 500,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 (200 10 6 par jour) 100 pays 8 10 9 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
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
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
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 1.5 2 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
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
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 = 1 + 1 = 2 Etape 2 : a(3) = a(2) + 1 = 2 + 1 = 3 Etape 3 : a(4) = a(3) + 1 = 3 + 1 = 4... Exécution vectorielle : pipeline à p étages p éléments dans le pipeline Etages du pipe ------------------------------------------- Temps 1 2 3... p sortie ------------------------------------------------------- t0 a(1) t0 + dt a(2) a(1) t0 + 2dt a(3) a(2) a(1)... t0 + pdt a(p+1) a(p)... a(2) a(1) ------------------------------------------------------- D où : a(2) = a(1) + 1 = 1 + 1 = 2 a(3) = a(2) + 1 = 1 + 1 = 2... car on utilise la valeur initiale de a(2). Résultat exécution vectorielle exécution scalaire 33
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
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 400-32,000 (BI)CMOS compiler Cache 4MB 3-10 ns 800-5,000 CMOS SRAM hardware Main memory 4GB 80-400 ns 400-2,000 CMOS DRAM OS Disk 1GB 5 10 6 ns 4-32 magnetic disk OS/user 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/14 16 2.9 16GW/sec 1 CPU CRAY-C90 4 4.2 2.8GW/sec Digital α 21064 2 1/2 1 5 0.6GW/sec Intel i860 XP 2 1/2 3/2 20 0.275GW/sec 35
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 1 2 3 4 5 6 7 8 a(1), a(2),..., a(128) a(129),..., a(256) Banks 1 2 3 4 5 6 7 8 a(1), a(9),..., a(249) a(2), a(10),..., a(250) a(3),a(11),..., a(251) a(4),... a(5),... a(6),... a(7),..., a(255) a(8), a(16),..., a(256) "well adapted to pipelining memory access" Effect of bank cycle time Bank cycle time: Time interval during which the bank cannot be referenced again Example Low order interleaved memory, 4 banks, bank cycle time 3CP. % column access %row access Real a(4,2) Real a(4,2) Do j=1,2 Do i=1,4 Do i=1,4 Do j=1,2... = a(i,j)... = a(i,j) Enddo Enddo Enddo Enddo Bank Bank 1 a(1,1) a(1,2) 1 a(1,1) a(1,2) a(2,1) a(2,2) a(2,1) a(2,2) 2 2 3 a(3,1) a(3,2) 3 a(3,1) a(3,2) 4 a(4,1) a(4,2) 4 a(4,1) a(4,2) 1 CP 10 Clock Period time 18 Clock Period Bank Conflict: Consecutive accesses to the same bank in less than bank cycle time. Stride: Memory address interval between successive elements 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
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
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
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
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 24 24 Characteristics of the processor 40
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
load x(i-1) -> F6 7 1 stall F8 = F6 + F2 9 2 stalls store F8 -> x(i-1) 12 load x(i-2) -> F10 13 1 stall F12= F10+ F2 15 2 stalls store F12-> x(i-2) 18 load x(i-3) -> F14 19 1 stall F16= F14+ F2 21 2 stalls store F16-> x(i-3) 24 R1 = R1 - #32 25 BNEZ R1, Loop 26 stall 27 27 cycles per iteration Cost of calculation 1000 4 27 = 6750 cycles 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) 14 14 cycles per iteration Cost of calculation 1000 4 14 = 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
12 cycles per iteration Cost of calculation 1000 5 12 = 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 21064 200 7/9 8 8 2 200 DEC 21164 437 7/9 8 + 96 + 4 MB 8 4 874 HP PA 7200 120-2 MB ext. 2 240 HP PA 8000 180-2 MB ext. 4 720 IBM Power 66 6 32-64 8-32 4 132 IBM Power2 71.5 6 128-256 8-32 6 286 MIPS R8000 75 5/7 16+ 4 MB ext. 16 4 300 MIPS R10000 195-32 + 4 MB ext. 32 4 390 MIPS R12000 300-32 + 8 MB ext. 32 4 600 Pentium Pro 200-512 ext. 200 UltraSPARC I 167-16 + 512 KB ext. 16 2 334 UltraSPARC II 200-1 MB ext. 16 2 400 43
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
* 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/64 40 35 Rolled Unrolled 2 Unrolled 4 Unrolled 8 30 MFlops 25 20 15 10 5 0 200 400 600 800 1000 1200 Size Figure 7: Effect of loop unrolling on HP 715/64 AXPY variant Habituellement préférée sur processeurs vectoriels 45
50 Performance of y = At x on CRAY T3D 45 40 35 Rolled Unrolled 2 Unrolled 4 Unrolled 8 MFlops 30 25 20 15 10 5 0 200 400 600 800 1000 1200 Size Figure 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
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
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
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 21164 32 B 1 8 KB Direct-mapped 2 C 2 2 96 KB 3-way ass. 8 C 2 3 1-64 MB Direct-mapped 12 C 2 IBM Power2 128 B / 1 128 KB / 4-way-ass. 8 C 2 256 B 256 KB MIPS R8000 16 B 1 16 KB Direct-mapped 7 C 2 2 4-16 MB 4-way-ass. 50 C 2 Cache configurations on some computers. : data + instruction cache Current trends: Large caches of several MBytes Several levels of cache 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.9 0.1)+0.1 = 1 0.19 = 5.3 (similar to Amdahl s law) 49
Tmiss %hits Tps hits Tps misses Ttotal Perf. 100% 1.00 0.00 1.00 100% 10 99% 0.99 0.11 1.10 91% 20 99% 0.99 0.22 1.21 83% 10 95% 0.95 0.55 1.50 66% 20 95% 0.95 1.10 2.05 49% 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
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. 2.10 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 = 3 3.2 GB = 9.6 GB capacité mémoire : 128 pages soit: 128 2Mmots = 256Mmots = 2GB A, B, C ne peuvent être stockées totalement 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
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
6 Blocking : C = C + A.B on HP 714/64 5.5 5 4.5 No blocking Blocking MFlops 4 3.5 3 2.5 2 50 100 150 200 250 300 350 400 450 500 550 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
15 14 Blocking : C = C + A.B on CRAY T3D No blocking Blocking 13 12 MFlops 11 10 9 8 7 6 50 100 150 200 250 300 350 400 450 500 550 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
8.5 Blocking : C = C + A.B on HP 715/64 8 7.5 Blocking Blocking and copying 7 6.5 MFlops 6 5.5 5 4.5 4 3.5 50 100 150 200 250 300 350 400 450 500 550 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
line 1 line 2 line 256 1... 16 17... 32......... 1024 1025............... 2048 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
0 1 2 o o o o o o o o o o o o 3 o o o o o 1 2 3 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. 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 7 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
0 1 2 4 5 6 3 4 6 3 7 7 5 2 1 0 Le réseau Omega reproduit à chaque étage un Perfect Shuffle. Autorise la distribution d une entrée sur toutes les sorties ( broadcast ). 0 1 2 4 0 3 5 6 1 2 3 4 5 6 7 7 0 1 2 3 4 5 6 7 0 1 2 4 5 6 7 3 A B C D E F G H I J K L Réseau Omega 8 8. Autre topologie possible (réseau Butterfly, BBN, Meiko CS2) 0 1 2 4 6 3 5 7 6 4 3 0 1 2 5 7 A B C D E F G H I J K L 58
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
Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc Proc 0 1 2 3 4 5 6 7 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,... ) 0 1 2 3 4 5 6 7 60
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 www.top500.org) 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 2004. 61
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 31 205 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 2007. 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 131072 280 367 2005 2-Cray XT4/XT3 1 Oak Ridge Nationl Lab 23016 101 119 2006 3-Cray RedStorm 2 NNSA/Sandia Lab 26544 101 127 2006 4-IBM eserver BlueGene IBM TJWatson Res. Ctr. 40960 91 114 2005 5-IBM eserver BlueGene New York Ctr. in CS 36864 82 103 2007 6-IBM eserver pseries 3 DOE/NNSA/LLNL 12208 75 92 2006 7-IBM eserver Blue Gene Nonotechnology 4 32768 73 91 2007 8-DELL PowerEdge 5 Nat.Ctr. Supercomp. Appl. 10240 62 94 2007 9-IBM cluster 6 Barcelona Supercomp. Ctr. 10240 62 94 2006 10-SGI Altix4700-1.6GHz Leibniz Rechenzentrum 9728 56 62 2007 12-Tera-10 Novascale 7 CEA 9968 52 63 2006 62
Top 7 mondial (Juin 2005) Rang-Configuration Implantation #proc. Rmax Rpeak Nmax TFlops TFlops 10 3 1-IBM eserver BlueGene Solution DOE/NNSA/LLNL 65536 136 183 1278 2-IBM eserver BlueGene Solution IBM TJWatson Res. Ctr. 40960 91 114 983 3-SGI Altix 1.5GHz NASA/Ames Res.Ctr./NAS 10160 51 60 1290 4-NEC Earth simulator Earth Simul. Center. 5120 36 41 1075 5-IBM cluster, PPC-2.2GHz-Myri. Barcelona Supercomp. Ctr. 4800 27 42 977 6-IBM eserver BlueGene Solution ASTRON/Univ. Groningen 12288 27 34 516 7-NOW Itanium2-1.4GHz-Quadrix Los Alamos Nat. Lab. 8192 19 22 975 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 192 38.4 2060 3121 679128 HP 201 40.2 1193 1860 227028 Dell 22 4.4 427 616 67264 Cray Inc. 11 2.2 359 438 81070 SGI 19 3.8 281 317 48464 NEC 4 0.8 53 59 5952 Self-made 5 1.0 48 79 10056 Sun 7 1.4 43 59 5952 Fujitsu 4 0.8 25 47 7488 All 500 100 4946 7183 1221114 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 5160 8 CEA 9968 52840 63798 22-NovaScale 3045 9 CEA 6144 35130 39321 38-IBM Blue Gene L EDF R&D 8192 18665 22937 110-HP Cluster 10 HP 1024 8751 12288 238-HP Cluster 11 Industrie alim. 668 5210 8016 329-HP Cluster 12 IT Service Prov. 640 4992 7680 349-IBM BladeCenter 13 Finance 2000 4925 8800 394-IBM Cluster 14 PSA Peugeot 1184 4673 6157 458-459 IBM eserver 15 Total SA 1024 4307 7782 480-HP Cluster Xeon 16 Industrie alim. 688 4173 6420 489-490 NEC SX8R (2.2 Ghz) Meteo-France 128 4058 405 Analyse des sites français Juin 2005 Rang-Configuration Implantation #proc. Rmax Rpeak Nmax GFlops GFlops 10 3 77-HP AlphaServer SC45, 1GHz CEA 2560 3980 5120 360 238-HP Cluster P4 Xeon-2.4GHz Finance 512 1831 3276 251-IBM Cluster Xeon2.4GHz-Gig- Total 1024 1755 4915 335 E E 281-IBM eserver (1.7GHz Power4+) 359-SGI Altix 1.5GHz 257-HP Cluster P4 Xeon-2.4GHz Caylon 530 1739 3392 258-HP Cluster P4 Xeon-2.4GHz Caylon 530 1739 3392 266-IBM Cluster Xeon2.4GHz-Gig- Soc.Gen. 968 1685 4646 CNRS- IDRIS CEG Gramat (armement) 384 1630 2611 256 1409 1536 384-HP Superdome 875MHz France 704 1330 2464 Telec. 445-HP Cluster Xeon 3.2 GHz Soc.Gen. 320 1228 2048 Répartition géographique 63
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
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
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
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
Blue Gene L (65536 dual-procs, 360 TFlops peak) 68
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
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) http://www.nnsa.doe.gov/asc 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) http://www.grid5000.org 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 2010. 70
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 2.13.1 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
Table 7: Performance de versions differentes de GEMM sur processeurs RISC avec des matrices 128 128. Calculateur standard optimisé perf. de crête DEC 3000/300 AXP 23.1 48.4 150.0 HP 715/64 16.9 38.4 128.0 IBM RS6000/750 25.2 96.1 125.0 Pentium 4 113 975 3600 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) dans la résolution de pbs physiques. 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 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 grâce au rapport entre opérations flottantes et réfrences mémoire : ( 4n 2 références mémoire, 2n 3 opérations flottantes) 72
i.e. n 2 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. http://netlib.enseeiht.fr/atlas/ Goto from Univ. Texas at Austin http://www.cs.utexas.edu/users/flame/goto/ Figure de J. Dongarra 73
3 Notions et techniques générales pour l algèbre linéaire 3.1 Introduction Linear algebra Linear algebra: branch of mathematics that deals with solutions of systems of linear equations and the related geometric notions of vector spaces and linear transformations. linear comes from the fact that equation defines a line (in two-dimensional geometry). ax + by = c similar to the form of a system of linear equations: a i1 x 1 + a i2 x 2 +... + a in x n = b i, i = 1,..., m Linear transformation from a vector space V to W : T (v 1 + v 2) = T (v 1) + T (v 2) T (αv 1) = αt (v 2) Linear 2 transformations 3 (rotations, projections,... ) are often represented by matrices. A = 0 1» 4 2 2 5 x, v =, then T : v Av is a linear transformation from IR 2 to IR 3, defined by y 1 0 T (x, y) = (y, 2x + 2y, x). Use of Linear algebra Continuous problem Discretization Mathematical representation involving vectors and matrices This leads to problems involving vectors and matrices, in particular: systems of linear equations (sparse, dense, symmetric, unsymmetric, well conditionned,... ) least-square problems eigenvalue problems Résolution de Ax = b A générale carrée : factorisation LU avec pivotage A symétrique définie positive : factorisations de Cholesky LL t ou LDL t A symétrique indéfinie : factorisation LDL t A rectangulaire m n avec m n : factorisation QR Problèmes aux moindres carrés min x Ax b 2 Si rang(a) maximal : factorisation de Cholesky ou QR Sinon QR avec pivotage sur les colonnes ou Singular Value Decomposition (SVD) 74
Problèmes aux valeurs propres Ax = λx Exemple: déterminer les fréquences de résonnance d un pont / d un avion Techniques à base de transformations orthogonales: décomposition de Schur, Hessenberg, réduction à une matrice tri-diagonale Problèmes généralisés : Ax = λbx et A t Ax = µ 2 B t Bx : Schur et SVD généralisée Implantation efficace critique 3.2 Gaussian Elimination System of linear equations? Example: can be written under the form: with A = 2 1 3 4 6 5 6 13 16 Gaussian Elimination Example: 2 x 1-1 x 2 3 x 3 = 13-4x 1 + 6 x 2 + 5 x 3 = -28 6 x 1 + 13 x 2 + 16 x 3 = 37, x = x 1 x 2 x 3 Ax = b,, and b = With 2 * (1) + (2) (2) and -3*(1) + (3) (3) we obtain: Thus x 1 is eliminated. With -4*(5) + (6) (6): 13 28 37 2x 1 x 2 + 3x 3 = 13 (1) 4x 1 + 6x 2 + 5x 3 = 28 (2) 6x 1 + 13x 2 + 16x 3 = 37 (3) 2x 1 x 2 + 3x 3 = 13 (4) 0x 1 + 4x 2 + x 3 = 2 (5) 0x 1 + 16x 2 + 7x 3 = 2 (6) 2x 1 x 2 + 3x 3 = 13 0x 1 + 4x 2 + x 3 = 2 0x 1 + 0x 2 + 3x 3 = 6 The linear system is then solved by backward (x 3 x 2 x 1 ) substitution: x 3 = 6 3 = 2, x 2 = 1 4 ( 2 x 3) = 1, and finally x 1 = 1 2 (13 3x 3 + x 2 ) = 3 3.3 LU Factorization LU Factorization Find L unit lower triangular and U upper triangular such that: A = L U 2 1 3 1 0 0 A = 4 6 5 = 2 1 3 2 1 0 0 4 1 6 13 16 3 4 1 0 0 3 75
Procedure to solve Ax = b A = LU Solve Ly = b (descente / forward elimination) Solve U x = y (remontée / backward substitution) Ax = (LU)x = L(Ux) = Ly = b From Gaussian Elimination to LU Factorization 0 A = A (1), b = b (1), A (1) x = b (1) : @ a 1 0 11 a 12 a 13 a 21 a 22 a 23 A @ x 1 0 1 x 2 A = @ b 1 1 b 2 A 2 2 1 a 21 /a 11 a 31 a 32 a 33 x 3 b 3 3 3 1 a 31 /a 0 1 11 0 a 11 a 12 a 13 A (2) x = b (2) B @ 0 a (2) 22 a (2) C 23 A @ x 1 0 1 b 1 1 x 2 A B = @ b (2) C 0 a (2) 32 a (2) 2 A b (2) x 3 33 b (2) 2 = b 2 a 21 b 1 /a 11... 3 a (2) 32 = a 32 a 31 a 12 /a 11... Finally 3 3 2 a 32 /a 22 gives A (3) x = b (3) Typical Gaussian elimination at step k: 0 B @ 1 0 a 11 a 12 a 13 0 a (2) 22 a (2) C 23 A @ x 1 0 1 x 2 A B = @ 0 0 a (3) x 3 33 b 1 b (2) 2 b (3) 3 1 C A a (3) 33 = a(2) 33 a(2) 32 a(2) 23 /a(2) 22... (and a (k+1) ij = a (k) ij for i k) a (k+1) ij = a (k) ij a(k) ik a (k) kk a (k) kj, for i > k From 8 Gaussian Elimination to LU factorization >< >: a (k+1) ij a (k+1) ij = a (k) ij = a (k) ij a(k) ik a (k) kk, for i k a (k) kj, for i > k One step of Gaussian elimination can be written: A (k+1) = L (k) A (k) (and b (k+1) = L (k) b (k) ), with L k = 0 1 B @.. 1 l k+1,k... l n,k 1 1 C A and l ik = a(k) ik a (k) kk. After n 1 steps, A (n) = U = L (n 1)... L (1) A gives A = LU, with L = [L (1) ] 1... [L (n 1) ] 1 = 0 B @ 1 l 21 1..... l n1 1 1 0 1... C B A @ LU Factorization Algorithm... 1 l n,n 1 1 1 0 = C B A @ 1 0... l i,j 1 Overwrite matrix A: we store a (k) ij, k = 2,..., n in A(i,j) In the end, A = A (n) = U do k=1, n-1 L(k,k) = 1 do i=k+1, n L(i,k) = A(i,k)/A(k,k) do j=k, n (better than: do j=1,n) A(i,j) = A(i,j) - L(i,k) * A(k,j) end do enddo enddo L(n,n)=1 1 C A, 76
Matrix A at each step: 0 0 0 Avoid building the zeros under the diagonal Before L(n,n)=1 do k=1, n-1 L(k,k) = 1 do i=k+1, n L(i,k) = A(i,k)/A(k,k) do j=k, n A(i,j) = A(i,j) - L(i,k) * A(k,j) After L(n,n)=1 do k=1, n-1 L(k,k) = 1 do i=k+1, n L(i,k) = A(i,k)/A(k,k) do j=k+1, n A(i,j) = A(i,j) - L(i,k) * A(k,j) Use lower triangle of array A to store L(i,k) multipliers Before: L(n,n)=1 do k=1, n-1 L(k,k) = 1 do i=k+1, n L(i,k) = A(i,k)/A(k,k) do j=k+1, n A(i,j) = A(i,j) - L(i,k) * A(k,j) After (diagonal 1 of L is not stored): do k=1, n-1 do i=k+1, n A(i,k) = A(i,k)/A(k,k) do j=k+1, n A(i,j) = A(i,j) - A(i,k) * A(k,j) More compact array syntax (Matlab, scilab, Fortran 90): do k=1, n-1 A(k+1:n,k) = A(k+1:n,k) / A(k,k) A(k+1:n,k+1:n) = A(k+1:n,k+1:n) - A(k+1:n,k) * A(k,k+1:n) end do corresponds to a rank-1 update: 0 0 0 0 0 0 0 0 0 0 77
k j Computed elements of U k A(k,k) A(k,j) A(k,k+1:n) L multipliers i A(i,k) A(i,j) A(k+1:n,k) What we have computed we have stored the L and U factors in A: A(i,j), i > j corresponds to l ij A(i,j), i j corresponds to u ij and we had l ii = 1, i = 1, n Finally, L U A = L + U I Nombre d opérations flottantes (flops) Dans la descente Ly = b calcul de la k-ème inconnue k 1 y k = b k L kj y j j=1 Soit (k-1) multiplications et (k-1) additions, k de 1 à n-1 Donc n 2 n flops au total Idem pour la remontée Ux = y Nombre de flops dans la factorisation de Gauss: n k divisions (n k) 2 multiplications, (n k) 2 additions k = 1, 2,..., n 1 total: 2 n3 3 78
Exercise do k=1, n-1 A(k+1:n,k) = A(k+1:n,k) / A(k,k) A(k+1:n,k+1:n) = A(k+1:n,k+1:n) - A(k+1:n,k) * A(k,k+1:n) end do 2 1 3 Compute the LU factorization of A = 4 6 5 6 13 16 Answer: A = Remark 2 1 0 1 0 0 3 4 1 2 1 3 0 4 1 0 0 3 Assume that a decomposition A = LU exists with L=(l ij ) i,j=1...n lower triangular with unit diagonal U=(u ij ) i,j=1...n upper triangular Computing the LU product, we have: { aij = i 1 k=1 l iku kj + u ij for i j a ij = j 1 k=1 l iku kj + l ij u jj for i > j Renaming i K in the 1st equation and j K in the 2nd, { u Kj = a Kj K 1 k=1 I l Kku kj for j {K;...; N} K l ik = 1 u KK (a ik K 1 k=1 l iku kk ) for i {K + 1;...; N} Explicit computation of u Kj and l ik for K = 1 to n Finally, same computations are performed but in a different order (called left-looking) 3.4 Vector and Matrix norms Vector Norms Definition 1. A vector norm is a function f : IR n IR n such that f(x) 0 x IR n, f(x) = 0 x = 0 f(x + y) f(x) + f(y) x, y IR n f(αx) = α f(x) α IR, x IR n p-norm: x p = ( x 1 p + x 2 p +... + x n p ) 1 p Most important p-norms are 1, 2, and norm: x 1 = x 1 + x 2 +... + x n x 2 = ( x 1 2 + x 2 2 +... + x n 2 ) 1 2 = (x T x) 1 2 x = max 1 i n x i Vector Norms Some properties Cauchy-Schwarz inequality: x T y x 2 y 2 (Proof based on 0 x λy 2 with λ = xt y y 2 ) All norms on IR n are equivalent:. α and. β, c 1, c 2 s.t. c 1 x α x β c 2 x α 79
In particular: x 2 x 1 n x 2 x x 2 n x x x 1 n x Matrix Norms As for vector norms, f(a) 0 A IR m n, f(a) = 0 A = 0 f(a + B) f(a) + f(b) A, B IR m n f(αa) = α f(a) α IR, A IR m n Most matrix norms satisfy AB A B Norms induced by p norms on vectors: A p = max x 0 A 1 = max 1 j n A = max 1 i m Ax p x p = max m i=1 a ij n j=1 a ij A p ρ(a) = max 1 i n λ i Frobenius norm: x p=1 Ax p A F = m i=1 n j=1 a ij 2 = i σ2 i = trace(at A) 3.5 Erreur, sensibilité, conditionnement Considérons le système linéaire: [.780.563.913.659 ] [.217 [x] =.254 Supposons que l on obtient les résultats suivants par 2 méthodes différentes : [ ] [ ] 0.314 0.999 x 1 = et x 0.87 2 = 1.00 Quelle solution est la meilleure? ] Résidus : b Ax 1 = [.0000001 0 ] et b Ax 2 = [.001343.001572 ] x 1 est la meilleure solution car possède le plus petit résidu Solution exacte : [ x = 1 1 ] En réalité x 2 est plus précis. Notion de bonne solution : ambigu 80
Sensibilité des problèmes Soit A : [.780.563.913.659 ] matrice presque singulière Soit A : [.780.563001095.913.659 ] matrice singulière une perturbation des données en O(10 6 ) rend le problème insoluble Autre problème si A proche de matrice singulière : petit changement sur A et/ou b perturbations importantes sur la solution Cela n est pas lié à l algorithme de résolution utilisé Représentation des réels en machine Réels codés en machine avec nombre fini de chiffres Représentation normalisée d un réel flottant normalisé: x = ( 1) s m 2 e Plupart des calculateurs base = 2 (norme IEEE), mais aussi 8 (octal) ou 16 (IBM), 10 (calculettes) macheps : précision machine i.e. plus petit réel positif tel que 1 + macheps > 1 Norme IEEE définit: format des nombres modes d arrondis possibles traitement des exceptions (overflow, division par zéro,... ) procédures de conversion (en décimal,... ) l arithmétique Simple précision IEEE : 31 30 23 22 0 s exposant mantisse Exposant codé sur 8 bits, mantisse 23 bits plus 1 implicite. Double précision IEEE : 63 62 52 51 0 s exposant mantisse Exposant sur 11 bits, mantisse 52 bits plus 1 implicite Simple précision : macheps 1.2 10 7 xmin 1.2 10 38 xmax 3.4 10 38 Double précision : macheps 2.2 10 16 xmin 2.2 10 308 xmax 1.8 10 308 81
Nombres spéciaux ± : signe, mantisse=0, exposant max NaN : signe, mantisse 0, exposant max ±0 : signe, mantisse = 0, exposant min Nombres dénormalisés: signe, mantisse 0, exposant min Remarques 0/0, 1 NaN 1/( 0) NaN op x NaN Exceptions: overflows, underflows, divide by zero, Invalid (NaN) Possibilité d arrêt avec un message d erreur ou bien poursuite des calculs Analyse d erreur en arithmétique flottante Avec la norme IEEE (modèle pour le calcul à précision finie): fl(x op y) = (x op y)(1 + ɛ) avec ɛ u f l(x): x représenté en arithmétique flottante op = +,,, / u = macheps: précision machine Exemple: fl(x 1 + x 2 + x 3) = fl((x 1 + x 2) + x 3) = ((x 1 + x 2)(1 + ɛ 1) + x 3) (1 + ɛ 2) = x 1(1 + ɛ 1)(1 + ɛ 2) + x 2(1 + ɛ 1)(1 + ɛ 2) + x 3(1 + ɛ 3) = x 1(1 + e 1) + x 2(1 + e 2) + x 3(1 + e 3) avec chaque e i < 2 macheps. Somme exacte de valeurs modifiées x i (1 + e i ), avec e i < 2u Analyse d erreur inverse: un algorithme est dit backward stable s il donne la solution exacte pour des données légèrement modifiées (ici x i (1 + e i )). Analyse d erreur inverse solution approchée = solution exacte d un problème modifié quelle taille d erreur sur les données peut expliquer l erreur sur la solution? solution approchée OK si solution exacte d un problème avec des données proches 82
erreur inverse x x F G y erreur directe F y = F(x ) Conditionnement Pb bien conditionné: x x petit f(x) f(x ) petit Sinon: problème sensitif ou mal conditionné Sensibilité ou conditionnement: changement relatif solution / changement relatif données = f(x ) f(x) f(x) / (x x) x Erreur sur la résolution de Ax = b Représentation de A (et b) en machine inexacte : résolution d un problème perturbé (A + E) x = b + f avec E = (e ij ), e ij u a ij et f i u b i. x : meilleure solution accessible A quel point x est proche de x? Si un algorithme calcule x alg et x x alg / x est grand, deux raisons possibles: le problème mathématique est très sensible aux perturbations (et alors, x x pourra être grand aussi) l algorithme se comporte mal en précision finie L analyse des erreurs inverses permet de discriminer ces deux cas (Wilkinson, 1963[?]) Notion de conditionnement d un système linéaire A A + A F F x t.q. Ax = b x + x t.q. (A + A)(x + x) = b Alors avec K(A) = A A 1. x x K(A) A A K(A) est le conditionnement de l application F. Si A macheps A (précision machine) alors erreur relative K(A) macheps (A singulière : κ(a) = + ) 83
Backward error of an algorithm Let x be the computed solution. We have ([?]): err = min {ɛ > 0 such that A ɛ A, b ɛ b, (A + A) x = b + b} = A x b A x + b. Proof: (A + A) x = b + b b A x = b A x b A x A x + b r ε( A x + b ) r min{ε} = err A x + b A b Bound is attained for A min = x ( A x + b ) r xt and b min = A x + b r. A r We have A min x b min = r with A min = A x + b and b b r min = A x + b. Furthermore, it can be shown that Relative forward error Condition Number Backward Error Ce qu il faut retenir Conditionnement (cas général): κ(a, b) = A 1 ( A + b x ) mesure la sensibilité du problème mathématique Erreur inverse d un algorithme: mesure la fiabilité de l algorithme Ax b A x + b. à comparer à la précision machine ou à l incertitude sur les données Prédiction de l erreur: Erreur directe conditionnement erreur inverse 3.6 Factorisation LU avec pivotage [ ] [ ɛ 1 1 0 Soit A = = 1 1 κ 2 (A) = 1 + O(ɛ). Si on résoud : Solution exacte x = (1, 1). En faisant varier ɛ on a : [ ɛ 1 1 1 ] [ x1 x 2 1 ɛ 1 ] = ] [ ɛ 1 0 1 1 ɛ [ 1 + ɛ 2 ] ] 84
x x x ɛ 10 3 6 10 6 10 6 2 10 11 10 9 9 10 8 10 12 9 10 5 10 15 7 10 2 Table 8: Précision relative de la solution en fonction de ɛ. Donc même si A bien conditionnée : élimination de Gauss introduit des erreurs Explication : le pivot ɛ est trop petit Solution : échanger les lignes 1 et 2 de A [ 1 1 ɛ 1 ] [ x1 x 2 ] [ = 2 1 + ɛ ] précision parfaite! Pivotage partiel : pivot choisi à chaque étape = plus grand élément de la colonne Avec pivotage partiel : 1. P A = LU où P matrice de permutation 2. Ly = P b 3. Ux = y LU avec pivotage: backward stable Ax b A x u(1) x x x u κ(a) (2) 1. la LU donne de faibles résidus indépendamment du conditionnement de A 2. la précision dépend du conditionnement si u 10 q et κ (A) 10 p alors x a approximativement (q p) chiffres corrects Factorisation LU avec pivotage do k = 1 à n-1 find l such that A(l,k) = max { A(j,k), j = k à n } if A(l,k) = 0 exit. // A is (almost) singular endif if k!= l, swap rows k and l in A (and in b) A(k+1:n,k) = A(k+1:n,k) / A(k,k) A(k+1:n,k+1:n) = A(k+1:n,k+1:n) - A(k+1:n,k)*A(k,k+1:n) end do 3.7 Systèmes bande Systèmes bande 85
x x 0 0 0 x x x 0 0 A = 0 x x x 0 largeur de bande = 3 0 0 x x x A tridiagonale 0 0 0 x x Exploitation de la structure bande lors de la factorisation : L et U bidiagonales x 0 0 0 0 x x 0 0 0 x x 0 0 0 0 x x 0 0 L = 0 x x 0 0 U = 0 0 x x 0 0 0 x x 0 0 0 0 x x 0 0 0 x x 0 0 0 0 x on peut donc réduire le nombre d opérations Systèmes bande KL: nombre de sous-diagonales de A KU: nombre de sur-diagonales de A KL+KU+1: largeur de bande Question: Si p = KL = KU (largeur totale, 2p+1), quel est le nombre d opérations de l algo de factorisation LU (sans pivotage)? Réponse: (n p) (p divisions + p 2 multiplications + p 2 additions ) + 2 3 (p 1)3 ) 2np 2 flops (quand n >> p), au lieu de 2n3 3. Pivotage partiel la largeur de bande augmente!! échange des lignes k et i, A(i,k)=max(A(j,k), j > k) KL = KL KU = KL + KU 3.8 Matrices symétriques Matrices symétriques A symétrique : on ne stocke que la triangulaire inférieure ou supérieure de A A = LU A t = A LU = U t L t Donc (U)(L t ) 1 = L 1 U t = D diagonale et U = DL t, soit A = L(DL t ) = LDL t Exemple : 4-8 -4 1 0 0 1 0 0 1-2 -1-8 18 14 = -2 1 0 * 0 2 0 * 0 1 3-4 14 25-1 3 1 0 0 3 0 0 1 Résolution : 1. A = LDL t 2. Ly = b 3. Dz = y 4. Ux = z LDL t : n 3 3 flops (au lieu de 2n3 3 pour la LU) 86
Matrices symétriques et pivotage pas de stabilité numérique sur A a priori pivotage maintien de la symétrie pivotage diagonal, mais insuffisant approches possibles: Aasen, Bunch & Kaufman,... En général on cherche: P AP t = LDL t où P matrice de permutation L : triangulaire inférieure D : somme de matrices diagonales 1 1 et 2 2 1 0 0 0 x 0 0 0 1 0 0 0 t x 1 0 0 0 x x 0 x 1 0 0 PAPt= x 0 1 0 * 0 x x 0 * x 0 1 0 x x x 1 0 0 0 x x x x 1 L D Lt Examples of 2x2 pivots: 0 1 eps1 1 1 0 1 eps2 Détermination du pivot complexe: 2 colonnes à chaque étape [ ] E C Let P AP t t =. If E is a 2x2 pivot, form E C B 1 to get: [ ] [ ] [ ] I 0 E 0 I E P AP t = 1C t CE 1 I 0 B CE 1 C t 0 I Possible pivot selection algorithm (Bunch-Parlett): µ 1 = max i a ii ; µ 2 = max ij a ij if µ 1 αµ 2 (for a given α > 0) else Choose largest 1x1 diag. pivot. Permute s.t. e 11 = µ 1 Choose 2x2 pivot s.t. e 21 = µ 2 Choice of α to minimize growth factor, ie, the magnitude of the entries in B CE 1 C t, with E 1x1 or 2x2 1x1 pivot (µ 1 αµ 2 ), C has 1 column, B C 1 µ 1 C t ij max ij B ij + max ij ( c i c j /µ 1 ) µ 2 + µ 2 2/µ 1 = µ 2 (1 + µ 2 /µ 1 ) µ 2 (1 + 1/α) 2x2 pivot, one can shot that bound is 3 α 1 α µ 2 Choose α s.t 3 α 1 α = (1 1 α )2 (2 pivots) gives. α = 1+ 17 8. Unfortunately, previous algorithm requires between n2 12 and n2 6 More efficient variants exist, also with a good backward error Example: Bunch-Kaufman algorithm (1977) comparisons, and is too costly. Determination of first pivot: α (1 + 17)/8 0.64 r index of largest element colmax = a r1 below the diagonal if a 11 α colmax 1x1 pivot a 11 is ok else 87
rowmax = a rp =largest element in row r if rowmax a 11 α colmax 2 1x1 pivot a 11 is ok elseif a rr α rowmax 1x1 pivot a rr is ok, permute else» a11 a r1 2x2 pivot is chosen a r1 a rr interchange rows r and 2 endif endif 3.9 Factorisation de Cholesky Factorisation de Cholesky A définie positive si x t Ax > 0 x 0 A symétrique définie positive factorisation de Cholesky A = LL t avec L triangula Par identification : [ A11 A 12 A 21 A 22 ] [ L11 0 = L 21 L 22 ] [ L11 L 21 0 L 22 ] De là : Pas de pivotage, Cholesky est backward stable Factorisation : n3 3 flops Algorithme de factorisation de type Cholesky do k=1, n A(k,k)=sqrt(A(k,k)) A(k+1:n,k) = A(k+1:n,k)/A(k,k) do j=k+1, n A(j:n,j) = A(j:n,j) - A(j:n,k) A(j,k) end do end do A 11 = L 2 11 L 11 = (A 11 ) 1 2 (7) A 21 = L 21 L 11 L 21 = A 21 L 11 (8) A 22 = L 2 21 + L 2 22 L 22 = (A 22 L 2 21) 1 2 (9)... (10) Schéma similaire à la LU, mais on ne met à jour que le triangle inférieur LU factorization: A(k+1:n,k+1:n) = A(k+1:n,k+1:n) / A(k,k) - A(k+1:n,k) * A(k,k+1:n,k) 88
3.10 Factorisation QR Factorisation QR Définition d un ensemble de vecteurs orthonormés {x 1,..., x k } x t i x j = 0 i j x t i x i = 1 Matrice orthogonale Q : les vecteurs colonnes de Q sont orthonormés, QQ t = I, Q 1 = Q t Factorisation QR: R A = Q Q orthogonale R triangulaire supérieure Exemple 1 8 2 1 2 14 = 1 3 2 3 2 3 2 3 1 3 2 3 2 3 2 3 1 3 3 6 0 15 0 0 = Q R Factorisation QR Factorisation QR obtenue en général par applications successives de transformations orthogonales sur les données : Q = Q 1... Q n où Q i matrices orthogonales simples telles que Q t A = R Transformations utilisées : Réflexions de Householder Rotations de Givens Procédé de Gram-Schmidt (auquel cas Q est de taille m n et R est de taille n n) Réflexions de Householder H = I 2v.v t où v vecteur de IR n tq v 2 = 1 H orthogonale symétrique. Permet en particulier d annuler tous les éléments d un vecteur sauf une composante. Exemple : x = 2 1 2 u = x + x 2 0 0 = 5 1 2 et v = u u 2 Alors : H = I 2v v t = 1 15 10 5 10 5 14 2 10 2 11 89
Donc : H x = 3 0 0 Réflexions de Householder u x Vect {u} Hx Réflexions de Householder Vecteur de Householder : u = x + ou - x 2 e 1 puis u = v/ v 2 Permettent d obtenir des matrices de la forme: 2 3 a 11 a 12 a 13 0 a 22 a 23 A = 6 0 a 32 a 33 7 4 0 a 42 a 43 5 0 a 52 a 53 Soit H telle que : Si H =» 1 0 0 H 2 H 6 4 a 22 a 32 a 42 a 52 3 7 5 = 2 6 4 a 22 0 0 0 2 Alors H A = 6 4 3 7 5 a 11 a 12 a 13 0 a 22 a 23 0 0 a 33 0 0 a 43 0 0 a 53 3 7 5 Triangularisation d une matrice 4 3 : Q = H 1 H 2 H 3 x x x x x x x x x x x x H1 0 x x H2 0 x x x x x -> 0 x x -> 0 0 x x x x 0 x x 0 0 x x x x 90
H3 0 x x -> 0 0 x = R 0 0 0 QR backward stable, avec une erreur inverse meilleure que LU Nombree d opérations 4 3 n3 Rotations de Givens Rotation 2 2 : [ G(θ) = c s s c ] orthogonale avec c = cos(θ) et s = sin(θ). Utilisation : x = {x 1, x 2 } x 1 x 2 c = (x 2 1 + x2 2 ) et s = 1 2 (x 2 1 + x2 2 ) 1 2 y = (y 1, y 2 ) = G t x alors y2 = 0 Permet d annuler certains éléments d une matrice Rotations de Givens Exemple : factorisation QR de A = r 11 r 12 r 13 0 r 22 r 23 0 0 r 33 v 1 v 2 v 3 Déterminer (c, s) tels que : [ c s s c ] t [ r11 v 1 ] = [ r 11 0 ] Rotations de Givens Rotation dans le plan (1,4) : G(1, 4) = G(1, 4) t A = c 0 0 s 0 1 0 0 0 0 1 0 s 0 0 c r 11 r 12 r 13 0 r 22 r 23 0 0 r 33 0 v 2 v 3 Rotations successives pour annuler les autres éléments : 4n 3 3 flops pour triangulariser la matrice. 91
3.11 Gram-Schmidt Process Gram-Schmidt Process Hypothesis: a basis of a subspace is available Goal: Build an orthonormal basis of that subspace Very useful in iterative methods, where: each iterate is searched for in a subspace of increasing dimension one needs to maintain a basis of good quality Gram-Schmidt Process Consider two linearly independent vectors x 1 and x 2 q 1 = x 1 x 1 2 has norm 1. x 2 (x 2, q 1 )q 1 is orthogonal to q 1 : (x 2 (x 2, q 1 )q 1, q 1 ) = x t 2q 1 (x t 2q 1 )q t 1q 1 = 0 q 2 = x 2 (x 2, q 1 )q 1 x 2 (x 2, q 1 )q 1 2 has norm 1 Gram-Schmidt Process 1. Compute r 11 = x 1 2, if r 11 = 0 stop 2. q 1 = x 1 r 11 3. For j = 2,..., r Do (q 1..., q j 1 form an orthogonal basis) 4. r ij x t jq i, for i = 1, 2,..., j 1 j 1 5. ˆq x j r ij q i i=1 6. r jj = ˆq 2, if r jj = 0 stop 7. q j ˆq r jj 8. EndDo Remarks From steps 5-7, it is clear that x j = j i=1 r ijq i We note X = [x 1, x 2,..., x r ] and Q = [q 1, q 2,..., q r ] Let R be the r-by-r upper triangular matrix whose nonzeros are the ones defined by the algorithm. Then the above relation can be written as where Q is n-by-r and R is r-by-r. X = QR, 92
Example: x 1 = (1, 2, 2) T, x 2 = ( 8, 1, 14) T r 11 = x 1 2 = 3, 2 q 1 = x 1 r 11 = 1 3 4 1 2 2 Ce qui correspond à la factorisation : 2 4 1 8 3 2 2 1 5 = 4 2 14 3 5, r 12 = x T 2 q 1 = 18 3 = 6, and ˆq = x 2 r 12 q 1 2 ˆq = 4 8 3 2 1 5 6 1 4 1 3 2 2 5 et r 22 = ˆq = 15, q 2 = ˆq 14 3 2 ˆq = 1 3 4 2 3 1 5 2 1 2 3 3 2 1 3 3 2 2 3 3 Factorisation QR où Q orthogonale et R triangulaire supérieure 3 5» 3 6 0 15 3.12 Problèmes aux moindres carrés Problèmes aux moindres carrés Soit A : m n, b IR n, m n (et le plus souvent m >> n) Problème : trouver x tel que Ax = b 2 1 2 2 3 2 3 3 3 = 4 2 1 2 5 3 3 3 2 2 1 3 3 3 Système sur-déterminé : existence de solution pas garantie. Donc on cherche la meilleure solution au sens d une norme: min x Ax b 2 4 3 6 0 15 0 0 3 5 r b Span{A} Ax Principales approches: Equations normales ou factorisation QR Equations normales min Ax b 2 min Ax b 2 2 x x Ax b 2 2 = (Ax b) t (Ax b) = x t A t Ax 2x t A t b + b t b Dérivée nulle par rapport à x: 2A t Ax 2A t b = 0 système de taille (n x n) A t Ax = A t b A t A symétrique semi-définie positive, définie positive si A est de rang maximal (rang(a)=n) résolution: avec Cholesky A t A = LDL t problème : κ(a t A) = κ(a) 2 pas backward stable (A t A) 1 A t : pseudo-inverse de A 93
Résolution par factorisation QR Si Q est une matrice orthogonale : A : m n, Q : m m tel que A = QR Ax b = Q t (Ax b) = (Q t A)x (Q t b) Q t A = R = R est triangulaire supérieure. En posant : Q t b = [ R1 0 [ c d ] n m n ] n m n on a donc : Ax b 2 2 = Q t Ax Q t b 2 2 = R 1 x c 2 2 + d 2 2 si rang(a) = rang(r 1 )=n alors la solution est donnée par R 1 x = c nombre de flops (2n 2 m) 3.13 Problèmes aux valeurs propres Problèmes aux valeurs propres Résolution de Ax = λx où λ valeurs propres et x vecteurs propres Polynôme caractéristique : p(λ) = det(a λi) (revient à chercher λ tel que A λi singulière) Soit T non singulière et Ax = λx (T 1 AT )(T 1 x) = λ(t 1 x) A et (T 1 AT ) sont des matrices dites similaires, elles ont mêmes valeurs propres. T : transformation de similarité Problèmes aux valeurs propres On prend T = Q, orthogonale A Q t AQ est très intéressant backward stable avec des transformations de Householder ou Givens Q t AQ similaire à (A + E) avec E u A On cherche donc à déterminer Q tel que valeurs propres de Q t AQ évidentes Exemple A matrice 2 2 de valeurs propres réelles On peut toujours trouver (c, s) tel que : [ ] t [ c s a11 a 12 s c a 21 a 22 ] [ c s s c ] [ λ1 t = 0 λ 2 ] = S λ 1 et λ 2 sont les valeurs propres de A : décomposition de Schur Si y est vecteur propre de S alors x = Qy est vecteur propre de A Sensibilité d une valeur propre aux perturbations fonction de l indépendance de son vecteur propre par rapport aux vecteurs propres des autres valeurs propres 94
Valeurs propres: méthodes itératives Méthode de la puissance avec v 0 pris au hasard v n+1 = Av n / Av n converge vers v tel que Av = λ 1 v ( λ 1 > λ 2... λ n ) Preuve: - si v 0 = α i x i avec (x i ): base de vecteurs propre alors - A k v = A k ( n n α i x i ) = α i λ k i x i = α 1 λ k α j 1(x 1 + ( λ i ) k x i ) α 1 λ 1 - avec ( λi λ 1 ) k 0 i=1 i=2 Shift-and-invert (A µi)v k+1 = v k méthode de la puissance appliquée à (A µi) 1 permet d obtenir la valeur propre la plus proche de µ factorisation (par exemple, LU) de (A µi) à chaque itération: Ly = v k, puis Uv k+1 = y Des améliorations existent pour accélérer la convergence (Lanczos,... ). 3.14 Décomposition en valeurs singulières (SVD) Décomposition en valeurs singulières (SVD) A IR m n, alors il existe U et V matrices orthogonales telles que : A = UΣV t décomposition en valeurs singulières. Remarque: A t A = V Σ 2 V t et AA t = UΣU t U IR m m formée des m vecteurs propres orthonormés associés aux m plus grandes valeurs propres de AA t. V IR n n formée des n vecteurs propres orthonormés associés aux valeurs propres de A t A Σ matrice diagonale constituée des valeurs singulières de A qui sont les racines carrées des valeurs propres de A t A (tq σ 1 σ 2... σ n ). Si A est de rang r < n, alors s r+1 = s r+2 =... = s n = 0. Très utile dans certaines applications lorsque rang(a) pas maximal moindres carrés, valeurs propres détermination précise du rang d une matrice 95
4 Efficient dense linear algebra libraries 4.1 Use of scientific libraries Use of scientific libraries (a) Robustness (b) Efficiency (c) Portability (d) Usable on a wide range of applications (a)+(b)+(c) should be true for all scientific software Robustness: Reliability of the computations (backward stable algorithms) In particular if input is far from an underflow/overflow threshold, the code should not produce underflow/overflow. Efficiency: Good performance No performance degradation for large-scale problems Time for execution should not vary too much for problems of identical size Portability : Code should be written in a standard language Source code can be compiled on an arbitrary machine with an arbitrary compiler execution should be correct (robustness) and efficient Wide range of applications: Can be used on several problems/data structures (example: matrices in BLAS library can be dense, symmetric, packed, band) Use of scientific libraries and parallelism Two main models for parallelism: shared address space (example: multi-processor or multi-core workstation): all processors have access to the same logical memory works like POSIX threads, system maps threads to different cores/processors parallelism can be transparent to the user of the library standards: POSIX thread, OpenMP distributed memory model (example: cluster) each processor has its own memory each processor has a network interface communication and synchronization require message passing standards: PVM, MPI 96
Example: dot product on 2 processors shared memory (dot = 0 initially) thread 1 on proc 1 thread 2 on proc 2 loc s1 = 0 loc s2 = 0 do i = 1, n/2 do i = n/2+1, n loc s1 = loc s1 + x(i) * y(i) loc s2 = loc s2 + x(i) * y(i) enddo enddo lock lock dot = dot + loc s1 dot = dot + loc s2 unlock unlock Result could be wrong problem: dot = dot + loc s is not atomic possible solution: mutual exclusion with locks (critical sections) Dot product on 2 processors Message Passing Suppose that initially: p1 owns x(1:n/2) and y(1:n/2) p2 owns x(n/2+1:n) and y(n/2+1:n) Processor 1: s loc = dot seq ( x(1:n/2), y(1:n/2) ) send s loc to P2 receive s remote from P2 s=s loc + s remote Correctness depends on send/receive protocols asynchronous: ok rendezvous protocol: deadlock Processor 2: s loc = dot seq (x(n/2+1:n), y(n/2+1:n)) send s loc to P1 receive s remote from P1 s=s loc + s remote Calling parallel libraries shared memory parallelism Parallelism (threads) can be created inside the call threads OpenMP standard Can be transparent for the user distributed memory parallelism Each processor executes a program Each processor calls the library function (SPMD) Data distribution must be specified in the API data replicated on the processors, (large mem usage) data only on one (master) processor initially, (bottleneck on master) chunks of data on each processor. There exist other parallel programming models (SIMD or data parallel, BSP, mixed shared-distributed programming,... ) 97
Parallelism and portable libraries Historically: each parallel machine was unique, along with its programming model and programming language For each new type of machine, start development again Now distinguish between programming model from the underlying machine, so we can write portably correct code shared memory: OpenMP directives above threads (loop parallelism,... ) distributed memory: MPI most portable 4.2 Level 1 BLAS and LINPACK Level 1 BLAS and LINPACK First effort to define a standard for basic vector operations used in linear algebra (BLAS, later called BLAS 1) a portable package to solve systems of linear equations (LINPACK) LINPACK/BLAS1 standard was defined in 1979 Goals/motivations: ease the concetpion of numerical codes better readability efficiency: optimized versions or assembler robustness, reliability and portability improved (standardization) Level 1 BLAS used in LINPACK Linpack performance (MFlops) Computer Peak perf Effective perf Efficiency ALLIANT FX/2800 (14 proc) 560 31 0.06 CONVEX C-210 50 17 0.34 CONVEX C-3810 (1 proc) 106 37 0.35 CONVEX C-240 (4 proc) 126 27 0.21 CRAY-XMP-1 235 70 0.28 CRAY-XMP-4 (4 proc) 940 178 0.22 CRAY-2 (4 proc) 1951 129 0.066 CRAY-YMP-1 333 161 0.48 CRAY-YMP-8 (8 proc) 2664 275 0.10 CRAY C-90 (1 proc) 1000 326 0.33 FUJITSU VP 2600/10 5000 249 0.05 HITACHI S-820/80 3000 107 0.036 IBM RS/6000-530 50 13 0.26 IBM RS/6000-550 83 27 0.34 NEC SX-2 1300 43 0.033 NEC SX-3 5500 314 0.06 98
Why performance is small? Memory contention In LINPACK, the main kernel used is: SAXPY : y y + α x SAXPY : 2 loads, multiplication, addition, et store Ratio flops/memory ref = 2/3 Does not allow for an efficient use of memory hierarchy (data are not reused) Objective Increase flops/memory ref ratio How? Re-use several times data that are in scalar/vector registers, in low-level cache definition of higher level BLAS (matrix operations) 4.3 BLAS BLAS library BLAS : Basic Linear Algebra Subprograms 3 levels: BLAS1 : vector-vector operations - complexity O(n) BLAS2 : matrix-vector operations - complexity O(n 2 ) BLAS3 : matrix-matrix operation - complexity O(n 3 ) BLAS performance typical memory operation flop access ratio BLAS1 2 1979 y = αx + y 2n 3n + 1 3 BLAS2 1988 y = αax + βy 2n 2 n 2 + 3n 2 BLAS3 1990 C = αab + βc 2n 3 4n 2 n 2 99
BLAS Benefits The BLAS offer several benefits 1. Robustness: low level details (treatment of exception like overflow are handled by the library). 2. Portability/Efficiency: thanks to the standardization of the API. Machine dependent optimization are left to the vendors/system administrator. Nowadays, available on all scientific computers. 3. Readability: modular description of the mathematical algortithms (Matlab-like). The subroutines are available for the four standard arithmetics 1. single real: prefix S, 2. double real: prefix D, 3. single complex: prefix C, 4. double complex: prefix Z. BLAS 1: quick overview scal x = αx axpy y = αx + y swap y x copy y = x dot dot = x T y nrm2 nrm2 = x 2 min, max search generating and applying plane rotations call DAXPY(N, ALPHA, X, INCX, Y, INCY) BLAS 2: quick overview α, β are scalar, x, y are vectors, A is a general matrix, T is a triangular matrix and H an Hermitian matrix. Matrix-vector product Rank-one and rank-two update y = αax + βy y = αa T x + βy y = αa H x + βy x = T x x = T T x x = T H x A = αxy T + A H = αxx H + H A = αxy t + αyx t + A H = αxy H + ᾱyx H + H Solution of triangular systems x = T 1 x x = T T x x = T H x call DGEMV(TRANS, M, N, ALPHA, A, LDA, X, INCX, BETA, Y, INCY) BLAS 2: naming scheme 1. first character: data type (S, D, C, Z) 2. characters 2 and 3: matrix type GE : general matrix. GB : general band matrix. HE : Hermitian matrix. SY : symmetric matrix. SP : symmetric matrix in packed format. HP : Hermitian matrix in packed format. 100
HB : Hermitian band matrix. SB : symmetric band matrix. TR : triangular matrix. TP : triangular matrix in packed format. TB : triangular band matrix. 3. characters 4 and 5: operation type MV : matrix-vector product y = αax + y. R : rank-one update A = A + αxy T. R2 : rank-two update A = A + αxy T + αyx T. SV : triangular system solution x = T 1 x. BLAS 3: quick overview A, B, C are general matrices and T is a triangular matrix. Matrix-matrix product C = αab + βc C = αab T + βc C = αa T B + βc C = αa T B T + βc Rank-k and 2k updates of a symmetric matrix C = αaa T + βc C = αa T B + αab T + βc C = αa T A + βc C = αab T + αba T + βc Mutiply a matrix by a triangular matrix B = αt B B = αbt B = αt T B B = αbt T Solving triangular systems with multiple right-hand sides B = αt 1 B B = αbt 1 B = αt T B B = αbt T call DGEMM(TRANSA, TRANSB, M, N, K, ALPHA, A, LDA, B, LDB, BETA, C, LDC) BLAS 3: naming scheme 1. first character: data type (S, D, C, Z) 2. characters 2 and 3 : matrix type GE : general matrix. HE : Hermitian matrix. SY : symmetric matrix. TR : triangular matrix. 3. characters 4 and 5 : operation type MM : matrix-matrix product C = αab + βc. RK : rank-k update of a symmetric or Hermitian matrix C = αaa T + βc. R2K : rank-2k update of symmetric or Hermitian matrix C = αab T + αba T + βc SM : solution of a triangular system with multiple right-hand sides B = T 1 B. 101
Performance of the BLAS Today s processors can achieve high performance, but this requires extensive machine-specific hand tuning. Blocking sizes, loop nesting permuta- Routines have a large design space with many parameters: tions, loop unrolling depths,... Complicated interactions with the increasingly sophisticated micro-architectures of modern microprocessors. Need for quick/dynamic deployment of optimized routines. ATLAS - Automatically Tuned Linear Algebra Software. PhiPac from Berkeley. More recent approach: Flame/Goto BLAS from Univ. Texas at Austin Main idea: minimize TLB misses Optimized Blas Optimized Blas Peak performance of the Power 4 : 3.5 GFlops 102
Peak performance of the Itanium 2 : 3.7 GFlops Atlas performance J. Dongarra figures Conclusion on BLAS standard used to design portable and efficient codes optimized BLAS libraries available 103
Computer Prec 1 proc. # procs 1 2 4 8 16 24 BBN TC2000 32 bits 7.8 6.6 13.4 26.2 52.1 98.8 124.4 64 bits 2.7 2.5 4.9 9.7 19.2 37.2 47.0 KSR1 64 bits 27.5 25.4 42.9 81.9 165.4 305.4 418.3 Table 9: Performance in MFlops of GEMM using square matrices of order 512 on BBN TC2000 and KSR1. Never code vector/matrix operations yourself, always rely on optimized kernels parallel BLAS kernels (exploit parallelism inside BLAS routines) Pros: portability + parallelism is hidden to the user Cons: not always the most efficient way to parallelize an application frequent on multicores/multiprocessors with shared memory rare on multiprocessors with virtual shared memory distributed memory: PBLAS and message passing Parallel BLAS performance Exists since a long time Several BLAS libraries (ATLAS, GOTO Blas, vendors BLAS) provide threaded parallelism that can be efficiently exploited on SMP or multi-core architectures 4.4 LU Factorization Factorisation LU Solution of Ax = b factorization P A = LU with P : permutation matrix forward-backward substitution: Ly = P b Ux = y Gaussian elimination: do... do... do... a(i,j) = a(i,j) - a(i,k) * a(k,j) / a(k,k) end do end do end do Order of nested loops 6 alternatives, 3 column-oriented 104
Column-oriented variants KJI- SAXPY (right-looking) do k=1, n-1 do j=k+1, n do i=k+1, n a(i,j) = a(i,j) - a(i,k) * a(k,j) / a(k,k) end do end do end do Note: divisions of the columns by the pivot are omitted. Column-oriented variants JKI- GAXPY (left-looking) do j=2, n do k=1, j-1 do i=k+1, n a(i,j) = a(i,j) - a(i,k) * a(k,j) / a(k,k) end do end do end do Note: divisions of the columns by the pivot are omitted. Column-oriented variants JIK- SDOT do j=2, n do i=2, n do k=1, min(i,j)-1 a(i,j) = a(i,j) - a(i,k) * a(k,j) / a(k,k) end do end do end do Note: divisions of the columns by the pivot are omitted. LU factorization: Crout variant At each step K, build Kth row and Kth column. do K=2, n! build row K (=i) i=k do k=1,k-1 do j=k, n end do end do a(i,j) = a(i,j) - a(i,k) * a(k,j) / a(k,k)! build column K (=j) j=k do k=1, K-1 105
do i=k+1, n a(i,j) = a(i,j) - a(i,k) * a(k,j) / a(k,k) end do end do end do Blocked algorithms (Key to get high performance) A 11 A 12 A 13 A 21 A 22 A 23 A 31 A 32 A 33 = L 11 L 21 L 22 L 31 L 32 L 33 U 11 U 12 U 13 U 22 U 23 U 33. That is equivalent (equating terms with A): A 11 = L 11U 11, A 12 = L 11U 12, A 13 = L 11U 13, A 21 = L 21U 11, A 22 = L 21U 12 + L 22U 22, A 23 = L 21U 13 + L 22U 23, A 31 = L 31U 11, A 32 = L 31U 12 + L 32U 22, A 33 = L 31U 13 + L 32U 23 + L 33U 33. Various variants A 11 = L 11U 11, A 12 = L 11U 12, A 13 = L 11U 13, A 21 = L 21U 11, A 22 = L 21U 12 + L 22U 22, A 23 = L 21U 13 + L 22U 23, A 31 = L 31U 11, A 32 = L 31U 12 + L 32U 22, A 33 = L 31U 13 + L 32U 23 + L 33U 33. Postponing some updates and changing the order in which they are computed, leads to different variants. Left looking Right looking Crout (i,j,k variant) Left looking LU A 11 = L 11U 11, A 12 = L 11U 12, A 13 = L 11U 13, A 21 = L 21U 11, A 22 = L 21U 12 + L 22U 22, A 23 = L 21U 13 + L 22U 23, A 31 = L 31U 11, A 32 = L 31U 12 + L 32U 22, A 33 = L 31U 13 + L 32U 23 + L 33U 33. Step 1: 106
0 @ 2 4 L 11, U 11 L 21 L 31 3 5 = LU 0 @ A 11 A 21 A 31 1 A A 12 A 13 A 22 A 23 A 32 A 33 1 A Step 2: 0 @ L 11 U 12 = L 1 11 A12 A13 L 21 L 31» L22, U 22 L 32 = LU A22 A 32 «L21 L 31 «U 12 «A 23 A 33 1 A Step 3: 0 B B @ L 11 L 21 L 22 U13 U 23 «= L11 L 21 L 22 «1 A13 A 23 «L 31 L 32 [L 33U 33] = LU A 33 ` L 31 L 32 U 13 U 23 ««1 C C A Right-looking LU A 11 = L 11U 11, A 12 = L 11U 12, A 13 = L 11U 13, A 21 = L 21U 11, A 22 = L 21U 12 + L 22U 22, A 23 = L 21U 13 + L 22U 23, A 31 = L 31U 11, A 32 = L 31U 12 + L 32U 22, A 33 = L 31U 13 + L 32U 23 + L 33U 33. Step 1: 107
0 B @ [L 11, U 11 ] = LU (A 11 ) (U 12 U 13 ) = L 1 11 ` A12 A 13 L21 L 31 «= A21 A 31 «U 1 11 A (1) 22 A(1) 23 A (1) 32 A(1) 33! = A22 A 23 A 32 A 33 «L21 L 31 «` U12 U 13 1 C A Right-looking LU Step 2: [L 22, U 22] = LU A (1) 22 U 23 = L 1 22 A(1) 23 L 32 = A 1 32U 1 22 A (2) 33 = A(1) 22 L32U23! Step 3: [L 33, U 33] = LU A (2) 33 Crout LU A 11 = L 11U 11, A 12 = L 11U 12, A 13 = L 11U 13, A 21 = L 21U 11, A 22 = L 21U 12 + L 22U 22, A 23 = L 21U 13 + L 22U 23, A 31 = L 31U 11, A 32 = L 31U 12 + L 32U 22, A 33 = L 31U 13 + L 32U 23 + L 33U 33. Step 1: 0 @ [L 11, U 11] = LU (A 11) ` U12 U 13 = L 1 11 ` A12 A 13 L21 L 31 «= A21 A 31 «U 1 11 A 22 A 23 A 32 A 33 1 A Crout LU Step 2: 108
( ( ) A (1/2) 22 A (1/2) 23 = (A 22 A 23 ) L 21 (U 12 U 13 ) A (1/2) 32 = A 32 L 31 U 12 A 33 ( [ ] ( ) L22, U 22 A (1/2) = LU 22 L 32 A (1/2) 32 ) U 23 = L 1 22 A(1/2) 23 A 33 ) Crout LU Step 3: ( ( A (1/2) U13 33 = A 33 (L 31 L 32 ) U 23 )) [L 33 U 33 ] = LU(A (1/2) 33 ) Performance of blocked algorithms n 100 500 1000 1500 F77 loops 0.0240 2.87 30.19 105.82 BLAS 1 0.0057 0.40 11.97 44.81 BLAS 3 0.0021 0.18 1.42 4.68 Elapsed time (seconds) of Cholesky factorization on SGI O2K n 3 growth for the Fortran loops (Cholesky complexity n3 3 flops). Use of BLAS 3 in LU factorization All these block algorithms can be expressed using BLAS 3 kernels Example: LU right-looking (KJI-SAXPY): Lk Uk At each step: Bk Ck 1. Unblocked (pivoting) factorization of B k 2. Compute row block U k : TRSM 3. Update submatrix C k : GEMM All variants same number of flops Different memory access Efficiency depends on relative BLAS 3 efficiency 109
BLAS 3 operations (n=500, nb=64) for LU variants Variant Routine % Operations % Time Avg. MFlops Left-Looking DGEMM 49 32 438 DTRSM 41 45 268 unblock LU 10 20 146 Right-Looking DGEMM 82 56 414 DTRSM 8 23 105 unblock LU 10 19 151 Crout DGEMM 82 57 438 DTRSM 8 24 105 unblock LU 10 16 189 Other block algorithms Most of the linear algebra algorithms can be recasted in block variants: Linear systems Symmetric positive definite (LL T ), symmetric indefinite (LDL T ). Eigensolvers Linear least-squares QR decomposition based on Householder transformations. Example of performance with parallel BLAS Speed-up on 8 processors vs. 1 processor with 1000x1000 matrices, CRAY YMP. Factorisation LU : 6.1 Factorisation Cholesky : 6.2 Factorisation LDL T : 5.3 Factorisation QR : 6.8 4.5 LAPACK LAPACK: Linear Algebra PACKage Scientific library developed in Fortran 77 intensively using BLAS 3 routines (600 000 lines of code). Supersedes LINPACK (Ax = b) and EISPACK (Ax = λx) Scope: linear equations, linear least-squares, standard eigenvalue and singular value problems, generalized eigenvalue problems. Components: driver routines: solve the complete problem (e.g. solve a linear sytem); expert routines: similar to driver but provides the users with more numerical information (e.g. estimate condition number of a matrix, only compute a subset of eigenpairs, etc.) computational routines: that perform a distinct computational task (e.g. LU or QR factorization). 110
The LAPACK library Good numerical robustness (rely on clean IEEE arithmetic) First public release: 1991. Available on netlib Latest release: 3.1.1, February 2007 Main credits: Cray research, Univ. Kentucky, Univ. of Tennessee, Courant Institute, NAG Ltd, Rice Univ., Argonne Nat. Lab., Oak Ridge Nat. Lab. Parallel implementation on shared memory/multicores inherited from parallel BLAS (efficiency limited on large numbers of processors/cores) Parallel implementation on shared memory/multicores inherited from parallel BLAS (efficiency limited on large numbers of processors) Evolution for distributed memory multiprocessors: ScaLAPACK Case Study: Cholesky Factorization on multicores 111
(slides from Alfredo Buttari, Jack Dongarra, Jakub Kurzak and Julien Langou) Parallelism in LAPACK: Cholesky factorization DPOTF2: BLAS-2 non-blocked factorization of the panel DTRSM: BLAS-3 T updates U=L by applying the transformation computed in DPOTF2 DGEMM (DSYRK): BLAS-3 updates trailing submatrix Parallelism in LAPACK: Cholesky factorization BLAS2 operations cannot be efficiently parallelized because they are bandwidth bound. strict synchronizations poor parallelism poor scalability 112
4.6 Linear algebra for distributed memory architectures Linear algebra for distributed memory architectures Difficulties: Distribute data on the processors Define enough parallel tasks but not too many Explicit message passing between processors Example: LU factorization Suppose that Each processor holds part of the matrix Each processor performs the update operations on its part Which data distribution should be used? Data distribution for dense matrices 1D 0 1 0 1 0 1 0 1 2D 2 3 2 3 2 3 2 3 0 1 0 1 0 1 0 1 1 2 3 4 1 2 3 4 2 3 2 3 2 3 2 3 0 1 0 1 0 1 0 1 2 3 2 3 2 3 2 3 0 1 0 1 0 1 0 1 2 3 2 3 2 3 2 3 block-cyclic block-cyclic Main reasons for 2D block-cyclic: 1. good load balance, minimize communication, 2. use of BLAS 3 on each processor. Need to communicate blocks of matrices between processors: BLACS 4.7 BLACS (Basic Linear Algebra Communication Subprograms) BLACS (Basic Linear Algebra Communication Subprograms) (User s Guide, J. J. Dongarra, R. C. Whaley) Set of communication routines to imlpement linear algebra algorithms on distributed memory architectures Portable available on top of MPI or PVM, on CMMD (Thinking Machine), MPL (IBM SPx), NX (Intel),... SPMD model 113
Main concept: communication based on 2D arrays: MxN rectangular matrices trapezoidal matrices UPLO M <= N M > N U n m m n+1 n m n m+1 n m+1 L m n m m n+1 n Processes organized in a 2D grid: P Q such that P Q = N number of processes Processes identified by their row/column indices Example: 8 processes in a 2x4 grid 0 1 2 3 0 1 0 1 2 4 5 6 3 7 Building a grid: BLACS GRIDINIT BLACS GRIDMAP Termination: grid: BLACS GRIDEXIT blacs: BLACS EXIT BLACS: communication routines send/receive broadcast Naming: character 1: type of data (S,D,C,Z,I) characters 2+3 : data structure GE : general matrix TR : trapeze matrix (upper, lower, unit or not) characters 5 and 6: function SD : send RV : receive BS : broadcast BR : broadcast (receiver side) 114
Examples send trapezoidal matrix: TRSD2D(ICONTXT, M, N, A, LDA, RDEST, CDEST) receive general (rectangular) matrix: GERV2D(ICONTXT, M, N, A, LDA, LDA, RSRC, CSRC) broadcast general matrix: GEBS2D(ICONTXT,SCOPE, TOP,M, N, A, LDA) broadcast reception: GEBR2D(ICONTXT, SCOPE, TOP, M, N, LDA, RSRC, CSRC) Parameters ICONTXT: context (identifies the grid of processes) SCOPE: one process, complete row, complete column or all processes TOP: network topology emulated M : nombre de lignes de A N : nombre de colonnes de A A : matrice à envoyer A( LDA, * ) RSRC: row of sender/receiver CSRC: column of sender/receiver Global operators GAMX : maximum GAMN : minimum GSUM : summation 4.8 PBLAS : parallel BLAS for distributed memory machines PBLAS : parallel BLAS (LAPACK Working note 100, Choi, Dongarra, Ostrouchov, Petitet, Walker, and Whaley) Parallel operations based on BLAS 1 + 2 + 3, on top of sequential BLAS (similar interface) Based on BLACS Computations: BLAS / communications: BLACS 2D cyclic data distribution good scalability/load balance Used to develop (part of) ScaLAPACK PBLAS : subset of BLAS (no operations on band or packed matrices), some extra operations (matrix transpose) level 1 PBLAS: largest element of a vector 115
x y x t y x αx x 2 y x re(x) 1 + im(x) 1 y αx + y level 2 PBLAS: matrix-vector multiplication rank 1 updates multiplication by a triangular matrix triangular system solving Level 3 PBLAS: matrix-matrix multiplication rank k and rank 2k updates multiplication of a matrix by triangular matrix solution of triangular systems matrix transpose (C βc + αa t ) Storage, intialization of distributed matrices Let A : M N with M = N = 5 partitioned in 2x2 blocks a11 a12 a13 a14 a15 a21 a22 a23 a24 a25 a31 a32 a33 a34 a35 a41 a42 a43 a44 a45 a51 a52 a53 a54 a55 On a 2 by 2 grid of processors: 0 1 0 ------------------------------------------ a11 a12 a13 a14 a ------------------------------------------ a31 a32 a33 a34 a35 1 a41 a42 a43 a44 a45 ------------------------------------------ 0 a51 a52 a53 a54 a55 Proc 0,0 :a11, a21, a51, a12, a22, a52, a15, a25, a55 (3x3) Proc 0,1 :a13, a23, a53, a14, a24, a54 (3x2)... Redistribution routines exist Array descriptor Integer array of length 9 DESC() Name Scope Definition 1 DTYPE A Global Descriptor type DTYPE A=1 for dense matrices. 2 CTXT A Global BLACS context indicating the BLACS process grid over which the global matrix is distributed. 3 M A Global Number of rows in the global array A. 4 N A Global Number of columns in the global array A. 5 MB A Global Blocking factor used to distribute the rows of the array. 6 NB A Global Blocking factor used to distribute the columns of the array. 7 RSRC A Global Process row over which the first row of the array A is distributed. 8 CSRC A Global Process row over which the first column of the array A is distributed. 9 LLD A Local Leading dimension of the local array. 116
Example of PBLAS call BLAS call CALL DGEMM (TRANSA, TRANSB, M, N, K, ALPHA, $ A(IA,JA), LDA, B(IB,JB), LDB, $ BETA,C(IC,JC), LDC) PBLAS call CALL PDGEMM (TRANSA, TRANSB, M, N, K, ALPHA, $ A, IA, JA, DESCA, B, IB, JB, DESCB, $ BETA, C, IC, JC, DESC) 4.9 ScaLAPACK ScaLAPACK Software Hierarchy Goal: reuse most of the existing dense linear algebra software. 117
ScaLAPACK PBLAS Global Local LAPACK BLACS BLAS Message passing library (MPI,PVM,...) ScaLAPACK : Right-looking LU Factorization Conversion of LAPACK codes Sequential LU: 1. Factor a column block (I AMAX, SWAP, GER) 2. Pivot on the rest of the matrix ( SWAP) 3. Update the submatrix ( TRSM suivi de GEMM) Parallel Implementation with PBLAS : 1. Factor a column block (P AMAX, P SWAP, P GER) 2. Pivot on the rest of the matrix (P SWAP) 3. Update the submatrix (P TRSM suivi de P GEMM) 118
119
120
ScaLapack: out-of-core algorithms Based on left-looking variants of LU, QR and Cholesky Same as cache, but much higher latency + smaller bandwidth QR easier than LU (no pivoting, more flops) Performance models for ScaLAPACK Communication: volume= C v N 2, no of msgs = C m N/NB flops: C f T (N, P ) = C f N 3 P t f + C vn 2 P t v + C mn NB t m (t f : avg. time for a flop, t m : latency, t 1 v : bandwidth) 4.10 Recursive algorithms Recursive algorithms Example 1: LU factorization 1. Split matrix A into two rectangles m x n/2 If only 1 column divide column by pivot and return 2. Apply LU algorithm to the left part: A 11 = LU with updated A 21 121
3. Apply transformations to the right part (triangular solve A 12 = L 1 A 12 and matrix multiplication A 22 = A 22 A 21 A 12 ) 4. Apply LU algorithm to the right (square) part Matrices with n/2, n/4, n/8... columns Example 2: Matrix-matrix multiplication: AB = «««A11 A 12 B11 B 12 A11 B = 11 + A 12 B 21 A 21 B 11 + A 22 B 21 A 21 A 22 B 21 B 22 A 11 B 12 + A 12 B 22 A 21 B 12 + A 22 B 22 with recursive blocking for each matrix-matrix multiplication. Recursive algorithms automatic adaptation to cache size (at all levels) easier to tune and often very efficient compared to classical approaches can exploit recursive data layouts Z or U storage for unsymmetric matrices recursive packed storage possible for symmetric matrices (Cholesky factorization,... ) Conclusion Standards have been defined for most useful linear algebra operations One should not try to write his/her own routine Efficient sequential and parallel implementations available: Shared memory architectures Distributed memory architectures But... a higher degree of parallelism is now needed (multicores, thousands of processors) 122
123
Parallelism in Linear Algebra software so far Shared Memory Distributed Memory LAPACK ScaLAPACK parallelism Threaded BLAS PBLAS PThreads OpenMP BLACS + MPI Parallelism in Linear Algebra software so far parallelism Shared Memory LAPACK Distributed Memory ScaLAPACK Threaded BLAS PBLAS PThreads OpenMP 124 BLACS + MPI