View
1
Download
0
Category
Preview:
Citation preview
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)
2010-2011
1/ 378
Outline
IntroductionIntroduction aux calculateurs haute-performanceEvolutions architecturalesProgrammationConclusion
2/ 378
Outline
IntroductionIntroduction aux calculateurs haute-performanceEvolutions architecturalesProgrammationConclusion
3/ 378
I Intérêts du Calcul Haute-PerformanceI Applications temps-critiqueI Cas de calcul plus grosI Diminution du temps de réponseI Minimisation des coûts de calcul
I Difficultés
I Accès aux données : hiérarchie mémoire complexe→ Exploiter la localité des références aux données
I Identification et gestion du parallélisme dans une application→ Approche algorithmique
4/ 378
Systèmes parallèles : enfin l’age adulte !
I Les machines les plus puissantes sont à haut degré deparallélisme
I Le rapport prix / performance est attractif
I Plus que quelques constructeurs dans la course
I Systèmes plus stables
I Logiciels applicatifs et librairies disponibles
I Exploitation industrielle et commerciale : plus uniquementlaboratoires de recherche
I Mais : travail algorithmique important etvalidation/maintenance difficile.
Nouvelles évolutions:I 1 core per chip → multi-core chipsI supercomputing → métacomputing (“grid computing”)
5/ 378
Classes de calculateursI Serveurs de calcul :
I Utilisables sur une large gamme d’applicationsI Multiprogrammation et temps partagéI Stations de travail, serveurs départementaux, centre de calcul
I Calculateurs plus spécifiques :I Efficaces sur une classe plus limitée de problèmes (haut degré
de parallélisme)I A cause de leur architecture ou de limitations du logicielI Par exemple architectures massivement parallèles (MPP,
clusters de PC,.....)I Gains importants possibles avec rapport coût-performance
intéressantI Calculateurs spécialisés :
I Résolution d’un problème (image processing, crash test, . . . )I Hardware et logiciels conçus pour cette application-cibleI Gains très importants possibles avec un rapport
coût-performance très intéressantI Par exemple, la machine MDGRAPE-3 (dynamique
moléculaire) installée au Japon atteint 1 PFlop/s !
6/ 378
Besoins dans le domaine du calcul scientifique
Science traditionnelle
1. Construire une théorie,
2. Effectuer des expériences ou construire un système.
I trop difficile (ex: souffleries de grandes tailles)
I trop cher (fabriquer un avion juste pour quelques expérimentations)
I trop lent (attente de l’évolution du climat / de l’univers)
I trop dangereux (armes, médicaments, expérimentations sur leclimat)
Calcul scientifique
I simuler le comportement de systèmes complexes grâce à lasimulation numérique.
I lois physiques + algorithmes numériques + calculateurs hauteperformance
7/ 378
Exemples dans le domaine du calcul scientifique
I Contraintes de durée: prévision du climat
8/ 378
Quelques exemples dans le domaine du calculscientifique
I Cost constraints: wind tunnels, crash simulation, . . .
9/ 378
Scale Constraints
I large scale: climate modelling, pollution, astrophysics
I tiny scale: combustion, quantum chemistry
10/ 378
Pourquoi des traitements parallèles ?
I Besoins de calcul non satisfaits dans beaucoup de disciplines(pour résoudre des problèmes significatifs)
I Performance uniprocesseur proche des limites physiques
Temps de cycle 0.5 nanoseconde↔ 4 GFlop/s (avec 2 opérations flottantes / cycle)
I Calculateur 20 TFlop/s ⇒ 5000 processeurs→calculateurs massivement parallèles
I Pas parce que c’est le plus simple mais parce que c’estnécessaire
I Objectif actuel (2010):
supercalculateur à 3 PFlop/s,500 TBytes de mémoire ?
11/ 378
Quelques unités pour le calcul haute performance
Vitesse
1 MFlop/s 1 Megaflop/s 106 opérations / seconde1 GFlop/s 1 Gigaflop/s 109 opérations / seconde1 TFlop/s 1 Teraflop/s 1012 opérations / seconde1 PFlop/s 1 Petaflop/s 1015 opérations / seconde
Mémoire
1 kB / 1 ko 1 kilobyte 103 octets1 MB / 1 Mo 1 Megabyte 106 octets1 GB / 1 Go 1 Gigabyte 109 octets1 TB / 1 To 1 Terabyte 1012 octets1 PB / 1 Po 1 Petabyte 1015 octets
12/ 378
Mesures de performance
I Nombre d’opérations flottantes par seconde (pas MIPS)I Performance crête :
I Ce qui figure sur la publicité des constructeursI Suppose que toutes les unités de traitement sont activesI On est sûr de ne pas aller plus vite :
Performance crête = #unités fonctionnellesclock (sec.)
I Performance réelle :I Habituellement très inférieure à la précédente
Malheureusement
13/ 378
Rapport (Performance réelle / performance de crête) souvent bas !!Soit P un programme :
1. Processeur séquentiel:I 1 unité scalaire (1 GFlop/s)I Temps d’exécution de P : 100 s
2. Machine parallèle à 100 processeurs:I Chaque processor: 1 GFlop/sI Performance crête: 100 GFlop/s
3. Si P : code séquentiel (10%) + code parallélisé (90%)I Temps d’exécution de P : 0.9 + 10 = 10.9 sI Performance réelle : 9.2 GFlop/s
4. Performance réellePerformance de crête = 0.1
14/ 378
Loi d’Amdahl
I fs fraction d’une application qui ne peut pas être parallélisée
fp = 1− fs fraction du code paralléliséN: nombre de processeurs
I Loi d’Amdahl:
tN ≥ ( fpN + fs)t1 ≥ fst1Speed-up: S = t1tN ≤
1
fs+fpN
≤ 1fs
Sequential Parallel
t3 t2 t1t∞= fst1
15/ 378
Calculateur procs LINPACK LINPACK Perf.n = 100 n = 1000 crête
Intel WoodCrest (1 core, 3GHz) 1 3018 6542 12000HP ProLiant (1 core, 3.8GHz) 1 1852 4851 7400HP ProLiant (1 core, 3.8GHz) 2 8197 14800IBM eServer(1.9GHz, Power5) 1 1776 5872 7600IBM eServer(1.9GHz, Power5) 8 34570 60800Fujitsu Intel Xeon (3.2GHz) 1 1679 3148 12800Fujitsu Intel Xeon (3.2GHz) 2 5151 6400SGI Altix (1.5GHz Itanium2) 1 1659 5400 6000NEC SX-8 (2 GHz) 1 2177 14960 16000Cray T932 32 1129 (1 proc.) 29360 57600Hitachi S-3800/480 4 408 (1 proc.) 20640 32000
Table: Performance (MFlop/s) sur la résolution d’un système d’équationslinéaires (d’après LINPACK Benchmark Dongarra [07])
16/ 378
Machine Problème de Problème depetite taille grande taille
PFlop/s computer - 36 secondesTFlop/s computer 2 secondes 10 heuresCM2 64K 30 minutes 1 anCRAY-YMP-8 4 heures 10 ansALLIANT FX/80 5 jours 250 ansSUN 4/60 1 mois 1500 ansVAX 11/780 9 mois 14,000 ansIBM AT 9 ans 170,000 ansAPPLE MAC 23 ans 450,000 ans
Table: Vitesse de certains calculateurs sur un problème Grand Challengeen 1995 (d’après J.J. Dongarra)
Depuis, les problèmes “Grand Challenge” ont grossi !
17/ 378
Machine Problème de Problème depetite taille grande taille
PFlop/s computer - 36 secondesTFlop/s computer 2 secondes 10 heuresCM2 64K 30 minutes 1 anCRAY-YMP-8 4 heures 10 ansALLIANT FX/80 5 jours 250 ansSUN 4/60 1 mois 1500 ansVAX 11/780 9 mois 14,000 ansIBM AT 9 ans 170,000 ansAPPLE MAC 23 ans 450,000 ans
Table: Vitesse de certains calculateurs sur un problème Grand Challengeen 1995 (d’après J.J. Dongarra)
Depuis, les problèmes “Grand Challenge” ont grossi !
17/ 378
Outline
IntroductionIntroduction aux calculateurs haute-performanceEvolutions architecturalesProgrammationConclusion
18/ 378
Evolutions architecturales: historique
Pour 1,000 $ : calculateur personnel plus performant, avecplus de mémoire et plus de disque qu’un calculateur desannées 70 avec 1,000,000 $
technologie et conception !
I Durant les 25 premières années de l’informatique progrès :technologie et architecture
I Depuis les années 70 :I conception basée sur les circuits intégrésI performance : +25-30% par an pour les “mainframes” et minis
qui dominaient l’industrie
I Depuis la fin des années 70 : émergence du microprocesseurI meilleure exploitation des avancées dans l’intégration que pour
les mainframes et les minis (intégration moindre)I progression et avantage de coût (production de masse) : de
plus en plus de machines sont basées sur les microprocesseursI possibilité de pourcentage d’amélioration plus rapide = 35%
par an
19/ 378
Evolutions architecturales: historique
I Deux changements sur le marché facilitent l’introduction denouvelles architectures :
1. utilisation décroissante de l’assembleur (compatibilité binairemoins importante)
2. systèmes d’exploitation standards, indépendants desarchitectures (e.g. UNIX)
⇒ développement d’un nouvel ensemble d’architectures :RISC à partir de 85
I performance : + 50% par an !!!I Conséquences :
I plus de puissance :I Performance d’un PC > CRAY C90 (95)I Prix très infèrieur
I Domination des microprocesseursI PC, stations de travailI Minis remplacés par des serveurs à base de microprocesseursI Mainframes remplacés par des multiprocesseurs à faible
nombre de processeurs RISC (SMP)I Supercalculateurs à base de processeurs RISC (essentiellement
MPP)19/ 378
Moore’s law
I Gordon Moore (co-fondateur d’Intel) a prédit en 1965 que ladensité en transitors des circuits intégrés doublerait tous les24 mois.
I A aussi servi de but à atteindre pour les fabriquants.I A été déformé:
I 24 → 18 moisI nombre de transistors → performance
20/ 378
Comment accrôıtre la vitesse de calcul ?
I Accélérer la fréquence avec des technologies plus rapides
On atteint les limites:I Conception des pucesI Consommation électrique et chaleur dissipéeI Refroidissement ⇒ problème d’espace
I On peut encore miniaturiser, mais:I pas indéfinimentI résistance des conducteurs (R = ρ×ls ) augmente et ..I la résistance est responsable de la dissipation d’énergie (effet
Joule).I effets de capacités difficiles à mâıtriser
Remarque: 1 nanoseconde = temps pour qu’un signalparcourt 30 cm de cable
I Temps de cycle 1 nanosecond ↔ 2 GFlop/s (avec 2opérations flottantes par cycle)
21/ 378
Seule solution: le parallélisme
I parallélisme: exécution simultanée de plusieurs instructions àl’intérieur d’un programme
I A l’intérieur d’un processeur :I micro-instructionsI traitement pipelinéI 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)
I Entre des processeurs ou cœurs distincts:I suites d’instructions différentes exécutées
→ synchronisations implicites (compilateur, parallélisationautomatique) ou explicites (utilisateur)
22/ 378
Unités centrales haute-performance
Concept clé: Traitement pipeliné :
I L’exécution d’une opération (arithmétique) est décomposée enplusieurs sous-opérations
I Chaque sous-opération est exécutée par une unitéfonctionnelle dédiée = étage (travail à la chaine)
I Exemple pour une opérations diadique (a← b × c) :T1. Séparer mantisse et exposantT2. Multiplier mantissesT3. Additionner les exposantsT4. Normaliser le résultatT5. Ajouter signe au résultat
23/ 378
Exemple pour des opérations diadiques (suite)
I Supposition: l’opération a← b × c s’effectue en 5 traitementsélémentaires T1,T2,. . . ,T5 d’un cycle chacun. Quel est lenombre de cycles processeur pour la boucle suivante ?
Pour i = 1 à NA(i) = B(i) * C(i)
Fin Pour
I Traitement non pipeliné: N * 5 cyclesI Traitement pipeliné (à la chaine): N + 5 cycles
I 1er cycle: T1(1)I 2ème cycle: T1(2), T2(1)I 3ème cycle: T1(3), T2(2), T3(1)I . . .I kème cycle: T1(k), T2(k-1), T3(k-2), T4(k-3), T5(k-4)I . . .
24/ 378
Impact de l’approche CRAY
L’approche CRAY (années 80) a eu un grand impact sur laconception des supercalculateurs :
I horloge la plus rapide possible
I unité vectorielle pipelinée sophistiquée
I registres vectoriels
I mémoire très haute performance
I multiprocesseurs à mémoire partagéeI processeurs vectoriels
I exploitent la régularité des traitements sur les éléments d’unvecteur
I traitement pipelinéI couramment utilisés sur les supercalculateursI vectorisation par le compilateur
25/ 378
Processeurs RISC
I Processeurs RISC : introduits sur le marché vers 1990“the attack of the killer micros”
I pipeline sur les opérations scalairesI performance proche de celle des processeurs vectoriels à
fréquence égaleI plus efficaces sur des problèmes scalaires
I CISC (Complex Instruction Set Computer)I Efficacité par un meilleur encodage des instructions
I RISC (Reduced Instruction Set Computer)I Concept étudié fin des années 70I Décrôıtre le nombre de cycles par instruction à 1
Jeu d’instructions simple↓
Hardware simplifié↓
Temps de cycle plus faible
26/ 378
I Idées mâıtresses dans la conception des RISC :I Instructions décodées en 1 cycleI Uniquement l’essentiel réalisé au niveau du hardwareI Interface load/store avec la mémoireI Utilise intensivement le principe du pipeline pour obtenir un
résultat par cycle même pour les opérations complexesI Hiérarchie mémoire haute-performanceI Format d’instructions simpleI RISC super scalaires ou superpipelines: plusieurs unités
fonctionnelles
27/ 378
Architectures multi-cœurs
ConstatsI La quantité de composants / puce va continuer à augmenter
I La fréquence ne peut plus augmenter beaucoup(chaleur/refroidissement)
I Il est difficile de trouver suffisamment de parallélisme dans leflot d’instructions d’un processus
Multi-cœursI plusieurs cœurs à l’intérieur d’un même processeur
I vus comme plusieurs processeurs logiques par l’utilisateur
I Mais: multi-threading nécessaire au niveau de l’application
28/ 378
Processeur Cell
I La PS3 est basée sur un processeurCell (Sony,Toshiba,IBM)
I 1 Cell= un Power PC + 8 SPE(Synergetic Process. Elem.)
I 1 SPE = processeur vectoriel SIMD+ DMA = 25.6 GFlop/s
I 204 GFlop/s de performance crêteen arithmétique 32 bits
(14.6 GFlop/s en 64 bits)
I D’où regain d’intérêt pour le calcul en 32 bitsI Mélange d’arithmétiques simple et double précision (voir [13])I Typiquement: 32-bit pour le gros des calculs, 64 bits pour
améliorer la précisionI Pas seulement sur processeur Cell
Example of mixed-precision arithmetic
I Solve Ax = b, A sparse with the sparse direct solver MUMPSI Compare single precision + iterative refinement to double
precision run (Number of steps of iterative refinementsindicated on Figure).
Speed-up obtained wrt double precision(Results from A. Buttari et.al., 2007)
30/ 378
Année Calculateur MFlop/s1955-65 CDC 6600 1-101965-75 CDC 7600 10 - 100
IBM 370/195ILLIAC IV
1975-85 CRAY-1, XMP, CRAY 2 100 - 1000CDC CYBER 205FUJITSU VP400
NEC SX-21985-1995 CRAY-YMP, C90 1000 - 100,000
ETA-10NEC SX-3
FUJITSU VP26001995-2005 CRAY T3E 1.2 TFlop/s
INTEL 1.8 TFlop/sIBM SP 16 TFlop/s
HP 20 TFlop/sNEC 40 TFlop/s
IBM Blue Gene 180 TFlop/s2008 - Roadrunner 1 PFlop/s
Table: Evolutions des performances par décennie
Problèmes
I On est souvent (en pratique) à 10% de la performance crêteI Processeurs plus rapides → accès aux données plus rapide :
I organisation mémoire,I communication inter-processeurs
I Hardware plus complexe : pipe, technologie, réseau, . . .
I Logiciel plus complexe : compilateur, système d’exploitation,langages de programmation, gestion du parallélisme,. . . applications
Il devient plus difficile de programmer efficacement
32/ 378
Problèmes de débit mémoire
I L’accés aux données est un problème crucial dans lescalculateurs modernes
I Accrôıssement de la vitesse de calcul sans accrôıtre le débitmémoire → goulet d’étranglement
MFlop/s plus faciles que MB/s pour débit mémoire
I
Temps de cyle processeurs → 2 GHz (.5 ns)Temps de cycle mémoire → ≈ 20 ns SRAM
≈ 50 ns DRAM
33/ 378
Comment obtenir de hauts débits mémoire ?
I Plusieurs chemins d’accès entre mémoire et processeursI CRAY XMP et YMP :
I 2 vector load + 1 vector store + 1 I/OI utilisés pour accéder des vecteurs distincts
I NEC SX :I chemins d’accès multiples peuvent être aussi utilisés pour
charger un vecteur
I (améliore le débit, mais pas la latence !)
I Plusieurs modules mémoire accédés simultanément(entrelaçage)
I Accès mémoire pipelinés
I Mémoire organisée hiérarchiquementI La façon d’accéder aux données peut affecter la performance:
I Minimiser les défauts de cacheI Minimiser la pagination mémoireI Localité: améliorer le rapport références à des mémoires
locales/ références à des mémoires à distance
34/ 378
Cache level #2
Cache level #1 1−2 / 8 − 66
6−15 / 30 − 200
Main memory 10 − 100
Remote memory 500 − 5000
Registers < 1
256 KB − 16 MB
1 − 128 KB
Average access time (# cycles) hit/missSize
Disks 700,000 / 6,000,000
1 − 10 GB
Figure: Exemple de hiérarchie mémoire.
35/ 378
Conception mémoire pour nombre important deprocesseurs ?
Comment 100 processeurs peuvent-ils avoir accès à des donnéesrangé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)
I 2 solutions :I mémoires locales globalement adressables : Calulateurs à
mémoire partagée virtuelleI transferts explicites des données entre processeurs avec
échanges de messagesI Scalibité impose :
I augmentation linéaire débit mémoire / vitesse du processeurI augmentation du débit des communications / nombre de
processeurs
I Rapport coût/performance → mémoire distribuée et bonrapport coût/performance sur les processeurs
36/ 378
Architecture des multiprocesseurs
Nombre élevé de processeurs → mémoire physiquement distribuée
Organisation Organisation physiquelogique Partagée (32 procs max) DistribuéePartagée multiprocesseurs espace d’adressage global
à mémoire partagée (hard/soft) au dessus de messagesmé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, OpenMPOrganisation logique distribuée: PVM, MPI, sockets
37/ 378
Remarques
Mémoire physiquement partagée
I Temps d’accès uniforme à toute la mémoire
Mémoire physiquement distribuée
I Temps d’accès dépend de la localisation de la donnée
Mémoire logiquement partagée
I Espace d’adressage unique
I Communications implicites entre les processeurs via lamémoire partagée
Mémoire logiquement distribuée
I Plusieurs espaces d’adressage privés
I Communications explicites (messages)
38/ 378
Terminologie
Architecture SMP (Symmetric Multi Processor)
I Mémoire partagée (physiquement et logiquement)
I Temps d’accès identique à la mémoire
I Similaire du point de vue applicatif aux architecturesmulti-cœurs (1 cœur = 1 processeur logique)
I Mais communications bcp plus rapides dans les multi-cœurs(latence < 3ns, bande passantee > 20 GB/s) que dans lesSMP (latence ≈ 60ns, bande passantee ≈ 2 GB/s)
Architecture NUMA (Non Uniform Memory Access)
I Mémoire physiquement distribuée et logiquement partagée
I Plus facile d’augmenter le nombre de procs qu’en SMP
I Temps d’accès dépend de la localisation de la donnée
I Accès locaux plus rapides qu’accès distants
I hardware permet la cohérence des caches (ccNUMA)39/ 378
Outline
IntroductionIntroduction aux calculateurs haute-performanceEvolutions architecturalesProgrammationConclusion
40/ 378
Classification de Flynn
I S.I.S.D. : Single Instruction Single Data streamI architecture monoprocesseurI calculateur von Neumann conventionnelI exemples : SUN, PC
I S.I.M.D. : Single Instruction Multiple Data streamI 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’unematrice, d’une image)
I une unité de contrôle diffuse les instructionsI processeurs identiquesI Exemples : CM-2, DAP, MasPar,. . .I plus récemment: chacun des 8 SPE du processeur CELL se
comporte comme un système SIMD
41/ 378
I M.I.S.D. : n’existe pasI M.I.M.D. : Multiple Instructions Multiple Data stream
I processeurs exécutent de façon asynchrone des instructionsdifférentes sur des données différentes
I processeurs éventuellement hétérogènesI chaque processeur a sa propre unité de contrôleI exemples : ALLIANT, CONVEX, CRAYs, IBM SP, clusters
BEOWULF, serveurs multi-processeurs, réseaux de stations detravail, . . .
42/ 378
Modes de programmation SIMD et MIMD
I Avantages du SIMD :I Facilité de programmation et de débogageI Processeurs synchronisés → coûts de synchronisation
minimauxI Une seule copie du programmeI Décodage des instructions simple
I Avantages du MIMD :I Plus flexible, beaucoup plus généralI Exemples:
I mémoire partagée: OpenMP, threads POSIXI mémoire distribuée: PVM, MPI (depuis C/C++/Fortran)
43/ 378
Outline
IntroductionIntroduction aux calculateurs haute-performanceEvolutions architecturalesProgrammationConclusion
44/ 378
Evolutions du Calcul Haute-Performance
I Mémoire virtuellement partagée :I clustersI Hiérarchie mémoire plus étendue
I Clusters de machinesI Souvent à base de PCs (Pentium ou Dec Alpha, NT ou
LINUX)
I Programmation parallèle (mémoire partagée, transfert demessage, data parallèle) :
I Efforts de définition de standards : Open MP et threadsPOSIX, MPI, HPF, . . .
I MPPs et clustersI représentent l’avenir pour le calcul haute-performanceI rapport communicationspuissance de calcul souvent faible par rapport aux
multiprocesseurs à mémoire partagéeI intégration dans l’ensemble des moyens de calcul d’une
entreprise de plus en plus courante
45/ 378
Environnements de programmation
I On n’évitera pas le calcul parallèleI Logiciels ont toujours un temps de retard / aux architectures
I Système d’exploitationI Parallélisation automatiqueI Logiciels applicatifs et librairies scientifiques
I Pour des architectures massivement parallèles :I Standard de programmation : MPI ou MPI + threads
(POSIX/OpenMP)I Langages: le plus souvent C ou FortranI Besoins d’outils de dévelopement (débogueurs, compilateurs,
analyseurs de performance, librairies, . . . )I Développements/maintenance difficiles et difficultés
d’utilisation des outils de mise au point.
46/ 378
HPC Spectrum (d’après J.Dongarra)
� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �
� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �� � � � � � � � � � � � � � � � � � � � � � � � � � � � � � � �
�����
�����
�����
�����
Peer
to p
eer
(SET
I@ho
me)
Grid
−bas
ed co
mpu
ting
Net
wor
k of
ws
Beow
ulf c
luste
rCl
uste
rs w
/
Para
llel d
ist m
emTF
lop
mac
hine
s
spec
ial i
nter
conn
ect
Distributed Systems
- Gather (unused) resources- Steal cycles- System software managesresources- 10% - 20% overhead is OK- Resources drive applications- Completion time not critical- Time-shared- Heterogeneous
Massively // Systems
- Bounded set of resources- Apps grow to consume all cycles- Application manages resources- 5% overhead is maximum- Apps drive purchase of equipment- Real-time constraints- Space-shared- Homogeneous 47/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
48/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
49/ 378
Introduction
I Conception d’un supercalculateurI Déterminer quelles caractéristiques sont importantes (domaine
d’application)I Maximum de performance en respectant les contraintes de
coût (achat, maintenance,consommation)I Conception d’un processeur :
I Jeu d’instructionsI Organisation fonctionnelle et logiqueI Implantation (intégration, alimentation, . . . )
I Exemples de contraintes fonctionnelles vs domained’application
I Machine généraliste : performance équilibrée sur un largeensemble de traitements
I Calcul scientifique : arithmétique flottante performanteI Gestion : base de données, transactionnel, . . .
50/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
51/ 378
Pipeline
I Pipeline = principe du travail à la châıneI un traitement est découpé en un certain nombre de
sous-traitements réalisés par des unités différentes (étages dupipeline)
I les étages fonctionnent simultanément sur des opérandesdifférents (éléments de vecteurs par exemple)
I après amorçage du pipeline, on obtient un résultat par tempsde cyle de base
I Processeur RISC :I Pipeline sur des opérations scalaires indépendantes :
a = b + cd = e + f
I Code exécutable plus complexe sur RISC :
do i = 1, na(i) = b(i) + c(i)
enddo
52/ 378
I Code correspondant :
i = 1boucle : load b(i) dans registre #1
load c(i) dans registre #2registre #3 = registre #1 + registre #2store registre #3 dans a(i)i = i + 1 et test fin de boucle
I Exploitation du pipeline → déroulage de boucle
do i = 1, n, 4a(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
53/ 378
I Sur processeur vectoriel :
do i = 1, na(i) = b(i) + c(i)
enddo
load vector b dans registre #1load vector c dans registre #2register #3 = register #1 + register #2store registre #3 dans vecteur a
Stripmining : si n > nb (taille registres vectoriels)
do i = 1, n, nbib = min( nb, n-i+1 )do ii = i, i + ib - 1
a(ii) = b(ii) + c(ii)enddo
enddo
54/ 378
Problèmes dans la conception des pipelines
I Beaucoup d’étages:I coût d’amorçage plus élévéI performances plus sensibles à la capacité de nourrir le pipelineI permet de réduire le temps de cycle
I
I Moins d’étagesI sous-instructions plus complexesI plus difficile de décrôıtre le temps de cycle
55/ 378
Problèmes des dépendences de données
I Exemple :
do i = 2, na(i) = a(i-1) + 1
enddo
a(i) initialisés à 1.
I Exécution scalaire :
Etape 1 : a(2) = a(1) + 1 = 1 + 1 = 2
Etape 2 : a(3) = a(2) + 1 = 2 + 1 = 3
Etape 3 : a(4) = a(3) + 1 = 3 + 1 = 4.....
56/ 378
I Exécution vectorielle : pipeline à p étages → p éléments dansle pipeline
Etages du pipe-------------------------------------------
Temps 1 2 3 ... p sortie-------------------------------------------------------t0 a(1)t0 + dt a(2) a(1)t0 + 2dt a(3) a(2) a(1)....t0 + pdt a(p+1) a(p) ... a(2) a(1)-------------------------------------------------------
D’où :
a(2) = a(1) + 1 = 1 + 1 = 2a(3) = a(2) + 1 = 1 + 1 = 2...
car on utilise la valeur initiale de a(2).
Résultat exécution vectorielle 6= exécution scalaire57/ 378
Overlapping (recouvrement)
I Utiliser des unités fonctionnelles en parallèle sur desopérations indépendantes. Exemple:
do i = 1, nA(i) = B(i) * C(i)D(i) = E(i) + F(i)
enddo
A
DE
F
B
C
Pipelined multiplier
Pipelined adder
Timeoverlapping = max{Startupmul ,Startupadd + dt}+ n×dtTimeno overlap. = {Startupmul +n×dt}+{Startupadd +n×dt}
I Avantages: parallélisme entre les unités fonctionnellesindépendantes et plus de flops par cycle
58/ 378
Chaining (châınage)
I La sortie d’une unité fonctionnelle est dirigée directement versl’entrée d’une autre unité fonctionnelle
I Exemple :
do i = 1, nA(i) = ( B(i) * C(i) ) + D(i)
enddo
D
A
Pipelined multiplier Pipelined adderB
C
Timechaining = Startupmul + Startupadd + n × dtTimenochaining = {Startupmul + n×dt}+{Startupadd + n×dt}
I Avantages : plus de flops par cyle, exploitation de la localitédes données, économie de stockage intermédiaire
59/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
60/ 378
Locality of references
Programs tend to reuse data and instructions recently used
I Often program spends 90% of its time in only 10% of code.
I Also applies - not as strongly - to data accesses :
I temporal locality : recently accessed items are likely to beaccessed in the future
I spatial locality : items whose addresses are near one anothertend to be referenced close together in time.
61/ 378
Concept of memory hierarchy - 1
In hardware : smaller is faster
Example :
I On a high-performance computer using same technology(pipelining, overlapping, . . . ) for memory:
I signal propagation is a major cause of delay thus largermemories → more signal delay and more levels to decodeaddresses.
I smaller memories are faster because designer can use morepower per memory cell.
62/ 378
Concept of memory hierarchy - 2
Make use of principle of locality of references
I Data most recently used - or nearby data - are very likely tobe accessed again in the future
I Try to have recently accessed data in the fastest memory
I Because smaller is faster → use smaller memories to holdmost recently used items close to CPU and successively largermemories farther away from CPU
→ Memory hierarchy
63/ 378
Typical memory hierarchy
access bandwidthLevel Size time MB/s technology manag.Registers ≤ 1KB 2-5 ns 400-32,000 (BI)CMOS compilerCache ≤ 4MB 3-10 ns 800-5,000 CMOS SRAM hardwareMain memory ≤ 4GB 80-400 ns 400-2,000 CMOS DRAM OSDisk ≥ 1GB 5 ×106 ns 4-32 magnetic disk OS/user
64/ 378
Memory interleaving
Banks
1
2
3
4
5
6
7
8
Banks
1
2
3
4
5
6
7
8
a(1), a(9), ..., a(249)
a(2), a(10), ..., a(250)
a(3),a(11), ..., a(251)
a(4),...
a(5), ...
a(6), ...a(7), ..., a(255)
a(8), a(16), ..., a(256)
Two basic ways of distributing the addresses
Memory size 210
=1024 Words divided into 8 banks
a(1), a(2), ..., a(128)
a(129), ..., a(256)
Low order interleaving
Real a(256)
"well adapted to pipelining memory access"
Memory Interleaving
"The memory is subdivided into several independent memory modules (banks)"
Example:
High order interleaving
65/ 378
Effect of bank cycle time
1
3
2
Bank
4
1
3
2
Bank
4
... = a(i,j)
EnddoEnddo
Do i=1,4
Real a(4,2)
Do j=1,2
... = a(i,j)Enddo
Real a(4,2)
Do i=1,4Do j=1,2
Enddo
cannot be referenced again
Time interval during which the bank
Example
a(1,1) a(1,2)
1 CP
Low order interleaved memory, 4 banks, bank cycle time 3CP.
% column access %row access
Bank cycle time:
10 Clock Period 18 Clock Period
Bank Conflict: Consecutive accesses to the same bank in less than bank cycle time.
Stride: Memory address interval between successive elements
time
a(3,1)
a(4,1) a(4,2)
a(2,2)a(2,1)
a(1,2)a(1,1)
a(3,2)
a(4,1) a(4,2)
a(2,1) a(2,2)
a(3,1) a(3,2)
66/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
67/ 378
Organisation interne et performance des processeursvectoriels (d’après J. Dongarra)
I Soit l’opération vectorielle triadique :
do i = 1, ny(i) = alpha * ( x(i) + y(i) )
enddoI On a 6 opérations :
1. Load vecteur x2. Load vecteur y3. Addition x + y4. Multiplication alpha × ( x + y )5. Store dans vecteur y
68/ 378
I Organisations de processeur considérées :
1. Séquentielle2. Arithmétique châınée3. Load mémoire et arithmétique châınées4. Load mémoire, arithmétique et store mémoire châınés5. Recouvrement des loads mémoire et opérations châınées
I Notations :
a : startup pour load mémoireb : startup pour additionc : startup pour multiplicationd : startup pour store mémoire
69/ 378
Sequential Machine Organization
a
a
b
c
d
memory path busy
load x
load y
add.
mult.
store
Chained Arithmetic
a load x
a load y
b add.
c mult.
d store
memory path busy
70/ 378
a
a
memory path busy
load x
load y
a load x
a load y
memory path busy
Chained Load and Arithmetic
b add.
mult.c
d store
Chained Load, Arithmetic and Store
add. b
c mult.
d store
71/ 378
a load x
Overlapped Load with Chained Operations
a load y
b add.
c mult.
stored
memory path 2 busy
memory path 3 busy
memory path 1 busy
72/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
73/ 378
Organisation des processeurs RISC
The execution pipeline
Instruction
Decode
Instruction
FetchExecution
Memory access
and branch
completion
(write results
in register file)
Write back
Example (DLX processor, Hennessy and Patterson, 96 [11])
I Pipeline increases the instruction throughputI Pipeline hazards: prevents the next instruction from executing
I Structural hazards: arising from hardware resource conflictsI Data hazards: due to dependencies between instructionsI Control hazards: branches for example
74/ 378
Instruction Level Parallelism (ILP)
I Pipelining: overlap execution of independent operations →Instruction Level Parallelism
I Techniques for increasing amount of parallelism amonginstructions:
I reduce the impact of data and control hazardsI increase the ability of processor to exploit parallelismI compiler techniques to increase ILP
I Main techniquesI loop unrollingI basic and dynamic pipeline schedulingI dynamic branch predictionI Issuing multiple instructions per cycleI compiler dependence analysisI software pipeliningI trace scheduling / speculationI . . .
75/ 378
Instruction Level Parallelism (ILP)
I Simple and common way to increase amount of parallelism isto exploit parallelism among iterations of a loop : Loop LevelParallelism
I Several techniques :I Unrolling a loop statically by compiler or dynamically by the
hardwareI Use of vector instructions
76/ 378
ILP: Dynamic scheduling
I Hardware rearranges the instruction execution to reduce thestalls.
I Advantage: handle cases where dependences are unknown atcompile time and simplifies the compiler
I But: significant increase in hardware complexity
I Idea: execute instructions as soon as their data are availableOut-of-order execution
I Handling exceptions becomes tricky
77/ 378
ILP: Dynamic scheduling
I Scoreboarding: technique allowing instruction out-of-orderexecution when resources are sufficient and when no datadependences
I full responsability for instruction issue and execution
I goal : try to maintain an execution rate of one instruction /clock by executing instructions as early as possible
I requires multiple instructions to be in the EX stagesimultaneously → multiple functional units and/or pipelinedunits
I Scoreboard table record/update data dependences + status offunctional units
I Limits:I amount of parallelism available between instructionsI number of scoreboard entries: set of instructions examined
(window)I number and type of functional units
78/ 378
ILP: Dynamic scheduling
I Other approach : Tomasulo’s approach (register renaming)
I Suppose compiler has issued:
F10
Impact of ILP : example
This example is from J.L. Hennessy and D.A. Patterson (1996)[11].
I Original Fortran code
do i = 1000, 1x(i) = x(i) + temp
enddo
I Pseudo-assembler code
R1 F2
Loop : load x(i) -> F0F4 = F0 + F2store F4 -> x(i)R1 = R1 - #8 % decrement pointerBNEZ R1, Loop % branch until end of loop
80/ 378
I Architecture
IF ID MEM WB
Integer Unit1 stage
FP add
FP mult
Dividenot pipelined
4 stages
4 stages
Example of pipelined processor (DLX processor, Hennessy andPatterson, 96 [11])
81/ 378
I Latency: # cycles between instruction that produces resultand instruction that uses result
I Initiation interval : # cycles between issuing 2 instructions ofsame type
I Latency = 0 means results can be used next cycle
Functional unit Latency Initiation intervalInteger ALU 0 1Loads 1 1FP add 3 1FP mult 3 1FP divide 24 24
Characteristics of the processor
Inst. producing result Inst. using result LatencyFP op FP op 3FP op store double 2Load double FP op 1Load double store double 0
Latency between instructions
Latency FP op to store double : forwarding hardware passes result from
ALU directly to memory input. 82/ 378
I Straightforward code
#cycleLoop : load x(i) -> F0 1 load lat. = 1
stall 2F4 = F0 + F2 3stall 4 FP op -> store = 2stall 5store F4 -> x(i) 6R1 = R1 - #8 7BNEZ R1, Loop 8stall 9 delayed branch 1
I 9 cycles per iteration
I Cost of calculation 9,000 cycles
I Peak performance : 1 flop/cycle
I Effective performance : 19 of peak
83/ 378
I With a better scheduling
#cycleLoop : load x(i) -> F0 1 load lat. = 1
stall 2F4 = F0 + F2 3R1 = R1 - #8 4 Try keep int. unit busyBNEZ R1, Loop 5store F4 -> x(i) 6 Hide delayed branching
by store
I 6 cycles per iteration
I Cost of calculation 6,000 cycles
I Effective performance : 16 of peak
84/ 378
I Using loop unrolling (depth = 4)
do i = 1000, 1, -4x(i ) = x(i ) + tempx(i-1) = x(i-1) + tempx(i-2) = x(i-2) + tempx(i-3) = x(i-3) + temp
enddo
85/ 378
I Pseudo-assembler code (loop unrolling, depth=4):#cycle
Loop : load x(i) -> F0 1 1 stallF4 = F0 + F2 3 2 stallsstore F4 -> x(i) 6load x(i-1) -> F6 7 1 stallF8 = F6 + F2 9 2 stallsstore F8 -> x(i-1) 12load x(i-2) -> F10 13 1 stallF12= F10+ F2 15 2 stallsstore F12-> x(i-2) 18load x(i-3) -> F14 19 1 stallF16= F14+ F2 21 2 stallsstore F16-> x(i-3) 24R1 = R1 - #32 25BNEZ R1, Loop 26stall 27
I 27 cycles per iterationI Cost of calculation 10004 × 27 = 6750 cyclesI Effective performance : 10006750 = 15% of peak
86/ 378
I Using loop unrolling (depth = 4) and scheduling
#cycleLoop : load x(i) -> F0 1
load x(i-1) -> F6 2load x(i-2) -> F10 3load x(i-3) -> F14 4F4 = F0 + F2 5F8 = F6 + F2 6F12= F10+ F2 7F16= F14+ F2 8store F4 -> x(i) 9store F8 -> x(i-1) 10store F12-> x(i-2) 11R1 = R1 - #32 12BNEZ R1, Loop 13store F16-> x(i-3) 14
I 14 cycles per iterationI Cost of calculation 10004 × 14 = 3500 cyclesI Effective performance : 10003500 = 29% of peak
87/ 378
I Now assume superscalar pipeline : integer and floating pointoperations can be issued simultaneously
I Using loop unrolling with depth = 5Integer inst. | Float.inst.|#cycle
___________________________________________Loop: load x(i) -> F0 | | 1
load x(i-1)-> F6 | | 2load x(i-2)-> F10| F4 =F0 +F2 | 3load x(i-3)-> F14| F8 =F6 +F2 | 4load x(i-4)-> F18| F12=F10+F2 | 5store F4 ->x(i) | F16=F14+F2 | 6store F8 ->x(i-1)| F20=F18+F2 | 7store F12->x(i-2)| | 8store F16->x(i-3)| | 9R1 = R1 - #40 | | 10BNEZ R1, Loop | | 11store F20->x(i-4)| | 12
I 12 cycles per iterationI Cost of calculation 10005 × 12 = 2400 cyclesI Effective performance : 10002400 = 42% of peakI Performance limited by balance between int. and float. instr.
88/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
89/ 378
Réutilisation des données (dans les registres)
I Améliorer l’accès aux données et exploiter la localité spatialeet temporelle des références mémoire
I Déroulage de boucles : réduit le nombre d’accès mémoire enutilisant le plus de registres possible
I Utiliser des scalaires temporaires
I Distribution de boucles : si nombre de données réutilisables >nombre de registres : substituer plusieurs boucles à une seule
90/ 378
Déroulage de boucle
Objectif : réduire nombre d’accès mémoire et améliorer pipelineopérations flottantes.
I Produit matrice-vecteur : y ← y + At × xdo ...
do ...y(i) = y(i) + x(j)*A(j,i)
enddoenddo
I 2 variantes :I AXPY :
do j = 1, Ndo i = 1, N
...I DOT
do i = 1, Ndo j = 1, N
...91/ 378
DOT variant
Processeurs RISC mieux adaptés à DOT que AXPY
do i = 1, Ntemp = 0.do j = 1, N
temp = temp + x(j)*A(j,i)enddoy(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 = 22 = 1
92/ 378
Réutilisation de x(j) : déroulage à une profondeur 2
* Cleanup odd iterationi = MOD(N,2)if ( i >= 1 ) then
do j = 1, Ny(i) = y(i) + x(j)*A(j,i)
enddoend if
* Main loopimin = i + 1do 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)
enddoy(i-1) = y(i-1) + temp1y(i ) = y(i ) + temp2
enddo
93/ 378
load A(j,i-1)load x(j)perform A(j, i-1 ) * x(j) + temp1load A(j,i)perform A(j,i ) * x(j) + temp2
I Ratio Flops/références mémoire = 43I Déroulage à une profondeur de 4 : 85I Déroulage à une profondeur k : 2kk+1
94/ 378
Rolled
Unrolled 2
Unrolled 4
Unrolled 8
0 200 400 600 800 1000 12005
10
15
20
25
30
35
40
45
Size
MF
lops
Performance of y = At x on HP 715/64
Figure: Effect of loop unrolling on HP 715/64
95/ 378
Rolled
Unrolled 2
Unrolled 4
Unrolled 8
0 200 400 600 800 1000 12005
10
15
20
25
30
35
40
45
50
Size
MF
lops
Performance of y = At x on CRAY T3D
Figure: Effect of loop unrolling on CRAY T3D
96/ 378
AXPY variant
Habituellement préférée sur processeurs vectoriels
do j = 1, Ndo 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 = 23
97/ 378
Réutilisation de y(i) : déroulage à profondeur 2
* Cleanup odd iterationj = MOD(N,2)if ( j .GE. 1 ) then
do i = 1, Ny(i) = y(i) + x(j)*A(j,i)
enddoend if
* Main loopjmin = j + 1do j = jmin, N, 2
do i = 1, Ny(i) = y(i)+A(j-1,i)*x(j-1)+A(j,i)*x(j)
enddoenddo
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)
I Ratio Flops/références mémoire = 1
I Déroulage à profondeur 4 → Ratio = 43I Déroulage à profondeur p → Ratio = 2p2+p
99/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
100/ 378
Organisation d’une mémoire cache
I CacheI Buffer rapide entre les registres et la mémoire principaleI Divisé en lignes de cache
I Ligne de cacheI Unité de transfert entre cache et mémoire principale
I Défaut de cacheI Référence à une donnée non présente dans le cacheI Stratégie de choix d’une ligne à remplacer (LRU parmi les
éligibles)I Une ligne de cache contenant la donnée est chargée de la
mémoire principale dans le cache
I Problème de la cohérence de cache sur les multiprocesseurs àmémoire partagée
I Rangement des données dans les cachesI correspondance mémoire ↔ emplacements dans le cache
101/ 378
I Stratégies les plus courantes :I “direct mapping”I “fully associative”I “set associative”
I Conception des caches :I L octets par ligne de cacheI K lignes par ensemble (K est le degré d’associativité)I N ensembles
I Correspondance simple entre l’adresse en mémoire et unensemble :
I N = 1 : cache “fully associative”I K = 1 : cache “direct mapped”
102/ 378
I “Direct mapping”I Chaque bloc en mémoire ↔ un placement unique dans le cacheI Recherche de données dans cache peu coûteuse (mais
remplacement coûteux)I Problème de contention entre les blocs
line
cache
main memory
I “Fully associative”I Pas de correspondance a prioriI Recherche de données dans cache coûteuse
103/ 378
I “Set associative”I Cache divisé en plusieurs ensemblesI Chaque bloc en mémoire peut être dans l’une des lignes de
l’ensembleI “4-way set associative” : 4 lignes par ensemble
line
main memory
line 1line 2line 3
cache set #k
line 4
104/ 378
Gestion des caches
I Coût d’un défaut de cache : entre 2 et 50 C (temps de cycle)I “Copyback”
I 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
I “Writethrough”I 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
105/ 378
Cache coherency problem
cache cache
Y
Processor # 2Processor # 1
X
cache line
I Cache coherency mechanisms to:I avoid processors accessing old copies of data (copyback and
writethrough)I update memory by forcing copybackI invalidate old cache lines
I Example of mechanism (snooping):I assume writethrough policyI Each processor observes the memory accesses from othersI If a write operation occurs that corresponds to a local
cacheline, invalidate local cacheline
106/ 378
Cache coherency problem
cache cache
Y
Processor # 2Processor # 1
X
cache line
I Cache coherency mechanisms to:I avoid processors accessing old copies of data (copyback and
writethrough)I update memory by forcing copybackI invalidate old cache lines
I Example of mechanism (snooping):I assume writethrough policyI Each processor observes the memory accesses from othersI If a write operation occurs that corresponds to a local
cacheline, invalidate local cacheline106/ 378
Processor Line size Level Size Organization miss Access /cycle
DEC 21164 32 B 1 8 KB Direct-mapped 2 C 22∗ 96 KB 3-way ass. ≥ 8 C 23∗ 1-64 MB Direct-mapped ≥ 12 C 2
IBM Power2 128 B / 1 128 KB / 4-way-ass. 8 C 2256 B 256 KB
MIPS R8000 16 B 1 16 KB Direct-mapped 7 C 22∗ 4-16 MB 4-way-ass. 50 C 2
Cache configurations on some computers.∗ : data + instruction cache
I Current trends:I Large caches of several MBytesI Several levels of cache
107/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
108/ 378
Réutilisation des données (dans les caches)
Example
I cache 10 times faster than memory, hits 90% of the time.I What is the gain from using the cache ?
I Cost cache miss: tmissI Cost cache hit: thit = 0.1× tmissI Average cost:
90%(0.1× tmiss) + 10%× tmissI gain = tmiss×100%90%×(0.1×tmiss )+10%×tmiss =
1(0.9×0.1)+0.1 =
10.19 = 5.3
(similar to Amdahl’s law)
109/ 378
Réutilisation des données (dans les caches)
Example
I cache 10 times faster than memory, hits 90% of the time.I What is the gain from using the cache ?
I Cost cache miss: tmissI Cost cache hit: thit = 0.1× tmissI Average cost: 90%(0.1× tmiss) + 10%× tmissI gain = tmiss×100%90%×(0.1×tmiss )+10%×tmiss =
1(0.9×0.1)+0.1 =
10.19 = 5.3
(similar to Amdahl’s law)
109/ 378
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
I Exemple : effet du % de défauts de cache sur un code donné
I Pmax performance lorsque toutes les données tiennent dans lecache (hit ratio = 100%). Tmin temps correspondant.
I Lecture de donnée dans le cache par une instruction etexécution : thit = 1 cycle
I Temps d’accès à une donnée lors d’un défaut de cache : tmiss= 10 ou 20 cycles (exécution instruction tmiss + thit)
I Ttotal = %hits.thit + %misses × (tmiss + thit)I Topt = 100%× thitI Perf =
ToptTtotal
110/ 378
Tmiss %hits Tps hits Tps misses Ttotal Perf.
100% 1.00 0.00 1.00 100%
10 99% 0.99 0.11 1.10 91%20 99% 0.99 0.22 1.21 83%
10 95% 0.95 0.55 1.50 66%20 95% 0.95 1.10 2.05 49%
Table: Effet des défauts de cache sur la performance d’un code (exprimésen pourcentages vs pas de défaut de cache).
111/ 378
Efficient cache utilization: ExerciseReuse as much as possible data held in cache ↔ Improve cache hitratio
I Cache : single block of CS (cache size) wordsI When cache is full: LRU line returned to memoryI Copy-back: memory updated only when a modified block
removed from cacheI For simplicity, we assume cache line size L=1
Example from D. Gannon and F. Bodin :
do i=1,ndo 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.
112/ 378
I Total number of memory references = 3× n2 i.e. n2 loads fora, n2 stores for a, and n2 loads for b (assuming the compiler isstupid).
I Total number of flops = n2
I Cache empty at beginning of calculations.I Inner loop:
do j=1,na(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:
I each read of a(j) → 1 missI each write of a(j) → 1 hitI each read of b(i) → 1 hit (except the first one)
I Hit ratio = # of hitsMem.Refs =23 = 66%
113/ 378
blocked version
The inner loop is blocked into blocks of size nb < CS so that nbelements of a can be kept in cache and entirely updated withb(1:n).
do j=1,n,nbjb = min(nb,n-j+1) ! nb may not divide ndo i=1,n
do jj=j,j+jb-1a(jj) = a(jj) + b(i)
enddoenddo
enddo
114/ 378
To clarify we load the cache explicitely; it is managed as a 1Darray : CA(0:nb)
do j=1,n,nbjb = 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
enddoa(j:j+jb-1) = CA(1:jb)
enddo
Each load into cache is a miss, each store to cache is a hit.
115/ 378
I Total memory references = 3n2
I Total misses:I load a = nnb × nbI load b = nnb × nI Total = n + n
2
nb
I Total hits = 3n2 − n − n2nb = (3−1nb )× n
2 − n
Hit ratio = hitsMem.Refs ≈ 1−1
3nb ≈ 100%if nb is large enough.
116/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
117/ 378
Mémoire virtuelle
I Mémoire réelle : code et données doivent être logés enmémoire centrale (CRAY)
I Mémoire virtuelle : mécanisme de pagination entre lamémoire et les disques
Une pagination mémoire excessive peut avoir desconséquences dramatiques sur la performance !!!!
I TLB :I Translation Lookaside Buffer : correspondance entre l’adresse
virtuelle et l’adresse réelle d’une page en mémoireI TLB sur IBM Power4/5: 1024 entréesI Défaut de TLB : 36 C environ
I AIX offre la possibilité d’augmenter la taille des pages (jusqu’à16 MB) pour limiter les défauts de TLB.
118/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
119/ 378
Exercice sur la réutilisation des données (enmémoire)
(inspiré de (Dongarra, Duff, Sorensen, van der Vorst [7]))C ← C + A× BA, B, C : matrices n × n, n = 20000, stockées par colonnes
I Calculateur vectoriel (Performance de crête 50 GFlop/s)
I Mémoire virtuelle (remplacement page : LRU)
I 1 page mémoire = 2Mmots = 100 colonnes de A, B, ou C(1 mot = 8 bytes)
I 1 défaut de page ≈ 10−4 secondesI Stockage de A, B, et C :
3× 400Mmots = 3× 3.2 GB = 9.6 GBI capacité mémoire : 128 pages soit:
128× 2Mmots = 256Mmots = 2GB → A, B, C ne peuventêtre stockées totalement
120/ 378
Variante (1) : ijk
do i = 1, ndo j = 1, n
do k = 1, nCij
Variante (1) : ijk
do i = 1, ndo j = 1, n
do k = 1, nCij
Variante (2) : jki
do j = 1, ndo k = 1, n
do i = 1, nCij
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-matricesdo 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
Défauts de page :
I nb = 400 colonnes (4 pages mémoire)
I accès à B et C, défauts de page lors de la boucle en j: 200défauts de page
I n/nb accès (boucle en j) à A par blocs de colonnes, pourchaque indice k : 200, soit n/nb × 200 au total.
I Total ≈ ( nnb + 2)× 200 défauts de pageI nb = 400 donc nnb = 50
I et donc ≈ 104 défauts de pageI Temps de chargement mémoire = 1 sec
Attention : le temps de calcul n’est plus négligeable !!Temps = 2× n3/vitesse ≈ 320 secondesIdées identiques au blocage pour cacheBlocage : très efficace pour exploiter au mieux une hiérarchiemémoire (cache, mémoire virtuelle, . . . )
125/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
126/ 378
Interconnexion des processeurs
I Réseaux constitués d’un certain nombre de bôıtes deconnexion et de liens
I Commutation de circuits : chemin créé physiquement pourtoute la durée d’un transfert (idéal pour un gros transfert)
I Commutation de paquets : des paquets formés de données +contrôle trouvent eux-même leur chemin
I Commutation intégrée : autorise les deux commutationsprécédentes
I Deux familles de réseaux distincts par leur conception et leurusage :
I Réseaux mono-étageI Réseaux multi-étages
127/ 378
I Anneau
Proc 1 Proc 2 Proc nProc 0
I GrilleProc Proc Proc Proc
ProcProcProc
Proc Proc Proc Proc
ProcProcProcProc
Proc
Utilisé sur Intel DELTA et PARAGON, . . .128/ 378
I Shuffle Exchange : Perfect Shuffle avec en plus Proc # iconnecté à Proc # (i+1)
1 2 3 4 5 6 70
I N-cube ou hypercube : Proc #i connecté au Proc # j si i et jdiffèrent d’un seul bit.
0 1 2 3 4 5 6 7
I Grand classique utilisé sur hypercubes Intel (iPSC/1, iPSC/2,iPSC/860), machines NCUBE, CM2, . . .
129/ 378
Figure: 4-Cube in space.
130/ 378
Topologies usuelles pour les architectures distribuées
I Notations :I # procs = N = 2p
I diamètre = d (chemin critique entre 2 procs)I # liens = w
I Anneau : d = N2 ,w = N
I Grille 2D : d = 2× (N12 − 1),w = 2× N
12 × (N
12 − 1)
I Tore 2D (grille avec rebouclage sur les bords) :
d = N12 ,w = 2× N
Proc Proc Proc Proc
ProcProcProc
Proc Proc Proc Proc
ProcProcProcProc
Proc
I Hypercube ou p-Cube : d = p,w = N×p2131/ 378
Remarques
I Tendance actuelle:I Réseaux hiérarchiques/multi-étagesI Beaucoup de redondances (bande passante, connections
simultanées)
I Conséquence sur les calculateurs haute performance:I Peu de différence de coût selon sources/destinationsI La conception des algorithmes parallèles ne prend plus en
compte la topologie des réseaux (anneaux, . . . )
132/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
133/ 378
Statistiques Top 500 (voir www.top500.org)
I Liste des 500 machines les plus puissantes au monde
I Mesure: GFlops/s pour pour la résolution deAx = b, A matrice dense.
I Mises à jour 2 fois par an (Juin/ISC, Novembre/SC).
I Sur les 10 dernières années la performance a augmenté plusvite que la loi de Moore:
134/ 378
Analyse des sites - Definitions
I Rang (noté # par la suite): Position dans le top 500.
I Rpeak (Gflop/s): Performance crête de la machine en nombred’opérations flottantes par secondes.
I Rmax (Gflop/s): Performance maximum obtenue sur le testLINPACK
I Nmax: Taille du problème ayant servi à obtenir Rmax.I Power (MWatt/s) : Watt/s consommés (voir aussi
www.green500.org)I La consommation énergétique d’un système du TOP10 est de
2,89 MWatt (contre 2,45 il y a un an).I L’efficacité énergétique s’améliore : 300 MFlops/Watt contre
280 il y a un an.I Les calculateurs à efficacité energétique la plus forte possédent
des processeurs cell (pouvant aller jusqu’à 774 Mflops/Watt).
135/ 378
Top 500: évolution des performances
I June 1997: ASCI Red,Sandia NL
I #1 = 1.1 TFlop/s(effectif)
I #500 = 7.7 GFlop/s
I June 2007:IBM Bluegene, Livermore NL
I #1 = 280 TFlop/sI #500 = 4 TFlop/s
I June 2008: Roadrunner,LosAlamos NL
I #1 = 1 PFlop/s (1026TFlop/s)
I #500 = 4 TFlop/s
I June 2010: Jaguar,OakRidge NL
I #1 = 1,75 PFlop/s(1026 TFlop/s)
I #500 = 25 TFlop/s
136/ 378
Evolution des performances energétiques des Top#1
I Entre 2002 et 2005 :NEC earth simulator (40 Tflop/s) : 6 MFlops/Watt
I Entre 2005 et 2007 :IBM Bleu gene L (280 Tflop/s) : 205 Mflops/Watt
I 2008 :Roadrunner Blade center ( 1 Pflop/s) : 444 Mflops/Watt
I 2010 :Jaguar, Cray XT5 Opteron 6 core (1.7 Plop/s) :253 Mflops/Watt
137/ 378
Remarques générales (Juin 2010)
I Jaguar (# 1, performance de crête 2.3 Petaflops/s et 1.75atteint sur du Linpack) posséde 1/2 Million de Coeurs (processeurs quad-core).
I La chine entre fortement dans le TOP10 avec 2calculateurs (#2 Nebulae et #7 Tianhe-1). Performance decrète de Nebulae (3 Petaflop/s) > performance de crête deJaguar. Machines hybrides basées sur processeurs Intel Xeonet Accelerateurs AMD ou NVidia.
I Processeurs :
I 425/500 systèmes utilisent des processeurs quad-core.I 408 Intel, 47 AMD Opteron, 42 IBM Power processorsI 186 systèmes basés sur des Intel Core i7 (Nehalem-EP)
138/ 378
Remarques générales (Juin 2010, suite)
I Roadrunner (#1 en Juin 2009) est # 3 en Juin 2010.
I NEC ”Earth simulator supercomputer” (36 Tflop/s, 5120processeurs vectoriels) est aujourd’hui numéro 37. Est restéen tête de Juin 2002 à Juin 2004.
I Le 500 ième (24.7 TeraFlops effectif) était 226 au 6/2009.
I Somme cumulée :32 Pflops effectif (contre 22 Pflops au 6/2009)5 Million de coeurs (contre 4 Millions au 6/2009)
I Europe: UK (38), France (29), Germany (24)(France machine #18 (Jade, CINES, SGI ALTIX, 238 Tflop/s)#334 (Hyperion, CICT-Toulouse, SGI Altix 30 Tflop/s))
139/ 378
Top 10 mondial (Juin 2010)
Rang Site Système Rmax
1 ORNL, USA Cray XT5-HE 1759AMD Opteron
2 NSCS, Chine Dawning 1271Intel+NVidia
3 LANL, USA IBM, BladeCenter 1042Cell proc + AMD Opteron
4 Univ Tennessee, USA Cray XT5-HE 832AMD Opteron
5 FZK, Allemagne IBM BlueGene/P 825
6 NASA, USA SGI Altix 773Intel Xeon
7 NUDT, Chine NUDG TH1 563Intel Xeon+ATI Radeon
8 LLNL, USA IBM Blue gene 478
9 Argonne, USA IBM Blue gene 459
10 Sandia, USA Sun Blade, Xeon 433
140/ 378
Statistiques constructeurs: Nombre de systèmesinstallés en Juin 2010
IBMHewlett-PackardCray Inc.DellSGISun MicrosystemsBull SAFujitsuAppro InternationalHitachiClusterVisionDell/Sun/IBMNECDawningNEC/SunNUDT
141/ 378
Statistiques constructeurs: Pourcentage de lapuissance totale
IBMHPCray Inc.DellSGISun Micro.Bull SAFujitsuAppro Inter.HitachiClusterVisionDell/Sun/IBMNECDawningNEC/SunNUDT
142/ 378
Répartition par segment d’activité
Noter que 300/500 des calculateurs sont dans l’industrie mais “nereprésentent que” 31% de la puissance cumulée
143/ 378
Répartition géographique
Afrique: 1 Océanie : 8Amérique: 290 Europe: 144
Brésil 1 Allemagne 24Canada 7 France 27USA 282 Italie 7
RU 38Espagne 3Russie 11
Asie : 57Chine 24India 5Japon 18S. Arabia 4
144/ 378
Analyse des sites français – Juin 2010 (10/27)
Rang Site Système Rmax (TFlops)18 GENCI.CINES SGI Altix, Xeon 23525 Gouvernement HP cluster 18038 CNRS/IDRIS IBM Blue gene 11944 CEA Bull bullx, Xeon 10845 CEA/CCRT Bull Novascale, Xeon 10849 Total exploration SGI Altix, Xeon 10658 EDF R&D IBM BlueGene/P 9562 Manufacturing HP cluster, Xeon 8963 Bull Bull bullx supernode, Xeon 87100 CEA Bull Novascale, Itanium2 53
Autres domaines concernés (Institution financieres (4), Service, Automobile,
Simulation (EADS, CNES))
145/ 378
Evolution de la performance
146/ 378
Exemples d’architecture de supercalculateurs
I Machines de type scalaireI CRAY XT3/4 (Oak Ridge National Lab)I IBM Blue Gene
I Machines de type vectorielI NEC (Earth Simulator Center, Japon)I CRAY X1 (Oak Ridge Nat. Lab.)
I Machine à base de processeur CellI Roadrunner (Los Alamos National Lab (LANL))
147/ 378
NEC Earth Simulator Center (architecture)
unit
cacheRegisters
Scalar
unit
cacheRegisters
Scalar
Arithm. Proc 1 Arith. Proc. 8
UnitUnit
Noeud 640
unit
cacheRegisters
Scalar
unit
cacheRegisters
Scalar
Arithm. Proc 1 Arith. Proc. 8
UnitUnit
Noeud 1
Réseau (Crossbar complet)
640 Noeuds (8 Arith. Proc.) −> 40Tflops
(Rpeak −−> 16 flops // par AP)
Vector Vector Vector Vector
Mémoire partagée (16Gbytes) Mémoire partagée (16Gbytes)
Mémoire totale 10TBytes
Vector unit (500MHz): 8 ens. de pipes (8*2*.5= 8Glops)
Supercalculateur NEC (installé à Tokyo en 2002)
148/ 378
Cray X1 d’Oak Ridge National Lab.
I Performance: 6.4 Tflop/s, 2Terabytes, Rmax(5.9 TFlop/s)I Architecture 504 Multi Stream processeurs (MSP):
I 126 NoeudsI Chaque Noeud a 4 MSP et 16Gbytes de mémoire “flat”.I Chaque MSP a 4 Single Stream Processors (SSP)I Chaque SSP a une unité vectorielle et une unité superscalaire,
total 3.2Gflops.
149/ 378
Cray X1 node
150/ 378
Blue Gene L (65536 dual-procs, 360 TFlops peak)
I Système d’exploitationminimal (non threadé)
I Consommation limitée:I 32 TB mais seulement
512 MB de mémoire parnoeud !
I un noeud = 2 PowerPC à700 MHz (2x2.8 GFlop/s)
I 2.8 GFlop/s ou 5.6GFlop/s crête par noeud
I Plusieurs réseaux rapidesavec redondances
151/ 378
Blue gene: efficace aussi en Mflops/watt
152/ 378
Pour entrer dans l’ère du Petacale : Roadrunner
I Los Alamos National Lab et IBM
I 18 clusters de 170 noeuds de calcul
I Par noeud : 2 dual-core AMDOpteron et 4 IBM PowerXCell 8iproc(Machine complète : 12240PowerCell)
I Performance IBM PowerXCell 8i : 110 Glops (64 bits flottant)
I 122400 cores et 98 Terabytes
I Rmax=1026 Teraflops; Rpeak 1376 Teraflops; 2.3 MWatts
153/ 378
Roadrunner (suite)
I Différence Cell BroadBand Engine(CBE) et IBM PowerXCell 8i
I Amélioration significative de laperformance des calculs 64bits(100Gflops/15Gflops)
I Mémoire plus rapide
I Programmation du RoadrunnerI 3 compilateurs : Opteron,
PowerPC et Cell SPE jeud’instructions
I Gestion explicite des données etprogrammes entre Opteron,PowerPC et Cell.
154/ 378
Prévisions
I Projet japonnais (10 Pflops en 2011).
I Architectures à base de noeuds hybrides incluant desprocesseurs vectoriels/Cell
155/ 378
Outline
Calculateurs haute-performance: concepts générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion
156/ 378
Conclusion
I Performance :I Horloge rapideI Parallélisme interne au processeur
I Traitement pipelinéI Recouvrement, châınage des unités fonctionnelles
I Parallélisme entre processeurs
I Mais :I Accès aux données :
I Organisation mémoireI Communications entre processeurs
I Complexité du hardwareI Techniques de compilation : pipeline / vectorisation /
parallélisation
Comment exploiter efficacement l’architecture ?
157/ 378
Ecriture de code efficace (I) : MFLOPS ou MIPS ?
I MFLOPS: floating point operations /sec.Ne dépend pas du calculateur
I MIPS: instructions de bas-niveauDépend du calculateur
I Watt: code efficace sur des machines a faible consommationen Watt par proc. (Exemple des proc. Cell).
I Précision des calculs: travail partiel en précision numériqueaffaiblie (plus efficace).
158/ 378
Ecriture de code efficace (II)
I Facteurs architecturaux influençant la performance :I débit et latence mémoireI coûts des communications et de synchronisationI temps d’amorçage des unités vectoriellesI besoins en entrées/sorties
I Facteurs dépendant de l’application :I parallélisme (dépend des algorithmes retenus)
I régularité des traitementsI équilibrage des traitementsI volume de communications (localité)I granularité - scalabilité
I Localité des données (spatiale et temporelle)encore plus critique sur les architectures Cell et GPU(Graphical Proc Unit)
159/ 378
Notion de calcul potentiellement efficace
I Proposition: Soient x et y des vecteurs et A,B,C desmatrices d’ordre n; le noyau de calcul (1) x = x + αy estpotentiellement moins efficace que le noyau (2) y = A× x + yqui est potentiellement moins efficace que le noyau (3)C = C + A× B
I Exercice : justifier la proposition précédente.
160/ 378
I La mesure du rapport entre le nombre d’opérations flottanteset de réferences mémoire pour chacun des noyaux de calculexplique le potentiel.
I x = x + αyI 3n références mémoireI 2n opérations flottantesI rapport Flops/Ref = 2/3
I y = A× x + yI n2 références mémoireI 2n2 opérations flottantesI rapport Flops/Ref = 2
I C = C + A× BI 4n2 références mémoireI 2n3 opérations flottantesI rapport Flops/Ref = n/2
I Typiquement Vitesse (3) = 5 × vitesse(2) et vitesse(2) = 3 ×vitesse(1) . . . si on utilise des bibliothèques optimisées !
161/ 378
Limites de l’optimisation de code et de lavectorisation/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 ) THENTEMP = ALPHA * B( l, j )DO 20 i = 1, M
C( i, j ) = C( i, j ) + TEMP * A( i, l )20 CONTINUE
END IF30 CONTINUE40 CONTINUE
Plupart des compilateurs : parallélisent la boucle d’indice j etoptimisent / vectorisent la boucle d’indice i
162/ 378
Table: Performance de versions différentes de GEMM sur processeursRISC avec des matrices 128 × 128.
Calculateur standard optimisé perf. de crête
DEC 3000/300 AXP 23.1 48.4 150.0HP 715/64 16.9 38.4 128.0IBM RS6000/750 25.2 96.1 125.0
Pentium 4 113 975 3600
I Plupart des optimisations réalisées par les compilateurs sur laboucle interne
I En théorie très bon potentiel grâce au rapport entreopérations flottantes et références mémoire : ( 4n2 référencesmémoire, 2n3 opérations flottantes)
i.e. n2 mais les compilateurs ne savent pas l’exploiter !!
163/ 378
I Optimisation de code :I Améliorer l’accès aux données et exploiter la localité spatiale et
temporelle des références mémoireI Déroulage de boucles : réduit le nombre d’accés mémoire en
améliorant la réutilisation des registres, permet aussi unemeilleure exploitation du parallélisme interne aux processeurs
I Blocage pour une utilisation efficace du cache : améliore lalocalité spatiale et temporelle
I Copie des données dans des tableaux de travail pour forcer lalocalité et éviter des ”strides” critiques (pas toujours possiblescar parfois trop coûteux)
I ”prefetch” des donnéesI Utilisation de l’assembleur (cas désespéré !!)I Utilisation de bibliothèques optimisées (cas ideal !!)
164/ 378
Utilisation d’une bibliothèque optimiséeI Noyaux de calcul matriceXmatrice optimisés existent :
I ATLAS - Automatic Tuned Linear Algebra Software.http://netlib.enseeiht.fr/atlas/
I Goto from Univ. Texas at Austinhttp://www.cs.utexas.edu/users/flame/goto/
Figure: Comparaison de la performance de noyaux de calcul en algèbrelinéaire (BLAS) (J. Dongarra)
Outline
La programmation par mode messageContexte informatique, objectifs et besoinsLe modèle de programmation par transfert de messagesEnvoi et réception de messagesChoisir un mode de communication
166/ 378
Outline
La programmation par mode messageContexte informatique, objectifs et besoinsLe modèle de programmation par transfert de messagesEnvoi et réception de messagesChoisir un mode de communication
167/ 378
Contexte informatique
I Multiprocesseur à mémoire distribuée ou réseau de stations detravail
network #1
computer #2
computer #1
cluster
network #2
multiprocessor
Exemple de réseau de calculateurs.
168/ 378
Objectifs et besoins
I But : répartir/gérer des calculs sur la machine cibleI Outils nécessaires : ( minimum )
I Sécurité et droits d’accés (machines et données)I Création de processus distantsI Communication entre processusI Synchronisation entre processusI Gestion de la cohérence des donnés et des traitementsI Séquenceur des tâches répartiesI Gestion dynamiques des processeurs et des processus
(gestion des pannes, gestion de points de reprises)
169/ 378
Outline
La programmation par mode messageContexte informatique, objectifs et besoinsLe modèle de programmation par transfert de messagesEnvoi et réception de messagesChoisir un mode de communication
170/ 378
Le modèle de programmation par transfert demessages
I Permet d’exprimer la communication et la synchronisation
I C’est le modèle le plus répandu en calcul répartimais ce n’est pas le seul (voir par ex. LINDA )
I Il n’apporte pas de solution à tous les problèmes posés.I Caractéristiques :
I expression du parallélisme à la charge du programmeurI distribution des données à la charge du programmeurI l’échange de données est expliciteI prise en compte possible d’un réseau hétérogènes de
calculateurs avec gestion des pannes.
171/ 378
Modèle pelure d’oignon pour l’échange de message
Chaque niveau peut-être construit au dessus du précédent
I Niveau le plus bas : adressage au niveau canalI procédures pour transférer des paquets sur des liens
I Adressage au niveau processusI éventuellement plus d’un processus par processeurI échange de message en donnant l’adresse d’un processusI Exemples : Nx sur iPSC, Vertex sur nCUBE, Express,
PARMACS, PVM, MPI, . . .
I Niveau plus élevé d’abstraction : mémoire partagée virtuelle,LINDA, espace de tuples partagé ou réparti)
172/ 378
Hypothèse d’exécution
I Machine complètement connectée
I Routeur automatique de messages
P22
P21
Machine 3P31
P12
P11
Machine 1 Machine 2
Processus
les deux hypothèses ci-dessus ne sont pas toujours vraies(Transputers)
173/ 378
Bibliotèques portables pour la programmationd’applications parallèles distribuées
I P4 de l’Argonne National LaboratoryI offre à la fois les modèles mémoire partagée et transfert de
messageI communications entre processusI disponible et optimisé sur une large gamme de calculateurs (et
réseaux de calculateurs)
I PICL de l’Oak Ridge National Laboratory portable sur unelarge gamme de multiprocesseurs à mémoire distribuée
I PVM : Univ. Tennessee, Univ. Emory, Oak Ridge Nat. Lab.,. . .
I pour réseaux hétérogènes de calculateursI aussi disponible sur multiprocesseurs
I MPI : le standard pour le transfert de message
174/ 378
Outline
La programmation par mode messageContexte informatique, objectifs et besoinsLe modèle de programmation par transfert de messagesEnvoi et réception de messagesChoisir un mode de communication
175/ 378
Envoi et réception de messages
Un arbre qui cache la forêt
176/ 378
Environnement d’exécution des communications
I Chaque processus est identifié par un numéro d’instance(rang dans un groupe ou communicateur)
I L’enveloppe d’un message doit permettre la caractérisationet le traitement du message. Elle contient:
1. le numéro de l’émetteur2. le numéro du récepteur3. le label du message4. la taille du message5. . . .
177/ 378
Types de communication classiques
I communications point à point (one-to-one) :échange d’information entre 2 processus
I communications collectives ( dans groupe / communicateur ):
I one-to-many (broadcast, fan-out) :d’un processus vers un ensemble de processus
I many-to-one (collect, fan-in) :un processus collecte des informations issues d’un ensemble deprocessus
I many-to-many :échange global d’informations entre plusieurs processus
178/ 378
Communications point à point(quelques questions)
I Envoi et réception de messagesProcessus
Temps
Source
Send (Dest, data)
Dest
Recv(Source, data)data
data
I Questions:I Synchronisation entre l’envoi et la réception ?I Quand peut-on réutiliser la donnée envoyée ?I Bufferisation des communications ?
179/ 378
Outline
La programmation par mode messageContexte informatique, objectifs et besoinsLe modèle de programmation par transfert de messagesEnvoi et réception de messagesChoisir un mode de communication
180/ 378
Choisir un mode de communication(Communications Synchrones/ Asynchrones)
I Envoi/réception synchrones:Le premier arrivé attend l’autre (notion de rendez-vous).
I Envoi/Réception asynchrones:L’émetteur et le récepteur ne s’attendent pas.
I Un envoi asynchrone peut cependant être bloqué par la nonconsommation du message par le récepteur(ceci sera détaillé
Recommended