calcul réparti et grid computing - enseeihtamestoy.perso.enseeiht.fr/cours/crgc_1011.pdf · 2010....

Calcul Réparti et Grid Computing

Patrick Amestoy et Michel Daydé (ENSEEIHT-IRIT)

préparé 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


3/ 378

I Intérêts du Calcul Haute-PerformanceI Applications temps-critiqueI Cas de calcul plus grosI Diminution du temps de réponseI Minimisation des coûts de calcul

I Difficultés

I Accès aux données : hiérarchie mémoire complexe→ Exploiter la localité des références aux données

I Identification et gestion du parallélisme dans une application→ Approche algorithmique

4/ 378

Systèmes parallèles : enfin l’age adulte !

I Les machines les plus puissantes sont à haut degré deparallélisme

I Le rapport prix / performance est attractif

I Plus que quelques constructeurs dans la course

I Systè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 évolutions:I 1 core per chip → multi-core chipsI supercomputing → métacomputing (“grid computing”)

5/ 378

Classes de calculateursI Serveurs de calcul :

I Utilisables sur une large gamme d’applicationsI Multiprogrammation et temps partagéI Stations de travail, serveurs départementaux, centre de calcul

I Calculateurs plus spécifiques :I Efficaces sur une classe plus limitée de problèmes (haut degré

de parallélisme)I A cause de leur architecture ou de limitations du logicielI Par exemple architectures massivement parallèles (MPP,

clusters de PC,.....)I Gains importants possibles avec rapport coût-performance

intéressantI Calculateurs spécialisés :

I Résolution d’un problème (image processing, crash test, . . . )I Hardware et logiciels conçus pour cette application-cibleI Gains très importants possibles avec un rapport

coût-performance très intéressantI Par exemple, la machine MDGRAPE-3 (dynamique

moléculaire) installée au Japon atteint 1 PFlop/s !

6/ 378

Besoins dans le domaine du calcul scientifique

Science traditionnelle

1. Construire une théorie,

2. Effectuer des expériences ou construire un système.

I trop difficile (ex: souffleries de grandes tailles)

I trop cher (fabriquer un avion juste pour quelques expérimentations)

I trop lent (attente de l’évolution du climat / de l’univers)

I trop dangereux (armes, médicaments, expérimentations sur leclimat)

Calcul scientifique

I simuler le comportement de systèmes complexes grâce à lasimulation numérique.

I lois physiques + algorithmes numériques + calculateurs hauteperformance

7/ 378

Exemples dans le domaine du calcul scientifique

I Contraintes de durée: pré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 parallèles ?

I Besoins de calcul non satisfaits dans beaucoup de disciplines(pour résoudre des problèmes significatifs)

I Performance uniprocesseur proche des limites physiques

Temps de cycle 0.5 nanoseconde↔ 4 GFlop/s (avec 2 opérations flottantes / cycle)

I Calculateur 20 TFlop/s ⇒ 5000 processeurs→calculateurs massivement parallèles

I Pas parce que c’est le plus simple mais parce que c’estnécessaire

I Objectif actuel (2010):

supercalculateur à 3 PFlop/s,500 TBytes de mémoire ?

11/ 378

Quelques unités pour le calcul haute performance

Vitesse

1 MFlop/s 1 Megaflop/s 106 opérations / seconde1 GFlop/s 1 Gigaflop/s 109 opérations / seconde1 TFlop/s 1 Teraflop/s 1012 opérations / seconde1 PFlop/s 1 Petaflop/s 1015 opérations / seconde

Mé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’opérations flottantes par seconde (pas MIPS)I Performance crête :

I Ce qui figure sur la publicité des constructeursI Suppose que toutes les unités de traitement sont activesI On est sûr de ne pas aller plus vite :

Performance crête = #unités fonctionnellesclock (sec.)

I Performance réelle :I Habituellement très inférieure à la précédente

Malheureusement

13/ 378

Rapport (Performance réelle / performance de crête) souvent bas !!Soit P un programme :

1. Processeur séquentiel:I 1 unité scalaire (1 GFlop/s)I Temps d’exécution de P : 100 s

2. Machine parallèle à 100 processeurs:I Chaque processor: 1 GFlop/sI Performance crête: 100 GFlop/s

3. Si P : code séquentiel (10%) + code parallélisé (90%)I Temps d’exécution de P : 0.9 + 10 = 10.9 sI Performance réelle : 9.2 GFlop/s

4. Performance réellePerformance de crête = 0.1

14/ 378

Loi d’Amdahl

I fs fraction d’une application qui ne peut pas être parallélisée

fp = 1− fs fraction du code parallélisé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 crê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 résolution d’un système d’équationslinéaires (d’après LINPACK Benchmark Dongarra [07])

16/ 378

Machine Problème de Problè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 problème Grand Challengeen 1995 (d’après J.J. Dongarra)

Depuis, les problèmes “Grand Challenge” ont grossi !

17/ 378

Outline


18/ 378

Evolutions architecturales: historique

Pour 1,000 $ : calculateur personnel plus performant, avecplus de mémoire et plus de disque qu’un calculateur desannées 70 avec 1,000,000 $

technologie et conception !

I Durant les 25 premières années de l’informatique progrès :technologie et architecture

I Depuis les années 70 :I conception basée sur les circuits intégrésI performance : +25-30% par an pour les “mainframes” et minis

qui dominaient l’industrie

I Depuis la fin des années 70 : émergence du microprocesseurI meilleure exploitation des avancées dans l’intégration que pour

les mainframes et les minis (intégration moindre)I progression et avantage de coût (production de masse) : de

plus en plus de machines sont basées sur les microprocesseursI possibilité de pourcentage d’amélioration plus rapide = 35%

par an

19/ 378

Evolutions architecturales: historique

I Deux changements sur le marché facilitent l’introduction denouvelles architectures :

1. utilisation décroissante de l’assembleur (compatibilité binairemoins importante)

2. systèmes d’exploitation standards, indépendants desarchitectures (e.g. UNIX)

⇒ développement d’un nouvel ensemble d’architectures :RISC à partir de 85

I performance : + 50% par an !!!I Conséquences :

I plus de puissance :I Performance d’un PC > CRAY C90 (95)I Prix très infèrieur

I Domination des microprocesseursI PC, stations de travailI Minis remplacés par des serveurs à base de microprocesseursI Mainframes remplacés par des multiprocesseurs à faible

nombre de processeurs RISC (SMP)I Supercalculateurs à base de processeurs RISC (essentiellement

MPP)19/ 378

Moore’s law

I Gordon Moore (co-fondateur d’Intel) a prédit en 1965 que ladensité en transitors des circuits intégrés doublerait tous les24 mois.

I A aussi servi de but à atteindre pour les fabriquants.I A été déformé:

I 24 → 18 moisI nombre de transistors → performance

20/ 378

Comment accrôıtre la vitesse de calcul ?

I Accélérer la fréquence avec des technologies plus rapides

On atteint les limites:I Conception des pucesI Consommation électrique et chaleur dissipéeI Refroidissement ⇒ problème d’espace

I On peut encore miniaturiser, mais:I pas indéfinimentI résistance des conducteurs (R = ρ×ls ) augmente et ..I la résistance est responsable de la dissipation d’énergie (effet

Joule).I effets de capacités difficiles à mâıtriser

Remarque: 1 nanoseconde = temps pour qu’un signalparcourt 30 cm de cable

I Temps de cycle 1 nanosecond ↔ 2 GFlop/s (avec 2opérations flottantes par cycle)

21/ 378

Seule solution: le parallélisme

I parallélisme: exécution simultanée de plusieurs instructions àl’intérieur d’un programme

I A l’intérieur d’un processeur :I micro-instructionsI traitement pipelinéI recouvrement d’instructions exécutées par des unités distinctes

→ transparent pour le programmeur(géré par le compilateur ou durant l’exécution)

I Entre des processeurs ou cœurs distincts:I suites d’instructions différentes exécutées

→ synchronisations implicites (compilateur, parallélisationautomatique) ou explicites (utilisateur)

22/ 378

Unités centrales haute-performance

Concept clé: Traitement pipeliné :

I L’exécution d’une opération (arithmétique) est décomposée enplusieurs sous-opérations

I Chaque sous-opération est exécutée par une unitéfonctionnelle dédiée = étage (travail à la chaine)

I Exemple pour une opérations diadique (a← b × c) :T1. Séparer mantisse et exposantT2. Multiplier mantissesT3. Additionner les exposantsT4. Normaliser le résultatT5. Ajouter signe au résultat

23/ 378

Exemple pour des opérations diadiques (suite)

I Supposition: l’opération a← b × c s’effectue en 5 traitementsélémentaires T1,T2,. . . ,T5 d’un cycle chacun. Quel est lenombre de cycles processeur pour la boucle suivante ?

Pour i = 1 à NA(i) = B(i) * C(i)

Fin Pour

I Traitement non pipeliné: N * 5 cyclesI Traitement pipeliné (à la chaine): N + 5 cycles

I 1er cycle: T1(1)I 2ème cycle: T1(2), T2(1)I 3ème cycle: T1(3), T2(2), T3(1)I . . .I kè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 (années 80) a eu un grand impact sur laconception des supercalculateurs :

I horloge la plus rapide possible

I unité vectorielle pipelinée sophistiquée

I registres vectoriels

I mémoire très haute performance

I multiprocesseurs à mémoire partagéeI processeurs vectoriels

I exploitent la régularité des traitements sur les éléments d’unvecteur

I traitement pipelinéI couramment utilisés sur les supercalculateursI vectorisation par le compilateur

25/ 378

Processeurs RISC

I Processeurs RISC : introduits sur le marché vers 1990“the attack of the killer micros”

I pipeline sur les opérations scalairesI performance proche de celle des processeurs vectoriels à

fréquence égaleI plus efficaces sur des problèmes scalaires

I CISC (Complex Instruction Set Computer)I Efficacité par un meilleur encodage des instructions

I RISC (Reduced Instruction Set Computer)I Concept étudié fin des années 70I Décrôıtre le nombre de cycles par instruction à 1

Jeu d’instructions simple↓

Hardware simplifié↓

Temps de cycle plus faible

26/ 378

I Idées mâıtresses dans la conception des RISC :I Instructions décodées en 1 cycleI Uniquement l’essentiel réalisé au niveau du hardwareI Interface load/store avec la mémoireI Utilise intensivement le principe du pipeline pour obtenir un

résultat par cycle même pour les opérations complexesI Hiérarchie mémoire haute-performanceI Format d’instructions simpleI RISC super scalaires ou superpipelines: plusieurs unités

fonctionnelles

27/ 378

Architectures multi-cœurs

ConstatsI La quantité de composants / puce va continuer à augmenter

I La fréquence ne peut plus augmenter beaucoup(chaleur/refroidissement)

I Il est difficile de trouver suffisamment de parallélisme dans leflot d’instructions d’un processus

Multi-cœursI plusieurs cœurs à l’intérieur d’un même processeur

I vus comme plusieurs processeurs logiques par l’utilisateur

I Mais: multi-threading nécessaire au niveau de l’application

28/ 378

Processeur Cell

I La PS3 est basé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 crêteen arithmétique 32 bits

(14.6 GFlop/s en 64 bits)

I D’où regain d’intérêt pour le calcul en 32 bitsI Mélange d’arithmétiques simple et double précision (voir [13])I Typiquement: 32-bit pour le gros des calculs, 64 bits pour

améliorer la pré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

Anné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 décennie

Problèmes

I On est souvent (en pratique) à 10% de la performance crêteI Processeurs plus rapides → accès aux données plus rapide :

I organisation mémoire,I communication inter-processeurs

I Hardware plus complexe : pipe, technologie, réseau, . . .

I Logiciel plus complexe : compilateur, système d’exploitation,langages de programmation, gestion du parallélisme,. . . applications

Il devient plus difficile de programmer efficacement

32/ 378

Problèmes de débit mémoire

I L’accés aux données est un problème crucial dans lescalculateurs modernes

I Accrôıssement de la vitesse de calcul sans accrôıtre le débitmémoire → goulet d’étranglement

MFlop/s plus faciles que MB/s pour débit mémoire

I

Temps de cyle processeurs → 2 GHz (.5 ns)Temps de cycle mémoire → ≈ 20 ns SRAM

≈ 50 ns DRAM

33/ 378

Comment obtenir de hauts débits mémoire ?

I Plusieurs chemins d’accès entre mémoire et processeursI CRAY XMP et YMP :

I 2 vector load + 1 vector store + 1 I/OI utilisés pour accéder des vecteurs distincts

I NEC SX :I chemins d’accès multiples peuvent être aussi utilisés pour

charger un vecteur

I (améliore le débit, mais pas la latence !)

I Plusieurs modules mémoire accédés simultanément(entrelaçage)

I Accès mémoire pipelinés

I Mémoire organisée hiérarchiquementI La façon d’accéder aux données peut affecter la performance:

I Minimiser les défauts de cacheI Minimiser la pagination mémoireI Localité: améliorer le rapport références à des mémoires

locales/ références à des mémoires à 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 hiérarchie mémoire.

35/ 378

Conception mémoire pour nombre important deprocesseurs ?

Comment 100 processeurs peuvent-ils avoir accès à des donnéesrangées dans une mémoire partagée (technologie, interconnexion,prix ?)→ Solution à coût raisonnable : mémoire physiquement distribuée(chaque processeur a sa propre mémoire locale)

I 2 solutions :I mémoires locales globalement adressables : Calulateurs à

mémoire partagée virtuelleI transferts explicites des données entre processeurs avec

échanges de messagesI Scalibité impose :

I augmentation linéaire débit mémoire / vitesse du processeurI augmentation du débit des communications / nombre de

processeurs

I Rapport coût/performance → mémoire distribuée et bonrapport coût/performance sur les processeurs

36/ 378

Architecture des multiprocesseurs

Nombre élevé de processeurs → mémoire physiquement distribuée

Organisation Organisation physiquelogique Partagée (32 procs max) DistribuéePartagée multiprocesseurs espace d’adressage global

à mémoire partagée (hard/soft) au dessus de messagesmémoire partagée virtuelle

Distribuée émulation de messages échange de messages(buffers)

Table: Organisation des processeurs

Remarque: standards de programmation

Organisation logique partagée: threads, OpenMPOrganisation logique distribuée: PVM, MPI, sockets

37/ 378

Remarques

Mémoire physiquement partagée

I Temps d’accès uniforme à toute la mémoire

Mémoire physiquement distribuée

I Temps d’accès dépend de la localisation de la donnée

Mémoire logiquement partagée

I Espace d’adressage unique

I Communications implicites entre les processeurs via lamémoire partagée

Mémoire logiquement distribuée

I Plusieurs espaces d’adressage privés

I Communications explicites (messages)

38/ 378

Terminologie

Architecture SMP (Symmetric Multi Processor)

I Mémoire partagée (physiquement et logiquement)

I Temps d’accès identique à la mé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 Mémoire physiquement distribuée et logiquement partagée

I Plus facile d’augmenter le nombre de procs qu’en SMP

I Temps d’accès dépend de la localisation de la donnée

I Accès locaux plus rapides qu’accès distants

I hardware permet la cohérence des caches (ccNUMA)39/ 378

Outline


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 exécutent de façon synchrone la même instruction

sur des données différentes (e.g. éléments d’un vecteur, d’unematrice, d’une image)

I une unité de contrôle diffuse les instructionsI processeurs identiquesI Exemples : CM-2, DAP, MasPar,. . .I plus récemment: chacun des 8 SPE du processeur CELL se

comporte comme un système SIMD

41/ 378

I M.I.S.D. : n’existe pasI M.I.M.D. : Multiple Instructions Multiple Data stream

I processeurs exécutent de façon asynchrone des instructionsdifférentes sur des données différentes

I processeurs éventuellement hétérogènesI chaque processeur a sa propre unité de contrôleI exemples : ALLIANT, CONVEX, CRAYs, IBM SP, clusters

BEOWULF, serveurs multi-processeurs, réseaux de stations detravail, . . .

42/ 378

Modes de programmation SIMD et MIMD

I Avantages du SIMD :I Facilité de programmation et de débogageI Processeurs synchronisés → coûts de synchronisation

minimauxI Une seule copie du programmeI Décodage des instructions simple

I Avantages du MIMD :I Plus flexible, beaucoup plus généralI Exemples:

I mémoire partagée: OpenMP, threads POSIXI mémoire distribuée: PVM, MPI (depuis C/C++/Fortran)

43/ 378

Outline


44/ 378

Evolutions du Calcul Haute-Performance

I Mémoire virtuellement partagée :I clustersI Hiérarchie mémoire plus étendue

I Clusters de machinesI Souvent à base de PCs (Pentium ou Dec Alpha, NT ou

LINUX)

I Programmation parallèle (mémoire partagée, transfert demessage, data parallèle) :

I Efforts de définition de standards : Open MP et threadsPOSIX, MPI, HPF, . . .

I MPPs et clustersI représentent l’avenir pour le calcul haute-performanceI rapport communicationspuissance de calcul souvent faible par rapport aux

multiprocesseurs à mémoire partagéeI intégration dans l’ensemble des moyens de calcul d’une

entreprise de plus en plus courante

45/ 378

Environnements de programmation

I On n’évitera pas le calcul parallèleI Logiciels ont toujours un temps de retard / aux architectures

I Système d’exploitationI Parallélisation automatiqueI Logiciels applicatifs et librairies scientifiques

I Pour des architectures massivement parallèles :I Standard de programmation : MPI ou MPI + threads

(POSIX/OpenMP)I Langages: le plus souvent C ou FortranI Besoins d’outils de dévelopement (débogueurs, compilateurs,

analyseurs de performance, librairies, . . . )I Développements/maintenance difficiles et difficultés

d’utilisation des outils de mise au point.

46/ 378

HPC Spectrum (d’aprè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 générauxIntroductionOrganisation des processeursOrganisation mémoireOrganisation interne et performance des processeurs vectorielsOrganisation des processeurs RISCRéutilisation des données (dans les registres)Mémoire cacheRéutilisation des données (dans les caches)Mémoire virtuelleRéutilisation des données (en mémoire)Interconnexion des processeursLes supercalculateurs du top 500 en Juin 2010Conclusion

48/ 378

Outline


49/ 378

Introduction

I Conception d’un supercalculateurI Déterminer quelles caractéristiques sont importantes (domaine

d’application)I Maximum de performance en respectant les contraintes de

coût (achat, maintenance,consommation)I Conception d’un processeur :

I Jeu d’instructionsI Organisation fonctionnelle et logiqueI Implantation (intégration, alimentation, . . . )

I Exemples de contraintes fonctionnelles vs domained’application

I Machine généraliste : performance équilibrée sur un largeensemble de traitements

I Calcul scientifique : arithmétique flottante performanteI Gestion : base de données, transactionnel, . . .

50/ 378

Outline


51/ 378

Pipeline

I Pipeline = principe du travail à la châıneI un traitement est découpé en un certain nombre de

sous-traitements réalisés par des unités différentes (étages dupipeline)

I les étages fonctionnent simultanément sur des opérandesdifférents (éléments de vecteurs par exemple)

I après amorçage du pipeline, on obtient un résultat par tempsde cyle de base

I Processeur RISC :I Pipeline sur des opérations scalaires indépendantes :

a = b + cd = e + f

I Code exé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 → dé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

Problèmes dans la conception des pipelines

I Beaucoup d’étages:I coût d’amorçage plus élévéI performances plus sensibles à la capacité de nourrir le pipelineI permet de réduire le temps de cycle

I

I Moins d’étagesI sous-instructions plus complexesI plus difficile de décrôıtre le temps de cycle

55/ 378

Problèmes des dépendences de données

I Exemple :

do i = 2, na(i) = a(i-1) + 1

enddo

a(i) initialisés à 1.

I Exé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 Exécution vectorielle : pipeline à p étages → p élé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’où :

a(2) = a(1) + 1 = 1 + 1 = 2a(3) = a(2) + 1 = 1 + 1 = 2...

car on utilise la valeur initiale de a(2).

Résultat exécution vectorielle 6= exécution scalaire57/ 378

Overlapping (recouvrement)

I Utiliser des unités fonctionnelles en parallèle sur desopérations indé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: parallélisme entre les unités fonctionnellesindépendantes et plus de flops par cycle

58/ 378

Chaining (châınage)

I La sortie d’une unité fonctionnelle est dirigée directement versl’entrée d’une autre unité 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 localitédes données, économie de stockage intermédiaire

59/ 378

Outline


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


67/ 378

Organisation interne et performance des processeursvectoriels (d’après J. Dongarra)

I Soit l’opération vectorielle triadique :

do i = 1, ny(i) = alpha * ( x(i) + y(i) )

enddoI On a 6 opé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 considérées :

1. Séquentielle2. Arithmétique châınée3. Load mémoire et arithmétique châınées4. Load mémoire, arithmétique et store mémoire châınés5. Recouvrement des loads mémoire et opérations châınées

I Notations :

a : startup pour load mémoireb : startup pour additionc : startup pour multiplicationd : startup pour store mé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


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


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


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

Outline


89/ 378

Réutilisation des données (dans les registres)

I Améliorer l’accès aux données et exploiter la localité spatialeet temporelle des références mémoire

I Déroulage de boucles : réduit le nombre d’accès mémoire enutilisant le plus de registres possible

I Utiliser des scalaires temporaires

I Distribution de boucles : si nombre de données réutilisables >nombre de registres : substituer plusieurs boucles à une seule

90/ 378

Déroulage de boucle

Objectif : réduire nombre d’accès mémoire et améliorer pipelineopé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 adaptés à 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/références mémoire = 22 = 1

92/ 378

Réutilisation de x(j) : déroulage à 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/références mémoire = 43I Déroulage à une profondeur de 4 : 85I Déroulage à 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 préféré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/références mémoire = 23

97/ 378

Réutilisation de y(i) : déroulage à 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/références mémoire = 1

I Déroulage à profondeur 4 → Ratio = 43I Déroulage à profondeur p → Ratio = 2p2+p

99/ 378

Outline


100/ 378

Organisation d’une mémoire cache

I CacheI Buffer rapide entre les registres et la mémoire principaleI Divisé en lignes de cache

I Ligne de cacheI Unité de transfert entre cache et mémoire principale

I Défaut de cacheI Référence à une donnée non présente dans le cacheI Stratégie de choix d’une ligne à remplacer (LRU parmi les

éligibles)I Une ligne de cache contenant la donnée est chargée de la

mémoire principale dans le cache

I Problème de la cohérence de cache sur les multiprocesseurs àmémoire partagée

I Rangement des données dans les cachesI correspondance mémoire ↔ emplacements dans le cache

101/ 378

I Straté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 degré d’associativité)I N ensembles

I Correspondance simple entre l’adresse en mémoire et unensemble :

I N = 1 : cache “fully associative”I K = 1 : cache “direct mapped”

102/ 378

I “Direct mapping”I Chaque bloc en mémoire ↔ un placement unique dans le cacheI Recherche de données dans cache peu coûteuse (mais

remplacement coûteux)I Problème de contention entre les blocs

line

cache

main memory

I “Fully associative”I Pas de correspondance a prioriI Recherche de données dans cache coûteuse

103/ 378

I “Set associative”I Cache divisé en plusieurs ensemblesI Chaque bloc en mémoire peut ê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 Coût d’un défaut de cache : entre 2 et 50 C (temps de cycle)I “Copyback”

I Pas de m-à-j lorsqu’une ligne de cache est modifiée, exceptélors d’un cache flush ou d’un défaut de cache

Mémoire pas toujours à jour.Pas de problème de cohérence si les processeurs modifient des

lignes de cache indépendantes

I “Writethrough”I Donnée écrite en mémoire chaque fois qu’elle est modifiée

Données toujours à jour.Pas de problème de cohérence si les processeurs modifient des

données indé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


108/ 378

Réutilisation des donné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


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


Il est critique d’utiliser au maximum les données dans le cache ↔améliorer le % de succès de cache

I Exemple : effet du % de défauts de cache sur un code donné

I Pmax performance lorsque toutes les données tiennent dans lecache (hit ratio = 100%). Tmin temps correspondant.

I Lecture de donnée dans le cache par une instruction etexécution : thit = 1 cycle

I Temps d’accès à une donnée lors d’un défaut de cache : tmiss= 10 ou 20 cycles (exé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 défauts de cache sur la performance d’un code (exprimésen pourcentages vs pas de dé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


117/ 378

Mémoire virtuelle

I Mémoire réelle : code et données doivent être logés enmémoire centrale (CRAY)

I Mémoire virtuelle : mécanisme de pagination entre lamémoire et les disques

Une pagination mémoire excessive peut avoir desconséquences dramatiques sur la performance !!!!

I TLB :I Translation Lookaside Buffer : correspondance entre l’adresse

virtuelle et l’adresse réelle d’une page en mémoireI TLB sur IBM Power4/5: 1024 entréesI Défaut de TLB : 36 C environ

I AIX offre la possibilité d’augmenter la taille des pages (jusqu’à16 MB) pour limiter les défauts de TLB.

118/ 378

Outline


119/ 378

Exercice sur la réutilisation des données (enmémoire)

(inspiré de (Dongarra, Duff, Sorensen, van der Vorst [7]))C ← C + A× BA, B, C : matrices n × n, n = 20000, stockées par colonnes

I Calculateur vectoriel (Performance de crête 50 GFlop/s)

I Mémoire virtuelle (remplacement page : LRU)

I 1 page mémoire = 2Mmots = 100 colonnes de A, B, ou C(1 mot = 8 bytes)

I 1 défaut de page ≈ 10−4 secondesI Stockage de A, B, et C :

3× 400Mmots = 3× 3.2 GB = 9.6 GBI capacité mémoire : 128 pages soit:

128× 2Mmots = 256Mmots = 2GB → A, B, C ne peuventêtre stockées totalement

120/ 378

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 bloquéLes matrices sont partitionées en blocs de colonnes tq bloc-colonne(nb = 400 colonnes) = 4 pages mémoire.

Réutilisation maximale des sous-matrices en mé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

Défauts de page :

I nb = 400 colonnes (4 pages mémoire)

I accès à B et C, défauts de page lors de la boucle en j: 200défauts de page

I n/nb accès (boucle en j) à A par blocs de colonnes, pourchaque indice k : 200, soit n/nb × 200 au total.

I Total ≈ ( nnb + 2)× 200 défauts de pageI nb = 400 donc nnb = 50

I et donc ≈ 104 défauts de pageI Temps de chargement mémoire = 1 sec

Attention : le temps de calcul n’est plus négligeable !!Temps = 2× n3/vitesse ≈ 320 secondesIdées identiques au blocage pour cacheBlocage : très efficace pour exploiter au mieux une hiérarchiemémoire (cache, mémoire virtuelle, . . . )

125/ 378

Outline


126/ 378

Interconnexion des processeurs

I Réseaux constitués d’un certain nombre de bôıtes deconnexion et de liens

I Commutation de circuits : chemin créé physiquement pourtoute la durée d’un transfert (idéal pour un gros transfert)

I Commutation de paquets : des paquets formés de données +contrôle trouvent eux-même leur chemin

I Commutation intégrée : autorise les deux commutationsprécédentes

I Deux familles de réseaux distincts par leur conception et leurusage :

I Réseaux mono-étageI Réseaux multi-étages

127/ 378

I Anneau

Proc 1 Proc 2 Proc nProc 0

I GrilleProc Proc Proc Proc

ProcProcProc

Proc Proc Proc Proc

ProcProcProcProc

Proc

Utilisé sur Intel DELTA et PARAGON, . . .128/ 378

I Shuffle Exchange : Perfect Shuffle avec en plus Proc # iconnecté à Proc # (i+1)

1 2 3 4 5 6 70

I N-cube ou hypercube : Proc #i connecté au Proc # j si i et jdiffèrent d’un seul bit.

0 1 2 3 4 5 6 7

I Grand classique utilisé 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 distribuées

I Notations :I # procs = N = 2p

I diamè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 Réseaux hiérarchiques/multi-étagesI Beaucoup de redondances (bande passante, connections

simultanées)

I Conséquence sur les calculateurs haute performance:I Peu de différence de coût selon sources/destinationsI La conception des algorithmes parallèles ne prend plus en

compte la topologie des réseaux (anneaux, . . . )

132/ 378

Outline


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 résolution deAx = b, A matrice dense.

I Mises à jour 2 fois par an (Juin/ISC, Novembre/SC).

I Sur les 10 dernières années la performance a augmenté plusvite que la loi de Moore:

134/ 378

Analyse des sites - Definitions

I Rang (noté # par la suite): Position dans le top 500.

I Rpeak (Gflop/s): Performance crête de la machine en nombred’opérations flottantes par secondes.

I Rmax (Gflop/s): Performance maximum obtenue sur le testLINPACK

I Nmax: Taille du problème ayant servi à obtenir Rmax.I Power (MWatt/s) : Watt/s consommés (voir aussi

www.green500.org)I La consommation énergétique d’un système du TOP10 est de

2,89 MWatt (contre 2,45 il y a un an).I L’efficacité énergétique s’améliore : 300 MFlops/Watt contre

280 il y a un an.I Les calculateurs à efficacité energétique la plus forte possédent

des processeurs cell (pouvant aller jusqu’à 774 Mflops/Watt).

135/ 378

Top 500: é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 energé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 générales (Juin 2010)

I Jaguar (# 1, performance de crête 2.3 Petaflops/s et 1.75atteint sur du Linpack) possé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 decrète de Nebulae (3 Petaflop/s) > performance de crête deJaguar. Machines hybrides basées sur processeurs Intel Xeonet Accelerateurs AMD ou NVidia.

I Processeurs :

I 425/500 systèmes utilisent des processeurs quad-core.I 408 Intel, 47 AMD Opteron, 42 IBM Power processorsI 186 systèmes basés sur des Intel Core i7 (Nehalem-EP)

138/ 378

Remarques géné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 numéro 37. Est restéen tête de Juin 2002 à Juin 2004.

I Le 500 ième (24.7 TeraFlops effectif) était 226 au 6/2009.

I Somme cumulé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 Systè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 systèmesinstallé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

Répartition par segment d’activité

Noter que 300/500 des calculateurs sont dans l’industrie mais “nereprésentent que” 31% de la puissance cumulée

143/ 378

Répartition géographique

Afrique: 1 Océanie : 8Amérique: 290 Europe: 144

Bré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 français – Juin 2010 (10/27)

Rang Site Systè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 concerné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 à 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 (installé à 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 mémoire “flat”.I Chaque MSP a 4 Single Stream Processors (SSP)I Chaque SSP a une unité vectorielle et une unité superscalaire,

total 3.2Gflops.

149/ 378

Cray X1 node

150/ 378

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

I Système d’exploitationminimal (non threadé)

I Consommation limitée:I 32 TB mais seulement

512 MB de mémoire parnoeud !

I un noeud = 2 PowerPC à700 MHz (2x2.8 GFlop/s)

I 2.8 GFlop/s ou 5.6GFlop/s crête par noeud

I Plusieurs réseaux rapidesavec redondances

151/ 378

Blue gene: efficace aussi en Mflops/watt

152/ 378

Pour entrer dans l’è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 complè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 Différence Cell BroadBand Engine(CBE) et IBM PowerXCell 8i

I Amélioration significative de laperformance des calculs 64bits(100Gflops/15Gflops)

I Mémoire plus rapide

I Programmation du RoadrunnerI 3 compilateurs : Opteron,

PowerPC et Cell SPE jeud’instructions

I Gestion explicite des données etprogrammes entre Opteron,PowerPC et Cell.

154/ 378

Prévisions

I Projet japonnais (10 Pflops en 2011).

I Architectures à base de noeuds hybrides incluant desprocesseurs vectoriels/Cell

155/ 378

Outline


156/ 378

Conclusion

I Performance :I Horloge rapideI Parallélisme interne au processeur

I Traitement pipelinéI Recouvrement, châınage des unités fonctionnelles

I Parallélisme entre processeurs

I Mais :I Accès aux données :

I Organisation mémoireI Communications entre processeurs

I Complexité du hardwareI Techniques de compilation : pipeline / vectorisation /

parallélisation

Comment exploiter efficacement l’architecture ?

157/ 378

Ecriture de code efficace (I) : MFLOPS ou MIPS ?

I MFLOPS: floating point operations /sec.Ne dépend pas du calculateur

I MIPS: instructions de bas-niveauDépend du calculateur

I Watt: code efficace sur des machines a faible consommationen Watt par proc. (Exemple des proc. Cell).

I Précision des calculs: travail partiel en précision numériqueaffaiblie (plus efficace).

158/ 378

Ecriture de code efficace (II)

I Facteurs architecturaux influençant la performance :I débit et latence mémoireI coûts des communications et de synchronisationI temps d’amorçage des unités vectoriellesI besoins en entrées/sorties

I Facteurs dépendant de l’application :I parallélisme (dépend des algorithmes retenus)

I régularité des traitementsI équilibrage des traitementsI volume de communications (localité)I granularité - scalabilité

I Localité des donné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 précédente.

160/ 378

I La mesure du rapport entre le nombre d’opérations flottanteset de réferences mémoire pour chacun des noyaux de calculexplique le potentiel.

I x = x + αyI 3n références mémoireI 2n opérations flottantesI rapport Flops/Ref = 2/3

I y = A× x + yI n2 références mémoireI 2n2 opérations flottantesI rapport Flops/Ref = 2

I C = C + A× BI 4n2 références mémoireI 2n3 opérations flottantesI rapport Flops/Ref = n/2

I Typiquement Vitesse (3) = 5 × vitesse(2) et vitesse(2) = 3 ×vitesse(1) . . . si on utilise des bibliothèques optimisées !

161/ 378

Limites de l’optimisation de code et de lavectorisation/parallé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 : parallélisent la boucle d’indice j etoptimisent / vectorisent la boucle d’indice i

162/ 378

Table: Performance de versions différentes de GEMM sur processeursRISC avec des matrices 128 × 128.

Calculateur standard optimisé perf. de crê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 réalisées par les compilateurs sur laboucle interne

I En théorie très bon potentiel grâce au rapport entreopérations flottantes et références mémoire : ( 4n2 référencesmémoire, 2n3 opérations flottantes)

i.e. n2 mais les compilateurs ne savent pas l’exploiter !!

163/ 378

I Optimisation de code :I Améliorer l’accès aux données et exploiter la localité spatiale et

temporelle des références mémoireI Déroulage de boucles : réduit le nombre d’accés mémoire en

améliorant la réutilisation des registres, permet aussi unemeilleure exploitation du parallélisme interne aux processeurs

I Blocage pour une utilisation efficace du cache : améliore lalocalité spatiale et temporelle

I Copie des données dans des tableaux de travail pour forcer lalocalité et éviter des ”strides” critiques (pas toujours possiblescar parfois trop coûteux)

I ”prefetch” des donnéesI Utilisation de l’assembleur (cas désespéré !!)I Utilisation de bibliothèques optimisées (cas ideal !!)

164/ 378

Utilisation d’une bibliothèque optimiséeI Noyaux de calcul matriceXmatrice optimisé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 algèbrelinéaire (BLAS) (J. Dongarra)

Outline

La programmation par mode messageContexte informatique, objectifs et besoinsLe modèle de programmation par transfert de messagesEnvoi et réception de messagesChoisir un mode de communication

166/ 378

Outline


167/ 378

Contexte informatique

I Multiprocesseur à mémoire distribuée ou réseau de stations detravail

network #1

computer #2

computer #1

cluster

network #2

multiprocessor

Exemple de réseau de calculateurs.

168/ 378

Objectifs et besoins

I But : répartir/gérer des calculs sur la machine cibleI Outils nécessaires : ( minimum )

I Sécurité et droits d’accés (machines et données)I Création de processus distantsI Communication entre processusI Synchronisation entre processusI Gestion de la cohérence des donnés et des traitementsI Séquenceur des tâches répartiesI Gestion dynamiques des processeurs et des processus

(gestion des pannes, gestion de points de reprises)

169/ 378

Outline


170/ 378

Le modèle de programmation par transfert demessages

I Permet d’exprimer la communication et la synchronisation

I C’est le modèle le plus répandu en calcul répartimais ce n’est pas le seul (voir par ex. LINDA )

I Il n’apporte pas de solution à tous les problèmes posés.I Caractéristiques :

I expression du parallélisme à la charge du programmeurI distribution des données à la charge du programmeurI l’échange de données est expliciteI prise en compte possible d’un réseau hétérogènes de

calculateurs avec gestion des pannes.

171/ 378

Modèle pelure d’oignon pour l’échange de message

Chaque niveau peut-être construit au dessus du précédent

I Niveau le plus bas : adressage au niveau canalI procédures pour transférer des paquets sur des liens

I Adressage au niveau processusI éventuellement plus d’un processus par processeurI échange de message en donnant l’adresse d’un processusI Exemples : Nx sur iPSC, Vertex sur nCUBE, Express,

PARMACS, PVM, MPI, . . .

I Niveau plus élevé d’abstraction : mémoire partagée virtuelle,LINDA, espace de tuples partagé ou réparti)

172/ 378

Hypothèse d’exécution

I Machine complètement connectée

I Routeur automatique de messages

P22

P21

Machine 3P31

P12

P11

Machine 1 Machine 2

Processus

les deux hypothèses ci-dessus ne sont pas toujours vraies(Transputers)

173/ 378

Bibliotèques portables pour la programmationd’applications parallèles distribuées

I P4 de l’Argonne National LaboratoryI offre à la fois les modèles mémoire partagée et transfert de

messageI communications entre processusI disponible et optimisé sur une large gamme de calculateurs (et

réseaux de calculateurs)

I PICL de l’Oak Ridge National Laboratory portable sur unelarge gamme de multiprocesseurs à mémoire distribuée

I PVM : Univ. Tennessee, Univ. Emory, Oak Ridge Nat. Lab.,. . .

I pour réseaux hétérogènes de calculateursI aussi disponible sur multiprocesseurs

I MPI : le standard pour le transfert de message

174/ 378

Outline


175/ 378

Envoi et réception de messages

Un arbre qui cache la forêt

176/ 378

Environnement d’exécution des communications

I Chaque processus est identifié par un numéro d’instance(rang dans un groupe ou communicateur)

I L’enveloppe d’un message doit permettre la caractérisationet le traitement du message. Elle contient:

1. le numéro de l’émetteur2. le numéro du récepteur3. le label du message4. la taille du message5. . . .

177/ 378

Types de communication classiques

I communications point à point (one-to-one) :é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 :échange global d’informations entre plusieurs processus

178/ 378

Communications point à point(quelques questions)

I Envoi et réception de messagesProcessus

Temps

Source

Send (Dest, data)

Dest

Recv(Source, data)data

data

I Questions:I Synchronisation entre l’envoi et la réception ?I Quand peut-on réutiliser la donnée envoyée ?I Bufferisation des communications ?

179/ 378

Outline


180/ 378

Choisir un mode de communication(Communications Synchrones/ Asynchrones)

I Envoi/réception synchrones:Le premier arrivé attend l’autre (notion de rendez-vous).

I Envoi/Réception asynchrones:L’émetteur et le récepteur ne s’attendent pas.

I Un envoi asynchrone peut cependant être bloqué par la nonconsommation du message par le récepteur(ceci sera détaillé

calcul réparti et grid computing - enseeihtamestoy.perso.enseeiht.fr/cours/crgc_1011.pdf · 2010....

Documents