Vous êtes sur la page 1sur 67

Architectures et Syst` emes des Calculateurs Parall` eles

Fran cois PELLEGRINI ENSEIRB pelegrin@enseirb.fr 3 octobre 2003

Ce document est copiable et distribuable librement et gratuitement a ` la condition expresse que son contenu ne soit modi e en aucune fa con, et en particulier que le nom de son auteur et de son institution dorigine continuent a ` y gurer, de m eme que le pr esent texte.

Cours darchitectures et syst` emes des calculateurs parall` eles

Avant-propos
La loi de Moore, enonc ee en 1975, et toujours v eri ee depuis, stipule que la puissance des ordinateurs, a ` prix egal, double en moyenne tous les 14 mois. Cette am elioration constante en puissance ne peut sexpliquer par la simple augmentation de la fr equence des processeurs, car celle-ci na pas suivi la m eme evolution. Elle est le fruit dune intense recherche qui porte tout a ` la fois sur larchitecture g en erale du processeur, loptimisation du c ablage de ses op erations, les strat egies ecaces de pr ediction de branchement, la d enition de hi erarchies m emoire, les techniques de compilation avanc ees, loptimisation des ressources disques, et lam elioration des syst` emes dexploitation. Lobjectif de ce cours est de faire un tour densemble des techniques mat erielles et logicielles mises en uvre au sein des architectures des processeurs hautes performances, an den tirer parti au maximum lors de l ecriture de programmes faisant un usage intensif du processeur et de la m emoire.

Cours darchitectures et syst` emes des calculateurs parall` eles

Ouvrages de r ef erence
Highly Parallel Computing Second edition, G. S. Almasi et A. Gottlieb. Benjamin Cummings. Advanced Computer Architecture : Parallelism, Scalability, Programmability, K. Hwang. McGraw-Hill. Designing and Building Parallel Programs, I. Foster. Addison-Wesley, http :// www.mcs.anl.gov/dbpp/. Practical Parallel Computing, H. S. Morse. AP Professional. Algorithmes et Architectures Parall` eles,M. Cosnard et D. Trystram.Inter Editions. CPU Info Center, http ://infopad.eecs.berkeley.edu/CIC/. Journal of Parallel and Distributed Computing, . . .

Cours darchitectures et syst` emes des calculateurs parall` eles

Chapitre 1

Introduction
1.1 Un aper cu du parall elisme

Depuis les d ebuts de linformatique sest pos ee la question de r esoudre rapidement des probl` emes (le plus souvent num eriques) co uteux en temps de calcul : simulations num eriques, cryptographie, imagerie, S.G.B.D., etc. Pour r esoudre plus rapidement un probl` eme donn e, une id ee naturelle consiste a ` faire coop erer simultan ement plusieurs agents a ` sa r esolution, qui travailleront donc en parall` ele. ` titre dillustration, on peut se repr A esenter le travail dun ma con en train de monter un mur de briques. Sil est seul, il proc` ede rang ee par rang ee (gure 1.1).

13 7 1 Tas de briques 8

14 9 2

15 10 3 Mur

16 11 4

17 12 5

18 6

Fig. 1.1 S equencement du travail dun ma con travaillant seul. Si lon veut monter le mur plus rapidement, on peut faire appel a ` deux ma cons, qui peuvent organiser leur travail de plusieurs mani` eres di erentes. a) Chacun pose une brique, lun apr` es lautre (gure 1.2). Dans ce cas, ils risquent de se g ener mutuellement, tant pour prendre les briques dans le tas que pour les mettre en place.

7a 4a 1a Tas de briques 4b

7b 5a 1b

8a 5b 2a Mur

8b 6a 2b

9a 6b 3a

9b 3b

Fig. 1.2 S equencement du travail de deux ma cons travaillant brique par brique.

CHAPITRE 1. INTRODUCTION b) Chacun sattribue une portion de mur pour travailler (gure 1.3). Ils ne se g enent plus, mais le ma con le plus eloign e du tas a plus de chemin a ` faire, et sa partie du mur avancera moins vite. Remarquons egalement quils se g enent toujours pour prendre les briques.

7a 4a 1a Tas de briques 5a

8a 6a 2a

9a 4b 3a Mur

7b 5b 1b

8b 6b 2b

9b 3b

Fig. 1.3 S equencement du travail de deux ma cons travaillant sur deux portions de mur s epar ees. c) Chacun sattribue une portion de mur pour travailler, mais le ma con le plus pr` es du tas lance une brique a ` lautre chaque fois quil en prend une pour lui. Dans ce cas, ils ne se g enent plus ni pour prendre les briques, ni dans leur travail. Cependant, ils doivent bien savoir viser et attraper. . . Le montage du mur en parall` ele est plus rapide que le montage par un seul ma con, mais la quantit e totale de travail est n ecessairement plus importante, car il faut que les ma cons sorganisent entre eux. Cet exemple impose plusieurs r eexions. Pour que la r esolution parall` ele soit possible, il faut que le probl` eme puisse etre d ecompos e en sous-probl` emes susamment ind ependants les uns des autres pour que chaque agent puisse travailler sans perturber les autres. Il faut pouvoir organiser ecacement le travail a ` r epartir. En plus du co ut de calcul intrins` eque du probl` eme, on g en` ere un surco ut d u aux calculs annexes et a ` la communication entre agents de linformation n ecessaire a ` sa r esolution. Les probl` emes r eels sont parall elisables a ` des degr es di erents. Parfois, il est m eme plus int eressant d eviter le parall elisme si le surco ut engendr e par celui-ci est trop important. Cest tout-` a-fait regrettable, mais il existe des algorithmes intrins` equement s equentiels. Lobtention dune version parall` ele ecace dun algorithme peut conduire a ` une formulation tr` es di erente de lalgorithme s equentiel equivalent. En fait, un probl` eme a souvent plusieurs formulations parall` eles di erentes, dont les performances peuvent elles aussi etre tr` es di erentes.

1.2

Le parall elisme est-il n ecessaire ?

La puissance des ordinateurs s equentiels augmentant de mani` ere r eguli` ere (en gros, elle est multipli ee par deux tous les quatorze mois), on pourrait croire quelles sera toujours susante, et que les machines parall` eles (ordinateurs multi-processeurs) sont inutiles. Cest faux, pour plusieurs raisons. ` mesure que la puissance des machines aug Plus on en a, plus on en veut. A mente, on introduit loutil informatique dans des disciplines o` u il ne pouvait jusqualors p en etrer, et on cherche a ` int egrer de plus en plus de param` etres dans les mod` eles num eriques : m et eorologie, synth` ese et reconstruction dimages, simulations num eriques, etc. Un certains nombre dapplications sensibles ont et e class ees Grand Challenge , et font lobjet de recherches intensives, tant au niveau du mat eriel que
Cours darchitectures et syst` emes des calculateurs parall` eles

1.3. LA RECHERCHE EN PARALLELISME

du logiciel. Elles sont egalement appel ees applications 3T , parce quelles n ecessitent pour leur ex ecution : 1 T era1 ops ( oating operation per second ) ; 1 T era octet de m emoire centrale ; 1 T era octet par seconde de bande passante pour produire les r esultats. ` lheure actuelle, ces applications ne peuvent A etre r ealis ees quen ayant recours au parall elisme massif, sur des machines a ` plus de 8000 processeurs hautes performances [13]. La vitesse de la lumi` ere est (actuellement) une limitation intrins` eque a ` la vitesse des processeurs. Supposons en eet que lon veuille construire une machine enti` erement s equentielle disposant dune puissance de 1 Tops et de 1 To de m emoire. Soit d la distance maximale entre la m emoire et le micro-processeur. Cette distance doit pouvoir etre parcourue 1012 fois par seconde a ` la vitesse de la lumi` ere, c 3.108 m.s1 , do` u: d 3.108 = 0, 3mm . 1012

Lordinateur devrait donc tenir dans une sph` ere de 0, 3 mm de rayon. Avec cette contrainte de distance, si lon consid` ere la m emoire comme une grille carr ee de 106 106 octets, alors chaque octet doit occuper une cellule de 3A de c ot e, cest a ` dire la surface occup ee par un petit atome. On ne tient ici pas compte de lespace n ecessaire a ` lacheminement de linformation et de l energie, ainsi qu` a lextraction de la chaleur. Cette argumentation est biais ee en ce que la mise en uvre dune hi erarchie m emoire (voir section 4.1) permet daugmenter la distance entre la m emoire de masse et lunit e de traitement. N eanmoins, elle reste globalement valable.

1.3

La recherche en parall elisme

Lutilisation ecace de machines parall` eles n ecessite de travailler sur : larchitecture des machines. Il faut assurer que : la machine est extensible ( scalable ) : on peut (facilement) augmenter la taille de la machine sans que les performances s ecroulent ; les echanges de donn ees entre processeurs sont rapides, pour eviter leur famine ; les entr ees/sorties ne sont pas p enalisantes. les mod` eles dexpression du parall elisme : chaque algorithme poss` ede un mod` ele de parall elisme avec lequel il sexprime mieux ; les langages parall` eles : il faut choisir le langage le plus adapt e au probl` eme ; lalgorithmique proprement dite : de nombreux probl` emes pour lesquels il existe un algorithme s equentiel optimal ne poss` edent encore pas de contrepartie parall` ele ecace ; lenvironnement de d eveloppement : d ebogueurs, proleurs, biblioth` eques portables, etc. ; la parall elisation automatique : compilateurs data-parall` eles ou multithreads avec directives dans le cas de HPF [6] et dOpenMP [9], parall elisation automatique de boucles, etc.

11

T era = 103 Giga = 106 M ega = 109 Kilo = 1012 .

c 2000, 2002 F. Pellegrini ENSEIRB

10

CHAPITRE 1. INTRODUCTION

Cours darchitectures et syst` emes des calculateurs parall` eles

Chapitre 2

Mod` eles de calculateurs parall` eles


An de d enir et comparer les architectures de machines, plusieurs classications ont et e d evelopp ees.

2.1

Classication de Flynn

La classication la plus connue est celle de Flynn [2], qui caract erise les machines suivant leurs ots de donn ees et dinstructions, ce qui donne quatre cat egories : SISD ( Single Instruction stream, Single Data stream ). Cette cat egorie correspond aux machines s equentielles conventionnelles, pour lesquelles chaque op eration seectue sur une donn ee a ` la fois (gure 2.1) ;
FI

E/S

UC

FI

UT

FD

UM

Fig. 2.1 Architecture SISD. Lunit e de contr ole (UC), recevant son ot dinstructions (FI) de lunit e m emoire (UM), envoie les instructions a ` lunit e de traitement (UT), qui eectue ses op erations sur le ot de donn ees (FD) provenant de lunit e m emoire. MISD ( Multiple Instruction stream, Single Data stream ). Cette cat egorie regroupe les machines sp ecialis ees de type systolique , dont les processeurs, arrang es selon une topologie xe, sont fortement synchronis es (gure 2.2) ;
FI

UM E/S
FD

UC
FI

UC
FI FD

UC
FI FD

UT

UT

UT

Fig. 2.2 Architecture MISD.

11

12

` ` CHAPITRE 2. MODELES DE CALCULATEURS PARALLELES SIMD ( Single Instruction stream, Multiple Data stream ). Dans cette classe darchitectures, les processeurs sont fortement synchronis es, et ex ecutent au m eme instant la m eme instruction, chacun sur des donn ees di erentes (gure 2.3). Des informations de contexte (bits de masquage) permettent dinhiber lex ecution dune instruction sur une partie des processeurs.
FI FI

UT UT UT

FD

UM UM UM

FD

E/S

UC

FD

FD

UM

FD

FD

Fig. 2.3 Architecture SIMD. Ces machines sont adapt ees aux traitements r eguliers, comme le calcul matriciel sur matrices pleines ou le traitement dimages. Elles perdent en revanche toute ecacit e lorsque les traitements a ` eectuer sont irr eguliers et d ependent fortement des donn ees locales, car dans ce cas les processeurs sont inactifs la majorit e du temps. Ainsi, pour ex ecuter une instruction conditionnelle de type if. . . then. . . else (gure 2.4), lensemble des instructions des deux branches doit etre pr esent e aux processeurs, qui d ecident ou non de les ex ecuter en fonction de leur bit local dactivit e, positionn e en fonction des valeurs de leurs variables locales. Chacun des processeurs nex ecutera eectivement que les instructions de lune des branches. Code source
blocA if (cond) blocV; else blocF; blocB

Code compil e
blocA; ACTIF = (cond); blocV; ACTIF = ~ACTIF; blocF; ACTIF = VRAI blocB

Ex ecution, cond=VRAI
blocA; ACTIF = (cond); blocV; ACTIF = ~ACTIF; -ACTIF = VRAI blocB

Ex ecution, cond=FAUX
blocA; ACTIF = (cond); -ACTIF = ~ACTIF; blocF; ACTIF = VRAI blocB

Fig. 2.4 Ex ecution dune expression conditionnelle if. . . then. . . else sur une architecture SIMD. MIMD ( Multiple Instruction stream, Multiple Data stream ). Cette classe comprend les machines multi-processeurs, o` u chaque processeur ex ecute son propre code de mani` ere asynchrone et ind ependante. On distingue habituellement deux sous-classes, selon que les processeurs de la machine ont acc` es a ` une m emoire commune (on parle alors de MIMD a ` m emoire partag ee, multiprocessor , gure 2.5), ou disposent chacun dune m emoire propre (MIMD a ` m emoire distribu ee, multicomputer , gure 2.6). Dans ce dernier cas, un r eseau dinterconnexion est n ecessaire pour echanger les informations entre processeurs.

Cette classication est trop simple, car elle ne prend en compte ni les machines vectorielles (quil faut ranger dans la cat egorie SISD et non pas SIMD, car elles ne
Cours darchitectures et syst` emes des calculateurs parall` eles

2.2. CLASSIFICATION DE RAINA


FI

13

E/S E/S

UC UC UC

FI

UT UT UT

FD

FI

FD

UM

FI

FD

Fig. 2.5 Architecture MIMD a ` m emoire partag ee.

E/S E/S

UC UC UC

FI

UT UT UT

FD

UM UM UM

FI

FI

FD

RI

FI

FD

Fig. 2.6 Architecture MIMD a ` m emoire distribu ee. disposent que dun seul ot m emoire, voir section 3.7), ni les di erences darchitecture m emoire.

2.2

Classication de Raina

Une sous-classication etendue des machines MIMD, due a ` Raina [11], et illustr ee en gure 2.7, permet de prendre en compte de mani` ere ne les architectures m emoire, selon deux crit` eres : lorganisation de lespace dadressage : SASM ( Single Address space, Shared Memory ) : m emoire partag ee ; DADM ( Distributed Address space, Distributed Memory ) : m emoire distribu ee, sans acc` es aux donn ees distantes. L echange de donn ees entre processeurs seectue n ecessairement par passage de messages, au moyen dun r eseau de communication ; SADM ( Single Address space, Distributed Memory ) : m emoire distribu ee, avec espace dadressage global, autorisant eventuellement lacc` es aux donn ees situ ees sur dautres processeurs. le type dacc` es m emoire mis en uvre : NORMA ( No Remote Memory Access ) : pas de moyen dacc` es aux donn ees distantes, n ecessitant le passage de messages ; UMA ( Uniform Memory Access ) : acc` es sym etrique a ` la m emoire, de co ut identique pour tous les processeurs ; NUMA ( Non-Uniform Memory Access ) : les performances dacc` es d ependent de la localisation des donn ees ;
c 2000, 2002 F. Pellegrini ENSEIRB

14

` ` CHAPITRE 2. MODELES DE CALCULATEURS PARALLELES CC-NUMA ( Cache-Coherent NUMA ) : type darchitecture NUMA int egrant des caches ; OSMA ( Operating System Memory Access ) : les acc` es aux donn ees distantes sont g er ees par le syst` eme dexploitation, qui traite les d efauts de page au niveau logiciel et g` ere les requ etes denvoi/copie de pages distantes ; COMA ( Cache Only Memory Access ) : les m emoires locales se comportent comme des caches, de telle sorte quune donn ee na pas de processeur propri etaire ni demplacement d etermin e en m emoire.

MIMD

DADM NORMA
Paragon XP-S Ncube CM-5 SP 1,2,3

SASM UMA
Sequent Symmetry CRAY X,Y, C SGI Power Challenge

SADM NUMA
BBN Butterfly CRAY T3D, E, F Meiko CS-2

CC-NUMA
Dash Flash Alewife

OSMA
Munin Ivy Koan Myoan

COMA
DDM KSR 1,2

Fig. 2.7 Classication MIMD de Raina.

Cours darchitectures et syst` emes des calculateurs parall` eles

Chapitre 3

Architecture des processeurs


Lobtention de performances elev ees sur une architecture parall` ele n ecessite lobtention de performances de calcul elev ees sur chacun des nuds qui la composent. Pour ce faire, il est n ecessaire de conna tre les principes architecturaux mis en uvre dans les processeurs haut-de-gamme actuels, an den tirer pleinement parti lors de l ecriture des logiciels, tout en conservant a ` ceux-ci une portabilit e maximale.

3.1

Horloge

La vitesse dun processeur d epend en premier lieu de la dur ee de son cycle dhorloge, qui cadence le syst` eme. Plus cette p eriode est courte, plus le processeur est rapide. Cependant, disposer dun processeur rapide ne sert a ` rien si les composants annexes (bus, m emoire) sont trop lents : le processeur passera son temps a ` les attendre. La fr equence dhorloge est le nombre de cycles dhorloge par seconde, mesur ee en Hertz (Hz). La relation entre le cycle dhorloge et la fr equence dhorloge f est 1 . donn ee par la relation f = Actuellement, selon la technologie utilis ee (bipolaire, CMOS, etc.), les temps de cycle vont de 250 ps a ` 60 ns, ce qui correspond a ` des fr equences de 16 MHz a ` 4 GHz. On ne peut augmenter la fr equence a ` linni, et lon pense que les limites de la technologie actuelle seront bient ot atteintes, aux alentours de 10 GHz. Il faut egalement noter quil y a un lien direct entre la fr equence dhorloge et le prix du processeur (cest dailleurs un argument commercial). Le parall elisme semble donc int eressant en ce quil permet de tirer parti de processeurs moins puissants, mais plus nombreux.

3.2

C ablage

Un premier moyen dacc el erer le traitement des op erations par le processeur consiste a ` exhiber le parall elisme au niveau des bits. Nous allons illustrer cette approche en etudiant un additionneur et un multiplicateur en arithm etique enti` ere.

3.2.1

Additionneur

On peut r ealiser laddition de deux bits au moyen du circuit pr esent e en gure 3.1, appel e demi-additionneur ( half-adder , ou HA), et constitu e de deux niveaux de portes logiques et et ou . Le bit s correspond a ` la somme, et c a ` la retenue. 15

16
y
0

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS x 0 0 1 1 y 0 1 0 1 c 0 0 0 1 s 0 1 1 0

1 2 0 1 2

si ci

= xi y i = xi yi

= xi yi + xi yi

Fig. 3.1 Sch ema, table, et equations logiques dun demi-additionneur binaire (HA). En combinant deux HA, on peut r ealiser une tranche dadditionneur complet ( full adder , ou FA), repr esent ee en gure 3.2.
x y
0,0
x y

s
4,t+2

HA
c s

1,1

2,2 0,t

c out

4,t+2

c in

HA
c s

3,t+1

4,t+2

Fig. 3.2 Sch ema dune tranche dadditionneur binaire (FA). En cha nant ensemble des FA, on peut alors construire un additionneur par propagation de retenue ( Ripple Carry Adder , ou RCA), montr e en gure 3.3.

x4 y4 s 4
x y s c

x3 y3 s 3
x y s c

x2 y2 s 2
x y s c

x1 y1 s 1
x y s c

x0 y0 s 0
x y s c

12

FA

10

FA

FA

FA

FA

Fig. 3.3 Sch ema dun additionneur binaire a ` propagation de retenue (RCA). Le temps de calcul dune addition sur n bits est donc : tRCA (n) = 2n + 2 . Ladditionneur ci-dessus pr esente une tr` es forte s equentialit e, qui d erive de la n ecessit e de conna tre la retenue cin du bit i pour calculer celle du bit i + 1. Plus la valeur des retenues partielles sera connue t ot, et plus le calcul des bits de la somme pourra etre acc el er e. Le circuit FA peut nous apporter des informations, au prix dune l eg` ere modication. Le circuit modi e FA de la gure 3.4 poss` ede deux sorties suppl ementaires, g et p, qui indiquent respectivement si une retenue a et e g en er ee au sein de ladditionneur, et si une retenue cin eventuelle sera propag ee. Si lon consid` ere deux additionneurs FA, et que lon cherche a ` calculer les valeurs globales de g et p, on trouve :
Cours darchitectures et syst` emes des calculateurs parall` eles

3.2. CABLAGE
x y
0,0
x y

17
s
4,t+2

HA
c s

1,1

2,2

c out
x y

c in

HA
c s

2,2

2,2

g p

Fig. 3.4 Sch ema dune tranche dadditionneur binaire modi ee (FA).
xh yh s h c out
x y s c

xl yl s l
x y s c

FAc
g p

FAc
g p

c in

g p cout

= g h + g l ph = p h pl = pcin + g

gh ph

gl pl

Les formules logiques de p, g , et cout peuvent etre c abl ees dans le circuit combineur de retenue ( Carry Merger , ou CM) pr esent e en gure 3.5, page 17.
gh ph gl pl
2,u 2,u

3,u+1

4,u+2 5,max(t+2,u+3) 4,max(t+1,u+2)

3,u+1 0,t

c out

c in

4,u+2

4,u+2

Fig. 3.5 Sch ema dun combineur de retenues (CM). On peut alors r ealiser un additionneur complet par pr e-calcul de retenue ( Carry Lookahead Adder , ou CLA) selon le sch ema de la gure 3.6, page 18. Le temps de calcul sur n = 2k bits de cet additionneur est donc : tCLA (n) = 2 + 2 (log2 (n) 2) + 3 virage + 2 (log2 (n) 2) + 2 + 2 remont ee remont ee FA descente FA

descente = 4 log2 (n) + 1 n RCA CLA

Le tableau ci-dessous permet de constater les gains r ealis es. 8 16 32 64 128 18 34 66 130 258 13 17 21 25 29

c 2000, 2002 F. Pellegrini ENSEIRB

18

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

x7 y7 s 7
x y s c

x6 y6 s 6
x y s c

x5 y5 s 5
x y s c

x4 y4 s 4
x y s c

x3 y3 s 3
x y s c

x2 y2 s 2
x y s c

x1 y1 s 1
x y s c

x0 y0 s 0
x y s c

13

11

11

4 0

FAc
g p

FAc
g p

FAc
g p

FAc
g p

FAc
g p

FAc
g p

FAc
g p

FAc
g p

2
h c l

2
h l

2
h c l

2
h l

CM c
g p

9 4
h c l

CM c
g p

CM c
g p

5 4

CM c 0
g p

remonte

virage
h l

descente

CM c
g p

7 6
h l

CM c 0
g p

CM c 0
g p

Fig. 3.6 Sch ema dun additionneur binaire a ` pr e-calcul de retenue (CLA).

3.2.2

Multiplicateur

En arithm etique binaire, la multiplication sexprime simplement au moyen de d ecalages et dadditions. Par exemple, si lon consid` ere la multiplication de deux nombres A et B cod es chacun sur 8 bits : A = B = 1 0 0 1 0 0 0 1 1 1 1 0 0 0 0 0 0 1 1 0 1 0 1 0 0 0 0 1 1 0 1 1 0 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 1 1

+ + + + + + +

0 1 0 1 0 1 1 0 0 1

1 0 1 1 0

0 0 0 1 0 0

0 0 1 0 0 0 0

1 1 0 0 0 1 1

multiplier A par B revient a ` sommer les huit produits partiels obtenus en d ecalant `me de i bits le mot obtenu par un et logique entre chacun des bits de A et le ie bit de B . La r ealisation dun multiplicateur ecace est bien plus d elicate que celle dun additionneur, en ce que lop eration de multiplication n ecessite de nombreuses additions. Le goulet d etranglement dun additionneur etant la propagation de la retenue, qui s erialise les calculs, il faut limiter leur nombre autant que possible dans le multiplicateur an dobtenir un parall elisme maximum. Ladditionneur a ` conservation de retenue ( Carry Save Adder , ou CSA) permet deectuer laddition de trois nombres binaires, en conservant les retenues de chaque bit dans un vecteur auxiliaire, Ainsi, si X , Y , et Z sont trois nombres
Cours darchitectures et syst` emes des calculateurs parall` eles

3.2. CABLAGE cod es sur 8 bits, on aura : + + X Y Z Sb Cb = = = = = 1 0 1 1 0 1 1 1 1 1 0 1 0 0 1 1 1 1 0 0 1 0 1 1 0 0 0 0 1 1 0 1 0 0 1 0 0 1 0 1

19

avec

sb i cb i

= x i y i z i = x i yi zi + x i yi zi + x i yi zi + x i yi zi = xi1 yi1 + xi1 zi1 + yi1 zi1 ,

o` u S b est le vecteur somme bit a ` bit, toujours sur 8 bits, et C b est le vecteur retenue bit a ` bit, sur neuf bits mais tel que le bit de poids le plus faible soit toujours z ero. Le r esultat produit v erie bien S b + C b = X + Y + Z , et tous les bits de S b et C b ont et e calcul es en parall` ele. En combinant entre eux les additionneurs CSA pour former un arbre de Wallace, et en intercalant des tampons ( latches ), on construit un multiplicateur pipelin e (voir section 3.4 pour de plus amples informations sur les pipe-lines), pr esent e en gure 3.7, dont le dernier etage est un additionneur a ` propagation de retenue ( Carry Propagate Adder , ou CPA) comme ladditionneur CLA d ecrit plus haut.
8 8 E1 15 14 8 8

Calcul des produits partiels

13 13

12 12 13

11 11 13
CSA

10 10 10

9 9 10

8 8

15 E2

14
CSA

CSA

CSA

15

15 15 15
CSA

13 13
13 15
CSA

13

E3 16 16 E4
CPA

15

16 16

16 16

Fig. 3.7 Sch ema dun multiplicateur binaire. En utilisant autant que possible des additionneurs CSA, on a consid erablement r eduit le nombre de propagations de retenues a ` calculer (il nen reste quune seule,
c 2000, 2002 F. Pellegrini ENSEIRB

20

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

in evitable). Pour un r esultat sur 16 bits, ladditionneur CLA a une profondeur de quatre niveaux, chaque CSA n ecessite deux niveaux de portes logiques, et la g en eration des produits partiels (au moyen de et logiques) n ecessite egalement deux niveaux. Le pipe-line est donc relativement equilibr e. Dans les deux exemples dop erateurs arithm etiques pr esent es dans cette section, a ` chaque fois, on a gagn e en temps au prix dun surco ut de calcul (mesur e ici en nombre de portes logiques).

3.3

Jeu dinstructions

On oppose conceptuellement deux types de jeux dinstructions : RISC ( Reduced Instruction Set Computer ) : jeu dinstructions r eduit ; CISC ( Complex Instruction Set Computer ) : jeu dinstructions complexe. Dans les faits, ces concepts impliquent dautres choix technologiques, que nous allons pr esenter dans cette section. Les premiers processeurs etaient RISC par nature, puisquils poss edaient un jeu dinstructions tr` es r eduit. Dans les ann ees 1960-1970, on sest orient e vers une complexication des jeux dinstructions, an de simplier l ecriture des compilateurs et d economiser la m emoire en r eduisant la taille des programmes. Lam elioration des techniques dint egration et laugmentation des fr equences dhorloge compensaient largement le surco ut induit par cette complexication. Le plus souvent, les instructions complexes n etaient pas c abl ees, mais micro-cod ees. ` titre dexemple, le jeu dinstructions de la famille VAX de DEC poss A edait 304 instructions, dont certaines etaient de tr` es haut niveau : linstruction POLY servait a ` evaluer les polyn omes ! Des etudes statistiques ont alors montr e que la plupart des instructions n etaient en fait pas utilis ees, car trop sp ecialis ees et de trop haut niveau pour quun compilateur puisse les g en erer a ` partir dun code source. On sest donc naturellement orient e vers une simplication des jeux dinstructions, marqu ee par la naissance en 1972 du premier processeur d elib er ement RISC, le RISC I de lUniversit e de Berkeley, qui ne poss edait que 32 instructions. On peut remarquer que cette date charni` ere co ncide avec celle du d eveloppement de la th eorie de la compilation, qui a permis la r ealisation de compilateurs ecaces. R eduire la taille du jeu dinstructions permet de gagner : en temps de d ecodage des instructions, du fait de la plus grande simplicit e de celles-ci, ce qui permet de r eduire le nombre de niveaux de portes logiques a ` traverser pour ex ecuter une instruction ; en surface dint egration, de par la r eduction de la circuiterie de d ecodage et labsence de la gestion du micro-code, ce qui diminue la longueur maximale des pistes a ` lint erieur du processeur. La combinaison de ces deux gains, en termes de nombre de niveaux logiques et de longueur de pistes, permet une augmentation signicative de la fr equence dhorloge dans les architectures RISC, par rapport aux processeurs CISC. Un rapport de deux a ` quatre est courant a ` lheure actuelle. Les caract eristiques g en eralement admises des architectures RISC sont les suivantes : toutes les instructions ont le m eme format et la m eme taille. Ceci simplie leur d ecodage, mais aussi les acc` es m emoire, car dans la plupart des processeurs RISC les instructions doivent etre align ees sur la taille dun mot machine.
Cours darchitectures et syst` emes des calculateurs parall` eles

3.4. PIPE-LINE

21

Cette caract eristique est egalement essentielle pour loptimisation des architectures pipe-lin ees ; le jeu dinstruction est de type load-store . Les seules instructions pouvant acc eder a ` la m emoire sont les op erations load et store , les autres op erations nop erant que sur les registres du processeur. Les processeurs RISC disposent donc dun grand nombre de registres, an de stocker les valeurs des op erandes qui ne peuvent plus etre directement acc ed ees en m emoire ; larchitecture est orthogonale . Chaque instruction peut utiliser indiff eremment toutes les op erandes des types autoris es. On na donc pas de registres sp ecialis es, comme cest par exemple le cas pour la famille des 80x86, o` u seul le registre AX sert aux op erations arithm etiques, le registre CX comme compteur de r ep etition, etc. ; la plupart des instructions sex ecutent en un cycle dhorloge. Dans les architectures RISC pures , toutes les instructions sex ecutent en un cycle dhorloge, a ` part les acc` es m emoire qui peuvent prendre plus de temps. Cependant, pour des raisons decacit e, on tend actuellement a ` inclure dans des processeurs dits RISC des instructions (le plus souvent arithm etiques : multiplication, division) sex ecutant en quelques cycles dhorloge, bien plus ecaces que leur contrepartie logicielle car c abl ees de fa con optimis ee ; ces processeurs evolu es sont parfois appel es CRISC ( Complexied RISC ). Dans tous les cas cependant, on na jamais recours a ` un micro-code ; le jeu dinstructions est limit e uniquement aux instructions n ecessaires en terme de compromis performance/place/pipe-line. Ainsi, les premiers processeurs SPARC ne poss edaient pas de multiplication c abl ee (ce qui a et e rajout e assez rapidement, il est vrai. . . ). Ces choix architecturaux ont un eet certain sur l ecriture des compilateurs. Si leur ecriture peut sembler plus compliqu ee au premier abord (n ecessit e d emuler les modes dadressage etendus, les op erations arithm etiques complexes, etc.), on peut gagner par rapport aux processeurs CISC pour lesquels : les instructions de trop haut niveau (comme le POLY du VAX) ne peuvent etre g en er ees a ` partir dun langage de bas niveau (comme le C) ; larchitecture non-orthogonale complique la gestion des registres (sauvegardes et restauration perp etuelles).

3.4
3.4.1

Pipe-line
Principe

Le pipe-line est une technique permettant dexploiter le parall elisme induit par lex ecution r ep et ee dune m eme op eration sur des donn ees distinctes. On peut tr` es simplement comparer un pipe-line a ` une cha ne de montage dans une usine. On d ecompose lunit e de traitement de lop eration en sous-unit es ind ependantes, qui travaillent en parall` ele sur les donn ees qui se pr esentent s equentiellement a ` elles, chaque sous-unit e travaillant a ` un instant donn e sur une donn ee di erente. Trois conditions sont n ecessaires a ` l elaboration dun pipe-line : une op eration de base doit etre r ep et ee dans le temps ; cette op eration doit pouvoir etre d ecompos ee en etapes ( etages) ind ependants ; la complexit e de ces etages doit etre a ` peut pr` es la m eme. Si ce nest pas le cas, on peut multiplexer les etages les plus co uteux pour augmenter le d ebit du pipe-line, comme illustr e en gure 3.8.

c 2000, 2002 F. Pellegrini ENSEIRB

22

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS


t3 t6 t5 t4 t2 t1 t0

Fig. 3.8 Utilisation du multiplexage pour augmenter le d ebit dun pipe-line. Les commutateurs basculent a ` chaque cycle. Ainsi, typiquement, le traitement des instructions par le processeur peut se d ecomposer en cinq etapes : fetch : recherche de la prochaine instruction a ` ex ecuter ; decode : d ecodage de linstruction, avec calculs eventuels des adresses ; read : chargement des op erandes dans lunit e dex ecution, par lecture a ` partir des registres ou de la m emoire ; execute : ex ecution proprement dite de linstruction ; write : ecriture du r esultat vers les registres ou la m emoire. Le nombre d etages composant un pipe-line est appel e profondeur du pipe-line. Dans le cas g en eral, un pipe-line de profondeur p peut ex ecuter n op erations en n+p etapes, sil ny a pas de bulles. Sans pipe-line, le temps dex ecution serait p, n + p n, ce qui de n p, do` u un facteur dacc el eration de nnp +p . Quand n donne une acc el eration de p, ce qui sugg` ere daugmenter le nombre d etages an de b en ecier de lacc el eration la plus grande possible. Cependant, plus le nombre d etages augmente, et plus le risque dapparition de bulles augmente, ce qui r eduit lecacit e du pipe-line. En r` egle g en erale, le nombre d etages des pipe-lines dinstructions est donc compris entre 5 et 15. Ainsi, si le Pentium dIntel avait 5 etages, les Pentium II et III en ont 12, et le Pentium IV en a 20, ce qui lui a permis daugmenter consid erablement sa fr equence de fonctionnement par rapport aux pr ec edents. Les gures 3.9 et 3.10 repr esentent lex ecution dans le temps dune s equence dinstructions. Sans pipe-line, lex ecution de chaque instruction ne peut se faire que lorsque la pr ec edente a et e enti` erement trait ee. Avec pipe-line, les di erents etages de traitement peuvent travailler en parall` ele, si les instructions ne pr esentent pas de d ependences. Sinon, des bulles peuvent appara tre a ` lex ecution.
F D R E W F D R E W F D R E W Temps

Instructions

Fig. 3.9 Ex ecution dune s equence dinstructions sur une machine non pipelin ee. Un autre domaine dapplication classique des pipe-line est lunit e arithm etique et logique, dont les nombreuses fonctions sont susceptibles d etre pipe-lin ees. Le calcul dune addition en virgule ottante peut ainsi se d ecomposer en cinq etapes : comparaison des exposants et calcul de leur di erence (soustraction enti` ere) ; alignement des mantisses en cons equence (d ecalage) ; addition des mantisses (addition enti` ere) ;
Cours darchitectures et syst` emes des calculateurs parall` eles

3.4. PIPE-LINE
F D F R D F E W En cas de conflit (ici, RAW), des bulles apparaissent E R D W E R W E W Temps

23

F
D

E R

W R D F

Instructions

Fig. 3.10 Ex ecution dune s equence dinstructions sur une machine pipelin ee a ` cinq etages. La troisi` eme instruction n ecessitant le r esultat calcul e par la premi` ere (conit Read After Write , ou RAW ), une bulle appara t dans le pipe-line. calcul du facteur de renormalisation (comptage de bits a ` z ero) ; normalisation du r esultat (d ecalage).

3.4.2

Pipe-lines non lin eaires

An dimpl ementer des op erations complexes tout en economisant de la place, il est possible de c abler plusieurs fonctions au sein de la m eme unit e pipe-line. Dans ce cas, en plus des liens directs entre etages voisins, on trouvra des connexions avant ( feedforward ) et arri` ere ( feedback ), ainsi que plusieurs sorties, qui seront activ ees ou non suivant la conguration dynamique du pipe-line, comme illustr e en gure 3.11.
Y E1 E2 E3 X

Fig. 3.11 Exemple de pipe-line non lin eaire. Ces connexions non-lin eaires compliquent beaucoup lutilisation du pipe-line, et en particulier la r eservation des di erents etages en fonction des op erations demand ees. Lenchainement des op erations dans le pipe-line est habituellement repr esent e au moyen dune table de r eservation ( reservation table ), dont les lignes repr esentent les etages du pipe-line, et les colonnes les pas de temps n ecessaires a ` l evaluation de la fonction associ ee. Dans le cas dun pipe-line lin eaire, cette table est triviale, puisque les etages sont travers es dans lordre. Dans le cas dun pipe-line non-lin eaire, les tables sont plus complexes, et a ` une structure de pipe-line donn ee peuvent correspondre plusieurs tables, d enissant chacune une fonction di erente, comme par exemples celles d enies en gure 3.12. Le fonctionnement du pipe-line peut lui aussi etre repr esent e sous forme de table, avec un format d erivant de celui des tables de r eservation. Les cases non-vides de la table dex ecution sont alors indic ees par le num ero dinstance de la fonction en train de sex ecuter a ` partir du temps de r ef erence, comme illustr e en gure 3.13. Le nombre de pas de temps s eparant deux ex ecutions dune fonction dans le pipe-line est appel e latence . Lorsque deux instances de fonctions n ecessitent un m eme etage du pipe-line en m eme temps, il y a collision. Les collisions se produisent pour des valeurs de latence particuli` eres, qui sont appel ees latences interdites .
c 2000, 2002 F. Pellegrini ENSEIRB

24

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS


E1 E2 E3 X X X X X X X X

E1 E2 E3

Y Y

Y Y Y

Fig. 3.12 Tables de r eservation pour le pipe-line non lin eaire de la gure 3.11.
E1 E2 E3 X1 X1 X1 X2 X1 X2 X1 X1 X1 X2 X2 X1 X2 X2 X2 X2 X3 X3 X3 X3 X3 X3 X3 X3

Fig. 3.13 Table dutilisation du pipe-line non lin eaire de la gure 3.11 pour calculer la fonction X . Lex ecution de X2 est lanc ee trois cycles apr` es celle de X1 , et celle de X3 est lanc ee 6 cycles apr` es celle de X2 . Ainsi, pour la fonction X d enie en gure 3.12, les latences 2, 4, et 5 sont-elles interdites.
E1 E2 E3 X1 X1 X1 X1 X1 X2 X1 X 1X 2 X 1X 2 X2 X2 X2 X2 X2

Fig. 3.14 Collision entre X1 et X2 lorsque lex ecution de celle-ci est lanc ee 4 cycles apr` es celle de X1 . Les latences interdites se d eduisent simplement des tables de r eservation. Elles correspondent aux distances entre cases occup ees appartenant aux m emes lignes. Une s equence de latences est une s equence de latences autoris ees entre ex ecutions successives. Un cycle de latences est une s equence de latences r ep etant ind eniment le m eme motif. Il peut y en avoir plusieurs, comme illustr e en gures 3.15 et 3.16.
E1 E2 E3 X1 X2 X1 X2 X1 X1 X2 X2 X1 X1 X1 X2 X2 X2 X1 X2 X3 X4 X3 X4 X3 X3 X4 X4 X3 X3 X3 X4 X4 X4 X3 X4 X5 X6 X5

Fig. 3.15 Table dutilisation du pipe-line pour calculer la fonction X, avec le cycle de latences { 1, 6 }. La latence moyenne dun cycle de latences est obtenue en divisant la somme de toutes les latences du cycle par le nombre de latences contenues dans le cycle. Un cycle de latences constant est un cycle ne contenant quune unique valeur de latence. Du point de vue de lecacit e, on souhaite d eterminer le cycle donnant le d ebit le plus elev e, cest-` a-dire correspondant la latence moyenne minimale ( Minimal Average Latency , ou MAL). En examinant la table de r eservation, il est possible de d eterminer lensemble des latences autoris ees, a ` partir des latences interdites. Si p est le nombre de colonnes
Cours darchitectures et syst` emes des calculateurs parall` eles

3.4. PIPE-LINE
E1 E2 E3 X1 X1 X1 X2 X1 X2 X1 X1 X1 X2 X3 X2 X1 X3 X2 X2 X2 X3 X4 X3 X2 X4 X3 X3 X3 X4 X5 X4 X3 X5 X4 X4 X4 X5 X6 X5 X4

25

Fig. 3.16 Table dutilisation du pipe-line pour calculer la fonction X, avec le cycle de latences { 3 }. de la table de r eservation, et m la plus grande latence interdite, avec m < p, on souhaite d eterminer la plus petite latence autoris ee a, dans le domaine 1 a < m. Lensemble d ecrivant les etats autoris es et interdits peut etre repr esent e sous la forme dun vecteur de collisions, qui est un vecteur binaire C = (cm cm1 . . . c1 ) sur m bits, o` u la valeur de ci est 1 si une latence de i provoque une collision et 0 si elle est autoris ee. ` partir du vecteur de collisions, il est possible de cr A eer un diagramme d etats sp eciant les transitions d etats autoris ees entre ex ecutions successives dans le pipeline. Le vecteur de collisions C correspond a ` l etat initial du pipe-line au temps 1, et est donc appel e vecteur initial de collision. Si a est une latence autoris ee a ` partir dun etat E , l etat obtenu a ` partir de E par lancement dune ex ecution apr` es une latence de a cycles sobtient en d ecalant le vecteur de collision de E de a bits sur la droite, et en additionnant C au vecteur d ecal e. Quand la latence est sup erieure a ` m + 1, toutes les transitions sont redirig ees vers l etat initial, et la transition est not ee (m + 1)+ . Ainsi, le diagramme d etat de la fonction X est repr esent e en gure 3.17.
6+ 1 1 0 1 0 1* 1 1 1 1 1 6+ 1 1 0 1 1 3*

6+

Fig. 3.17 Diagramme d etat de la fonction X. ` partir du diagramme d A etats, il est possible de d eterminer les cycles permettant dobtenir la MAL. Il existe une innit e de cycles obtensibles a ` partir dun etat donn e du diagramme d etats. Cependant, seuls les cycles simples, cest-` a-dire les cycles ne passant quune fois au plus par un etat donn e, sont int eressants. Certains cycles simples sont dits gloutons . Ce sont les cycles tels que les ar etes emprunt ees pour sortir de chaque etat travers e du cycle ont les plus petites etiquettes possibles. Le cycle donnant la MAL est le cycle glouton dont la latence moyenne est inf erieure a ` celle de tous les autres cycles gloutons.

3.4.3

D ependances

Dans les pipe-line dinstructions des processeurs, les d ependances entre instructions constituent la plus grande source de bulles, qui peuvent parfois etre evit ees par ` titre dexemple, une r eorganisation du code, qui est r ealis ee par les compilateurs. A supposons que lon veuille calculer lexpression de la gure 3.18, sous sa forme langage machine. Si les instructions sont s equenc ees dans cet ordre sur une machine pipe-lin ee a ` cinq etages, le temps dex ecution est de t = 14 cycles, comme illustr e en gure 3.19,
c 2000, 2002 F. Pellegrini ENSEIRB

26

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS A = B * C + D * E; F = G * H + I * J; mul mul add mul mul add r1, [B], r2, [D], [A], r1, r1, [G], r2, [I], [F], r1, [C] [E] r2 [H] [J] r2

Fig. 3.18 Fragment de langage machine (` a droite) correspondant directement a ` lexpression a ` calculer (` a gauche).

ce qui est deux fois plus rapide que sur une machine non pipe-lin ee, qui aurait n ecessit e 6 5 = 30 cycles el ementaires.
1 2 3 4 5 6 Instructions F D F R D F E R D F W Temps W

          R E W                   R E W D     
     




  F D


   
       R      E      W                        F D                            

Fig. 3.19 Ex ecution sur une machine pipe-lin ee a ` cinq etages du fragment de langage machine de la gure 3.18. Si lon r eordonne les instructions en fonction du pipe-line selon le sch ema de la gure 3.20, le nombre de cycles n ecessaire tombe a ` 11, comme illsutr e en gure 3.21. Cette diminution demande une augmentation du nombre de registres mis en uvre, ce qui est une caract eristique des architectures RISC. mul mul mul mul add add r1, [B], r2, [D], r3, [G], r4, [I], [A], r1, [F], r3, [C] [E] [H] [J] r2 r4

Fig. 3.20 Fragment de langage machine r eordonn e, s emantiquement equivalent a ` celui de la gure 3.18 On distingue habituellement dans la litt erature quatre types de d ependances, illustr ees en gure 3.22. Certaines sont r eelles, et re` etent le sch ema dex ecution ; dautres sont de fausses d ependances, qui r esultent daccidents dans la g en eration du code ou du manque dinformations sur le sch ema dex ecution. Deux instructions ont une d ependance r eelle de donn ees si le r esultat de la premi` ere est un op erande de la seconde. Deux instructions sont anti-d ependantes si la premi` ere utilise la valeur dun op erande qui est modi e par la deuxi` eme. Deux instructions ont une d ependance de r esultat si toutes deux modient le m eme op erande. Enn, il existe une d ependance de contr ole entre un branchement et une instruction dont lex ecution est conditionn ee par ce branchement.
Cours darchitectures et syst` emes des calculateurs parall` eles

3.4. PIPE-LINE
1 2 4 5 3 6 Instructions F D F R D F E R D F W E R D F W E R D F W E R D W Temps

27

  E             

W R E W

Fig. 3.21 Ex ecution sur une machine pipe-lin ee a ` cinq etages du fragment de langage machine de la gure 3.20. mov ... ... ... add r1, [A] add ... ... ... mov r2, r1, r4

r3, r1, r2

r1, [A]

D ependance r eelle add ... ... ... mov r1, r2, r3

Anti-d ependance bz ... div ... L: r4, L r1, r1, r4

r1, [A]

D ependance de r esultat

D ependance de contr ole

Fig. 3.22 Exemples des quatre types de d ependances.

3.4.4

Branchements conditionnels

Une autre source tr` es importante de bulles est lexistence des branchements, qui sont principalement les branchements conditionnels, dus aux boucles : dans le cas o` u le branchement est pris ( branch taken ), il faut vidanger le pipe-line, qui s etait automatiquement rempli avec les instructions situ ees directement apr` es le branchement. De nombreuses techniques ont et e d evelopp ees an de r eduire limpact des branchements sur le pipe-line dinstructions. D eroulage de boucle Le d eroulage de boucle ( loop unrolling ) consiste en la recopie en plusieurs exemplaires du corps de la boucle, qui permet de supprimer les branchements interm ediaires et par l` a m eme d eviter la vidange du pipe-line dinstructions a ` chaque tour de boucle. Lorsque le nombre dit erations initial nest pas connu ou nest pas un multiple de la valeur de d eroulage, une copie de la boucle originale est ajout ee avant ou apr` es la boucle d eroul ee, an dex ecuter les it erations restantes, comme repr esent e en gure 3.23. ` titre dexemple, la gure 3.24, page 29, pr A esente un fragment de code machine Intel 80x86 correspondant au d eroulage de la boucle dun programme C de sommation des valeurs dun tableau. Le nombre dit erations etant inconnu, le comc 2000, 2002 F. Pellegrini ENSEIRB

28

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

i = ideb

i = ideb

i < ifin-3 f(i) f(i+1) f(i+2) f(i+3) i += 4

i < ifin f(i) i ++

Fig. 3.23 D eroulage dordre 4 dun corps de boucle a ` nombre dit erations inconnu. pilateur prend tous les cas possibles en compte. Il d eroule la boucle quatre fois, et fait pr ec eder la portion d eroul ee dun pr e-traitement destin ea ` traiter les it erations r esiduelles, dont le nombre est compris entre z ero et trois. Ce code fonctionne de la fa con suivante : si le nombre dit erations est inf erieur ou egal a ` z ero, on evite la boucle ; si le nombre dit erations, modulo 4, est 1, on va a ` la portion du code permettant de r ealiser une it eration, puis deectuer un test de terminaison, avant dentrer dans la boucle d eroul ee ; si le nombre dit erations, modulo 4, est 2, on va a ` la portion du code permettant de r ealiser une it eration, puis de continuer avec le code pr ec edent, qui r ealise la deuxi` eme it eration avant deectuer le test de terminaison et dentrer dans la boucle d eroul ee ; si le nombre dit erations, modulo 4, est 3 (cas restant), on charge directement la somme avec la premi` ere valeur du tableau (le compilateur a donc pris en compte que la valeur de la somme etait nulle avant le d ebut de la boucle), et on met le compteur a ` 1, avant dentrer dans le code pr ec edent, qui r ealise les deux it erations suivantes. Lorsque le nombre dit erations est connu a ` la compilation, le compilateur d eroule la boucle dun ordre qui divise exactement le nombre dit erations, ou bien fait pr ec eder le corps de la boucle d eroul ee dun nombre dinstances du code egal au modulo du nombre dit erations par lordre de d eroulage. Le compilateur peut tirer parti du d eroulage des boucles pour factoriser le code d eroul e et calculer des optimisations inter-it erations, au prix dune augmentation de la taille du code g en er e et du nombre de registres mis en uvre. Cependant, cette technique peut diminuer lecacit e dautres techniques doptimisation, comme le renommage dynamique de registres ou la pr ediction de branchement, ce qui peut parfois conduire a ` une diminution de la concurrence des programmes [14, page 24] ; Pr ediction de branchement La pr ediction de branchement ( branch prediction ) a pour but daugmenter la probabilit e de suivre la bonne branche, et ainsi de ne pas rompre le ot du pipe-line.
Cours darchitectures et syst` emes des calculateurs parall` eles

3.4. PIPE-LINE

29

int

t[1000], n, s, i; // f() renvoie 1000 mais le // compilateur ne le sait pas

n = f (); for (i = 0, s = 0; i < n; i ++) s += t[i];

... xorl %edx,%edx movl %eax,%esi movl %edx,%eax cmpl %esi,%edx jge .L45 movl %esi,%ecx leal -4000(%ebp),%ebx andl $3,%ecx je .L47 cmpl $1,%ecx jle .L59 cmpl $2,%ecx jle .L60 movl -4000(%ebp),%edx movl $1,%eax .L60: addl (%ebx,%eax,4),%edx incl %eax .L59: addl (%ebx,%eax,4),%edx incl %eax cmpl %esi,%eax jge .L45 .align 4 .L47:

// // // // // // // // // // // // // // //

Met la somme a ` z ero Met le nombre dans esi Met le compteur a ` z ero Valeur de fin atteinte ? Si oui, rien a ` faire Copie le compteur dans ecx Adresse du tableau dans ebx Si compteur multiple de 4 Va a ` la boucle d eroul ee Si valeur modulo 4 est 1 Fait un tour et d eroule Si valeur modulo 4 est 2 Fait deux tours et d eroule Charge la premi` ere valeur Un tour fait, reste deux

// Fait un tour de boucle // Incr emente le compteur // // // // // // // Fait un tour de boucle Incr emente le compteur Valeur de fin atteinte ? Termine si cest le cas Alignement pour cache Corps de boucle d eroul ee D eroulage dordre 4

.L45:

addl (%ebx,%eax,4),%edx addl 4(%ebx,%eax,4),%edx addl 8(%ebx,%eax,4),%edx addl 12(%ebx,%eax,4),%edx addl $4,%eax // Ajoute 4 au compteur cmpl %esi,%eax // Valeur de fin atteinte ? jl .L47 // Reboucle si non atteinte ...

Fig. 3.24 Exemple de d eroulage de boucle a ` nombre dit erations inconnu r ealis e par gcc-2.8.1 sur une architecture Intel 80x86. La boucle est d eroul ee quatre fois, et est pr ec ed ee dun code destin ea ` traiter les it erations r esiduelles, dont le nombre est compris entre z ero et trois.

c 2000, 2002 F. Pellegrini ENSEIRB

30

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

En labsence de tout m ecanisme de pr ediction, les etudes statistiques eectu ees sur de tr` es nombreux codes indiquent que les meilleurs r esultats sont obtenus lorsquon suppose que tous les branchements sont pris. Cependant, cette technique nest pas ecace dans tous les cas. Les techniques statiques utilisent uniquement linformation contenue dans le code pour eectuer la pr ediction. Cette information peut etre un bit de linstruction de branchement, qui indique si le branchement est consid er e comme pris ou non, et qui est positionn e par le compilateur en fonction de son analyse du code (si 1 la probabilit e estim ee que le branchement soit pris est sup erieure a ` 2 ou non). Elle peut aussi etre constitu ee de ladresse du branchement elle-m eme : si ladresse de destination est inf erieure a ` ladresse courante (branchement remontant), le branchement est consid er e comme pris, et si elle est sup erieure (branchement descendant), non. Ces postulats correspondent a ` la mani` ere dont les compilateurs codent les boucles, qui sont les plus grosses consommatrices de branchements conditionnels : test de do...while dans le cas remontant, et test de sortie de for ou de while dans le cas descendant. Sur un ensemble repr esentatif de programmes, il a et e montr e [14, page 10] que la pr ediction statique suivant le signe du d eplacement (remontant ou descendant) donne le bon r esultat dans 55% des cas, alors que supposer que le branchement est toujours pris est ecace dans 63% des cas, et quune pr e-d etermination par inspection du code a ` la compilation peut amener un taux de r eussite moyen de 90%. Un des probl` emes de la pr ediction statique de branchement est que la plupart des branchements conditionnels sont biais es : la probabilit e quils soient pris evolue au cours du temps, m eme dans le cas de donn ees quelconques (ce qui est dailleurs rarement le cas). Ainsi, pour le fragment de code suivant : L1: L2: L3: L4: max = a[0]; for (i = 1; i < N; i ++) if (a[i] > max) max = a[i];

et en supposant que les a[i] sont al eatoires, la probabilit e que (a[i] > max) pour un i donn e est la probabilit e que a[i] soit plus grand que les i valeurs pr ec edentes d ej` a rencontr ees (partant de 0), cest-` a-dire la plus grande de i + 1 1 . La probabilit e que le branchement du if valeurs al eatoires, et est donc egale a ` i+1 soit pris diminue dans le temps. Les occurences successives du branchement sont donc corr el ees dans le temps, et leur traitement ecace n ecessite donc un m ecanisme de pr ediction utilisant un historique. Les techniques dynamiques utilisent lhistorique des d ecisions prises sur un ou plusieurs branchements pr ec edents pour pr edire la d ecision suivante. Pour des raisons decacit e, seul entre en compte actuellement lhistorique r ecent (les deux ou trois derniers branchements). An de prendre en compte lhistorique des d ecisions pr ec edentes, on peut conserver dans le cache dinstructions, dans le code de chaque instruction de branchement, un bit dhistorique qui est mis a ` jour lorsque la condition est r e evalu ee (ce bit peut avoir et e pr e-initialis e par le compilateur, au cours dune phase danalyse du code ; notez egalement que le segment de code reste en lecture seule). On dispose alors dun pr edicteur dynamique a ` un bit dhistorique. De m eme, Lee et Smith [7] ont propos e dutiliser un tampon de destination de branchement ( Branch Target Buer , ou BTB) pour r ealiser une pr ediction de branchement. Ce dispositif est constitu e comme un cache associatif adress e par ladresse pr ec edant ladresse du branchement (ce qui permet danticiper la
Cours darchitectures et syst` emes des calculateurs parall` eles

3.4. PIPE-LINE

31

pr ediction, et daugmenter leet dhistorique selon la mani` ere dont on arrive a ` linstruction de branchement), et contenant les informations dhistorique ainsi que ladresse de destination pr edite. Linformation contenue sera mise a ` jour en fonction de la destination eective du branchement, lorsquelle sera connue. Le plus souvent, la pr ediction est eectu ee en fonction dun diagramme d etat, similaire a ` celui de la gure 3.25, pour conserver lhistorique des deux d ecisions pr ec edentes.
P PP P NP

N PN

N NN

Branchement pris

Branchement non pris

Fig. 3.25 Diagramme d etat dun pr edicteur a ` deux bits. Un cache de destination de branchement ( Branch Target Cache , ou BTC) peut etre associ e au BTB, et a pour but de contenir les quelques instructions situ ees a ` ladresse de destination du branchement, an de les charger rapidement dans le pipe-line dinstructions. Lavantage de disposer dau moins deux bits de pr ediction appara t clairement pour les boucles. Si lon consid` ere le fragment de code suivant : L1: L2: for (i = 0; i < 100; i ++) { for (j = 0; j < 4; j ++) { ...

ex ecut e en r egime stationnaire, alors avec un pr edicteur a ` un bit, la pr ediction de L2 est fausse lors de la premi` ere it eration de la boucle (on y reste, alors quon en etait sorti la derni` ere fois), et de la derni` ere (on en sort, alors quon avait boucl e les fois pr ec edentes). Avec un pr edicteur a ` deux bits, en r egime stationnaire, on consid` ere toujours que la boucle est prise, puisquau moins deux it erations pris mettent le pr edicteur dans l etat PP , et que lit eration de sortie ne le met que dans l etat PN . Le branchement L2 nest donc mal pr edit que pour lit eration de sortie. Le pr edicteur a ` deux bits est donc bien plus ecace pour traiter les boucles que le pr edicteur a ` un bit, car il g en` ere deux fois moins de mauvaises pr edictions (seulement en sortie de boucle, mais pas en entr ee). Cependant, ce type dhistorique, local a ` chaque branchement, peut ne pas etre ecace. En eet, si lon consid` ere le fragment de code suivant : L1: L2: if (cond1) action1; if ((cond1) || (cond2)) action2;

et si lon suppose que les deux conditions cond1 et cond2 sont al eatoires et non 1 et la probabilit e corr el ees entre elles, alors la probabilit e que L1 soit pris est de 2 1 3 = . que L2 soit pris est de 1 1 2 2 4 Avec un pr edicteur local a ` un bit (mais les r esultats restent valables pour un plus grand nombre de bits), la probabilit e quun branchement soit bien pr edit est egale a ` la somme, pour chaque branche du test, de la probabilit e que cette branche soit prise multipli ee par la probabilit e que cette branche soit bien pr edite qui est, avec un pr edicteur a ` un bit, la probabilit e quelle ait egalement et e prise la fois
c 2000, 2002 F. Pellegrini ENSEIRB

32

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

pr ec edente. Cest donc la somme des carr es des probabilit es que chaque branche 2 1 2 1 soit prise. La probabilit e que L1 soit bien pr edite est donc de 2 + 1 =2 , et la 2 2 2 1 5 3 edicteur de probabilit e que L2 soit bien pr edite est de 4 + 4 = 8 . Avec un pr type toujours pris, la probabilit e que L2 soit bien pr edit est egale a ` la probabilit e 3 = 6 e de bonne que L2 soit pris, cest-` a-dire de 4 8 . Dans cet exemple, la probabilit pr ediction avec un pr edicteur dynamique est inf erieure a ` la probabilit e de bonne pr ediction avec un pr edicteur statique, ce qui peut sembler etrange. Ceci est d u au fait que, L2 etant tr` es fortement biais e vers pris , consid erer quil sera non-pris a ` nouveau est tr` es p enalisant. Il faut donc rendre le pr edicteur plus stable par rapport aux cas exceptionnels, en utilisant par exemple un pr edicteur a ` deux bits au lieu dun seul, mais le probl` eme de tels branchements corr el es demeure. ` titre dexemple, si lon pouvait pr A edire L2 en fonction du r esultat de cond1, la probabilit e que L2 soit pris si L1 est pris serait de 1, et la probabilit e que L2 soit pris si L1 nest pas pris serait de 1 . De m e me, la probabilit e que L2 soit bien pr edit 2 si L1 est pris serait de 1, et la probabilit e que L2 soit bien pr edit si L1 est non-pris 2 1 2 + 2 = 1 e que L2 soit bien pr edit conna ssant L1 serait de 1 2 2 . La probabilit 1 1 3 = . Lutilisation dun historique global, prenant en serait donc de 2 1 + 1 2 2 4 compte les r esultats des autres branchements, peut donc etre plus ecace que de ne consid erer que lhistorique local. Pour cela, on peut utiliser un pr edicteur a ` deux niveaux [8]. Le premier est constitu e dune fonction de hachage prenant comme arguments ladresse du branchement et lhistorique global, sur b bits, des d ecisions de branchement les plus r ecentes, cod e comme un registre a ` d ecalage de b bits ( 1 pour pris et 0 pour non pris ). Le deuxi` eme est constitu e dun tableau de pr edicteurs a ` deux bits index e par cette fonction de hachage. Le sch ema dun tel m ecanisme est donn e en gure 3.26.

Adresse du branchement Historique global

Fonction de hachage

Table de prdicteurs 2 bits

Fig. 3.26 Sch ema dun pr edicteur a ` historique global a ` deux niveaux. Ladresse du branchement et la cha ne de bits de lhistorique global courant servent dindex dans une table de pr edicteurs a ` deux bits. Le pr edicteur a ` historique global permet de traiter plus ecacement les branchements corr el es. Ainsi, dans lexemple pr ec edent, lorsque le branchement L1 est pris, le registre a ` d ecalage global vaut xxx1 lors de la pr ediction de L2, et adresse des pr edicteurs a ` deux bits di erents de ceux utilis es lorsque le registre a ` d ecalage vaut xxx0. Si lon ne consid` ere pas les risques dinterf erences dus a ` la fonction de hachage, la probabilit e de bonne pr ediction est donc celle calcul ee pr ec edemment, cest-` a-dire 3 ; 4 On peut egalement remarquer que les m ecanismes de pr ediction de branchement et de branchement retard e sont antagonistes : une pr ediction de branchement parfaitement ecace rend inutile les branchements retard es, et r eciproquement. Cependant, comme il est impossible de pr edire totalement les branchements, les architectures r ecentes impl ementent souvent au moins un niveau de branchement retard e, pour amortir la p enalit e des branchements mal pr edits ;
Cours darchitectures et syst` emes des calculateurs parall` eles

3.5. PARALLELISME DINSTRUCTIONS Ex ecution sp eculative

33

Lex ecution sp eculative ( speculative execution ) utilise les performances des architectures superscalaires pour ex ecuter concurrement les deux ots dinstructions associ es a ` chacune des branches, dont les r esultats sont temporairement stock es dans des registres fant omes ( shadow registers ). D` es que la condition de branchement est eectivement evalu ee, les registres fant omes correspondant a ` la branche prise sont renomm es pour devenir les registres visibles par lutilisateur ; ceux correspondant a ` lautre branche sont simplement lib er es, pour resservir lors dun prochain branchement conditionnel. Lex ecution sp eculative n ecessite des m ecanismes tr` es evolu es pour retarder les eets de bord tels que les ecritures en m emoire ou les exceptions tant que la branche qui les g en` ere nest pas encore d enitivement accept ee ou rejet ee. En pratique, les processeurs actuels nautorisent quau plus quatre niveaux simultan es dex ecution sp eculative. En fait, il est plus economique dimpl ementer des m ecanismes ecaces de pr edicition de branchement que daugmenter la profondeur dex ecution sp eculative. Les deux m ecansimes sont antagonistes, et disposer dun m ecanisme parfaitement ecace pour r ealiser lune rend inutile la pr esence de lautre [14, page 27]. Une approche propos ee consiste a ` utiliser lex ecution sp eculative si elle est possible, et ensuite la pr ediction de branchement lorsque la profondeur maximale a et e atteinte.

3.5
3.5.1

Parall elisme dinstructions


Superscalarit e

Les processeurs classiques, dits scalaires (par opposition aux processeurs vectoriels, voir section 3.7), nex ecutent au plus quune instruction par cycle : en labsence de d ependances, une seule instruction est introduite a ` chaque cycle dans le pipe-line dinstructions. Les processeurs superscalaires, eux, disposent de plusieurs pipe-lines dinstructions qui leur permettent de traiter plusieurs instructions par cycle, et ainsi dexploiter le parall elisme existant entre instructions cons ecutives. Le nombre de pipe-lines dinstructions dun processeur superscalaire est appel e degr e du processeur. Typiquement, sur un code sans d eroulement de boucles, le nombre dinstructions cons ecutives sans d ependances est proche de deux. De fait, les processeurs superscalaires actuels ont un degr e compris entre trois et cinq. Il existe di erents mod` eles dex ecution superscalaires, que lon peut classer suivant la fa con dont lallocation et le r eordonnancement des instructions sont eectu es. On entend par allocation la technique qui permet daecter une instruction a ` une unit e de calcul, et par r eordonnancement la technique qui permet dex ecuter une instruction avant ou apr` es une autre. Ces deux techniques peuvent etre trait ees soit de fa con statique au niveau du compilateur (celui-ci devra alors, au moyen des techniques de d eroulage de boucle, dentrelacement de code, et de pr ediction de branchement, fournir un code dont les instructions cons ecutives soient les plus ind ependantes possible), soit de fa con dynamique au niveau du processeur. Parmi les processeurs superscalaires a ` allocation dynamique, on trouve tous les processeurs r ecents, tels le Pentium IV, lAlpha 21164, le Power, etc. Lavantage de lallocation dynamique est que le code ex ecutable dun tel processeur ne d epend pas du nombre dunit es fonctionnelles quil poss` ede, et est donc identique a ` celui
c 2000, 2002 F. Pellegrini ENSEIRB

34

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

des architectures traditionnelles, garantissant la compatibilit e au sein dune m eme famille, comme par exemple la famille Power dIBM.

3.5.2

VLIW ( Very Long Instruction Word )

Les processeurs VLIW sont les repr esentants des processeurs superscalaires a allocation statique. Les instructions des processeurs VLIW, de grande taille (jusqu` a 1024 bits), permettent de coder dans leurs di erents champs les op erandes de toutes les unit es fonctionnelles du processeur, qui peuvent toutes travailler en parall` ele. Les programmes ecrits au moyen dinstructions courtes doivent etre r earrang es pour former des instructions VLIW. Ceci doit etre fait par le compilateur, qui doit mettre en uvre des strat egies tr` es elabor ees. Les di erences entre les processeurs VLIW et les processeurs a ` allocation dynamique sont que : la densit e du code est souvent meilleure pour les architectures a ` allocation dynamique, de nombreuses unit es fonctionnelles du processeur VLIW etant inhib ees en cas de d ependances ; le d ecodage des instructions VLIW est tr` es simple, puisquil ne concerne que les op erandes ; les processeurs VLIW nont pas besoin de circuiterie de gestion des d ependances et de res equencement des instructions, puisque cette t ache est d evolue au compilateur.

3.5.3

LIW ( Long Instruction Word )

Actuellement, on soriente vers une voie hybride, avec des processeurs de type LIW. Ainsi, la nouvelle architecture Itanium d evelopp ee conjointement par Intel et HP est bas ee sur une architecture LIW o` u une instruction longue (ou paquet ) de 64 bits code trois instructions courtes qui peuvent etre ex ecut ees concurremment. Le Crusoe de Transmeta est un autre exemple de ce mod` ele. Ici encore, on supprime la circuiterie de r eordonnancement et de gestion des d ependances, a ` charge pour le compilateur de r earranger le code en paquets de trois instructions courtes. Lavantage des architectures LIW par rapport aux VLIW est quelles garantissent une compatibilit e ascendante lorsque le nombre dunit es fonctionnelles augmente : si le nouveau processeur de la famille poss` ede deux unit es fonctionnelles daddition au lieu dune seule, les instructions LIW du plus vieux processeur seront cependant toujours l egales sur le nouveau. En revanche, les instructions LIW du nouveau processeur pourront contenir deux instructions daddition par paquet, ce qui nest pas l egal pour le vieux processeur. Lensemble des techniques permettant de mettre en uvre le parall elisme explicite au niveau des instructions (VLIW et LIW), est d esign ee en anglais par lacronyme EPIC, pour Explicit Parallel Instruction Computing .

3.6

Application ` a la programmation

Les techniques mat erielles et logicielles doptimisation d ecrites ci-dessus ont un impact majeur sur la performance des programmes, selon que ceux-ci en tirent parti ou non. ` titre dexemple, consid A erons le probl` eme suivant : on dispose dun tableau dentiers de tr` es grande taille, ne contenant que des 0, des 1, et des 2, et lon souhaite conna tre le nombre de 0, de 1, et de 2 contenus dans le tableau. Pour ce faire, on peut ecrire au moins trois programmes di erents :
Cours darchitectures et syst` emes des calculateurs parall` eles

` LA PROGRAMMATION 3.6. APPLICATION A

35

le premier programme (P1), pr esent e en gure 3.27, est con cu pour tirer parti de lex ecution sp eculative : a ` chaque tour de boucle, un ou deux tests sont eectu es, qui conditionnent lincr ementation de deux compteurs, la valeur du troisi` eme etant d eduite a ` la n par soustraction ; c0 = c1 = 0; for (i = 0; i < n; i ++) { if (t[i] == 0) c0 ++ else if (t[i] == 1) c1 ++; } c2 = n - c0 - c1; Fig. 3.27 Programme de comptage des 0, 1, et 2 dun tableau, bas e sur lex ecution sp eculative. le deuxi` eme programme (P2), pr esent e en gure 3.28, est bas e sur lindexation dun tableau de compteurs, dont le contenu est incr ement e en fonction des valeurs du tableau initial. Ce programme ne requiert aucun branchement conditionnel au sein du corps de boucle, mais n ecessite obligatoirement des acc` es m emoire (m eme si elles ils se feront a ` priori que dans le cache de premier niveau), puisque les cases a ` incr ementer ne peuvent pas etre connues a ` la compilation, et donc ne peuvent etre aect ees a ` des registres. c[0] = c[1] = c[2] = 0; for (i = 0; i < n; i ++) c[t[i]] ++; Fig. 3.28 Programme de comptage des 0, 1, et 2 dun tableau, bas e sur lindexation dun tableau de compteurs. le troisi` eme programme (P3), pr esent e en gure 3.29, di` ere du pr ec edent en ce que lon remplace lacc` es au tableau index e de compteurs par une mise a ` jour conjointe de deux compteurs par des valeurs obtenues par masquage binaire des valeurs du tableau. Cette version ne contient aucun test interne, et peut etre compil ee uniquement avec des registres, mais n ecessite plus dop erations arithm etiques par tour de boucle.

c1 = c2 = 0; for (i = 0; i c1 += (t[i] c2 += (t[i] } c2 >>= 1; c0 = n - c1

< n; i ++) { & 1); & 2);

- c2;

Fig. 3.29 Programme de comptage des 0, 1, et 2 dun tableau, bas e sur la mise a ` jour conjointe de deux compteurs par des valeurs masqu ees. Le comportement des deuxi` eme et troisi` eme programme ne d epend pas de la distribution des donn ees contenues dans le tableau. En revanche, pour le premier, lhistorique de pr ediction de branchement au sein du corps de boucle d ependra fortement des proportions relatives de 0, 1, et 2, ainsi que de leur placement dans le
c 2000, 2002 F. Pellegrini ENSEIRB

36

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

tableau (de grandes plages de valeurs identiques seront pr ef erables a ` une r epartition al eatoire des valeurs). Processeur Celeron 300A 450Mhz Pentium III 700Mhz Duron 700Mhz Athlon XP 1.4Ghz PowerPC 60Mhz PowerWhwk2+ 375Mhz U.SPARC II 450Mhz U.SPARC IIe 400Mhz U.SPARC IIe 500Mhz Alpha EV67 667Mhz HP PA-8700 750MHz t[i] = { 0, 1, 2 } P1 P2 P3 9860 6650 7160 9070 6660 7290 7860 5510 5830 2850 2030 2110 13550 12220 11810 5640 3960 2160 10330 8880 8050 11650 9960 8710 8030 7290 6370 7678 6002 4555 4480 3540 3310 t[i] = 0 P2 P3 6650 7170 6670 7280 5490 5830 1990 2110 12270 11810 6190 2190 9670 7940 10770 9170 8080 6360 6003 4553 4870 3320

P1 5730 6090 5340 2000 12280 3480 8800 9670 6610 4728 4370

Tab. 3.1 Temps dex ecution des programmes pr esent es en gures 3.27, 3.28, et 3.29, mesur es sur di erentes architectures, en mode 32 bits, pour un tableau rempli de fa con al eatoire ou constitu e uniquement de z eros. Le tableau 3.1 donne les temps dex ecution des trois versions sur de nombreuses architectures1 , pour un tableau de donn ees rempli soit de fa con al eatoire, soit uniquement avec des z eros. Il nest pas tr` es pertinent de comparer quantitativement les temps obtenus pour deux architectures di erentes ; seule l etude qualitative, ligne par ligne, nous int eresse ici. On peut en d egager les renseignements suivants : quelle que soit la distribution des valeurs du tableau, la version P3 donne des temps identiques sur toutes les architectures, et est la plus ecace sur les architectures Power, Alpha, et HP PA-RISC, fortement superscalaires (pour plus dinformations sur la superscalarit e, voir la section 3.5.1) ; quelle que soit la distribution des valeurs du tableau, la version P2 donne elle aussi des temps equivalents pour toutes les architectures, sauf sur le Power WinterHawk2+, o` u les temps explosent lorsque le tableau nest rempli quavec des z eros. Ceci est extr emement surprenant, vu le niveau haut de gamme du processeur, et doit provenir de conits dacc` es au cache lors de demandes de lectures- ecritures multiples a ` la m eme case m emoire. Le HP PA semble egalement sensible, bien que dans une moindre mesure, au m eme ph enom` ene ; la version P2 est la plus performante sur les architectures Intel lorsque la pr ediction de branchement est inop erante, car celles-ci poss` edent un cache de premier niveau peu co uteux et ne sont pas tr` es superscalaires, rendant la version P3 moins ecace ; la version P1 est en revanche la plus ecace, sur les architectures Intel uniquement, lorsque la pr ediction de branchement donne des r esultats optimaux. Intel, limit e en superscalarit e par son jeu dinstructions CISC, a en revanche fait des eorts importants pour disposer dune unit e dex ecution sp eculative performante, qui r eduit dun tiers le temps dex ecution. Celle du HP PA semble aussi tr` es performante, puisque le temps de la version P1 d epend relativement peu de la distribution des donn ees. Ces r esultats montrent bien quil est important d ecrire des tests biais es le plus possible, et que, sur les architectures fortement superscalaires, il est pr ef erable de remplacer des tests potentiellement g en erateurs de ruptures de pipe-line par quelques
1 Ces r esultats ont et e fournis par Baptiste Malguy, ENSEIRB Info PRCD, promotion 2001, et compl et es par Christophe Giaume, promotion 2003.

Cours darchitectures et syst` emes des calculateurs parall` eles

3.7. PROCESSEURS VECTORIELS op erations suppl ementaires.

37

Certains processeurs disposent dinstructions a ` pr edicats ( predicated instructions ), qui ne sont eectivement ex ecut ees que si une certaine condition (valeur de registre) est v eri ee, et permettent d eviter de recourir a ` des instructions de branchement pour ex ecuter ou non des blocs conditionnels de petite taille. Cependant, pour traiter au plus vite ces instructions sans attendre le r esultat du calcul de la condition, il faut disposer de capacit es importantes dex ecution sp eculative, dont la complexit e limite les gains en performance [1].

3.7

Processeurs vectoriels

De nombreux probl` emes scientiques sont intrins` equement vectoriels, cest-` adire quils op` erent sur des vecteurs unidimensionnels de donn ees. Pour les traiter ecacement, certaines architectures (dont les CRAY ont et e les plus c el` ebres repr esentants) disposent dinstructions vectorielles, qui sappliquent a ` des tableaux unidimensionnels de donn ees de m eme nature (le plus souvent des nombres en virgule ottante), el ement apr` es el ement. Quand lunit e de contr ole d ecode et ex ecute une instruction vectorielle, le premier el ement du (ou des) vecteur(s) impliqu e(s) est soumis a ` lunit e de traitement consid er ee. Apr` es un certain nombre de cycles, le second el ement est soumis, et ainsi de suite, jusqu` a ce que toutes les op erandes du (ou des) vecteur(s) aient et e trait es. Cette technique permet de remplacer une s equence dinstructions scalaires par une instruction vectorielle qui ne sera d ecod ee quune seule fois, mais surtout permet dutiliser a ` plein les pipe-lines des unit es de traitement en virgule ottante (addition, multiplication, inverse) auxquelles les instructions vectorielles sont le plus souvent associ ees. An dacc el erer encore plus les calculs, il est possible de cha ner plusieurs op erations vectorielles entre elles ( pipeline chaining ). Le r esultat dune unit e de traitement pipe-lin ee est alors soumis en entr ee dune autre, sans attendre que la premi` ere op eration vectorielle ait termin e. Ainsi, le cha nage de deux op erations vectorielles ne co ute que le temps dinitilisation du pipe-line de la deuxi` eme unit e de traitement, en plus du co ut dex ecution de la premi` ere instruction vectorielle. Ceci revient, du point de vue de lecacit e, a ` augmenter la profondeur du pipe-line de traitement. ` titre dexemple, on peut A etudier la mani` ere dont on calcule linverse de nombres ottants sur le CRAY 1. Cette machine ancienne (1976), dont une version simpli ee de larchitecture fonctionnelle est pr esent ee en gure 3.30, est bas ee sur une architecture vectorielle pipe-lin ee, avec un temps de cycle = 12, 5 ns, une profondeur de pipe-line de 6 cycles pour laddition, 7 cycles pour la multiplication, et 14 cycles pour lapproximation r eciproque ( reciprocal approximation , ou RA), qui permet dobtenir une approximation a ` deux bits pr` es de linverse dun nombre ottant. Le surco ut dutilisation des registres vectoriels est dun cycle pour la lecture et dun cycle pour l ecriture, et le surco ut de cha nage entre deux unit es est de deux cycles. 1 dun nombre a par la m ethode de Newton, Sur le CRAY 1, on calcule linverse x = a cest-` a-dire la recherche du z ero de la fonction f (x) = a x1 , avec f (x) = x2 , en it erant : f (xn ) xn+1 = xn = (2 a xn )xn . f (xn )
1 , une seule it eration Comme la fonction RA donne une bonne approximation de a de la m ethode de Newton est n ecessaire pour d eterminer les deux derniers bits de

c 2000, 2002 F. Pellegrini ENSEIRB

38

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS


P Instruction pointer (24 bits) Instruction buffers (4 * 64 * 16 bits = 256 instructions stack) 320 Mwords/s 4 words / clock period 1 Mword (64 bits) VL Vector length (7 bits) B0 B1 B2 B3 B4

Branch

0 (16 bits) 1 63

Control

Address registers (24 bits) Integer addition Integer multiplication

A0 A1 A2 A3 A4 A5 A6 A7

B62 B63 Address buffer registers 1 word / 2 clock periods T0 T1 T2 T3 T4 T62 T63 Scalar buffer registers 1 word / 2 clock periods Vector mask (64 bits) 80 Mwords/s 1 word / clock period

Memory cycle 50 ns

Scalar registers (64 bits) Integer addition Shift Logical Population count Floatingpoint addition Floatingpoint multiplication Reciprocal approximation

S0 S1 S2 S3 S4 S5 S6 S7

16 banks

VM

Vector registers 0 (64 bit elements) 1 2 3 4 Integer addition Shift Logical 62 63

V0

12

5 6 7

Fig. 3.30 Sch ema simpli e de larchitecture fonctionnelle du CRAY 1. Extrait de [4, page 73]. la mantisse de
1 a,

et donc x = (2 a RA(a))RA(a) .

Si lon eectue le calcul S6 = S1 / S2 au moyen des registres scalaires, selon la 1 s equence de la gure 3.31, on obtient une puissance de 29 2, 76 Mop/s. Si lon r ealise maintenant la division de fa con vectorielle, avec des vecteurs de taille l 9, selon la s equence de la gure 3.32, illustr ee par la gure 3.33, on obtient une l puissance de (24+3 23 , 7 Mop/s pour des vecteurs de taille l = 64. Remarquons l) que, dans lalgorithme vectoriel, on a invers e lordre des deux instructions du milieu, car sinon les deux instructions cha n ees acc` ederaient en m eme temps en lecture au vecteur V2, ce qui nest pas possible sur le CRAY 1. Dans le cas de la multiplication vectorielle V3 = V1 * V2, le temps de calcul pour un vecteur de taille l est 1 + 7 + 1 + (l 1) = 8 + l, ce qui donne une puissance de 70 Mop/s pour des vecteurs de taille l = 64. Il est a ` noter que la limitation dacc` es a ` la m emoire a fait lobjet dam eliorations tr` es pr ecoces. D` es la g en eration X-MP, les CRAY se sont vus dot es de trois pipe-line dacc` es a ` la m emoire : deux pour la lecture, et un pour l ecriture. Ainsi,
Cours darchitectures et syst` emes des calculateurs parall` eles

3.8. EVALUATION DES PERFORMANCES DES PROCESSEURS Instruction = RA(S2) = (2 - S3 * S2) = S1 * S3 = S4 * S5 Unit e RA mul ( !) mul mul D ebut 0 14 15 22 Fin 14 21 22 29

39

S3 S4 S5 S6

Pipe-line

Fig. 3.31 S equencement des instructions scalaires n ecessaires au calcul de S6 = S1 /S2. Instruction = RA(V2) = V1 * V3 = (2 - V3 * V2) = V4 * V5 Unit e RA mul mul mul D ebut 0 1 + 14 + 1 17 + (l - 1) 17 + 1 + 2 (l - 1) Fin 16 + (l 25 + (l 26 + 2 (l 27 + 3 (l

V3 V5 V4 V6

1) 1) 1) 1)

Cha nage Pipe-line Pipe-line

Fig. 3.32 S equencement des instructions vectorielles n ecessaires au calcul de V6 = V1 /V2.


Chanage
0 10 20

Pipeline
30

Pipeline
40 50

Temps
57

RA

MUL

MUL

MUL

lments

Fig. 3.33 S equencement des calculs vectoriels de la gure 3.32. lex ecution de la fonction BLAS-1 SAXPY, qui r ealise lop eration Y = aX + Y sur deux vecteurs X et Y , avec a scalaire, seectue-t-elle au moyen de trois cha nes sur le CRAY 1, mais seulement avec une sur le CRAY X-MP, comme illustr e en gure 3.34. La vectorisation automatique a et e un sujet de recherche tr` es actif au cours de la derni` ere d ecennie, qui a permis dorir aux utilisateurs des compilateurs vectoriseurs ecaces. Ceux-ci utilisent plusieurs techniques : le d eroulage de boucles ( loop unrolling ), pour transformer les op erations scalaires de plusieurs it erations en op erations vectorielles plus ecaces ; la segmentation de tableaux ( strip-mining ), pour convertir des op erations logiques sur des vecteurs de grandes tailles en instructions op erant sur les registres vectoriels de la machine, qui sont de taille xe ; la transformtion des boucles ( loop transformation ), qui permet de modier lordre dans lequel lespace des it erations dun nid de boucle est parcouru an de maximiser la localit e des donn ees dans les boucles les plus internes, comme illustr e en gure 3.35.

3.8

Evaluation des performances des processeurs

La fr equence dhorloge est un param` etre d eterminant de la puissance des processeurs. Cependant, de nombreux autres crit` eres architecturaux doivent etre pris en compte, sans parler de lenvironnement du processeur (la hi erarchie m emoire, en particulier). De fait, laugmentation de la fr equence dhorloge nest signicative par
c 2000, 2002 F. Pellegrini ENSEIRB

40

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS


Mmoire

R/W

V2

Mmoire

R/W

Mmoire

V1 S1 *S V2

R1

R2

V1

V2

S1
V3

*S

+V

V3

V4

+V

V4

V4

R/W

Mmoire

Mmoire

Fig. 3.34 Cha nages des instructions vectorielles n ecessaires a ` la r ealisation de lop eration BLAS-1 SAXPY, sur le CRAY 1 et sur le CRAY X-MP. elle m eme quau sein dune famille de processeurs donn ee. Pour comparer les performances de deux machines di erentes (architecture, type de jeu dinstructions, etc.), il faut d ecomposer le temps total dex ecution des programmes en leurs constituants. Le temps mis pour ex ecuter un programme donn e est le produit du nombre de cycles n ecessaires par le temps de cycle : T = c . Le nombre de cycles peut etre quant a ` lui r e ecrit comme le nombre dinstructions ex ecut ees multipli e par le nombre moyen de cycles par instructions : T =i c i .

Le nombre dinstructions d epend de facteurs logiciels (algorithme choisi, compilateur), mais aussi du type de jeu dinstructions utilis e (CISC ou RISC). Le fait davoir un jeu dinstructions plus complexe nacc el` ere pas forc ement lex ecution, car ces instructions n ecessitent plus de cycles pour sex ecuter.
Cours darchitectures et syst` emes des calculateurs parall` eles

3.8. EVALUATION DES PERFORMANCES DES PROCESSEURS DO 20 I = 2, N DO 10 J = 2, I A(I, J) = A(I, J - 1) * + A(I - 1, J) CONTINUE CONTINUE DO 20 J = 2, N DO 10 I = 2, J A(I, J) = A(I, J - 1) * + A(I - 1, J) CONTINUE CONTINUE

41

10 20

10 20

Fig. 3.35 Example de transformation de boucles. L echange des boucles en I et J permet dacc eder au tableau A par colonnes, qui est lordre naturel en FORTRAN, et donc de le charger en m emoire par des instructions vectorielles. Le nombre moyen de cycles par instruction ne mesure pas seulement la complexit e du jeu dinstructions, et d epend egalement de crit` eres architecturaux : superscalarit e, pipe-lines, etc. Le temps de cycle du processeur d epend de la technologie et des mat eriaux utilis es, mais aussi de larchitecture du processeur. Un jeu dinstructions petit et une circuiterie simple n ecessitent une surface de silicium moins importante, do` u un temps de parcours de linformation plus petit. La mesure eective des performances des machines seectue en mesurant le temps dex ecution de programmes de complexit e connue : calcul matriciel (LinPACK 100100 ou 10001000), etc. Cette m ethode seule permet de prendre en compte lint egralit e des ph enom` enes mis en jeu, tant du point de vue mat eriel que logiciel. Elle nest cependant valide que pour une application donn ee (si celle-ci est plut ot vectorielle ou superscalaire, on pourra avoir des performances tr` es variables sur des architectures di erentes).

c 2000, 2002 F. Pellegrini ENSEIRB

42

CHAPITRE 3. ARCHITECTURE DES PROCESSEURS

Cours darchitectures et syst` emes des calculateurs parall` eles

Chapitre 4

Architecture des m emoires


4.1 Hi erarchie m emoire

Lecacit e des processeurs d epend tr` es fortement du temps dacc` es aux informations stock ees en m emoire. Cependant, pour des raisons techniques (vitesse de la lumi` ere) autant que nanci` eres, il nest pas possible de r ealiser une m emoire de grande capacit e ayant un temps dacc` es compatible avec les fr equences de cadencement des processeurs actuels (4 GHz, soit 250 ps de latence). Dans tout programme, il est possible de mettre en evidence un ph enom` ene de localit e des acc` es m emoire, exprim e en termes de : localit e temporelle : plus une zone m emoire a et e acc ed ee r ecemment, et plus sa probabilit e de r e-acces est elev ee ; localit e spatiale : plus une zone m emoire est proche de la derni` ere zone m emoire acc ed ee, et plus la probabilit e quelle soit a ` son tour acc ed ee est importante. Ceci est vrai : pour les instructions. Cest le cas du d eroulement normal dun programme s equentiel sans branchements, dont on tire egalement partie dans les pipelines dinstructions ; pour les donn ees. Cest le cas lors des mises a ` jour de variables, de lacc` es a ` des donn ees structur ees, du parcours s equentiel de tableaux, etc. On sappuie sur ce principe pour mettre en place une hi erarchie de la m emoire, entre m emoires rapides de faible capacit e et m emoires de grande capacit e aux temps dacc` es plus longs, an que les informations les plus fr equemment utilis ees soient disponibles le plus rapidement possible ; cette structure pyramidale est illustr ee en gure 4.1. Le transfert des informations entre zones lentes et zones rapides seectue soit de fa con logicielle (registres, zones cache utilisateur, va-et-vient ( swap ) disque), soit de fa con mat erielle (cache).

4.2

Registres

Les registres sont des m emoires tr` es rapides (temps dacc` es de lordre des cent pico-secondes), situ es le plus souvent sur le processeur lui-m eme. An de mettre en uvre ecacement les techniques pipe-line et superscalaires, et de r eduire le nombre dacc` es a ` la m emoire, les processeurs actuels poss` edent de plus en plus de registres. Les architectures les plus courantes en ont de 32 a ` 192, mais on trouve des processeurs en ayant jusqu` a 2048. Cependant, le plus souvent, 43

44

CHAPITRE 4. ARCHITECTURE DES MEMOIRES

Registres
Vitesse Cot/octet

Cache(s) Mmoire centrale Mmoire de masse

Capacit

Fig. 4.1 Hi erarchie m emoire. tous ne sont pas simultan ement accessibles a ` lutilisateur. Pour eviter que les changements de contexte li es aux appels de fonctions ne g en` erent des acc` es m emoire co uteux, certains processeurs disposent dun m ecanisme de fen etres de registres , introduit dans le processeur RISC I de lUniversit e de Berkeley en 1972, et repris par les processeurs SPARC. Ceux-ci disposent de 32 registres visibles pour ex ecuter les programmes. Huit sont des registres globaux, communs a ` tous les contextes, et les 24 autres sont des registres fen etr es associ es a ` chaque proc edure, comme illustr e en gure 4.2.
Fentre prcdente Fentre courante Fentre suivante
r[7] r[0] r[31] r[24]

In

r[23] r[16]

Local

r[15] r[8] r[31] r[24]

Out In
r[23] r[16]

Local

r[15] r[8] r[31] r[24]

Out In

Global

Fig. 4.2 Fen etres de registres du processeur SPARC. Chaque fen etre est divis ee en trois sections : les Ins : param` etres pass es par la proc edure appelante ; les Locals : accessibles seulement a ` la proc edure courante ; les Outs : param` etres pass es aux proc edures appel ees, pouvant egalement servir de variables locales. Les 136 registres du processeur SPARC sont donc organis es en huit fen etres glissantes de 24 registres chacune, auxquelles il faut ajouter huit registres globaux (comprenant les pointeurs dinstructions et de pile), comme illustr e en gure 4.3. Un indicateur de fen etre courante et des bits dinvalidit e permettent de d eterminer quelles fen etres sont utilisables ou n ecessitent une sauvegarde de contexte. En th eorie, on peut parcourir sept niveaux de r ecursion sans eectuer dacc` es m emoire, ce qui permet un gain consid erable en ecacit e pour les programmes fortement r ecursifs. En pratique, lint egralit e de la fen etre de registres doit etre sauvegard ee entre chaque changement de contexte de processus, ce qui est tr` es p enalisant dans un environnement multi-processus en temps partag e. Cette id ee a n eanmoins et e reprise et etendue dans larchitecture Itanium, qui poss` ede 128 registres visibles, organis es en 32 registres globaux, num erot es de 0 a ` 31, visibles de tous les contextes, et 96 registres empil es, num erot es de 32 a ` 127. Chaque fonction d eclare lors de la cr eation de son contexte le nombre de registres In
Cours darchitectures et syst` emes des calculateurs parall` eles

4.3. MEMOIRE CACHE


L7 I7 O6 L6 O5 I6 L5 I5 O4 L4 I4 O3 L3 O2 I3 Global O7 I0 L0 O0 I1 L1 I2 O1 L2

45

Fig. 4.3 Recouvrement des fen etres de registres glissantes du processeur SPARC. quelle reconnait, ainsi que le nombre total de registres disponibles dont elle a besoin (In, Local et Out ), n ecessairement inf erieur ou egal a ` 96. Un m ecanisme mat eriel sp ecique, appel e Register Stack Engine, est charg e de sauvegarder ( spill ) dans la pile m emoire, appel ee zone de backing store, le contenu des registres physiques des contextes appelants les plus anciens et devant servir comme registres locaux du contexte courant, et a ` les restaurer ( ll ) lorsquon retournera a ` ces contextes, donnant ainsi lillusion dune pile de registres de taille innie. Une etude men ee par des ing enieurs dIntel a montr e que le m ecanisme de pile de registres pouvait conduire a ` un gain de performance de lordre de 10% par rapport a ` un processeur nen disposant pas [12].

4.3

M emoire cache

La m emoire cache est une m emoire rapide faisant tampon entre le processeur et la m emoire centrale. Selon leur localisation, on distingue : les caches internes, situ es sur le processeur, dune vitesse presque equivalente a ` celle des registres, et de taille comprise entre 1 et 32 ko ; les caches externes, ext erieurs au processeur, plus lents mais de capacit e plus importante, pouvant aller jusqu` a 1 Mo. Ces deux types de cache peuvent coexister au sein de la m eme architecture ; le cache interne est alors appel e cache de premier niveau, et le cache externe, cache de second niveau. Dans certaines architectures, on trouve m eme un troisi` eme niveau de cache.

4.3.1

M ecanismes dacc` es

Quand le processeur souhaite lire une donn ee a ` partir de la m emoire, il g en` ere ladresse correspondante, et emet une requ ete sur le bus, qui est intercept ee par le cache. Si la donn ee est pr esente dans le cache (on parle alors de cache hit ), elle est directement envoy ee au processeur. Sinon, en cas de d efaut de cache ( cache miss ), la requ ete est transmise a ` la m emoire centrale. Lorsque la donn ee est fournie par la m emoire, une copie est conserv ee dans le cache (en cas dacc` es futur), qui doit lib erer la place n ecessaire a ` son stockage. An de tirer parti du ph enom` ene de localit e, les transferts entre le cache et la m emoire seectuent par blocs (ou lignes , lines ). Pour des raisons decacit e (li ees au temps de transfert ainsi qu` a la limitation de la place dans le cache), la
c 2000, 2002 F. Pellegrini ENSEIRB

46

CHAPITRE 4. ARCHITECTURE DES MEMOIRES

taille de ces blocs est cependant limit ee a ` quelques octets (entre 16 et 64). Les lignes de cache sont charg ees sur demande. Lorsquune donn ee a ` lire nest pas pr esente dans le cache, celui-ci demande a ` la m emoire de lui transmettre la ligne a ` laquelle appartient la donn ee demand ee, et lib` ere lespace n ecessaire a ` son stockage. Plusieurs optimisations permettent dacc el erer les lectures a ` partir de la m emoire. Habituellement, en labsence de cache, les mots sont lus individuellement a ` partir de la m emoire : ladresse du mot a ` lire est plac ee sur le bus, et la m emoire renvoie alors son contenu, au bout dun certain temps. Pour optimiser le chargement des lignes de cache a ` partir de la m emoire (op eration dite de cache line ll ), on peut eectuer une lecture en mode rafale ( burst ). Dans ce cas, on place sur le bus ladresse du premier mot de la ligne a ` charger, les mots de la ligne etant alors envoy es par la m emoire les uns apr` es les autres. Par ce moyen, on diminue grandement le temps de chargement dune ligne de cache, puisquon ne sp ecie quune seule fois ladresse de lecture, au lieu de le faire une fois par mot de la ligne. De plus, lorsque le cache charge une ligne, il retourne le mot demand e au processeur d` es quil le re coit, sans attendre la n du chargement complet de la ligne. Quand le processeur souhaite ecrire une donn ee en m emoire, trois techniques peuvent etre utilis ees par le cache pour r ealiser cette op eration : write through : toute op eration d ecriture demand ee par le processeur provoque l ecriture eective de la donn ee en m emoire, m eme en cas de cache hit . Si la donn ee etait d ej` a pr esente dans le cache, celui-ci est egalement mis a ` jour. Faute doptimisations, cette technique reviendrait a ` supprimer le cache lors des op erations d ecriture, et ralentirait celles-ci de fa con catastrophique. Pour eviter cela, les caches de ce type disposent de tampons d ecriture ( fast write buers ), qui permettent le traitement asynchrone des op erations d ecriture, en evitant au processeur dattendre leur r ealisation eective. Le probl` eme ne resurgit que lorsque les tampons sont pleins. Le grand avantage de la technique write through est quelle rend les lignes de cache imm ediatement disponibles pour leur r eallocation ; write back : toute op eration d ecriture demand ee par le processeur provoque la mise a ` jour du cache, mais la ligne modi ee nest recopi ee en m emoire que lorsquelle doit faire place a ` de nouvelles donn ees dont le processeur a besoin. La technique write back ralentit le remplacement de lignes de cache, du fait des ecritures a ` r ealiser avant le chargement des nouvelles lignes, mais ceci est en g en eral compens e par la suppression des (multiples) op erations d ecriture en m emoire qui ont ainsi et e evit ees ; write allocate : dans le cas o` u la donn ee a ` ecrire nest pas d ej` a pr esente dans le cache, cette technique consiste a ` allouer la ligne de cache correspondante, en la chargeant a ` partir de la m emoire une fois que l ecriture a et e prise en compte par celle-ci. Comme la donn ee a eectivement et e ecrite, le processeur peut imm ediatement poursuivre son traitement, pendant que le chargement de la ligne seectue de fa con asynchrone. La technique write allocate nest vraiment utile que pour les caches de type write back . De fait, lors du chargement de la nouvelle ligne de cache, on aura souvent dabord a ` ecrire une ligne de cache modi ee avant de charger la nouvelle ligne a ` sa place. ` cause de cette complexit A e, la plupart des caches nimpl ementent pas de strat egie write allocate ; les op erations d ecriture provoquant des d efauts de cache sont simplement r epercut ees vers la m emoire centrale, et ignor ees par le cache.
Cours darchitectures et syst` emes des calculateurs parall` eles

4.3. MEMOIRE CACHE

47

Aucune des deux strat egies, write back ou write through , ne lemporte clairement sur lautre : leurs performances relatives d ependent de la structure des acc` es m emoire r ealis es par les programmes.

4.3.2

Structure

Tout cache n ecessite, en plus de la zone m emoire r eserv ee aux donn ees (servant au stockage des lignes), des informations de contr ole servant dindex de recherche (ou de r epertoire, directory ) dans le cache. On distingue quatre types principaux dorganisation des donn ees dans les caches : la correspondance directe ( direct mapping ) : chaque donn ee de la m emoire a une place pr ecalcul ee unique dans le cache. Ainsi, avec un cache de capacit e 2s+l , les donn ees situ ees aux adresses a, a + 2s+l , a + 2 2s+l, a + 3 2s+l serontelles stock ees a ` la m eme place de la m eme ligne du cache, comme illustr e en gure 4.4.
tiquette Ensemble Dplacement

Comparateur

hit/miss

donne

Fig. 4.4 Structure dun cache a ` correspondance directe. Cette organisation est extr emement simple et rapide, car elle ne requiert quun unique comparateur pour tester si l etiquette de la ligne de cache correspond bien a ` la partie haute de ladresse fournie ; si cest le cas, on a un cache hit , sinon un cache miss . Linconv enient majeur de ces caches est que leurs performances d ependent fortement de lalignement des structures de donn ees quils cachent. Dans le cas dune copie el ement par el ement entre deux tableaux dont les adresses de d ebut di` erent dun multiple de 2s+l , par exemple, on aura deux d efauts de cache par el ement ; la k -associativit e par ensemble ( k -way set associativity ) : le cache est subdivis e en ensembles ( sets ) contenant plusieurs lignes (de deux a ` seize), et disposant dinformations de contr ole propres servant a ` la gestion individuelle de ces lignes. Chaque donn ee de la m emoire a un unique ensemble destination, mais dans cet ensemble sa position est totalement libre. Cette structure est illustr ee en gure 4.5, pour un cache 2-associatif. Le choix de la ligne a ` remplacer lorsquune nouvelle ligne doit etre charg ee dans un ensemble seectue au moyen dune politique LRU ( Least Recently Used ). lassociativit e totale ( full associativity ) : le cache est constitu e dun unique ensemble, et donc une donn ee peut etre plac ee dans nimporte quelle ligne. Ce type de cache ore les meilleurs taux de r eussite ( hit ratio ), mais est le plus complexe a ` impl ementer ;
c 2000, 2002 F. Pellegrini ENSEIRB

48
tiquette

CHAPITRE 4. ARCHITECTURE DES MEMOIRES


Ensemble Dplacement

Comparateur

hit/miss

donne

Fig. 4.5 Structure dun cache 2-associatif. la correspondance par secteurs ( sector mapping ) : le cache est subdivis e en secteurs ( sectors ) contenant plusieurs lignes (de 2 a ` 32) qui disposent chacune dun bit de validit e. La recherche dune donn ee dans le cache seectue par comparaison associative totale entre son etiquette de secteur ( sector frame ) et toutes les etiquettes de secteur du cache, puis par indexation directe a ` lint erieur du secteur choisi. Cette structure est illustr ee en gure 4.6. Cette architecture revient a ` augmenter la granularit e du cache, tout en conservant une taille de donn ees en lecture/ ecriture egale a ` celle dune ligne. Elle est moins co uteuse que lassociativit e totale, en ce que les comparaisons seffectuent sur un nombre plus restreint d etiquettes. Elle convient bien aux machines d edi ees au calcul num erique, car les boucles r ealis ees dans les algorithmes de calcul scientique nacc` edent en g en eral qu` a quelques zones de grande taille a ` la fois.

4.3.3

Adressage

Les adresses m emoire soumises aux caches peuvent etre soit les adresses logiques fournies par le processeur, soit les adresses physiques r esultant de la traduction des adresses logiques par la MMU ( Memory Management Unit ). Lorsque le cache utilise ladressage physique, lacc` es au cache seectue apr` es que ladresse logique emise par le processeur a et e traduite en adresse physique par la MMU, ce qui ralentit les acc` es m emoire. Lorsque le cache utilise ladressage logique, les acc` es au cache seectuent parall` element a ` la traduction de ladresse logique en adresse physique, ce qui permet dacc el erer le traitement des acc` es m emoire. En revanche, cela g en` ere un probl` eme de coh erence pour les syst` emes multi-processus, puisqualors la m eme adresse logique, utilis ee par des processus di erents, doit correspondre a ` des donn ees di erentes. Pour rem edier a ` cela, une solution simple consiste a ` invalider lensemble des lignes du cache lors des changements de contextes entre processus. Cette solution est cependant extr emement co uteuse, surtout dans le cas des caches write back , qui
Cours darchitectures et syst` emes des calculateurs parall` eles

4.3. MEMOIRE CACHE


tiquette Ligne Dplacement

49

Comparateur

hit/miss

donne

Fig. 4.6 Structure dun cache sectoriel. n ecessitent l ecriture en m emoire de toutes leurs lignes modi ees. Une autre solution consiste a ` associer aux lignes du cache, en plus de leur etiquette, un identicateur de processus. Cette solution est viable, mais induit un surco ut m emoire qui peut etre important.

4.3.4

Coh erence

Lexistence de caches internes aux processeurs rend la r ealisation de machines multi-processeurs a ` m emoire partag ee plus d elicate, du fait des incoh erences pouvant exister entre les valeurs dune m eme r ef erence m emoire contenues dans les caches de processeurs di erents, comme illustr e en gure 4.7.
Processeur Cache Bus Mmoire x x x/y x x x x x y y x

Fig. 4.7 Mise en evidence dincoh erences potentielles entre caches locaux et m emoire commune sur une machine bi-processeur. Lorsque le premier processeur demande la valeur dune case m emoire, cette valeur est conserv ee dans son cache local. Il en est de m eme lorsque le deuxi` eme processeur eectue la m eme requ ete. Si le premier processeur modie la valeur, la modication peut etre ou non r epercut ee en m emoire selon le type de cache ( write through ou write back ), mais lors dacc` es ult erieurs, le deuxi` eme processeur verra toujours lancienne valeur contenue dans son cache local.
c 2000, 2002 F. Pellegrini ENSEIRB

50

CHAPITRE 4. ARCHITECTURE DES MEMOIRES

Lincoh erence entre caches est uniquement caus ee par les ecritures. Elle se produit lorsquune op eration d ecriture, qui modie la valeur de la r ef erence m emoire contenue dans le cache du processeur eectuant l ecriture (et egalement la m emoire elle-m eme, dans le cas dun cache write-through ), nest pas r epercut ee sur les autres caches poss edant lancienne valeur. Deux politiques sont envisageables pour maintenir la coh erence entre caches : linvalidation sur ecriture ( write-invalidate ) : la mise a ` jour eectu ee sur un cache provoque linvalidation (r einitialisation du bit de validit e) de toutes les copies de la ligne poss ed ees par les autres caches ; les lignes invalid ees sont dites p erim ees ( dirty ). Ainsi, lorsquun autre processeur demandera a ` lire cette r ef erence m emoire, la valeur transmise sera lue a ` partir de la m emoire centrale, et non a ` partir dune ligne de cache p erim ee. De fait, cette politique nest envisageable que pour les caches de type writethrough , qui assurent en permanence la coh erence entre l etat de la m emoire et des caches. la mise a ` jour sur ecriture ( write-update ) : la mise a ` jour eectu ee sur un cache est egalement eectu ee sur tous les autres caches poss edant la r ef erence m emoire. La prise en compte par tous les caches des op erations d ecriture eectu ees par lun dentre eux n ecessite dans tous les cas une circuiterie suppl ementaire. Lorsque les caches sont de type write through , un protocole despionnage du bus ( snooping protocol ) permet de tracer toutes les op erations d ecriture r ealis ees par les autres caches, et eventuellement de lire a ` la vol ee la nouvelle valeur des r ef erences m emoires an de r epercuter localement la mise a ` jour. Cependant, dans un environnement multi-processeurs, lutilisation syst ematique du bus par les caches write-through fait de celui-ci un goulet d etranglement. Pour rem edier a ` cela, tout en assurant la coh erence des caches dans un environnement multi-processeurs, a et e d evelopp e un protocole de gestion de caches dit a ` ecriture unique ( write-once ) [3], dont le repr esentant le plus connu est le protocole MESI ( Modied, Exclusive, Shared, Invalid ). Selon ce protocole, chaque ligne de cache peut prendre quatre etats distincts : invalid : la ligne de cache ne contient pas de donn ees valides ; shared : la ligne de cache contient des donn ees a ` jour, qui nont pas et e modi ees depuis leur chargement dans le cache. Dautres processeurs peuvent egalement poss eder des copies de ces donn ees dans leurs propres caches ; exclusive : les donn ees de la ligne de cache nont et e modi ees localement quune seule fois depuis leur chargement dans le cache (elles etaient alors en mode shared ), et la modication a et e r epercut ee en m emoire centrale, selon le principe write-through . Aucun autre cache ne poss` ede de copie valide de la ligne (do` u le nom) ; modied : les donn ees de la ligne de cache ont et e modi ees localement plusieurs fois depuis leur chargement dans le cache, mais les modications successives nont pas et e r epercut ees en m emoire centrale, selon le principe write-back . On ne peut arriver a ` cet etat qu` a partir de l etat exclusive . Ici encore, aucun autre cache ne poss` ede de copie valide. Lorsquune nouvelle ligne est charg ee dans le cache a ` partir de la m emoire, son etat est positionn ea ` shared . Dautres caches peuvent egalement charger les m emes donn ees, qui seront egalement etiquet ees localement shared . Lorsquune ligne shared est modi ee localement pour la premi` ere fois, son etat passe a ` exclusive , et la modication est r epercut ee a ` travers le bus vers
Cours darchitectures et syst` emes des calculateurs parall` eles

4.3. MEMOIRE CACHE

51

la m emoire centrale, selon le principe write-through . Ainsi, par lespionnage du bus, tous les caches poss edant une copie shared de la ligne linvalideront. Lorsquune ligne exclusive est modi ee localement pour la premi` ere fois, son etat passe a ` modied , et la modication nest pas r epercut ee vers la m emoire centrale, de m eme que les suivantes. Dapr` es ce qui pr ec` ede, aucun autre cache ne poss` ede de copie valide de la ligne, puisque le passage pr ec edent de la ligne en mode exclusive les a toutes invalid ees. Cependant, la m emoire centrale nest plus a ` jour, et tout processeur redemandant cette ligne chargera des donn ees p erim ees. Pour eviter cela, le cache poss edant une copie en mode modied dune ligne demand ee par un autre cache doit intercepter la requ ete, et placer lui-m eme la nouvelle valeur de la ligne sur le bus, en prenant le pas sur la m emoire centrale ; cette notion de pr eemptivit e du bus est impl ement ee dans tous les bus r ecents (Multibus et Futurebus ). Dans le m eme temps, le cache propri etaire ecrira la ligne en question en m emoire centrale, et remettra l etat de sa ligne a ` shared , puisquune autre copie existe sur un autre cache. Lid ee des caches write-once est donc de remplacer la mise a ` jour syst ematique de la m emoire, g en eratrice dengorgements, par une mise a ` jour a ` la demande, les caches propri etaires des lignes modi ees se chargeant alors de les fournir aux caches demandeurs. Un grand avantage de ce protocole est quil permet dassocier librement sur le m eme bus m emoire des unit es de traitement disposant de caches (comme les processeurs) et dautres nen ayant pas (comme les p eriph eriques dentr ees/sorties) ; cest en fait la pr eemptibilit e du bus qui permet de les interfacer sans circuiterie suppl ementaire.

4.3.5

Hi erarchies de caches

Le besoin de performance accrue en terme de d ebit m emoire le processeur a conduit les concepteurs de caches a ` r ealiser des caches a ` triple niveau. Ainsi, sur le processeur Itanium2, on trouve : un cache de premier niveau constitu e dun cache dinstructions de 16 Ko et dun cache de donn ees de 16 Ko egalement, capable de servir quatre requ etes en lecture par cycle, ou deux requ etes en lecture et deux en ecriture, structur e en lignes de 64 octets ; un cache de deuxi` eme niveau uni e de 256 Ko, 8-way associative write-back, structur e en 16 bancs de lignes de 128 octets, et capable de servir quatre requ etes par cycle, avec une latence dau moins 6 cycles. Le cache est nonbloquant, capable de g erer simultan ement, gr ace a ` une le sp ecique appel ee L2OzQ, jusqu` a 32 requ etes provenant du cache de premier niveau, de r eordonner les requ etes en fonction des conits de bancs et des identit es dadresses sur les Load et les Store, et de g erer jusqu` a 16 requ etes simultan ees vers le cache de troisi` eme niveau ; un cache de troisi` eme niveau uni e de 1.5 Mo, 12-way associative, avec une latence dau moins 12 cycles. La complexit e des m ecanismes mis en uvre dans ces hi erarchies de cache, qui peuvent interf erer entre eux et induire des pertes de performance consid erables (de plus de la moiti e) selon les positions relatives en m emoire des ots de donn ees manipul es, n ecessitent une analyse approfondie an de r ealiser les noyaux de calcul les plus ecaces possible [5]. Comme en moyenne, sur les processeurs Itanium de premi` ere g en eration, il a et e mesur e que le traitement des cache miss de donn ees repr esentait plus de la moiti e du temps dex ecution des programmes, larchitecture Itanium2 permet de sp ecier, au niveau des instructions Load , la localisation probable de la donn ee dans la hi erarchie de cache (pour adapter la latence de chargement) ainsi que le
c 2000, 2002 F. Pellegrini ENSEIRB

52

CHAPITRE 4. ARCHITECTURE DES MEMOIRES

niveau de cache dans lequel il sera pr ef erable de conserver la donn ee une fois quelle aura et e acc ed ee (qui permet aux caches de niveaux inf erieurs de marquer la donn ee comme pouvant etre remplac ee de pr ef erence a ` des donn ees plus utiles). Ces indices de gestion des caches ( cache hints ) sont positionn es par le compilateur apr` es analyse statique du code a ` la compilation, ou bien par le programmeur en langage machine souhaitant r ealiser des noyaux de calul ecaces.

4.4

M emoire centrale

Sur la plupart des machines, la vitesse de la m emoire centrale nest pas susante a ` elle seule pour alimenter le processeur selon ses besoins ; plusieurs cycles doivent s ecouler entre le moment o` u une donn ee est demand ee et celui o` u elle est disponible sur le bus. An dam eliorer le d ebit de la m emoire, on organise celle ci en bancs entrelac es ( interleaved banks ) ind ependants, dont chacun g` ere une partie de lespace dadressage. Typiquement, si lon dispose de N bancs m emoire num erot es de 0 a ` N 1, le banc i est aect e aux adresses de la forme bN + i, ce qui permet un acc` es concurrent a ` des adresses cons ecutives de la m emoire. Pour que la m emoire puisse fournir le d ebit demand e par le processeur, il faut que le nombre de bancs de m emoire soit au moins egal au nombre de cycles de latence de celle-ci. Sur le CRAY 1 (1976), qui avait un temps de cycle de 12, 5 ns et une latence m emoire de 50 ns, soit 4 cycles, la m emoire etait divis ee en 16 bancs ind ependants, permettant ainsi un d ebit entre le processeur et la m emoire de 4 mots par cycle, comme illustr e en gure 4.8.
0 4 8 12 1 5 9 13 2 6 10 14 3 7 11 15

A 4 -A19 A 3 -A 2 A 1 -A 0

320 Mm/s instructions

80 Mm/s donnes

Fig. 4.8 Sch ema dacc` es aux bancs m emoire du CRAY 1. Ce sch ema est a ` rapprocher de celui de larchitecture fonctionnelle g en erale du CRAY 1, pr esent ee en gure 3.30, page 38. Il y a conit dacc` es si deux op erations sont demand ees au m eme banc dans un intervalle inf erieur au temps de latence de la m emoire. Par exemple, si une m emoire de 16 bancs a une latence de 4 cycles, un conit se produira si au moins deux acc` es
Cours darchitectures et syst` emes des calculateurs parall` eles

4.4. MEMOIRE CENTRALE Incr ement Bancs 1 2 3 4 5 6 7 8 9 16 Cray X-MP/48 64 86 67 72 52 75 71 76 63 68 73 NEC SX-2 512 255 244 244 211 244 244 244 160 244 103 Fujitsu VP-200 128 365 127 228 67 227 127 228 67 225 67

53

Tab. 4.1 Performance, en Mop/s, du calcul terme a ` terme dun produit scalaire entre deux vecteurs dont les termes utiles sont espac es dun incr ement donn e.

sur quatre cons ecutifs di` erent dun multiple de 16, comme cest le cas pour un incr ement multiple de 8 (un conit tous les deux acc` es), voire de 16 (un conit par acc` es). Le tableau 4.1 donne la performance en Mop/s du calcul terme a ` terme dun produit scalaire entre deux vecteurs dont les termes utiles sont espac es dun incr ement donn e, en fonction de la valeur de cet incr ement. La performance de la m emoire d epend donc assez fortement de lalignement des donn ees, quil est souhaitable de modier en cons equence. Ainsi, dans le cas dun programme de diusion sur une grille p eriodique de taille 128 128, tel que celui pr esent e en gure 4.9, on allouera les tableaux TAB1 et TAB2 comme des grilles (130, 128) plut ot que (128, 128), pour optimiser le sch ema dacc` es a ` la m emoire, chaque cellule et ses quatre voisines etant alors situ ees sur des bancs m emoire tous di erents. DO 20 I = 1, 128 DO 10 J = 1, 128 IA = (I + 127) MOD 128 IP = (I + 1) MOD 128 JA = (J + 127) MOD 128 JP = (J + 1) MOD 128 TAB2 (I, J) = (TAB1(IA, J) + TAB1(I, JA) + * TAB1(I, JP) + TAB1(IP,J)) / 4 CONTINUE CONTINUE

10 20

Fig. 4.9 Boucle principale dun programme r esolvant l equation de la chaleur sur un r eseau torique carr e. Dans le cas darchitectures disposant dinstructions m emoire/m emoire, et comme certaines instructions agissent sur trois op erandes, il faut disposer dun d ebit m emoire eectif entre processeur et m emoire de trois mots par cycle, et garantir ce d ebit pour chaque processeur dans le cas darchitectures multi-processeurs. Pour cela, certaines architectures disposent de chemins dacc` es multiples. Ainsi, sur le CRAY Y-MP, qui a 8 processeurs de latence egale a ` 6 ns, et n ecessite donc un d ebit de 4 Gm/s, la m emoire est divis ee en 128 bancs, accessibles par trois chemins s epar es (deux en lecture et un en ecriture) pour chaque processeur, ce qui permet datteindre les 4 Gm/s si aucun conit nintervient.
c 2000, 2002 F. Pellegrini ENSEIRB

54

CHAPITRE 4. ARCHITECTURE DES MEMOIRES

4.5
4.5.1

Disques
Gestion des acc` es

Lorsquon manipule de tr` es gros volumes de donn ees, celles-ci ne peuvent tenir enti` erement en m emoire centrale. Lorsque cela est techniquement r ealisable (quand chaque processeur poss` ede son propre disque local, ou que lon ne risque pas d ecrouler le r eseau dinterconnexion), il est alors possible dutiliser des disques comme espace de stockage temporaire. Cette fonctionnalit e peut etre g er ee a ` deux niveaux : au niveau du syst` eme (mat eriel et noyau) : ce sont les m ecanismes classiques de m emoire virtuelle et de va-et-vient ( swapping ). Ces m ecanismes automatiques evitent de modier lalgorithme, mais il est souvent possible dexhiber des cas pathologiques d ecroulement r esultant dinterf erences entre lalgorithme de calcul et lalgorithme de gestion du va-et-vient ; au niveau de lapplication elle-m eme (logiciel) : le chargement et la sauvegarde explicites des ensembles de donn ees sont sp eci es par le programmeur, en fonction de lalgorithme, qui est alors dit out-of-core . Cette approche est la plus ecace, mais elle est co uteuse en temps de d eveloppement et demande une connaissance approfondie des param` etres du syst` eme (temps moyen des acc` es disques, taille des tampons syst` eme, etc.).

4.5.2

Organisation des donn ees

Lorganisation des donn ees et leurs sch emas dacc` es peuvent avoir des cons equen` titre ces extr emement importantes sur les temps dex ecution des programmes. A dexemple, consid erons un algorithme calculant le produit matriciel C = AB + C sur des matrices carr ees de taille 1024 1024 rang ees par colonne (style FORTRAN), sur une architecture disposant dune m emoire centrale de 16 pages de 65536 valeurs chacune (chaque page pouvant ainsi stocker 64 colonnes de matrice). En ecrivant lalgorithme de produit matriciel de fa con classique, comme d ecrit en gure 4.10, chaque lecture dune ligne de A provoque 16 d efauts de page, do` u plus de 16 millions de d efauts de page au total. DO 30 I = 1, 1024 DO 20 J = 1, 1024 DO 10 K = 1, 1024 C(I, J) = C(I, J) + A(I, K) * B(K, J) CONTINUE CONTINUE CONTINUE

10 20 30

Fig. 4.10 Ecriture classique de lalgorithme de calcul dun produit de matrices. Avec une approche par blocs colonne, o` u lon partitionne la matrice A en blocs de 64 colonnes et B en blocs de 6464 valeurs, comme pr esent e en gure 4.11, chaque parcours de J g en` ere 16 d efauts de page, et la boucle KK en g en` ere elle-m eme 16, do` u 16 (16 + 1) = 272 d efauts de page au total. Avec une approche purement par blocs, o` u lon partitionne les matrices en blocs de 256 256 valeurs, on descend jusqu` a 96 d efauts de page au total ! Le principal probl` eme des disques provient de la nature m ecanique des acc` es : les vitesses de rotation et les contraintes thermiques sont en eet telles quun
Cours darchitectures et syst` emes des calculateurs parall` eles

4.5. DISQUES DO 40 KK = 1, 1024, 64 DO 30 J = 1, 1024 DO 20 I = 1, 1024 DO 10 K = KK, KK + 63 C(I, J) = C(I, J) + A(I, K) * B(K, J) CONTINUE CONTINUE CONTINUE CONTINUE

55

10 20 30 40

Fig. 4.11 Ecriture classique de lalgorithme de calcul dun produit de matrices. Caract eristique Capacit e (Mo) Prix par Mo MTTF annonc e (h) MTTF eectif Nombre de t etes D ebit (Mo/s) Puissance (W) IBM 3380 7500 $18-$10 30000 100000 4 3 6600 Conners CP3100 100 $10-$7 30000 ? 1 1 10 Ratio 75,0 1,00-2,50 1,00 ? 4,00 3,00 660

Tab. 4.2 Caract eristiques des disques IBM 3380 mod` ele AK4 et Conners CP3100. r ealignement de la t ete de lecture est n ecessaire entre chaque acc` es, m eme si les blocs a ` lire sont situ es sur la m eme piste, ce qui limite actuellement les d ebits aux environs de 20 Mo/s. Le disk striping , qui r epartit les chiers sur plusieurs disques, permet le transfert des donn ees en parall` ele sur plusieurs unit es, au moyen de protocoles evolu es tels que IPI3 ( Intelligent Parallel Interface, version 3 ) ou HiPPI ( High Performance Parallel Interface ), qui permettent datteindre des d ebits de 100 Mo/s. Dans le futur, les techniques holographiques, encore condentielles, permettront des temps dacc` es de lordre de 1 a ` 10 s et des taux de transfert de 100 Mo a ` 1 Go/s. En revanche, le stockage ne peut etre que de courte dur ee, ce qui limitera lutilisation de ces techniques aux caches des unit es centrales et aux unit es de stockage temporaires.

4.5.3

Baies de disques (RAID)

Les baies de disques ( disk arrays ) sont une solution ecace. Elles sont constitu ees dun grand nombre de disques peu chers, acc ed es en parall` ele, et disposant de protocoles evolu es dits RAID ( Redundant Arrays of Inexpensive Disks ) [10] permettant la correction derreurs et la reprise a ` chaud. L emergence de la technologie RAID tient au fait que, si la capacit e unitaire des disques hautes performances ( Single Large Expensive Disk , ou SLED) a cr u en rapport avec laugmentation des puissances de calcul et des tailles des m emoires centrales, le temps de positionnement des bras na diminu e que dun facteur deux de 1971 a ` 1981. La table 4.2 compare quelques param` etres signicatifs dun disque SLED IBM 3380 mod` ele AK4 et dun disque de PC Conners CP3100, disponibles en 1987 lors de la publication de larticle d enissant le RAID. Ces caract eristiques ont permis dimaginer la d enition de syst` emes de stockage constitu es dun grand nombre de disques peu chers et de petite capacit e, g er es soit de mani` ere entrelac ee pour absorber les gros volumes produits par les supercalcuc 2000, 2002 F. Pellegrini ENSEIRB

56

CHAPITRE 4. ARCHITECTURE DES MEMOIRES Caract eristique MTTF annonc e (ann ees) Nombre total de disques Surco ut (%) Capacit e utile (%) Grosses lectures (1/s) Grosses ecritures (1/s) (1/s) Grosses L-M-E Petites lectures (1/s) Petites ecritures (1/s) (1/s) Petites L-M-E RAID 1 > 500 2D 100 50 2 D/S D/S 2 D/3 S 2D D 2 D/3

Tab. 4.3 Caract eristiques dun syst` eme RAID 1. lateurs, soit de mani` ere ind ependante pour traiter les nombreux petits transferts g en er es par les applications transactionnelles. Le probl` eme majeur des syst` emes RAID est la tol erance aux pannes. En eet, le MTTF ( Mean Time To Failure ) dun syst` eme compos e de plusieurs disques est inversement proportionnel au nombre de ces disques. Ainsi, un syst` eme RAID de 100 disques Conners CP3100 disposerait dun MTTF annonc e de 300 heures, soit moins de deux semaines ! Pour rem edier a ` cela, il faut mettre en place des m ecanismes autorisant le syst` eme a ` fonctionner malgr e la panne dau moins un disque, et permettant la r eparation a ` chaud . Du point de vue du stockage, ceci n ecessite lutilisation de disques suppl ementaires pour dupliquer linformation, an de palier la panne dun disque et de reconstruire linformation manquante lors de son remplacement par un disque neuf vierge. On organise donc les D disques de donn ees en groupes de G disques, a ` chacun desquels sont adjoints C disques de contr ole. Si ont d enit MTTR ( Mean Time to Repair ) comme le temps moyen de maintenance, on obtient la formule : 2 MTTFDisk MTTFRAID = . D 1 + C (G + C 1)MTTR
G

Plusieurs niveaux dorganisation RAID ont et e d enis, qui orent chacun des niveaux de s ecurit e et de performance di erents. Pour evaluer cette derni` ere, on distingera les grosses entr ees/sorties g en er ees par les supercalculateurs, qui mobilisent au moins un secteur de chaque disque dun groupe, des petites entr ees/sorties g en er ees par les syst` emes transactionnels, qui sont bas ees sur des cycles ind ependants de lecture-modication- ecriture. Dans tous les cas, on supposera que la taille des blocs de donn ees manipul ees par lutilisateur est au moins egale a ` la taille dun secteur disque. Notons que lutilisation de syst` emes RAID pour des entr ees/sorties mobilisant plusieurs disques g en` ere un surco ut S par rapport au temps dun acc` es unique sur un disque unique, car il faut attendre la terminaison dun ensemble de disques non synchronis es. Dans tous les cas enum er es ci-dessous, on prendra MTTR = 1 heure, et D = 100 disques, an de rendre la capacit e du syst` eme RAID equivalente a ` celle du SLED de m eme g en eration d ecrit plus haut. RAID 1 : disques miroirs ( mirroring ). Chaque disque est pourvu dune copie conforme, donc G = 1 et C = 1. Cest loption la plus co uteuse, puisque chaque donn ee est dupliqu ee. Elle est dailleurs economiquement bien trop co uteuse, puisque le MTTF annonc e est tr` es largement sup erieur a ` la dur ee de vie du produit, comme indiqu e dans le tableau 4.3.
Cours darchitectures et syst` emes des calculateurs parall` eles

4.5. DISQUES

57

RAID 2 : codage derreur par code de Hamming. Ce codage ne n ecessite que O(log2 (G)) disques de contr ole pour d eterminer le disque fautif et reg en erer linformation manquante. Ainsi, avec G = 25, on a C = 5. An de parall eliser les acc` es, chaque bloc de donn ees est r eparti sur tous les disques de donn ees du groupe charg e de son stockage, comme illustr e en gure 4.12. Les caract eristiques du RAID 2 sont donn ees dans le tableau 4.4.
 $$ $ << < 0 000 "! #   "# 89 89 :; :; ./ ./ 23 23 4 45 45 ! % % 9 98 ; = = 1 1 5 54    #" $ $%$ $%$%$% 6 77 6 77 8 ; ;: < <=< <=<=<= . / /. 0 010 01101 3 3   "!! "# " # 66 6 6 8666777 9 ./ 4323232 5 !! !"   ! "# "" #"#" % 6 88 9 88 9898 ; :: ; :: ;:;: = .. / .. /./. 1 22 3 22 4 44 5 44 5454 ! %% 6 9 == . 11 3 5   # 7 6 7 8 / a b c d a b c d a b c d
0 0 0 0 1 1 1 1 2 2 2 2

(( (( , ,,, *+ *+ *+ ) ) )( + - - ' '' ( ()( ()+ + +* , ,-, ,--,'' &' ** )) + ** + ** +*+* - )+ -'& ' '&& ) &  & &a&& b c d
3 3 3 3

DD D H HHH L LLL @A @A @A BC BC JK JK A A A@ C E E I I M M ? ? A C CB D DED DEDEDE G G G GG H HIH HIIHI K K KJ L LML LMMLM ?? >? @@ ?>?> A @@ A @@ A@A@ C BB C BB CBCB E FG FG FG JJ K JJ KJKJ M A EE G II K MM ?> ? G G GFF I >  >  F  F  F >a >> b c d FFaFF b c d
x x x x y y y y

PP P RS RS T TU TU Q Q U UT O OO P PQP PQPQPQ S S TSRSRSR U OO NO RR S RR T TT U TT UTUT QQ S U ON O ONN Q N  N Na NN b c d
z z z z

Fig. 4.12 Organisation des donn ees dans un syst` eme RAID 2.

Caract eristique MTTF annonc e (ann ees) Nombre total de disques Surco ut (%) Capacit e utile (%) Grosses lectures (1/s) Grosses ecritures (1/s) (1/s) Grosses L-M-E Petites lectures (1/s) Petites ecritures (1/s) (1/s) Petites L-M-E

RAID 2 12 1, 2 D 20 83 D/S D/S D/2 S D/S G D/2 S G D/2 S G

Tab. 4.4 Organisation des donn ees et caract eristiques dun syst` eme RAID 2. RAID 3 : codage derreur par parit e. Le codage de Hamming utilis e dans le RAID 2 est lui-m eme trop co uteux, puisquil permet de d eterminer le disque fautif, alors que dans la presque totalit e des cas ceci pourra etre d etermin e simplement au niveau du contr oleur. On na donc besoin que dun codage par parit e pour reg en erer linformation manquante, qui ne co ute quun disque suppl ementaire par groupe, comme illustr e en gure 4.13. Avec C = 1 et G = 25, la r eduction du nombre de diques de contr ole permet m eme daugmenter le MTTF par rapport au RAID 2, comme indiqu e dans le tableau 4.5.
YY ZW YY \W ]] ^W ]] ^^]] pW qq rW qq rrqq tW uu vW uu vvuu VWXW VWXV ZW [WZZYY \W [W\W [W\[ ^W oWpW oWpW oWqW sWtW sWuW XW qWpopo rW uWtsts vW ZW ZW ^W ^W rW rW vW vW VXW [\W [\W [\W opW opW opW stW stW YZW YZW ]^W ]^W qrW qrW uvW uvW XVW V XVXV ZW [ ZYZY \W [ \W [ \[\[ ^W o pW o pW o qW s tW s uW XVWXW Y ZW Y \W ] ^W ] ^]^] pW qWpo rW q rW q rqrq tW uWts vW u vW u vuvu
a0 b0 c0 d0 a1 b1 c1 d1

ii jW ii lW mm nW mm nnmm _W`W aa `_ bW aa bW aa bbaa dW ee fW ee ffee wWxW yy zW yy {Wzzyy |W }} |{ ~W }} ~W }} ~~}} gWhW gWhg jW kWjjii lW kWlW kWmW _W`W _WbW cWdW cWdc fW wWxW wWxw zW {W|W {W~W hW mWlklk nW jW jW nW nW bW bW bW fW fW zW zW ~W ~W ~W ghW klW klW klW _`W _`W cdW cdW wxW wxW {|W {|W ijW ijW mnW mnW abW abW abW efW efW yzW yzW }~W }~W }~W hgW g hghg jW k jiji lW k lW k mW _W`W _ `W _ bW c dW c dcdc fW wWxW w xW w xwxw zW {Wzyzy |W { |W { ~W hgWhW i jW i lW mWlk nW m nW m nmnm _W a `_`_ bW a bW a baba dW e fW e fefe wW y zW y {W } |{|{ ~W } ~W } ~}~}
a2 b2 c2 d2 a3 b3 c3 d3

a b c d

Fig. 4.13 Organisation des donn ees dans un syst` eme RAID 3. RAID 4 : lectures et ecritures ind ependantes. R epartir un transfert sur plusieurs disques a comme avantage de r eduire le temps de transfert de grosses entr ees/sorties car lensemble de la bande passante peut etre exploit ee. Cependant, les petites entr ees/sorties n ecessitent dutiliser tous les disques du groupe concern e, et donc les RAID 2 et 3 ne peuvent eectuer quune entr ee/sortie par groupe a ` la fois. De plus, si les disques ne sont pas synchronis es, le temps de r ealisation de lentr ee/sortie est celui du disque ayant termin e le dernier, do` u lexistence du facteur S pour les petites entr ees/sorties. Le RAID 4, en conservant chaque bloc de donn ees sur un unique disque, permet deectuer plusieurs entr ees/sorties simultan ees dans chaque groupe. Avec cette nouvelle organisation, illustr ee en gure 4.14, le calcul de parit e seectue sur les m emes portions de blocs di erents.
c 2000, 2002 F. Pellegrini ENSEIRB

58

CHAPITRE 4. ARCHITECTURE DES MEMOIRES Caract eristique MTTF annonc e (ann ees) Nombre total de disques Surco ut (%) Capacit e utile (%) Grosses lectures (1/s) Grosses ecritures (1/s) (1/s) Grosses L-M-E Petites lectures (1/s) Petites ecritures (1/s) (1/s) Petites L-M-E RAID 3 40 1, 04 D 4 96 D/S D/S D/2 S D/S G D/2 S G D/2 S G

Tab. 4.5 Caract eristiques dun syst` eme RAID 3. On pourrait penser quune petite ecriture implique tous les disques dun groupe, du fait de la n ecessit e de recalculer le contr ole derreur. Cependant, comme celui-ci se fait par parit e, on peut calculer localement sa variation par ou exclusif entre les anciennes donn ees et les nouvelles. Les caract eristiques du RAID 4 sont donn ees dans le tableau 4.6.
WW WW W WW WW W W WW W W WW W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W WW W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W W  W W W W W W W W W W WW W
a0 a1 a2 a3 b0 b1 b2 b3 c0 c1 c2 c3 d0 d1 d2 d3

0 1 2 3

Fig. 4.14 Organisation des donn ees dans un syst` eme RAID 4.

Caract eristique MTTF annonc e (ann ees) Nombre total de disques Surco ut (%) Capacit e utile (%) Grosses lectures (1/s) Grosses ecritures (1/s) (1/s) Grosses L-M-E Petites lectures (1/s) Petites ecritures (1/s) (1/s) Petites L-M-E

RAID 4 40 1, 04 D 4 96 D/S D/S D/2 S D D/2 G D/2 G

Tab. 4.6 Caract eristiques dun syst` eme RAID 4. RAID 5 : equivalent au RAID 4, mais avec entrela cage des disques de contr ole. La faiblesse du RAID 4 r eside dans les disques de contr ole de parit e, qui sont des goulots d etranglement puisquils sont sollicit es a ` chaque ecriture dans un groupe. Pour rem edier a ` cela, le RAID 5 r epartit les secteurs de contr ole sur tous les disques, de fa con cyclique. Les caract eristiques du RAID 5 sont donn ees dans le tableau 4.7.

4.6

Syst` emes de chiers parall` eles

Une autre approche consiste a ` distribuer les disques sur les nuds de la machine parall` ele, an que chacun dentre eux dispose dune zone de va-et-vient ( swap )
Cours darchitectures et syst` emes des calculateurs parall` eles

` ` 4.6. SYSTEMES DE FICHIERS PARALLELES Caract eristique MTTF annonc e (ann ees) Nombre total de disques Surco ut (%) Capacit e utile (%) Grosses lectures (1/s) Grosses ecritures (1/s) (1/s) Grosses L-M-E Petites lectures (1/s) Petites ecritures (1/s) (1/s) Petites L-M-E RAID 5 40 1, 04 D 4 96 D/S D/S D/2 S C 1+ G D C 1 + G D/4 C 1+ G D/4

59

Tab. 4.7 Caract eristiques dun syst` eme RAID 5. et dun espace temporaire de stockage (pour lex ecution de programmes out-ofcore ) propres. Ces disques peuvent etre f ed er es au moyen de protocoles parall` eles tels que PIOFS ( Parallel I/O File System ) pour constituer un syst` eme de chiers distribu e.

c 2000, 2002 F. Pellegrini ENSEIRB

60

CHAPITRE 4. ARCHITECTURE DES MEMOIRES

Cours darchitectures et syst` emes des calculateurs parall` eles

Chapitre 5

Syst` emes dexploitation


5.1 G en eralit es

Les syst` emes dexploitation supportant le parall elisme appartiennent a ` deux familles distinctes : celle des syst` emes dexploitation distribu es (ou r epartis), qui permettent dutiliser et de partager des ressources et services r epartis sur le r eseau, en assurant a ` lutilisateur la transparence de celui-ci, ainsi quune abilit e maximale ; celle des syst` emes dexploitation des machines multiprocesseurs et parall` eles d edi ees au calcul intensif, pour lesquels lobtention de performances elev ees est primordiale. ` mesure que les repr A esentants de ces deux familles gagnent en maturit e, on assiste a ` un rapprochement entre ces deux tendances, par inuence mutuelle, mais le rapprochement est loin d etre achev e, si tant est quil puisse l etre. Les architectures supportant ces syst` emes dexploitation peuvent etre regroup ees en trois classes : les machines multiprocesseurs a ` m emoire partag ee, de type UMA ou NUMA, voire COMA ; les machines parall` eles a ` m emoire distribu ee, de type NORMA, dont les el ements sont li es par un r eseau dinterconnexion rapide (de 1 a ` 10 Gbit/s) disposant eventuellement de fonctionnalit es sp eciques : diusion, synchronisation ; les syst` emes distribu es, constitu es dun ensemble de machines autonomes li ees par un r eseau local (avec un d ebit de 10 Mbit/s a ` 1 Gbit/s).

5.2

Structure

Un nombre tr` es important de (prototypes de) syst` emes dexploitation a et e propos e durant les dix derni` eres ann ees, qui di` erent par leurs buts, leur structure, et leurs fonctionnalit es. Du point de vue de leur structure, on peut les regrouper en plusieurs cat egories : les syst` emes monolithiques. Ils sont constitu es dun noyau complexe et de grande taille, isol e de lespace utilisateur par des moyens mat eriels simples (segmentation et mode privil egi e), mais ne poss edant pas de barri` eres entre ses di erents modules. Toute communication entre processus impl ementant des fonctionnalit es syst` eme de haut niveau (d emons) seectue au moyen de zones de m emoire partag ee g er ee par le syst` eme, ou par envoi explicite de requ etes ( sockets ). Cest le cas dUNIX et de VMS, par exemple. 61

62

` CHAPITRE 5. SYSTEMES DEXPLOITATION Le manque de barri` eres solides au sein du noyau, ainsi que la grande taille et la complexit e de celui-ci, rendent de tels syst` emes diciles a ` maintenir et a ` valider, et a ` fortiori a ` adapter a ` un environnement distribu e. De fait, les impl ementations parall` eles de tels syst` emes se sont limit ees aux architectures de type UMA : Solaris pour Sun, IRIX pour SGI, AIX pour IBM, par exemple ; les syst` emes micro-noyaux. Ils sont constitu es dun micro-noyau minimal sex ecutant sur chaque processeur et ne supportant quun nombre restreint de services (gestion de processus, de la m emoire, des communications inter-processus, et support des gestionnaires de p eriph eriques), le reste des fonctionnalit es du syst` eme etant assur e par des serveurs eventuellement situ es sur des nuds sp ecialis es (entr ee/sorties). Lex ecution de la plupart des primitives syst` eme seectue donc par linterm ediaire dappels de proc edures distantes ( Remote Procedure Call , ou RPC), ce qui fait du r eseau dinterconnexion un facteur critique de performance. Parmi les syst` emes micro-noyaux, on trouve MACH (et OSF/1), Amoeba, Chorus, Choices, Clouds, etc. La modularit e de larchitecture micro-noyau facilite ladaptation, lextension, et la maintenance du syst` eme, de m eme que son impl ementation en environnement distribu e. Cependant, les chercheurs du projet de micro-noyau PEACE sont arriv es a ` la conclusion quun micro-noyau supportant le multiprocessus, m eme recongurable, p enalisait le fonctionnement dune application mono-processus, et donc quil etait pr ef erable de disposer dune famille de micro-noyaux distincts plut ot que dun micro-noyau evolutif. Des m ethodes de conception orient ees objet permettent alors, par la d enition de classes interchangeables, la d enition ais ee dune famille de syst` emes dexploitation ; cest le cas de Choices, Apertos, Clouds, etc. les syst` emes orient es objet. a ` la di erence des syst` emes uniquement bas es objet, les syst` emes orient es objet permettent a ` lutilisateur dutiliser les m ecanismes objet de d enition par h eritage, de renommage dynamique lors de lappel des m ethodes de lobjet, et de polymorphisme. Le support du mod` ele objet repose sur quatre concepts cl es : le nommage, la protection, la synchronisation, et la reprise sur erreur. Chorus et Mach ne sont pas intrins` equement des syst` emes orient es objet, mais permettent dimpl ementer des environnements de programmation orient es objet, tels que COOL pour Chorus et Avalon/C++ pour Mach.

5.3

Fonctionnalit es

Un syst` eme dexploitation de machine parall` ele doit disposer des m emes fonctionnalit es que celles pr esentes dans un syst` eme monoprocesseur. Cependant, leur complexit e est largement sup erieure, du fait des contraintes fortes de performance a ` respecter, et des nouvelles fonctionnalit es a ` prendre en compte. Parmi les probl` emes sp eciques aux machines parall` eles, on peut citer la gestion et la protection de grands espaces dadressage, la pr evention des interblocages, la gestion ecace dentit es asynchrones telles que les processus et les t aches l eg` eres, leur synchronisation, l equilibrage de charge et la distribution des donn ees, etc.

5.3.1

Gestion et ordonnancement de processus

Dans les syst` emes dexploitation traditionnels, a ` un processus correspond un domaine de protection et un espace dadressage virtuel servant a ` lex ecution dun unique ot dinstructions. De tels processus sont appel es lourds , car la cr eation et la destruction de tels processus sont co uteuses. Le parall elisme exprim e par ce moyen est a ` gros grain, et correspond rarement au niveau de granularit e des
Cours darchitectures et syst` emes des calculateurs parall` eles

5.3. FONCTIONNALITES

63

probl` emes irr eguliers. La plupart des syst` emes dexploitation actuels d ecouplent lespace dadressage et les ots dinstructions, permettant a ` plusieurs dentre eux de partager le m eme espace. Ces t aches, dites t aches moyennement lourdes ( middleweight threads ), sont directement g er ees par le noyau (on les appelle aussi kernel threads ), et disposent de toutes les fonctionnalit es syst` eme oertes aux processus lourds. De fait, la gestion de ces t aches se fait au moyen dappels syst` eme lourds (POSIX Pthreads, par exemple), qui ne permettent pas de mettre en uvre un parall elisme a ` grain n. Pour exprimer le parall elisme a ` grain n sont apparues les t aches l eg` eres ( lightweight threads ), qui sappuient sur des syst` emes de poids lourd ou moyen, el laissent a ` la charge de lutilisateur les fonctions dordonnancement. Lutilisateur peut ainsi d enir la politique de gestion des t aches convenant le mieux a ` son application. Cest le cas des LWP et threads de SunOS et Solaris, des Cthreads de MACH, etc. Cette architecture a ` deux niveaux ne permet cependant pas aux t aches l eg` eres de r eagir aux ev enements li es au noyau (pr eemption, interruptions I/O, ordonnancement des processus moyens, . . . ), ce qui emp eche dadapter le s equencement des t aches l eg` eres au fonctionnement du syst` eme. Plusieurs solutions ont et e propos ees, comme le report des ev enements syst` eme a ` lordonnanceur des t aches l eg` eres, ou la possibilit e pour les t aches utilisateur dinuencer lordonnancement des t aches moyennes sur les processeurs (tel que le concurrency level des threads Solaris). Lordonnancement ( scheduling ) des processus inue grandement sur les performances des machines parall` eles. Il sagit de minimiser le temps de r eponse moyen du syst` eme, en r epartissant la charge ( load balancing ) de fa con ecace (mais ce probl` eme est NP-dur) lordonnancement statique est calcul e lors du lancement du programme parall` ele, et nest jamais remis en cause. Il g en` ere un faible surco ut, mais suppose que le comportement de lapplication est stable dans le temps ; lordonnancement dynamique permet une evolutivit e dans le temps convenant aux applications tr` es irr eguli` eres, mais alourdit beaucoup le code, du fait des m ecanismes d evaluation de la charge et de migration des donn ees devant etre impl ement es, qui doivent parfois op erer de fa con asynchrone, par threads ; le co-ordonnancement ( coscheduling , ou gang scheduling ) a pour but de favoriser lex ecution simultan ee de processus appartenant au m eme programme parall` ele, ce qui est tr` es utile dans le cas de processus coop eratifs a ` grain n et communiquant fr equemment. Cette technique est complexe, et soul` eve de nombreux probl` emes, tels la pr eemption simultan ee, lattente des processus retardataires, etc.

5.3.2

Gestion de la m emoire

La gestion de la m emoire par les machines de type UMA est semblable a ` celle des machines uniprocesseur multiprogramm ees. Un gestionnaire de m emoire convertit les adresses de lespace virtuel des processus en adresses physiques, g` ere les d efauts de page, et assure eventuellement les op erations de synchronisation si une page est acc ed ee simultan ement par plusieurs t aches. Les machines de type NUMA et NORMA n ecessitent des m ecanismes plus evolu es, qui sappuient cependant souvent sur les gestionnaires de m emoire locaux, an dorir un service de m emoire virtuellement partag ee ( Distributed Shared Memory ) ; cest le cas du CRAY T3D et de la SGI Origin, par exemple. Les premi` eres machines NUMA ne g eraient que des caches locaux, et sappuyaient sur une couche logicielle pour g erer la coh erence de la m emoire entre processeurs, en permettant toutefois a ` lutilisateur dinuer sur la r epartition des
c 2000, 2002 F. Pellegrini ENSEIRB

64

` CHAPITRE 5. SYSTEMES DEXPLOITATION

donn ees en m emoire pour augmenter la localit e des acc` es ; cetait le cas de lUniform System de la BBN Buttery. Les architectures NUMA r ecentes comme le T3D orent maintenant une m emoire virtuellement partag ee globalement coh erente, mais proposent toujours des instructions mat erielles de pr e-chargement et de post- ecriture an doptimiser leur performance. Les recherches actuelles sur la gestion de la m emoire dans les architectures distribu ees portent sur la possibilit e de d echarger le programmeur du placement explicite du code et des donn ees, en sappuyant sur les similitudes existant avec la gestion des caches sur les machines UMA. Plusieurs politiques de gestion ont et e etudi ees et implant ees dans des syst` emes tels que Mach OSF/1, Psyche, Platinum, etc : migration : les donn ees sont migr ees vers la m emoire locale du processeur qui les r ef erence, an de tirer parti le plus possible de la localit e des r ef erences pour amortir le co ut de la migration ; duplication en lecture : an de permettre a ` plusieurs processus de lire localement les m emes donn ees, on duplique celles-ci sur tous les lecteurs qui en font la demande. Cependant, les op erations d ecriture deviennent plus co uteuses, car il faut alors invalider ou mettre a ` jour les copies des donn ees sur tous les processeurs qui en poss` edent. Des m ecanismes mat eriels peuvent etre utilis es pour optimiser les ecritures, comme c etait le cas avec les m ecanismes de diffusion et dinvalidation des machines KSR. La relaxation des contraintes de coh erence forte permet egalement de gagner en vitesse, si les caract eristiques de lapplication le permettent (acc` es a ` des donn ees p erim ees).

5.3.3

Synchronisation

Lorsque des processus coop erants sex ecutent simultan ement, des primitives de synchronisation sont n ecessaires pour contr oler leur concurrence, en particulier an dassurer lexclusion mutuelle et lordonnancement global d ev enements. Ceci se fait principalement au moyen de verrous ( locks ). Un verrou est un objet qui nappartient qu` a un seul processus a ` la fois. Pour entrer en section critique, un processus doit dabord acqu erir le verrou qui lui est associ ee. Dans le cas contraire, il doit sendormir ( blocking lock ), ou boucler en attente active ( spin lock ). Cette derni` ere solution, qui peut sembler on ereuse, se r ev` ele plus ecace lorsque la section critique est petite ou que la machine est sous-utilis ee, car on evite ainsi de co uteux changements de contexte, et on r eduit la latence entre le moment o` u le verrou est lib er e et celui o` u on en acquerra la propri et e.

5.3.4

Syst` emes de chiers parall` eles et distribu es

Le parall elisme, en permettant de traiter des probl` emes de grande taille, pose le probl` eme du stockage et de lacc` es aux donn ees manipul ees. Pour le r esoudre, plusieurs solutions ont et e propos ees : la d el egation des fonctions dentr ees/sorties a ` des processeurs sp ecialis es (ou des nuds de la machine, pour les architectures NORMA). Dans ce cas, le syst` eme de chiers est physiquement centralis e, et les requ etes issues des nuds de calcul sont trait ees par appel distant de proc edure (RPC). Cette approche est simple a ` mettre en uvre, mais tant le r eseau que les nuds disques peuvent constituer des goulots d etranglement du syst` eme ; la distribution du stockage sur les nuds de la machine, au moyen de disques locaux. Ceci suppose de pouvoir maintenir une vision coh erente des syst` emes de chiers, et de savoir sur quels disques se trouvent les di erentes portions
Cours darchitectures et syst` emes des calculateurs parall` eles

5.3. FONCTIONNALITES

65

des chiers. En eet, an de r epartir la charge dacc` es sur tous les processeurs, les chiers sont d ecoup es en blocs ( disk stripping ) qui sont distribu es sur lensemble des disques des processeurs. Des impl ementations de ces m ecanismes commencent a ` etre propos ees par les constructeurs (PIOFS sur la SP-2 dIBM, par exemple), et une interface de programmation a m eme et e normalis ee dans le cadre de la norme MPI2 (m eme si lon s eloigne quelque peu de la communication par echange de messages).

c 2000, 2002 F. Pellegrini ENSEIRB

66

` CHAPITRE 5. SYSTEMES DEXPLOITATION

Cours darchitectures et syst` emes des calculateurs parall` eles

Bibliographie
[1] Y. Choi, A. Knies, L. Gerke, and T. Ngai. The impact of If-conversion and branch prediction on program execution on the Intel Itaniumtm processor. In Proceedings of the 34th Annual IEEE/ACM International Symposium on Microarchitecture, pages 3040, December 2001. http ://www.capsl.udel.edu/ COMPILER/MICRO34/pdf/choi y.pdf. [2] M. J. Flynn. Some computer organizations and their eectiveness. IEEE Trans. Computers, 21(9) :948960, 1972. [3] J. R. Goodman. Cache memory optimization to reduce processor/memory trac. Technical Report 580, University of WisconsinMadison, 1985. [4] R. W. Hockney and C. R. Jesshope. Parallel Computers Architecture, programming and algorithms. Adam Hilger, Bristol, 1983. [5] W. Jalby and C. Lemuet. Exploring and optimizing Itanium2tm cache(s) performance for scientic computing. In Proceedings of EPIC2, pages 419, November 2002. http ://systems.cs.colorado.edu/EPIC2/. [6] C. Koelbel, D. Loveman, R. Schreiber, G. Steele, and M. Zosel. The High Performance Fortran Handbook. MIT Press, Cambridge, MA, 1994. [7] J. Lee and A. Smith. Branch prediction strategies and branch target buer design. IEEE Trans. Computers, 21(7) :622, 1984. [8] P. Michaud. Chargement des instructions sur les processeurs superscalaires. Th` ese de Doctorat, IRISA, Universit e Rennes I, November 1998. [9] OpenMP Fortran Application Program Interface. http ://www.openmp.org/. [10] D. A. Patterson, G. Gibson, and R. H. Katz. A case for redundant arrays of inexpensive disks (raid). Research Report 87/391, CS Division, University of California at Berkeley, 1987. Disponible a ` partir de lURL ftp ://sunsite. berkeley.edu/pub/techreps/CSD-87-391.html. [11] S. Raina. Virtual shared memory : A survey of techniques and systems. Research Report CSTR-92-36, Department of Computer Science, University of Bristol, December 1992. Disponible a ` partir de lURL http ://www.cs.bris. ac.uk/Tools/Reports/Abstracts/1992-raina.html. [12] R. Rakvic, E. Grochowski, B. Black, M. Annavaram, T. Diep, and P. Shen. Performance advantage of the register stack in Intel Itaniumtm processors. In Proceedings of EPIC2, pages 3040, November 2002. http ://systems.cs. colorado.edu/EPIC2/. [13] http ://www.top500.org/. Site recensant les syst` emes install es les plus puissants au monde. [14] D. W. Wall. Limits of instruction-level parallelism. Research Report 93/6, DEC Western Research Laboratory, November 1993. Disponible a ` partir de lURL http ://www.research.digital.com/wrl/techreports/.

67