Calcul Réparti et Grid Computing

Dimension: px
Commencer à balayer dès la page:

Download "Calcul Réparti et Grid Computing"

Transcription

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

16 Calculateur procs LINPACK LINPACK Perf. n = 100 n = 1000 crête Intel WoodCrest (1 core, 3GHz) HP ProLiant (1 core, 3.8GHz) HP ProLiant (1 core, 3.8GHz) IBM eserver(1.9ghz, Power5) IBM eserver(1.9ghz, Power5) Fujitsu Intel Xeon (3.2GHz) Fujitsu Intel Xeon (3.2GHz) SGI Altix (1.5GHz Itanium2) NEC SX-8 (2 GHz) Cray T (1 proc.) Hitachi S-3800/ (1 proc.) Table: Performance (MFlop/s) sur la résolution d un système d équations linéaires (d après LINPACK Benchmark Dongarra [07]) 16 / 396

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

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

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

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

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

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

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

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

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

26 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) / 396

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

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

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

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

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

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

33 Année Calculateur MFlop/s CDC CDC IBM 370/195 ILLIAC IV CRAY-1, XMP, CRAY CDC CYBER 205 FUJITSU VP400 NEC SX CRAY-YMP, C ,000 ETA-10 NEC SX-3 FUJITSU VP CRAY T3E 1.2 TFlop/s INTEL 1.8 TFlop/s IBM SP 16 TFlop/s HP 20 TFlop/s NEC 40 TFlop/s IBM Blue Gene 180 TFlop/s Roadrunner 1 PFlop/s Table: Evolutions des performances par décennie

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

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

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

37 Size Average access time (# cycles) hit/miss Registers < KB Cache level #1 1 2 / KB 16 MB Cache level # / GB Main memory Remote memory Disks 700,000 / 6,000,000 Figure: Exemple de hiérarchie mémoire. 37 / 396

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

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

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

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

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

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

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

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

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

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

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

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

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

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

52 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, / 396

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

77 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 / 396

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

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

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

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

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

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

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

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

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

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

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

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

90 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) cycles per iteration Cost of calculation = 2400 cycles Effective performance : = 42% of peak Performance limited by balance between int. and float. instr. 90 / 396

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

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

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

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

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

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

97 45 Performance of y = At x on HP 715/ Rolled Unrolled 2 Unrolled 4 Unrolled 8 30 MFlops Size Figure: Effect of loop unrolling on HP 715/64 97 / 396

98 50 Performance of y = At x on CRAY T3D Rolled Unrolled 2 Unrolled 4 Unrolled 8 MFlops Size Figure: Effect of loop unrolling on CRAY T3D 98 / 396

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

100 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

115 Tmiss %hits Tps hits Tps misses Ttotal Perf. 100% % 10 99% % 20 99% % 10 95% % 20 95% % Table: Effet des défauts de cache sur la performance d un code (exprimés en pourcentages vs pas de défaut de cache). 115 / 396

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

136 A B C D E F G H I J K L Réseau Omega / 396

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

138 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, SGI / 396

139 Figure: 4-Cube in space. 139 / 396

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

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

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

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

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

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

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

147 Evolution des performances (RMAX) 147 / 396

148 Top 5 (Juin 2013) 148 / 396

149 Distribution géographique 149 / 396

150 Répartition par segment d activité 150 / 396

151 Statistiques constructeurs 151 / 396

152 Analyse des familles de processeurs 152 / 396

153 Analyse des familles de processeurs 153 / 396

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

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

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

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

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

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

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

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

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

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

164 Figure: Comparaison de la performance de noyaux de calcul en algèbre Utilisation d une bibliothèque optimisée Noyaux de calcul matricexmatrice optimisés existent : ATLAS - Automatic Tuned Linear Algebra Software. Goto from Univ. Texas at Austin

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

194 Communications asynchrones et performance Temps pour la factorisation LU (Matrice creuse d ordre avec 7Mega entrées, 8 procs d un Cray T3E): MPI buffer size (bytes) type de réception K 4K 64K 512K 2Mega standard asynchrone Valeur par défaut sur le Cray T3E. 194 / 396

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

281 Table: A very optimistic table Number of processors p f / 396

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

283 Exemples d outils pour l analyse de performances 283 / 396

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

285 Exemple de fichier profile obtenu : % cumulative self self total time seconds seconds calls ms/call ms/call name _matmul_ [3] _matsum_ [4] _MAIN [1] _matvec_ [5] / 396

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

287 Analyse automatiques de la performance et des cache-hits sur CRAY T3D (code de mécanique des fluides): secs Mflops data caches time PVMFRECV:11400 gradvelo: % infl3dc : % gradvel : % grad3d : % nufl3dc : % PVMFSEND: 635 SQRT : 320 vsfl3dc : % ns3dc : % implrssm: % edvialg : % shearstr: % dtvis3dc: % updpct : % heatflpg: % EXP : 53.7 Total code: secs 969 ( 6.07%) work 2514 (15.76%) loading instructions and data cache (75.59%) waiting on PVM communication 411 ( 2.58%) uninstrumented functions 287 / 396

288 Analyse de performance des boucles Traces obtenues sur CONVEX analyse beaucoup plus fine. Première partie: analyse du temps Optimization Times teration Count CPU Time Line NL Report Exec Min Max Avg (less inner loops) SM SM SM / 396

289 Deuxième partie: analyse du comportement. On peut par exemple calculer le rapport Nb flops sur Nb ref mémoire (i.e. Vector flops / Chime count). Static Profile Estimated Mflops Vector Vector Chime (less inner loops) (plus inner loops) Line NL Spills Flops Count Avg Peak Avg Peak / 396

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

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

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

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

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

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

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

Plan : Master IM2P2 - Calcul Scientifique

Plan : Master IM2P2 - Calcul Scientifique Plan : Les systèmes HPC Typologie des systèmes : Machines Mémoire partagée Machines à Mémoire Distribuées Machine NUMA Exemples Architectures Processeurs HPC Processeurs scalaires, superscalaires, vectoriels

Plus en détail

Outline. Calcul Réparti et Grid Computing. Outline

Outline. Calcul Réparti et Grid Computing. Outline Outline Calcul Réparti et Grid Computing Patrick Amestoy et Michel Daydé (ENSEEIHT-IRIT) préparé en collaboration avec J.-Y. L Excellent (INRIA/LIP-ENS Lyon) 2008-2009 Introduction Introduction aux calculateurs

Plus en détail

Calculateurs Haute Performance: concepts

Calculateurs Haute Performance: concepts Calculateurs Haute Performance: concepts généraux Calculateurs haute-performance: concepts généraux Introduction Organisation des processeurs Organisation mémoire Organisation interne et performance des

Plus en détail

Initiation au HPC - Généralités

Initiation au HPC - Généralités Initiation au HPC - Généralités Éric Ramat et Julien Dehos Université du Littoral Côte d Opale M2 Informatique 2 septembre 2015 Éric Ramat et Julien Dehos Initiation au HPC - Généralités 1/49 Plan du cours

Plus en détail

High Performance Matrix Computations

High Performance Matrix Computations 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)

Plus en détail

Design, améliorations, et implémentations

Design, améliorations, et implémentations CPU et Mémoire Design, améliorations, et implémentations Techniques et caractéristiques modernes qui permettent de donner aux ordinateurs actuels toute leur puissance 1 Architectures CPU Design de l architecture

Plus en détail

Systèmes et traitement parallèles

Systèmes et traitement parallèles Systèmes et traitement parallèles Mohsine Eleuldj Département Génie Informatique, EMI eleuldj@emi.ac.ma 1 Système et traitement parallèle Objectif Etude des architectures parallèles Programmation des applications

Plus en détail

Parallélisation Automatique

Parallélisation Automatique Parallélisation Automatique Paul Feautrier ENS de Lyon Paul.Feautrier@ens-lyon.fr 8 septembre 2008 1 / 23 Pourquoi la parallélisation automatique? Les gains de performances dus à la technologie s amenuisent

Plus en détail

Multi-processeurs, multi-cœurs, cohérence mémoire et cache

Multi-processeurs, multi-cœurs, cohérence mémoire et cache Multi-processeurs, multi-cœurs, cohérence mémoire et cache Intervenant : Thomas Robert Institut Mines-Télécom Parallélisme inter instructions n Exécution : une séquence d instructions appliquées à un 1

Plus en détail

Matériel : comment gagner en performance? Objectif Teraflop. les limites :

Matériel : comment gagner en performance? Objectif Teraflop. les limites : Matériel : comment gagner en performance? réduction du temps de cycle (aujourd hui de 0,6 à 2 ns) instructions vectorielles et pipelinées plusieurs unités fonctionnelles hiérarchie de mémoire multiprocesseurs

Plus en détail

Les Microprocesseurs partie2

Les Microprocesseurs partie2 Université Constantine 2 Abdelhamid Mehri Faculté des NTIC Département MI Electronique des Composants & Systèmes Les Microprocesseurs partie2 Cours de L1 - TRONC COMMUN DOMAINE MATHEMATIQUES INFORMATIQUE

Plus en détail

Architecture des ordinateurs

Architecture des ordinateurs Décoder la relation entre l architecture et les applications Violaine Louvet, Institut Camille Jordan CNRS & Université Lyon 1 Ecole «Découverte du Calcul» 2013 1 / 61 Simulation numérique... Physique

Plus en détail

Types et performances des processeurs

Types et performances des processeurs Types et performances des processeurs Laboratoire de Systèmes Logiques Structure d un ordinateur contrôle processeur traitement séquenceur registres mémoire entrées/sorties micromémoire opérateurs bus

Plus en détail

Informatique générale - processeurs

Informatique générale - processeurs Université de Nice Sophia Antipolis Licence 1 Sciences Fondamentales Informatique Générale Processeurs Jacques Farré (d'après Fabrice Huet, Wikipedia... et bien d'autres) Jacques.Farre@unice.fr http://deptinfo.unice.fr/~jf/infogene

Plus en détail

Eléments d architecture des. machines parallèles et distribuées. Notions d architecture de. machines parallèles et distribuées

Eléments d architecture des. machines parallèles et distribuées. Notions d architecture de. machines parallèles et distribuées M2-ILC Parallélisme, systèmes distribués et grille Eléments d architecture des Stéphane Vialle Stephane.Vialle@centralesupelec.fr http://www.metz.supelec.fr/~vialle 2 Depuis 24 les CPU sont multi-cœurs

Plus en détail

Analyse et mesure de performances du calcul distribué

Analyse et mesure de performances du calcul distribué Analyse et mesure de performances du calcul distribué Mohsine Eleuldj Département Génie Informatique, EMI eleuldj@emi.ac.ma CruCID Workshop, EMI, Rabat, 5 au 7 juillet 1999 Motivation Types d applications

Plus en détail

Eléments d architecture des machines parallèles et distribuées

Eléments d architecture des machines parallèles et distribuées M2-RISE - Systèmes distribués et grille Eléments d architecture des machines parallèles et distribuées Stéphane Vialle Stephane.Vialle@supelec.fr http://www.metz.supelec.fr/~vialle Notions d architecture

Plus en détail

Chap. 2 - Structure d un ordinateur

Chap. 2 - Structure d un ordinateur Architecture des ordinateurs Michèle Courant S2-27 octobre 2004 Chap. 2 - Structure d un ordinateur 2.1 Processeur ou unité centrale (CPU) 2.1.1 Organisation du CPU 2.1.2 Exécution d une instruction 2.1.3

Plus en détail

Stockage et mémoire, Du principe vers la réalité

Stockage et mémoire, Du principe vers la réalité Stockage et mémoire, Du principe vers la réalité Responsable :Thomas Robert C234-4 thomas.robert@telecom-paristech.fr Intervenants :Tamy Boubekeur, Guillaume Duc, Gérard Mouret, Thomas Robert Institut

Plus en détail

Formation en Calcul Scientifique - LIEM2I

Formation en Calcul Scientifique - LIEM2I Formation en Calcul Scientifique - LIEM2I Introduction au calcul parallèle Loïc Gouarin, Violaine Louvet, Laurent Series Groupe Calcul CNRS 9-13 avril 2012 Loïc Gouarin, Violaine Louvet, Laurent Series

Plus en détail

Eléments d architecture des machines parallèles et distribuées

Eléments d architecture des machines parallèles et distribuées Mineure HPC-SBD Eléments d architecture des machines parallèles et distribuées Stéphane Vialle Stephane.Vialle@centralesupelec.fr http://www.metz.supelec.fr/~vialle Notions d architecture de machines parallèles

Plus en détail

INF6500 : Structures des ordinateurs. Sylvain Martel - INF6500 1

INF6500 : Structures des ordinateurs. Sylvain Martel - INF6500 1 INF6500 : Structures des ordinateurs Sylvain Martel - INF6500 1 Cours 4 : Multiprocesseurs Sylvain Martel - INF6500 2 Multiprocesseurs Type SISD SIMD MIMD Communication Shared memory Message-passing Groupe

Plus en détail

Stockage : capacité, performances

Stockage : capacité, performances Stockage : capacité, performances Intervenant :Thomas Robert C234-4 thomas.robert@telecom-paristech.fr Transparents : Thomas Robert Institut Mines-Télécom Lectures possibles Chapitre 7.2 de : http://ceit.aut.ac.ir/~amirkhani/

Plus en détail

Architecture des ordinateurs, concepts du parallélisme

Architecture des ordinateurs, concepts du parallélisme Ecole Doctorale MathIf Architecture des ordinateurs, concepts du parallélisme Violaine Louvet 1 Remerciements à Françoise Roch, Guy Moebs, Françoise Berthoud 1 ICJ - CNRS Année 2009-2010 Objectifs de ce

Plus en détail

Architecture des calculateurs

Architecture des calculateurs Architecture des calculateurs Violaine Louvet 1 1 Institut Camille jordan - CNRS Ecole Doctorale 2012-2013 Sommaire 1 Architecture générale Processeur Mémoire Réseaux Stockage 2 Tendances Evolutions technologiques

Plus en détail

Architecture des calculateurs

Architecture des calculateurs Chapitre 1 Architecture des calculateurs 1.1 Introduction Ce paragraphe n a pas la prétention de présenter un cours d informatique. D une manière générale, seuls les caractéristiques architecturales qui

Plus en détail

Introduction aux systèmes informatiques Structure d un ordinateur

Introduction aux systèmes informatiques Structure d un ordinateur Introduction aux systèmes informatiques Structure d un ordinateur Michel Salomon IUT de Belfort-Montbéliard Département d informatique Michel Salomon Intro. aux sys. info. 1 / 36 Qu est-ce qu un système

Plus en détail

Multi-processeurs, multi-cœurs et cohérence mémoire et cache

Multi-processeurs, multi-cœurs et cohérence mémoire et cache Multi-processeurs, multi-cœurs et cohérence mémoire et cache Intervenant : Thomas Robert Institut Mines-Télécom Rappel système d exploitation & Parallélisme L unité d exécution pour un système d exploitation

Plus en détail

Architectures Parallèles

Architectures Parallèles Architectures Parallèles Cours pour Ingénieur Préparé par Dr. Olfa Hamdi-Larbi ola_ola79@yahoo.fr Reçoit les signaux du contrôleur, cherche les données et les traite Instructions, Données à traiter et

Plus en détail

Evolution des technologies de calcul intensif vers les systèmes multi-cœurs et accélérateurs

Evolution des technologies de calcul intensif vers les systèmes multi-cœurs et accélérateurs Evolution des technologies de calcul intensif vers les systèmes multi-cœurs et accélérateurs Marc Mendez-Bermond Expert solutions HPC Programme Contexte Technologies Evolutions 2 Confidentiel Research

Plus en détail

Architecture des ordinateurs

Architecture des ordinateurs Ecole d Automne «Informatique Scientifique pour le Calcul» Architecture des ordinateurs Françoise Berthoud 1 Violaine Louvet 2 Françoise Roch 3 1 Laboratoire de Physique et de Modélisation des Milieux

Plus en détail

Les systèmes embarqués

Les systèmes embarqués Unité IFS (Interface) Les systèmes embarqués Architecture des systèmes à processeur Etienne Messerli Le 17 février 2015 p 1 Ordinateur Système UNIVERSEL de traitement de l'information "binaire" Utilisé

Plus en détail

Tous les processeurs sont connectés à une large mémoire partagée. Difficulté de s étendre à de grands nombres de processeurs

Tous les processeurs sont connectés à une large mémoire partagée. Difficulté de s étendre à de grands nombres de processeurs Modèle de Machine 1a: Mém. Partagée Tous les processeurs sont connectés à une large partagée. Appelée Symmetric Multiprocessors (SMPs) SMPs de Sun, HP, Intel, IBM Puces Multicoeur, exceptées celles qui

Plus en détail

! Vous aurez pris connaissance de l'évolution. ! Vous comprendrez pourquoi on utilise le binaire en. ! Vous serez capable de construire un circuit

! Vous aurez pris connaissance de l'évolution. ! Vous comprendrez pourquoi on utilise le binaire en. ! Vous serez capable de construire un circuit Architecture élémentaire Un cours d architecture pour des informaticiens Samy Meftali Samy.meftali@lifl.fr Bureau 224. Bâtiment M3 extension Sans architecture pas d informatique Comprendre comment çà marche

Plus en détail

Génération de code binaire pour application multimedia : une approche au vol

Génération de code binaire pour application multimedia : une approche au vol Génération de binaire pour application multimedia : une approche au vol http://hpbcg.org/ Henri-Pierre Charles Université de Versailles Saint-Quentin en Yvelines 3 Octobre 2009 Présentation Présentation

Plus en détail

Architecture des ordinateurs. Optimisation : pipeline. Pipeline (I) Pipeline (II) Exemple simplifié : Instructions de type R

Architecture des ordinateurs. Optimisation : pipeline. Pipeline (I) Pipeline (II) Exemple simplifié : Instructions de type R Architecture des ordinateurs Licence Informatique - Université de Provence Jean-Marc Talbot Optimisation : pipeline jtalbot@cmi.univ-mrs.fr L3 Informatique - Université de Provence () Architecture des

Plus en détail

CPU ou UCT. Circuit Intégré. Processor (data processing)

CPU ou UCT. Circuit Intégré. Processor (data processing) CPU ou UCT Processor (data processing) Le processeur est une unité d exécution, plus précisément appelée unité centrale de traitement (désignée en franç.par UCT, en ang. CPU (Central Processing Unit) CPU+mémoire

Plus en détail

Parallélisme. Cours 1

Parallélisme. Cours 1 Parallélisme Cours 1 TD : 20% - TP : 30% - Examen : 50% Feuille A4 manuscrite (pas de photocopie) Fabrice.Huet@etu.unice.fr (prendre rdv par mail pr le contacter) A quoi sert le parallélisme? Augmenter

Plus en détail

Résultats des benchmarks de HPC1 après ajout de 100 cœurs. Date : 06/09/2012. Auteur : Ph Parnaudeau

Résultats des benchmarks de HPC1 après ajout de 100 cœurs. Date : 06/09/2012. Auteur : Ph Parnaudeau Résultats des benchmarks de HPC1 après ajout de 1 cœurs. Date : 6/9/212 Auteur : Ph Parnaudeau 1. Evolution de la configuration la plate forme de calcul du LJLL : HPC1 HPC1 1 Février 211 : UV1 est une

Plus en détail

3A-IIC - Parallélisme & Grid : Intérêts et Motivations. Intérêts et Motivations

3A-IIC - Parallélisme & Grid : Intérêts et Motivations. Intérêts et Motivations 3A-IIC - Parallélisme & Grid : Stéphane Vialle Stephane.Vialle@supelec.fr http://www.metz.supelec.fr/~vialle 1 1 Exemple d applications et clients Défis du calcul parallèle 3 Calcul parallèle dans le monde

Plus en détail

Chap. I : Architecture de base d un ordinateur

Chap. I : Architecture de base d un ordinateur UMR 7030 - Université Paris 13 - Institut Galilée Cours Architecture et Système Dans cette partie, nous décrivons rapidement l architecture de base d un ordinateur et les principes de son fonctionnement.

Plus en détail

Comment concevoir un ordinateur? Quelques questions à considérer

Comment concevoir un ordinateur? Quelques questions à considérer Comment concevoir un ordinateur? Quelques questions à considérer Unité d entrée Unité de traitement Unité de sortie Comment coder les données Entiers, réels, caractères Comment restituer les résultats

Plus en détail

Cours Parallélisme. I. Parallélismes Jean-Louis Pazat. Plan. Introduction Parallélisme d'expression Applications Parallélisme d'exécution

Cours Parallélisme. I. Parallélismes Jean-Louis Pazat. Plan. Introduction Parallélisme d'expression Applications Parallélisme d'exécution Cours Parallélisme I. Parallélismes Jean-Louis Pazat Plan 2 Introduction Parallélisme d'expression Applications Parallélisme d'exécution Architecture de machines Influence sur l'expression du parallélisme

Plus en détail

LES SUPER-ORDINATEURS

LES SUPER-ORDINATEURS LES SUPER-ORDINATEURS Un ordinateur fait au bas mot 1 million d'opérations à la seconde, mais il a que ça à penser, aussi. - J.M. Gourio "Brèves de comptoir 1988" CRAY 1 1 Mesure des performances La mesure

Plus en détail

Windows Server 2008. Chapitre 1: Découvrir Windows Server 2008

Windows Server 2008. Chapitre 1: Découvrir Windows Server 2008 Windows Server 2008 Chapitre 1: Découvrir Windows Server 2008 Objectives Identifier les caractéristiques de chaque édition de Windows Server 2008 Identifier les caractéristiques généraux de Windows Server

Plus en détail

ARCHITECTURES A PASSAGE DE MESSAGES

ARCHITECTURES A PASSAGE DE MESSAGES ARCHITECTURES A PASSAGE DE MESSAGES Daniel Etiemble LRI, Université Paris Sud de@lri.fr D. Etiemble 1 Architecture parallèle à passage de messages RESEAU D INTERCONNEXION réseau réseau réseau réseau CPU

Plus en détail

Architecture et Système

Architecture et Système Architecture et Système Stefan Schwoon Cours L3, 2014/15, ENS Cachan Rappels Quelques éléments qu on a pu construire à partir des transistors (et une horloge): fonctions arithmétiques et logiques multiplexeur,

Plus en détail

Architecture des calculateurs

Architecture des calculateurs Formation en Calcul Scientifique - LEM2I Architecture des calculateurs Violaine Louvet 1 1 Institut Camille jordan - CNRS 12-13/09/2011 Introduction Décoder la relation entre l architecture et les applications

Plus en détail

Rappels, SISD, SIMD. Calculateurs hybrides (GPU-OpenCL) Rappels, MIMD mémoire partagée. Rappels, MIMD mémoire partagée. Rappels... SISD,...

Rappels, SISD, SIMD. Calculateurs hybrides (GPU-OpenCL) Rappels, MIMD mémoire partagée. Rappels, MIMD mémoire partagée. Rappels... SISD,... Rappels, SISD, SIMD Calculateurs hybrides (GPU-OpenCL) Rappels... SISD,... SIMD Formation d Ingénieurs de l Institut Galiléee MACS 3 Philippe d Anfray Philippe.d-Anfray@cea.fr CEA DSM 2013-2014 SISD :

Plus en détail

GEL 1001 Design I (méthodologie)

GEL 1001 Design I (méthodologie) GEL 1001 Design I (méthodologie) Technique 2 Systèmes embarqués et fiabilité Hiver 2013 Département de génie électrique et de génie informatique Plan Système embarqué Ordinateur et architecture Von Neumann

Plus en détail

Mémoire principale. Von Neumann vs. Harvard. Terminologie. Architecture et technologie des ordinateurs II. G. Tempesti Semaine VIII 1 CPU.

Mémoire principale. Von Neumann vs. Harvard. Terminologie. Architecture et technologie des ordinateurs II. G. Tempesti Semaine VIII 1 CPU. principale Structure Fonctionnement Accès MÉMOIRE PRINCIPALE BUS SYSTÈME DD Instructions MMU TLB Unité de de Unité de de Traitement Données Décodeur PC ALU Unité Flottante Registres Von Neumann vs. Harvard

Plus en détail

Architectures des ordinateurs Caches et mémoire virtuelle. Daniel Etiemble de@lri.fr. Capacité mémoire SRAM. X 4 tous les trois ans.

Architectures des ordinateurs Caches et mémoire virtuelle. Daniel Etiemble de@lri.fr. Capacité mémoire SRAM. X 4 tous les trois ans. Architectures des ordinateurs Caches et mémoire virtuelle Daniel Etiemble de@lri.fr Capacité mémoire 1M (bits) DRAM.5 T 1M 1M 1K 1K Date d apparition 1K 1978 1981 1984 1987 199 1993 1996 Surface SRAM/DRAM

Plus en détail

Cours 13. RAID et SAN. 2004, Marc-André Léger

Cours 13. RAID et SAN. 2004, Marc-André Léger Cours 13 RAID et SAN Plan Mise en contexte Storage Area Networks Architecture Fibre Channel Network Attached Storage Exemple d un serveur NAS EMC2 Celerra Conclusion Démonstration Questions - Réponses

Plus en détail

Architecture des ordinateurs

Architecture des ordinateurs Architecture des ordinateurs Généralités Processeur Carte mère Mémoire Bus Interfaces d'entrée-sortie Cartes d'extension Périphériques Évolution Presque le montage d'un PC 1 Familles d'ordinateurs Serveur

Plus en détail

Gestion Mémoire. Informatique Embarquée M2 / 2014. Gestion Mémoire

Gestion Mémoire. Informatique Embarquée M2 / 2014. Gestion Mémoire Informatique Embarquée M2 / 24 24 Interaction CPU / mémoire Bus d'adresses CPU Bus de Données Bus de Contrôle 24 Architecture Von Neumann CPU contient: Instructions et Données CPU charge les instructions

Plus en détail

MATÉRIEL GRAPHIQUE POUR LE CALCUL SCIENTIFIQUE. François Rousselle LISIC Image et Apprentissage OASIS

MATÉRIEL GRAPHIQUE POUR LE CALCUL SCIENTIFIQUE. François Rousselle LISIC Image et Apprentissage OASIS MATÉRIEL GRAPHIQUE POUR LE CALCUL SCIENTIFIQUE François Rousselle LISIC Image et Apprentissage OASIS Cadre BQR 2010 CGR LISIC LMPA : Réalisation d'une plateforme générique de calcul intensif pour cartes

Plus en détail

Introduction à la programmation parallèle p. 1/85

Introduction à la programmation parallèle p. 1/85 Introduction à la programmation parallèle Maîtrise d informatique Philippe MARQUET Philippe.Marquet@lifl.fr Laboratoire d informatique fondamentale de Lille Université des sciences et technologies de Lille

Plus en détail

Exécution des instructions machine

Exécution des instructions machine Exécution des instructions machine Eduardo Sanchez EPFL Exemple: le processeur MIPS add a, b, c a = b + c type d'opération (mnémonique) destination du résultat lw a, addr opérandes sources a = mem[addr]

Plus en détail

Architecture & Nouveautés du Core i7. Xpose Core i7 Guillaume Bedos

Architecture & Nouveautés du Core i7. Xpose Core i7 Guillaume Bedos Architecture & Nouveautés du Core i7 Xpose Core i7 Sommaire Définition Historique Rôle du microprocesseur Architecture d un microprocesseur Core i7 : Améliorations Cache HyperThreading IMC/QPI TurboBoost

Plus en détail

Cours n n 1. Introduction au Noyau. Master Informatique - Noyau - 2007-2008

Cours n n 1. Introduction au Noyau. Master Informatique - Noyau - 2007-2008 Cours n n 1 Introduction au Noyau 1 PLAN DU MODULE Objectifs Mécanismes internes du noyau (UNIX) Processus, Ordonnancement Fichiers, Mémoire virtuelle 2 PLAN DU MODULE Organisation Sur 10 semaines Début

Plus en détail

Chap. I : Architecture de base d un ordinateur

Chap. I : Architecture de base d un ordinateur UMR 7030 - Université Paris 13 - Institut Galilée Cours Architecture et Système Dans cette partie, nous décrivons rapidement l architecture de base d un ordinateur et les principes de son fonctionnement.

Plus en détail

Environnement Logiciel pour le calcul scientifique

Environnement Logiciel pour le calcul scientifique Environnement Logiciel pour le calcul scientifique Patrick Amestoy et Michel Daydé (ENSEEIHT-IRIT) préparé en collaboration avec J.-Y. L Excellent (INRIA/LIP-ENS Lyon) 2014-2015 1 / 221 Outline Introduction

Plus en détail

Architecture matérielle et logicielle

Architecture matérielle et logicielle Architecture matérielle et logicielle Contents I Le Cours 2 1 Généralités 2 2 Micro-processeur 2 3 Mémoire 2 4 Performances 3 II TPs 3 1 Création d un exécutable : 3 2 Les bibliothèques 3 3 Codage de l

Plus en détail

Problématique des accès mémoires irréguliers causés par les maillages non structurés :

Problématique des accès mémoires irréguliers causés par les maillages non structurés : Problématique des accès mémoires irréguliers causés par les maillages non structurés :! étude comparative entre les machines massivement multicoeurs et les GPU Loïc Maréchal / INRIA! LJLL, Demi-Journée

Plus en détail

Architecture des processeurs généralistes haute performance

Architecture des processeurs généralistes haute performance Architecture des processeurs généralistes haute performance Pierre Michaud (pmichaud@irisa.fr) 19 Mars 1 Exemples en technologie 90 nm Intel Pentium M «Dothan» 1.5 GHz ~ 85 mm 2 77 millions de transistors

Plus en détail

Questions à choix multiples Page 1 de 11

Questions à choix multiples Page 1 de 11 INF4170 Architecture des ordinateurs Examen final hiver 2015 Question #1 Quelle est la taille du registre IF/ID dans le circuit du processeur avec pipeline sans gestion des aléas, considérant que le signal

Plus en détail

Architecture des Ordinateurs. Partie II:

Architecture des Ordinateurs. Partie II: Architecture des Ordinateurs Partie II: Le port Floppy permet le raccordement du lecteur de disquette àla carte mère. Remarque: Le lecteur de disquette a disparu il y a plus de 6 ans, son port suivra.

Plus en détail

Parallélisme et Répartition

Parallélisme et Répartition Parallélisme et Répartition Master Info Françoise Baude Université de Nice Sophia-Antipolis UFR Sciences Département Informatique baude@unice.fr web du cours : deptinfo.unice.fr/~baude Septembre 2009 Chapitre

Plus en détail

Analyse et programmation 1

Analyse et programmation 1 Analyse et programmation Aperçu du fonctionnement de l ordinateur Fonctionnement de l ordinateur Codage de l information Bus d échange d information CPU Exécution d un programme par la CPU Gestion des

Plus en détail

Limitations of the Playstation 3 for High Performance Cluster Computing

Limitations of the Playstation 3 for High Performance Cluster Computing Introduction Plan Limitations of the Playstation 3 for High Performance Cluster Computing July 2007 Introduction Plan Introduction Intérêts de la PS3 : rapide et puissante bon marché L utiliser pour faire

Plus en détail

QUELQUES CONCEPTS INTRODUCTIFS

QUELQUES CONCEPTS INTRODUCTIFS ESIEE Unité d'informatique IN101 Albin Morelle (et Denis Bureau) QUELQUES CONCEPTS INTRODUCTIFS 1- ARCHITECTURE ET FONCTIONNEMENT D UN ORDINATEUR Processeur Mémoire centrale Clavier Unité d échange BUS

Plus en détail

CPU ou UCT. Le processeur est une unité d exécution, plus précisément appelée unité centrale de traitement (désignée en franç.

CPU ou UCT. Le processeur est une unité d exécution, plus précisément appelée unité centrale de traitement (désignée en franç. CPU ou UCT Processor (data processing) Le processeur est une unité d exécution, plus précisément appelée unité centrale de traitement (désignée en franç.par UCT, en ang. CPU (Central Processing Unit) CPU+mémoire

Plus en détail

Exemple: le processeur MIPS

Exemple: le processeur MIPS Exécution des instructions machine Exemple: le processeur MIPS add a, b, c a = b + c type d'opération (mnémonique) destination du résultat lw a, addr opérandes sources a = mem[addr] adresse (donnée, instruction

Plus en détail

PC industriels et disques associés

PC industriels et disques associés Technical Service Bulletin PRODUIT DATE CREATION DATE MODIFICATION FICHIER PC INDUSTRIEL 23/03/2010 201005 REV A PC industriels et disques associés English version follows. SF01 (du 4 au 8 janvier 2010)

Plus en détail

Les Systèmes d Exploitation: Concepts et Programmation

Les Systèmes d Exploitation: Concepts et Programmation Les Systèmes d Exploitation: d Concepts et Programmation Samia Bouzefrane MCF en Informatique, CNAM samia.bouzefrane@cnam.fr http://cedric.cnam.fr/~bouzefra Samia Bouzefrane, Cours SYSTEME 1 Introduction

Plus en détail

Processeur JAP. Le langage JAVA

Processeur JAP. Le langage JAVA Processeur JAP Ce document présente les dernières nouveautés concernant le processeur JAVA de la société AED. Il commence par un rappel sur les caractéristiques du processeur actuel, puis présente les

Plus en détail

DB2 10.5 BLU Acceleration Francis Arnaudiès f.arnaudies@fr.ibm.com

DB2 10.5 BLU Acceleration Francis Arnaudiès f.arnaudies@fr.ibm.com DB2 10.5 BLU Acceleration Francis Arnaudiès f.arnaudies@fr.ibm.com #solconnect13 SOLUTIONS ADAPTEES AUX BESOINS CLIENTS Mobile/Cloud Data Serving and Transaction Processing Mobile Storefront JSON Database

Plus en détail

Architecture matérielle http://nicodewaele.info Nicolas Dewaele

Architecture matérielle http://nicodewaele.info Nicolas Dewaele Architecture des ordinateurs Définition d'un ordinateur Architecture matérielle Architecture de Von Neumann (Années 1940) Von Neumann : Mathématicien, inventeur de l'architecture des ordinateurs modernes

Plus en détail

Première approche. Définition. Définition de l informatique donnée par l Académie Française en 1966 :

Première approche. Définition. Définition de l informatique donnée par l Académie Française en 1966 : Première approche Définition Définition de l informatique donnée par l Académie Française en 1966 : L informatique est la science du traitement rationnel, notamment par machines automatiques, de l information

Plus en détail

AMESD-Puma2010-EFTS- Configuration-update-TEN (en-fr)

AMESD-Puma2010-EFTS- Configuration-update-TEN (en-fr) AMESD-Puma2010-EFTS- Configuration-update-TEN (en-fr) Doc.No. : EUM/OPS/TEN/13/706466 Issue : v2 Date : 23 July 2013 WBS : EUMETSAT Eumetsat-Allee 1, D-64295 Darmstadt, Germany Tel: +49 6151 807-7 Fax:

Plus en détail

Architecture matérielle

Architecture matérielle Architecture matérielle Jacques Madelaine 1 Modèle de Von Neumann Mémoire Périphérique d E/S Bus de données Bus d adresses Bus de commandes UC centrale (CPU Central Processing Unit) prend depuis la mémoire

Plus en détail

Les mémoires. Eric Cariou. Département Informatique Université de Pau et des Pays de l'adour. Eric.Cariou@univ-pau.fr

Les mémoires. Eric Cariou. Département Informatique Université de Pau et des Pays de l'adour. Eric.Cariou@univ-pau.fr Les mémoires Eric Cariou Département Informatique Université de Pau et des Pays de l'adour Eric.Cariou@univ-pau.fr 1 Mémoire Mémoire Dispositif capable d'enregistrer, de conserver et de restituer des informations

Plus en détail

Composantes principales des ordinateurs

Composantes principales des ordinateurs Composantes principales des ordinateurs GIF-1001: Ordinateurs: Structure et Applications Jean-François Lalonde, Hiver 2015 Stallings ch. 3, Englander ch. 7, 10.1 Architecture von Neumann Mémoire (données

Plus en détail

Programmation Système des Multicœurs

Programmation Système des Multicœurs Évolution de la puissance des machines Programmation Système des Multicœurs Gaël Thomas gael.thomas@lip6.fr Accélération Évolution Traditionnelle des mono-processeurs Université Pierre et Marie Curie Master

Plus en détail

Instructions Mozilla Thunderbird Page 1

Instructions Mozilla Thunderbird Page 1 Instructions Mozilla Thunderbird Page 1 Instructions Mozilla Thunderbird Ce manuel est écrit pour les utilisateurs qui font déjà configurer un compte de courrier électronique dans Mozilla Thunderbird et

Plus en détail

Architecture des ordinateurs. Mémoires (II) Licence Informatique - Université de Provence. Jean-Marc Talbot

Architecture des ordinateurs. Mémoires (II) Licence Informatique - Université de Provence. Jean-Marc Talbot Architecture des ordinateurs Licence Informatique - Université de Provence Jean-Marc Talbot Mémoires jtalbot@cmi.univ-mrs.fr L3 Informatique - Université de Provence () Architecture des ordinateurs 120

Plus en détail

GELE5340 Circuits ITGÉ (VLSI) Chapitre 1: Introduction

GELE5340 Circuits ITGÉ (VLSI) Chapitre 1: Introduction GELE5340 Circuits ITGÉ (VLSI) Chapitre 1: Introduction Contenu du cours Introduction aux circuits intégrés Dispositifs CMOS, processus de fabrication. Inverseurs CMOS et portes logiques. Délai de propagation,

Plus en détail

Évolution de la puissance des machines. Système pour architectures multicœurs. Évolution de la puissance des machines

Évolution de la puissance des machines. Système pour architectures multicœurs. Évolution de la puissance des machines Évolution de la puissance des machines Accélération Système pour architectures multicœurs Évolution Traditionnelle des mono-processeurs CSC5001 : Systèmes Hautes Performances Architecte de Services informatiques

Plus en détail

Les processeurs. Les entrées-sorties

Les processeurs. Les entrées-sorties Les entrées-sorties La problématique des entrées sorties est la suivante : - Le processeur va vite, plus vite que des éléments mécaniques tel que l on trouve dans une imprimante, une souris, un clavier.

Plus en détail

Elements de microarchitecture. 1. Processeurs

Elements de microarchitecture. 1. Processeurs Elements de microarchitecture 1. Processeurs 1 Architecture simplifiée (10.000 feet view) P Core E/S IOH Caches E/S Contrôleur mémoire DIMM DIMM DIMM 2 Processeurs - A l'heure actuelle, dominé par les

Plus en détail

NOTICE D UTILISATION Option USB 2-Ports USB FRANCAIS

NOTICE D UTILISATION Option USB 2-Ports USB FRANCAIS NOTICE D UTILISATION Option USB 2-Ports USB FRANCAIS Introduction Ce supplément vous informe de l utilisation de la fonction USB qui a été installée sur votre table de mixage. Disponible avec 2 ports USB

Plus en détail

Konstantin Avrachenkov, Urtzi Ayesta, Patrick Brown and Eeva Nyberg

Konstantin Avrachenkov, Urtzi Ayesta, Patrick Brown and Eeva Nyberg Konstantin Avrachenkov, Urtzi Ayesta, Patrick Brown and Eeva Nyberg Le présent document contient des informations qui sont la propriété de France Télécom. L'acceptation de ce document par son destinataire

Plus en détail

AMESD-Puma2010-EFTS- Configuration-update-TEN (en-fr)

AMESD-Puma2010-EFTS- Configuration-update-TEN (en-fr) AMESD-Puma2010-EFTS- Configuration-update-TEN (en-fr) Doc.No. : EUM/OPS/TEN/13/706466 Issue : v3 Date : 7 May 2014 WBS : EUMETSAT Eumetsat-Allee 1, D-64295 Darmstadt, Germany Tel: +49 6151 807-7 Fax: +49

Plus en détail

LMW : Architecture des équipements

LMW : Architecture des équipements LMW : Architecture des équipements Antoine FRABOULET antoine.fraboulet@insa-lyon.fr p. 1 Plan Introduction aux network processors Architecture des routeurs Commutation Quelques network processors p. 2

Plus en détail

7.2 Structure interne d'un processeur de base.

7.2 Structure interne d'un processeur de base. LES PROCESSEURS Introduction Dans le chapitre 5, nous avons vu les processeurs selon leur type (famille, fabricant). Ce chapitre va expliquer l'architecture interne de ces processeurs et leurs performances

Plus en détail

Benchmarks. Ensemble de codes permettant de tester la fonctionnalité et les performances d'une solution HPC dans son ensemble.

Benchmarks. Ensemble de codes permettant de tester la fonctionnalité et les performances d'une solution HPC dans son ensemble. Ensemble de codes permettant de tester la fonctionnalité et les performances d'une solution HPC dans son ensemble. (Merci à Ludovic Saugé) Françoise BERTHOUD, Francoise.Berthoud@grenoble.cnrs.fr Les benchmarks

Plus en détail

Gestion de la Mémoire 1 ère partie: Point de vue processeur. Chapitre 5

Gestion de la Mémoire 1 ère partie: Point de vue processeur. Chapitre 5 Gestion de la Mémoire 1 ère partie: Point de vue processeur Chapitre 5 Présentation La mémoire peut être adressée de 3 points de vue Point de vue processeur Comment le processeur adresse la mémoire physique

Plus en détail

1 Architecture du cœur ARM Cortex M3. Le cœur ARM Cortex M3 sera présenté en classe à partir des éléments suivants :

1 Architecture du cœur ARM Cortex M3. Le cœur ARM Cortex M3 sera présenté en classe à partir des éléments suivants : GIF-3002 SMI et Architecture du microprocesseur Ce cours discute de l impact du design du microprocesseur sur le système entier. Il présente d abord l architecture du cœur ARM Cortex M3. Ensuite, le cours

Plus en détail

Systèmes & Réseaux. Georges Arhodakis Université Paris 8

Systèmes & Réseaux. Georges Arhodakis Université Paris 8 Systèmes & Réseaux Georges Arhodakis Université Paris 8 Sommaire Introduction Historique Service du noyau Appel Système Trappes & Interruptions Horloge & Gestion du Temps Ordonnancement Contrôle & Gestion

Plus en détail

Comment un ordinateur fonctionne Processeur

Comment un ordinateur fonctionne Processeur Comment un ordinateur fonctionne Processeur Les processeurs Cerveau de l ordinateur Règle flux d information par intermédiaire du bus Détermine puissance de l ordi (486, Pentium, ) Vitesse définit par

Plus en détail