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 processeurs vectoriels Organisation des processeurs RISC Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 1/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 2/ 98

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 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,... 3/ 98

Utilisation des architectures Besoins toujours croissants en volume mémoire : x 1.5 2 par an pour un code moyen (soit 1 bit d adresse tous les 1-2 ans) 20 dernières années remplacement assembleur par langages de haut niveau compilateurs / optimisation de code Evolution technologique Circuits intégrés (CPU) : densité + 50 % par an Semi-conducteurs DRAM (mémoire) : Densité + 60 % par an Temps de cycle : -30 % tous les 10 ans Taille : multipliée par 4 tous les 3 ans 4/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 5/ 98

CPU performance CPU time = #ProgramCycles ClockRate IC = #instructions for program CPI = average number of cycles per instruction Thus CPU time = IC CPI ClockRate CPU performance on a program depends on three factors : 1. clock cycle time 2. #cycles per instruction 3. number of instructions But they are inter-dependent : Cycle time depends on hardware technology and processor organization CPI depends on organization and instruction set architecture IC depends on instruction set and compiler 6/ 98

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 7/ 98

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 8/ 98

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 effectuer register #3 = register #1 + register # 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 9/ 98

Problèmes dans la conception des pipelines Accoître le nombre d étages (réduction du temps de cycle) Accroître le temps d amorçage Problème des dépendances de données : Exemple : do i = 2, n a(i) = a(i-1) + 1 enddo a(i) initialisés à 1. Exécution scalaire : Etape 1 : a(2) = a(1) + 1 = 1 + 1 = 2 Etape 2 : a(3) = a(2) + 1 = 2 + 1 = 3 Etape 3 : a(4) = a(3) + 1 = 3 + 1 = 4... 10/ 98

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

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 12/ 98

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 13/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 14/ 98

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 stronly - 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. 15/ 98

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. 16/ 98

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 17/ 98

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

Speed of computation High memory bandwidth Example: X <--- Y + Z Memory Flow requirement Data Intruction Intruction Y Adder X Z 1 Word = 8 Bytes NI = Nb. Instructions/cycle LI = Nb. Words/Instruction NO = Nb. Operations/cycle Bandwidth required: (NI*LI+3*NO) (in Words/sec) cycle time NI LI NO Cycle time (in nsec) Bandwidth Required 1 CPU NEC SX3/14 16 2.9 16GW/sec 1 CPU CRAY-C90 4 4.2 2.8GW/sec Digital α 21064 2 1/2 1 5 0.6GW/sec Intel i860 XP 2 1/2 3/2 20 0.275GW/sec

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 1 2 3 4 5 6 7 8 a(1), a(2),..., a(128) a(129),..., a(256) 1 2 3 4 5 6 7 8 a(1), a(9),..., a(249) a(2), a(10),..., a(250) a(3),a(11),..., a(251) a(4),... a(5),... a(6),... a(7),..., a(255) a(8), a(16),..., a(256) "well adapted to pipelining memory access" 20/ 98

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) 2 a(2,1) a(2,2) 2 a(2,1) a(2,2) 3 a(3,1) a(3,2) 3 a(3,1) a(3,2) 4 a(4,1) a(4,2) 4 a(4,1) a(4,2) 1 CP 10 Clock Period time 18 Clock Period Bank Conflict: Consecutive accesses to the same bank in less than bank cycle time. Stride: Memory address interval between successive elements 21/ 98

Performance improvement due to the use of a cache Using Amdahl s law cache 10 times faster than memory, hits 90% of the time. What is the gain from using the cache? Cost cache miss: m Cost cache hit: 0.1 m Average cost: 90%(0.1 m) + 10% m gain = m 90% (0.1 m)+10% m = 1 (0.9 0.1)+0.1 = 1 0.19 = 5.3 CPU execution time can also be expressed as: CPU time = (CPU cycles + MemoryStallCycles) clock (1) MemoryStallCycles = #miss C miss = IC (#mem.refs/inst.) %miss C miss where C miss = miss penalty 22/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 23/ 98

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 24/ 98

Organisations de processeur considérées : 1. Séquentielle 2. Arithmétique chaînée 3. Load mémoire et arithné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 25/ 98

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 26/ 98

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 27/ 98

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

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 29/ 98

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

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 Major techniques loop unrolling basic and dynamic pipeline scheduling dynamic branch prediction Issuing multiple instructions per cycle compiler dependence analysis software pipelining trace scheduling / speculation... 31/ 98

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 32/ 98

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 33/ 98

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 instrcutions 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 Limits: amount of parallelism available between instructions number of scoreboard entries : set of instructions examined (window) number and type of functional units 34/ 98

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 35/ 98

ILP : Multiple issue CPI cannot be less than one except if more than one instruction issued each cycle multiple-issue processors (CPI: average nb of cycles per instruction) Two types : superscalar processors VLIW processors (Very Long Instruction Word) Superscalar processors issue varying number of instructions per cycle either statically scheduled by compiler or dynamically (e.g. using scoreboarding). Typically 1-8 instructions per cycle with some constraints. VLIW issue a fixed number of instructions formatted either as one large instruction or as a fixed instruction packet : inherently statically scheduled by compiler 36/ 98

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

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 [?]) 38/ 98

Latency: # cycles between instruction that produces result and instruction that uses result Initiation interval : # cycles between issuing 2 instructions of same type Latency = 0 means results can be used next cycle Functional unit Latency Initiation interval Integer ALU 0 1 Loads 1 1 FP add 3 1 FP mult 3 1 FP divide 24 24 Characteristics of the processor 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. 39/ 98

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 40/ 98

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 41/ 98

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 42/ 98

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) -> F10 13 1 stall F12= F10+ F2 15 2 stalls store F12-> x(i-2) 18 load x(i-3) -> F14 19 1 stall F16= F14+ F2 21 2 stalls store F16-> x(i-3) 24 R1 = R1 - #32 25 BNEZ R1, Loop 26 stall 27 27 cycles per iteration Cost of calculation 1000 4 27 = 6750 cycles Effective performance : 1000 6750 = 15% of peak 43/ 98

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

Now assume superscalar pipeline : integer and floating point operations can be issued simultaneously Using loop unrolling with depth = 5 Integer inst. Float.inst. #cycle Loop: load x(i) -> F0 1 load x(i-1)-> F6 2 load x(i-2)-> F10 F4 =F0 +F2 3 load x(i-3)-> F14 F8 =F6 +F2 4 load x(i-4)-> F18 F12=F10+F2 5 store F4 ->x(i) F16=F14+F2 6 store F8 ->x(i-1) F20=F18+F2 7 store F12->x(i-2) 8 store F16->x(i-3) 9 R1 = R1 - #40 10 BNEZ R1, Loop 11 store F20->x(i-4) 12 12 cycles per iteration Cost of calculation 1000 5 12 = 2400 cycles Effective performance : 1000 2400 = 42% of peak Performance limited by balance between int. and float. instr. 45/ 98

Survol des processeurs RISC Processeur RISC pipeliné: exemple pipeline d exécution à 4 étages stage #1 stage #2 stage #3 stage #4 fetch decode execute write result 46/ 98

Survol des processeurs RISC Processeur RISC superscalaire : plusieurs pipelines plusieurs instructions chargées + décodées + exécutées simultanément stage #1 stage #2 stage #3 stage #4 fetch decode execute write result pipeline #1 fetch decode execute write result pipeline #2 fetch decode execute write result pipeline #3 fetch decode execute write result pipeline #4 souvent opération entière / opérations flottante / load mémoire problème : dépendances largement utilisés : DEC, HP, IBM, Intel, SGI, Sparc,... 46/ 98

Survol des processeurs RISC Processeur RISC superpipeline : plus d une instruction initialisée par temps de cycle pipeline plus rapide que l horloge système exemple : sur MIPS R4000 horloge interne du pipeline est 2 (ou 4) fois plus rapide que horloge système externe Superscalaire + superpipeline : non existant 46/ 98

Exemples de processeurs RISC Exec. pipe D-cache I-cache inst./ Peak Processor MHz #stages (KB) (KB) cycle Perf. DEC 21064 200 7/9 8 8 2 200 DEC 21164 437 7/9 8 + 96 + 4 MB 8 4 874 HP PA 7200 120-2 MB ext. 2 240 HP PA 8000 180-2 MB ext. 4 720 IBM Power 66 6 32-64 8-32 4 132 IBM Power2 71.5 6 128-256 8-32 6 286 MIPS R8000 75 5/7 16+ 4 MB ext. 16 4 300 MIPS R10000 195-32 + 4 MB ext. 32 4 390 MIPS R12000 300-32 + 8 MB ext. 32 4 600 Pentium Pro 200-512 ext. 200 UltraSPARC I 167-16 + 512 KB ext. 16 2 334 UltraSPARC II 200-1 MB ext. 16 2 400 47/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 48/ 98

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 pas dans le cache 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 49/ 98

Stratégies les plus courantes : direct mapping fully associative set associative Conception des caches : L octets par ligne de cache K lignes par ensemble N ensembles Correspondance simple entre l adresse en mémoire et un ensemble : N = 1 : cache fully associative K = 1 : cache direct mapped 50/ 98

Direct mapping Chaque bloc en mémoire un placement unique dans le cache Problème de contention entre les blocs line cache Fully associative Pas de correspondance a priori main memory 51/ 98

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 52/ 98

Gestion des caches Coût d un défaut de cache : IBM RS/6000 : 8-11 C SUN SPARC 10 : 25 C 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 53/ 98

Cache coherency problem Processor # 1 Processor # 2 cache cache cache line X Y Cache coherency to: Avoid processors accessing old copies of data (copyback and writethrough) Update memory using copyback 54/ 98

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

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 56/ 98

Mémoire virtuelle Mémoire réelle : code et données doivent être logés en mémoire centrale (CRAY) Mémoire virtuelle : mécanisme de pagination entre la mémoire et les disques Une pagination mémoire excessive peut avoir des conséquences dramatiques sur la performance!!!! TLB : Translation Lookaside Buffer : correspondance entre l adresse virtuelle et l adresse réelle d une page en mémoire TLB sur IBM RS/6000 : 128 entrées Défaut de TLB : 36 C environ 57/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 58/ 98

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-étage 59/ 98

Réseau Crossbar 0 1 2 o o o o o o o o o o o o 3 o o o o o 1 2 3 Toute entrée peut être connectée à toute sortie sans blocage. Théoriquement, le plus rapide des réseaux mais concevable seulement pour un faible nombre d Entrées/Sortie. Utilisé sur calculateurs à mémoire partagée : Alliant, Cray, Convex,... 60/ 98

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

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. 62/ 98

Topologie : mode d assemblage des boîtes de connexion pour former un réseau de N = 2 p entrées / N sorties. La plupart des réseaux sont composés de p étages de N 2 boîtes. Exemple : Réseau Omega Topologie basée sur le Perfect Shuffle, permutation sur des vecteurs de 2 p éléments. 0 1 2 3 4 5 6 7 0 1 2 3 4 5 6 Le réseau Omega reproduit à chaque étage un Perfect Shuffle. Autorise la distribution d une entrée sur toutes les sorties ( broadcast ). Réseau Butterfly sur les machines BBN, Meiko CS2,... 7 63/ 98

0 1 2 4 0 3 5 6 1 2 3 4 5 6 7 7 0 1 2 3 4 5 6 7 0 1 2 4 5 6 7 3 A B C D E F G H I J K L Réseau Omega 8 8. 64/ 98

Autre exemple de topologie 0 A E 1 I 0 1 2 3 B F J 2 3 4 5 C G K 4 5 6 7 D H L 6 7 65/ 98

Réseaux mono-étage Réalisent un nombre fini de permutations entre les entrées et les sorties, chacune de ces permutations faisant l objet d une connexion physique (en général canal bidirectionnel). Généralement statique. Proc 1 Proc 2 Proc 3 Proc 4 Proc 5 Proc 6 Très utilisé dans les architectures à mémoire partagée. 66/ 98

Exemples : Bus partagé Proc #0 B U S Cache Local Memory Main Memory Proc #n Cache Local Memory Largement utilisé sur SMP (SGI, SUN, DEC,... ) 67/ 98

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,... 68/ 98

Shuffle Exchange : Perfect Shuffle avec en plus Proc # i connecté à Proc # (i+1) 0 1 2 3 4 5 6 7 N-cube ou hypercube : Proc #i connecté au Proc # j si i et j diffèrent d un seul bit. 0 1 2 3 4 5 6 7 Grand classique utilisé sur hypercubes Intel (ipsc/1, ipsc/2, ipsc/860), machines NCUBE, CM2,... 69/ 98

Figure: 4-Cube in space. 70/ 98

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 2 71/ 98

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,... ) 72/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 73/ 98

Statistiques Top 500 (voir www.top500.org) Liste des 500 machines les plus puissantes au monde Mesure: GFlops/s pour pour la résolution de où A est une matrice dense. Mis à jour 2 fois par an. Ax = b Sur les 10 dernières années la performance a augmenté plus vite que la loi de Moore: 1993: #1 = 59.7 GFlop/s #500 = 422 MFlop/s 2005: #1 = 136 TFlop/s #500 = 1 TFlop/s 74/ 98

Quelques remarques générales Arrivée massive d architectures de type IBM Blue Gene dans le top 10. NEC Earth simulator supercomputer (40Tflops, 5120 processeurs vectoriels) est resté en tête de Juin 2002 à Juin 2005. Il faut 15 Tflops/s pour entrer dans le Top 10. Le 500 ième (1.17 Tflops) aurait été 299 ème il y a 6 mois. Somme accumulée: 1.69 PFlop/s (contre 1.127 il y a 6 mois). 75/ 98

Remarques générales (suites) Domaine d activité Recherche 22%, Accadémie 19%, Industrie 53% Par contre 100% du TOP10 pour recherche et accadémie. France (10/500) dont 8 pour l industrie. Processeurs 333 systèmes basés sur de l Intel 52 sur de l IBM Power 3 ou 4 36 sur des HP PA-RISC 25 sur des AMD 9 sur des CRAY 7 sur des Nec 18/500 basés sur des processeurs vectoriels. Architecture 117 MPP (Cray SX1, IBM SP, NEC SX, SGI ALTIX, Hitatchi SR) pour 383 Clusters 76/ 98

Analyse des sites - Definitions Rang: Position dans le top 500 en Juin 2004. Rpeak: Performance maximum de la machine en nombre d opérations flottantes par secondes. Rmax: Performance maximum obtenue sur le test LINPACK. Nmax: Taille du problème ayant servi à obtenir Rmax. 77/ 98

Constructeur Nombre Pourcent. Rmax Rpeak Procs (TFlop/s) (TFlop/s) IBM 259 51.8 977 1660 374638 HP 131 26.2 224 373 80792 NEC 8 1.6 54 62 7448 SGI 24 4.8 125 148 3032 Dell 21 4.2 69 107 17038 Cray Inc. 16 3.2 72 89 16656 Sun 5 1 9 13 3440 Fujitsu 4 0.8 25 47 7488 Self-made 6 1.2 23 40 5360 All 500 100 1686 2632 580336 Statistiques constructeurs Top 500, nombre de systèmes installés.

Top 7 mondial Rang-Configuration Implantation #proc. Rmax Rpeak Nmax TFlops TFlops 10 3 1-IBM eserver BlueGene Solution DOE/NNSA/LLNL 65536 136 183 1278 2-IBM eserver BlueGene Solution IBM TJWatson Res. Ctr. 40960 91 114 983 3-SGI Altix 1.5GHz NASA/Ames Res.Ctr./NAS 10160 51 60 1290 4-NEC Earth simulator Earth Simul. Center. 5120 36 41 1075 5-IBM cluster, PPC-2.2GHz-Myri. Barcelona Supercomp. Ctr. 4800 27 42 977 6-IBM eserver BlueGene Solution ASTRON/Univ. Groningen 12288 27 34 516 7-NOW Itanium2-1.4GHz-Quadrix Los Alamos Nat. Lab. 8192 19 22 975 Stockage du problème de taille 10 6 = 8 Terabytes 79/ 98

Analyse des sites français Rang-Configuration Implantation #proc. Rmax Rpeak Nmax GFlops GFlops 10 3 77-HP AlphaServer SC45, 1GHz CEA 2560 3980 5120 360 238-HP Cluster P4 Xeon-2.4GHz Finance 512 1831 3276 251-IBM Cluster Xeon2.4GHz-Gig-E Total 1024 1755 4915 335 257-HP Cluster P4 Xeon-2.4GHz Caylon 530 1739 3392 258-HP Cluster P4 Xeon-2.4GHz Caylon 530 1739 3392 266-IBM Cluster Xeon2.4GHz-Gig-E Soc. Gen. 968 1685 4646 281-IBM eserver (1.7GHz Power4+) CNRS-IDRIS 384 1630 2611 359-SGI Altix 1.5GHz CEG Gramat 256 1409 1536 384-HP Superdome 875MHz France Telec. 704 1330 2464 445-HP Cluster Xeon 3.2 GHz Soc. Gen. 320 1228 2048 80/ 98

Répartition géographique Afrique: 3 Océanie : 8 Amérique: 294 Europe: 114 Brésil 4 Allemagne 40 Canada 7 France 10 Mexico 5 Italie 11 USA 277 RU 32 Espagne 4 Russie 3 Asie : 81 Chine 19 Japon 23 S. Arabia 5 81/ 98

Processor Types 82/ 98

Exemples d architecture de supercalculateurs Machines de type scalaire MPP IBM SP (NERSC-LBNL, IDRIS (France)) Cluster HP (Los Alamos Nat. Lab.) Non-Uniform Memory Access (NUMA) computer SGI Altix (Nasa Ames) Blue Gene L Machines de type vectoriel NEC (Earth Simulator Center, Japon) Cray X1 (Oak Ridge Nat. Lab.) 83/ 98

MPP IBM SP NERSC-LBNL Noeud 1 Noeud 416 P1 P16 P1 P16 12Gbytes 12Gbytes Réseau 416 Noeuds de 16 processeurs 6656 processeurs (Rpeak=9.9Teraflops) 375MHz processeur (1.5Gflops) Mémoire: 4.9 Terabytes Remarque: Machine pécédente (en 2000) Cray T3E (696 procs à 900MFlops et 256Mbytes) Supercalculateur du Lawrence Berkeley National Lab. (installé en 2001) 84/ 98

MPP IBM SP CNRS-IDRIS Noeud 1 Noeud 12 P1 P32 P1 P32 128Gbytes 128Gbytes Réseau 12 Noeuds de 32 processeurs 1.3GHz processeur (5.2Gflops) Mémoire: 1.5 Terabytes + X noeuds de 4 procs Supercalculateur de l IDRIS (installé en 2004) 384 processeurs (Rpeak=2.61Tflops) 85/ 98

ASCI Q Cluster de Los Alamos (12ème mondial) Performance: 20Tflops, 22Terabytes, Rmax (13.8Tera) Architecture (8192 procs): 2 Segments de 1024 noeuds (HP AlphaServer ES45s) 4 processeurs HP Alpha21264 EV-68 par noeud 2.6Gbytes/proc 86/ 98

Non Uniform Memory Access Computer SGI Altix 4.1Tbytes de mémoire globalement adressable C Brick 1 Noeud 1 Noeud 2 P1 P2 P1 P2 C Brick 128 Noeud 1 Noeud 2 P1 P2 P1 P2 16Gb 16Gb 16Gb 16Gb Réseau 128 C Bricks de 2 Noeuds de 2 procs 512 processeurs (Rpeak=3.1Teraflops) 1.5GHz Itanium 2 (6Gflops/proc) Mémoire: 4.1 Terabytes Remarque: NUMA et latence Noeud (145nsec); C Brick (290ns); Entre C Bricks(+ 150 à 400ns); Supercalculateur SGI Altix (installé à NASA-Ames en 2004) 87/ 98

NEC Earth Simulator Center (charactéristiques) 640 NEC/SX6 nodes 5120 CPU (8 GFlops) > 40 TFlops 2 $ Billions, 7 MWatts. 88/ 98

NEC Earth Simulator Center (architecture) Arithm. Proc 1 Arith. Proc. 8 Arithm. Proc 1 Arith. Proc. 8 Vector Scalar Vector Scalar Vector Scalar Vector Unit unit Unit unit Unit unit Unit Registers cache Noeud 1 Registers cache Registers cache Noeud 640 Scalar unit Registers cache Mémoire partagée (16Gbytes) Mémoire partagée (16Gbytes) Réseau (Crossbar complet) 640 Noeuds (8 Arith. Proc.) > 40Tflops Mémoire totale 10TBytes Vector unit (500MHz): 8 ens. de pipes (8*2*.5= 8Glops) (Rpeak > 16 flops // par AP) Supercalculateur NEC (installé en 2002) 89/ 98

Cray X1 d Oak Ridge National Lab. Performance: 6.4Tflops, 2Terabytes, Rmax(5.9TFlops) Architecture 504 Muti Stream processeurs (MSP): 126 Noeuds Chaque Noeud a 4 MSP et 16Gbytes de mémoire flat. Chaque MSP a 4 Single Stream Processors (SSP) Chaque SSP a une unité vectorielle et une unité superscalaire, total 3.2Gflops. 90/ 98

Cray X1 node 91/ 98

Blue Gene L (65536 procs, 183.5 TFlops peak) Système d exploitation minimal (non threadé) Consommation limitée: Seulement 256 MB de mémoire par noeud!! un noeud = 2 PowerPC à 700 MHz 2.8 GFlops ou 5.6 GFlops crête par noeud Plusieurs réseaux rapides avec redondances 92/ 98

Machines auxquelles on a accès depuis le LIP Calculateurs des centres nationaux IDRIS: 1024 processeurs Power4 IBM, 3 noeuds NEC SX1 CINES: 9 noeuds de 32 Power4 IBM, SGI Origin 3800 (768 processeurs),... Calculateurs régionaux/locaux: icluster2 à Grenoble: 100 bi-processeurs itanium Clusters de la fédération lyonnaise de calcul haute performance Grid 5000 node in Lyon: 55 bi-processeurs opteron pour l instant 93/ 98

Programmes nationaux d équipement USA: Accelerated Strategic Computing http://www.nnsa.doe.gov/asc/home.htm Début du projet : 1995 DOE (Dept. Of Energy) Objectifs : 100 Tera (flops and bytes) en 2004 France: le projet Grid 5000 (en plus des centres de calcul CNRS (IDRIS et CINES)) http://www.grid5000.org Début du projet : 2004 (Ministère de la Recherche) Objectifs : réseau de 5000 machines sur 8 sites répartis (Bordeaux, Grenoble, Lille, Lyon, Nice, Rennes, Toulouse) 94/ 98

Accelerated Strategic Computing (Initiative) Début du projet : 1995 (DOE) Objectifs : 10 TFlops en 2000 30 TFlops en 2001 100 TFlops en 2004 Principaux sites : Blue-Mountain : SGI + Los Alamos NL Clusters SGI Blue-Pacific : IBM + Lawrence Livermore NL Clusters IBM SP Red : Intel + Sandia NL Clusters Intel White-Pacific : IBM + Lawrence Livermore NL Clusters IBM SP 95/ 98

Prévisions La machine Blue Gene/L du LLNL une fois complète aura une performance crête de 360 TFlops. BlueGeneL et ses successeurs: 3 PFlops en 2010 Fujitsu prévoit de construire une machine au moins aussi puissante (3 PFlops) d ici 2010. 96/ 98

Plan 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 Mémoire cache Mémoire virtuelle Interconnexion des processeurs Les supercalculateurs du top 500 en Juin 2005 Conclusion 97/ 98

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 Programmation efficace? 98/ 98