Académique Documents
Professionnel Documents
Culture Documents
Fonctionnementd'un Ordinateur Depuis Zero PDF
Fonctionnementd'un Ordinateur Depuis Zero PDF
ordinateur depuis
zro
Par Lucas Pesenti (Lucas-84)
et Guy Grave (Mewtow)
www.openclassrooms.com
2/467
Sommaire
Sommaire ...........................................................................................................................................
Lire aussi ............................................................................................................................................
Fonctionnement d'un ordinateur depuis zro .....................................................................................
Partie 1 : Tout a rien qu'avec des 0 et des 1 ! ...................................................................................
2
7
9
9
Un ordinateur, c'est trs bte : a ne sait pas compter jusqu' deux ! ........................................................................... 10
Nombres entiers ........................................................................................................................................................................................................ 10
Diffrentes bases ...................................................................................................................................................................................................... 10
Le binaire, la base 2 .................................................................................................................................................................................................. 11
Reprsentation en signe-valeur absolue ................................................................................................................................................................... 12
Codage en complment 1 ...................................................................................................................................................................................... 13
Complment deux .................................................................................................................................................................................................. 14
Nombres virgule ..................................................................................................................................................................................................... 16
criture scientifique ................................................................................................................................................................................................... 16
Formats de flottants .................................................................................................................................................................................................. 17
Exceptions et arrondis ............................................................................................................................................................................................... 18
Codage du texte ........................................................................................................................................................................................................ 19
Standard ASCII .......................................................................................................................................................................................................... 19
Unicode ..................................................................................................................................................................................................................... 20
www.openclassrooms.com
Sommaire
3/467
www.openclassrooms.com
Sommaire
4/467
209
209
213
215
215
218
220
220
220
221
www.openclassrooms.com
222
222
223
224
227
228
228
229
230
232
232
233
234
235
236
236
236
238
239
239
241
Sommaire
5/467
270
271
273
273
275
276
276
276
276
277
277
278
280
293
293
293
294
295
296
296
296
298
299
www.openclassrooms.com
Sommaire
6/467
316
316
317
319
319
319
320
320
321
321
321
323
326
327
329
330
330
331
332
333
334
334
335
335
335
337
338
www.openclassrooms.com
382
382
383
383
384
384
384
Sommaire
7/467
385
388
390
398
398
400
www.openclassrooms.com
Lire aussi
8/467
www.openclassrooms.com
Lire aussi
9/467
Par
www.openclassrooms.com
10/467
C'est juste une faon de reprsenter un nombre en utilisant seulement des 0 et des 1. Et un ordinateur ne sait compter qu'en
binaire. Toutefois, le binaire ne sert pas qu' stocker des nombres dans notre ordinateur. Aprs tout, votre ordinateur ne fait pas
que manipuler des nombres : il peut aussi manipuler du texte, de la vido, du son, et pleins d'autres choses encore. Eh bien,
sachez que tout cela est stock... avec uniquement des 0 et des 1. Que ce soit du son, de la vido, ou tout autre type de donne
manipulable par notre ordinateur, ces donnes sont stockes sous la forme de suites de zros et de uns que notre ordinateur
pourra manipuler comme bon lui semble.
Pour comprendre le fonctionnement d'un ordinateur, on va donc devoir aborder le binaire. Nous allons commencer par voir
comment sont stockes quelques donnes de base comme les nombres ou le texte. Et pour cela, nous allons commencer par un
petit rappel pour ceux qui n'ont jamais t en CM1.
Nombres entiers
Nous allons commencer par parler des nombres entiers.
Dans notre systme de reprsentation dcimal, nous utilisons dix chiffres pour crire nos nombres entiers positifs : 0, 1, 2, 3, 4 ,
5 , 6 , 7 , 8 et 9.
Prenons le nombre 1337. Le chiffre le plus droite est le chiffre des units, celui ct est pour les dizaines, suivi du chiffre des
centaines...
Cela nous donne :
Tous les nombres entiers qui existent peuvent eux aussi tre crits sous cette forme : on peut les dcomposer en une somme de
multiples de puissances de 10. Lorsque c'est le cas, on dit qu'ils sont en base 10.
Diffrentes bases
Ce qui peut tre fait avec des puissances de 10 peut tre fait avec des puissances de 2, 3, 4, 125, etc : on peut utiliser dautres
bases que la base 10. Rien nempche de dcomposer un nombre en une somme de multiples de puissance de 2, ou de 3, par
exemple. On peut ainsi utiliser d'autres bases.
En informatique, on utilise rarement la base 10 laquelle nous sommes tant habitus. Nous utilisons la place deux autres bases
:
La base 2 (systme binaire) : les chiffres utiliss sont 0 et 1 ;
La base 16 (systme hexadcimal) : les chiffres utiliss sont 0, 1, 2, 3, 4, 5, 6, 7, 8 et 9 ; auxquels s'ajoutent les six premires
lettres de notre alphabet : A, B, C, D, E et F.
www.openclassrooms.com
11/467
10
11
100
101
110
111
1000
1001
10
1010
11
1011
12
1100
13
1101
14
1110
15
1111
Le binaire, la base 2
Le binaire, c'est la base 2. Seuls deux chiffres sont utiliss : 0 et 1. Lorsque vous crivez un nombre en binaire, celui-ci peut
toujours tre crit sous la forme d'une somme de puissances de 2.
Par exemple 6 s'crira donc
en binaire :
Capacit
Petite remarque assez importante : avec bits, on peut coder
valeurs diffrentes, dont le . Ce qui fait qu'on peut compter de
. N'oubliez pas cette petite remarque : elle sera assez utile dans le suite de ce tutoriel.
Changement de base
La reprsentation des entiers positifs en binaire est trs simple : il suffit simplement de changer de base, et de passer de la base
10 la base 2. Il existe un algorithme qui permet de changer un nombre en base dcimale vers un nombre en base binaire : il
www.openclassrooms.com
12/467
consiste diviser itrativement le quotient de la division prcdente par 2, et de noter le reste. Enfin, il faut lire de bas en haut les
restes trouvs.
Exemple :
Soit
en binaire.
Capacit
En utilisant
bits, bit de signe inclut, un nombre cod en reprsentation signe-valeur absolue peut prendre toute valeur
comprise entre
et
. Cela vient du fait qu'on utilise un bit pour le signe : il reste alors N-1 bits pour coder les
valeurs absolues. Ces N-1 bits permettent alors de coder des valeurs absolues allant de
Avec 4 bits, cela donne ceci :
www.openclassrooms.com
13/467
On remarque que l'intervalle des entiers reprsentables sur N bits est symtrique : pour chaque nombre reprsentable sur n bits
en reprsentation signe-valeur absolue, son inverse l'est aussi.
Dsavantages
Vous avez certainement remarqu que le zro, est reprsentable par deux entiers signs diffrents, quand on utilise la
reprsentation signe-magnitude.
Exemple avec un nombre dont la valeur absolue est code sur 8 bits, et un bit de signe au dbut. Le bit de signe est color en
rouge.
0 0000 0000 = 0
1 0000 0000 = -0, ce qui est gal zro.
Comme vous le voyez sur cet exemple, le zro est prsent deux fois : un
, et un
. Cela peut parfois poser certains
problmes, lorsqu'on demande notre ordinateur d'effectuer des calculs ou des comparaisons avec zro par exemple.
Il y a un autre petit problme avec ces entiers signe-valeur absolue : faire des calculs dessus est assez compliqu. Comme on le
verra plus tard, nos ordinateurs disposent de circuits capables d'additionner, de multiplier, diviser, ou soustraire deux nombres
entiers. Et les circuits capables de faire des oprations sur des entiers reprsents en signe-magnitude sont compliqus
fabriquer et assez lents, ce qui est une dsavantage.
Codage en complment 1
Passons maintenant une autre mthode de codage des nombres entiers qu'on appelle le codage en complment 1. Cette
mthode est trs simple. Si le nombre crire en binaire est positif, on le convertit en binaire, sans rien faire de spcial. Par
contre, si ce nombre est un nombre ngatif, on code sa valeur absolue en binaire et on inverse tous les bits du nombre obtenu :
les 0 deviennent des 1, et vice-versa.
Avec cette mthode, on peut remarquer que le bit de poids fort (le bit le plus gauche) vaut 1 si le nombre est ngatif, et 0 si le
nombre reprsent est positif. Celui-ci se comporte comme un bit de signe. Par contre, il y a un petit changement compar la
reprsentation en signe-valeur absolue : le reste du nombre (sans le bit de signe) n'est pas gal sa valeur absolue si le nombre
est ngatif.
Capacit
En utilisant
bits, un nombre reprsent en complment un peut prendre toute valeur comprise entre
et
www.openclassrooms.com
14/467
Dsavantages
Cette mthode est relativement simple, mais pose exactement les mmes problmes que la reprsentation signe-magnitude. Le
zro est toujours reprsent par deux nombres diffrents : un nombre ne contenant que des 0 (0000 0000 ...), et un nombre ne
contenant que des 1 (1111 1111 ...). Pour la complexit des circuits, la situation est un peu meilleure qu'avec la reprsentation en
signe-valeur absolue. Mais les circuits manipulant des nombres en complment un doivent grer correctement la prsence de
deux zros, ce qui ajoute un peu de complexit inutilement. Il faut avouer que ces problmes mritent bien une solution !
Pour faciliter la vie des concepteurs de circuits ou des programmeurs, on prfre utiliser une autre reprsentation des nombres
entiers, diffrente du complment 1 et de la reprsentation signe-valeur absolue, qui permet de faire des calculs simplement,
sans avoir utiliser de circuits complexes, et avec laquelle le zro ne pose pas de problmes.
Complment deux
Pour viter ces problmes avec le zro et les oprations arithmtiques, on a d recourir une astuce : on ne va utiliser que des
entiers non-signs et se dbrouiller avec . L'ide derrire la mthode qui va suivre est de coder un nombre entier ngatif par un
nombre positif non-sign en binaire, de faon ce que les rsultats des calculs effectus avec ce nombre positif non-sign
soient identiques avec ceux qui auraient ts faits avec notre nombre ngatif. Par contre, pour les nombres positifs, rien ne
change au niveau de leur reprsentation en binaire.
Pour cela, on va utiliser les rgles de l'arithmtique modulaire. Si vous ne savez pas ce que c'est, ce n'est pas grave ! Il vous
faudra juste admettre une chose : nos calculs seront faits sur des entiers ayant un nombre de bits fix une fois pour toute. En
clair, si un rsultat dpasse ce nombre de bits fix (qu'on notera ), on ne gardera que les
bits de poids faible (les
bits les
plus droite).
Prenons un exemple : prenons des nombres entiers non-signs de 4 bits. Ceux-ci peuvent donc prendre toutes les valeurs entre 0
et 15. Prenons par exemple 13 et 3. 13 + 3 = 16, comme vous le savez. Maintenant, regardons ce que donne cette opration en
binaire.
.
Ce rsultat dpasse 4, qui est le nombre de bits fix. On doit donc garder uniquement les 4 bits de poids faible et on va virer les
autres.
Et voici le rsultat :
.
En clair, avec ce genre d'arithmtique,
.
, ou encore que
Et ne croyez pas que a marche uniquement dans cet exemple : cela se gnralise assez rapidement. Pire : ce qui marche pour
l'addition marche aussi pour les autres oprations, tel la soustraction ou la multiplication. Un nombre ngatif va donc tre
reprsent par un entier positif strictement quivalent dans nos calculs qu'on appelle son complment deux.
Capacit
En utilisant
bits, un nombre reprsent en complment deux peut prendre toute valeur comprise entre
et
cette fois, l'intervalle n'est pas symtrique. Au passage, avec la mthode du complment deux, le zro n'est cod que par un
seul nombre binaire.
Exemple avec des nombres cods sur 4 bits
www.openclassrooms.com
15/467
Au fait : je ne sais pas si vous avez remarqu, mais le bit de poids fort (le bit le plus gauche) vaut 1 si le nombre est ngatif, et 0
si le nombre reprsent est positif. Celui-ci se comporte comme un bit de signe.
Sign Extend
Dans nos ordinateurs, tous les nombres sont reprsents sur un nombre fix et constant de bits. Ainsi, les circuits d'un
ordinateur ne peuvent manipuler que des nombres de 4, 8, 12, 16, 32, 48, 64 bits, suivant l'ordinateur. Si l'on veut utiliser un entier
cod sur 16 bits et que l'ordinateur ne peut manipuler que des nombres de 32 bits, il faut bien trouver un moyen de convertir
notre nombre de 16 bits en un nombre de 32 bits, sans changer sa valeur et en conservant son signe. Cette conversion d'un
entier en un entier plus grand, qui conserve valeur et signe s'appelle l'extension de signe, ou sign extend .
L'extension de signe des nombres positif ne pose aucun problme : il suffit de remplir les bits gauche de notre nombre de base
avec des 0 jusqu arriver la taille voulue. C'est la mme chose qu'en dcimal : rajouter des zros gauche d'un nombre ne
changera pas sa valeur. Cela marche quelque soit la reprsentation utilise, que ce soit la reprsentation signe-valeur absolue, le
complment 1 ou complment 2.
Exemple, si je veux convertir l'entier positif 0100 0101, prenant 8 bits, en l'entier quivalent mais utilisant 16 bits, il me suffit de
remplir les 8 bits gauche de 0100 0101 par des 0. On obtient ainsi 0000 0000 0100 0101.
Pour les nombres ngatifs, la conversion dpend de la reprsentation utilise. Avec le complment 2, l'extension de signe d'un
entier ngatif est simple effectuer : il suffit de remplir les bits gauche du nombre convertir avec des 1, jusqu' obtenir le bon
nombre de bits.
Exemple, prenons le nombre -128, cod sur 8 bits en complment deux : 1000 0000. On veut le convertir en nombre sur 16 bits.
Il suffit pour cela de remplir les 8 bits de poids fort (les 8bits les plus gauche) de 1 : on obtient 1111 1111 1000 000.
www.openclassrooms.com
16/467
L'extension de signe d'un nombre cod en complment 2 se rsume donc en une phrase.
Pour un nombre cod en complment deux, il suffit de recopier le bit de poids fort de notre nombre convertir gauche de
celui-ci jusqu atteindre le nombre de bits voulu.
Nombres virgule
On sait donc comment sont stocks nos nombres entiers dans un ordinateur. Nanmoins, les nombres entiers ne sont pas les
seuls nombres que l'on utilise au quotidien : il nous arrive d'utiliser des nombres virgule. Notre ordinateur n'est pas en reste : il
est lui aussi capable de manipuler des nombres virgule sans trop de problmes (mme si de ce point de vue, certains
ordinateurs se dbrouillent mieux que d'autres). Notre ordinateur va parfaitement pouvoir manipuler des nombres virgule.
Il existe deux mthodes pour coder des nombres virgule en binaire :
La virgule fixe ;
La virgule flottante.
La mthode de la virgule fixe consiste muler nos nombres virgule partir de nombre entiers. Un nombre virgule fixe est
donc cod par un nombre entier proportionnel notre nombre virgule fixe. Pour obtenir la valeur de notre nombre virgule fixe,
il suffit de diviser l'entier servant le reprsenter par un nombre constant, fix une bonne fois pour toute.
Par exemple, pour coder 1,23 en virgule fixe, on peut choisir comme "facteur de conversion" 1000. L'entier permettant de coder
1,23 sera alors 1230. La reprsentation en virgule fixe tait utile du temps o les ordinateurs n'intgraient pas de circuits capables
de travailler directement sur des nombres virgule flottante. Cette mthode n'est presque plus utilise, et vous pouvez l'oublier
sans problme.
Les nombres virgule fixe ont aujourd'hui ts remplacs par les nombres virgule flottante. Ce sont des nombres dont le
nombre de chiffre aprs la virgule est variable. De nombreuses mthodes existent pour reprsenter ces nombres virgule qui
sont souvent incompatibles entre-elles.
Les concepteurs de matriel lectronique se sont dit qu'il fallait normaliser le stockage des flottants en mmoire ainsi que les
rsultats des calculs afin que tous les ordinateurs supportent les mmes flottants et pour que les calculs flottants donnent les
mmes rsultats quelque soit l'ordinateur. C'est ainsi qu'est ne la norme IEEE754.
Cette norme IEEE754 impose diverses choses concernant nos flottants. Elle impose une faon d'organiser les bits de nos
nombres flottants en mmoire, standardise par la norme. Il faut tout de mme noter qu'il existe d'autres normes de nombres
flottants, moins utilises.
criture scientifique
L'criture d'un nombre flottant en binaire est base sur son criture scientifique. Cela permet de coder beaucoup plus de valeurs
qu'un nombre en virgule fixe, nombre de bits gal. Pour rappel, en dcimal, lcriture scientifique d'un nombre consiste crire
celui-ci comme un produit entre un nombre et une puissance de 10. Ainsi, un nombre aura une criture scientifique en base 10
de la forme :
Notre nombre ne possde qu'un seul chiffre gauche de la virgule : on peut toujours trouver un exposant tel que ce soit le cas.
En clair, en base 10, sa valeur est comprise entre 1 (inclus) et 10 (exclu).
En binaire, c'est peu prs la mme chose, mais avec une puissance de deux. L'criture scientifique binaire d'un nombre consiste
crire celui-ci sous la forme
Le nombre ne possde toujours qu'un seul chiffre gauche de la virgule, comme en base 10. Le seul truc, c'est qu'en binaire,
seuls deux chiffres sont possibles : 0 et 1. Le chiffre de situ gauche de la virgule est donc soit un zro ou un 1.
Pour stocker cette criture scientifique avec des zros et des un, il nous faut stocker la partie fractionnaire de notre nombre ,
qu'on appelle la mantisse et l'exposant. On rajoute souvent un bit de signe qui sert calculer le signe du nombre flottant : ce bit
vaut 1 si ce nombre est ngatif et vaut 0 si notre flottant est positif.
www.openclassrooms.com
17/467
Mantisse
Mantisse
Mais parlons un peu de cette mantisse. Vous croyez surement que l'ensemble de cette mantisse est stocke dans notre nombre
flottant. Et bien rien n'est plus faux : seule la partie fractionnaire est stocke dans nos nombres flottants : le chiffre situ gauche
de la virgule n'est pas stock dans la mantisse. Ce bit est stock dans notre nombre flottant de faon implicite et peut se dduire
en fonction de l'exposant : on ne doit pas le stocker dans notre nombre flottant, ce qui permet d'conomiser un bit. Il est souvent
appel le bit implicite dans certains livres ou certaines documentations. Dans la majorit des cas, il vaut 1, et ne vaut 0 que dans
quelques rares exceptions : les flottants dnormaux. On verra ceux-ci plus tard.
Exposant
Aprs avoir stock notre mantisse, parlons de l'exposant. Sachez que celui-ci peut tre aussi bien positif que ngatif : c'est pour
permettre de coder des nombres trs petits. Mais notre exposant n'est pas cod avec les reprsentations de nombres entiers
qu'on a vues au-dessus. A la place, notre exposant est stock en lui soustrayant un dcalage prdtermin. Pour un nombre
flottant de bits, ce dcalage vaut
.
Formats de flottants
La norme IEEE754 impose diverses choses concernant la faon dont on gre nos flottants. Elle impose un certain format en
mmoire : les flottants doivent tre stocks dans la mmoire d'une certaine faon, standardise par la norme. Elle impose une
faon d'organiser les bits de nos nombres flottants en mmoire. Cette norme va (entre autres) dfinir quatre types de flottants
diffrents. Chacun de ces types de flottants pourra stocker plus ou moins de valeurs diffrentes.
Voici ces types de flottants :
Format
Nombre de bits de
l'exposant
Simple prcision
32
23
Simple prcision
tendue
Au moins 43
Variable
Variable
Double prcision
64
11
52
Double prcision
tendue
80 ou plus
15 ou plus
64 ou plus
IEEE754 impose aussi le support de certains nombres flottants spciaux. Parmi eux, on trouve l'infini (aussi bien en ngatif qu'en
positif), la valeur NaN, utilise pour signaler des erreurs ou des calculs n'ayant pas de sens mathmatiquement, ou des nombres
spciaux nomms les dnormaux qui reprsentent des valeurs trs petites et qui sont utiliss dans des scnarios de calcul assez
particuliers.
Flottants dnormaliss
Commenons notre revue des flottants spciaux par les dnormaux, aussi appels flottants dnormaliss. Pour ces flottants,
l'exposant prend la plus petite valeur possible. Ces flottants ont une particularit : le bit implicite attach leur mantisse vaut 0.
Bit de signe
1 ou 0
Exposant
Mantisse
Le zro
Le zro est un flottant dnormalis spcial. Sa seule particularit est que sa mantisse est nulle.
Bit de signe
Exposant
www.openclassrooms.com
Mantisse
18/467
Au fait, remarquez que le zro est cod deux fois cause du bit de signe. Si vous mettez l'exposant et la mantisse la bonne
valeur de faon avoir zro, le bit de signe pourra valoir aussi bien 1 que 0 : on se retrouve avec un
et un
.
par exemple. Si
Exposant
Mantisse
Bit de signe
Exposant
Mantisse
Et le pire, c'est qu'on peut effectuer des calculs sur ces flottants infinis. Mais cela a peu d'utilit.
On peut donner comme exemple :
L' addition ou soustraction d'un nombre rel fini un de ces deux infinis, qui ne changera rien l'infini de dpart.
Idem pour la multiplication par un nombre positif :
aura pour rsultat .
La multiplication par un nombre ngatif changera le signe de l'infini. Par exemple,
aura pour rsultat
NaN
Mais malheureusement, l'invention des flottants infinis n'a pas rgl tous les problmes. On se retrouve encore une fois avec des
problmes de calculs avec ces infinis.
Par exemple, quel est le rsultat de
? Et pour
? Ou encore ?
Autant prvenir tout de suite : mathmatiquement, on ne peut pas savoir quel est le rsultat de ces oprations. Pour pouvoir
rsoudre ces calculs dans notre ordinateur sans lui faire prendre feu, il a fallu inventer un nombre flottant qui signifie "je ne sais
pas quel est le rsultat de ton calcul pourri". Ce nombre, c'est NAN.
Voici comment celui-ci est cod :
Bit de signe
Exposant
Mantisse
NAN est l'abrviation de Not A Number, ce qui signifie : n'est pas un nombre. Pour tre plus prcis, il existe diffrents types de
NaN, qui diffrent par la valeur de leur mantisse, ainsi que par les effets qu'ils peuvent avoir. Malgr son nom explicite, on peut
faire des oprations avec NAN, mais cela ne sert pas vraiment grand chose : une opration arithmtique applique avec un
NAN aura un rsultat toujours gal NAN.
Exceptions et arrondis
www.openclassrooms.com
19/467
La norme impose aussi une gestion de certains cas particuliers. Ces cas particuliers correspondant des erreurs, auxquelles il
faut bien "rpondre". Cette rponse peut tre un arrt de lexcution du programme fautif, ou un traitement particulier (un arrondi
par exemple).
En voici la liste :
Invalid operation : opration qui produit un NAN.
Overflow : rsultat trop grand pour tre stock dans un flottant. Le plus souvent, on traite l'erreur en arrondissant le
rsultat vers
.
Underflow : pareil, mais avec un rsultat trop petit. Le plus souvent, on traite l'erreur en arrondissant le rsultat vers 0.
Division par zro. La rponse la plus courante est de rpondre + ou - l'infini.
Inexact : le rsultat ne peut tre reprsent par un flottant et on doit l'arrondir.
Pour donner un exemple avec l'exception Inexact , on va prendre le nombre
. Ce nombre ne semble pourtant pas mchant,
mais c'est parce qu'il est crit en dcimal. En binaire, ce nombre s'crit comme ceci :
et ainsi de suite jusqu l'infini. Notre nombre utilise une infinit de
dcimales. Bien videment, on ne peut pas utiliser une infinit de bits pour stocker notre nombre et on doit imprativement
l'arrondir.
Comme vous le voyez avec la dernire exception, le codage des nombres flottants peut parfois poser problme : dans un
ordinateur, il se peut qu'une opration sur deux nombres flottants donne un rsultat qui ne peut tre cod par un flottant. On est
alors oblig d'arrondir ou de tronquer le rsultat de faon le faire rentrer dans un flottant. Pour viter que des ordinateurs
diffrents utilisent des mthodes d'arrondis diffrentes, on a dcid de normaliser les calculs sur les nombres flottants et les
mthodes d'arrondis. Pour cela, la norme impose le support de quatre modes d'arrondis :
Arrondir vers + l'infini,
vers - l'infini,
vers zro
vers le nombre flottant le plus proche.
Codage du texte
Nous savons donc comment faire pour reprsenter des nombres dans notre ordinateur, et c'est dj un bon dbut. Mais votre
ordinateur peut parfaitement manipuler autre chose que des nombres. Il peut aussi manipuler des images, du son, ou pleins
d'autres choses encore. Eh bien sachez que tout cela est stock dans votre ordinateur... sous la forme de nombres cods en
binaire, avec uniquement des 0 et des 1.
Le codage dfinit la faon de reprsenter une information (du texte, de la vido, du son...) avec des nombres. Ce codage va
attribuer un nombre : une lettre, la couleur d'un pixel l'cran... Ainsi, notre ordinateur sera non seulement capable de manipuler
des nombres (et de faire des calculs avec), mais il sera aussi capable de manipuler une information ne reprsentant pas forcment
un nombre pour l'utilisateur.
Bien videment, l'ordinateur n'a aucun moyen de faire la diffrence entre un nombre qui code un pixel, un nombre qui code une
lettre ou mme un nombre. Pour lui, tout n'est que suites de zro et de uns sans aucune signification : une donne en binaire ne
contient aucune information sur linformation qu'elle code (son "type"), et l'ordinateur n'a aucun moyen de le deviner.
Par exemple, si je vous donne la suite de bits suivante : 1100101 cod sur 7 bits ; vous n'avez aucun moyen de savoir s'il s'agit
d'une lettre (la lettre e avec l'encodage ASCII), le nombre 101, ou l'entier -26 cod en complment 1, ou encore l'entier -25 cod
en complment deux.
Ce qui va faire la diffrence entre les types c'est la faon dont sera interprte la donne : on n'effectuera pas les mmes
traitements sur une suite de bits selon ce qu'elle reprsente. Par exemple, si on veut afficher un 'e' l'cran, les manipulations
effectues ne seront pas les mmes que celles utilise pour afficher le nombre 101, ou le nombre -25, etc.
Pour la suite, on va prendre l'exemple du texte.
Standard ASCII
Pour stocker un texte, rien de plus simple : il suffit de savoir comment stocker une lettre dans notre ordinateur et le reste coule de
source. On va donc devoir coder chaque lettre et lui attribuer un nombre. Pour cela, il existe un standard, nomme la table ASCII
qui va associer un nombre particulier chaque lettre. L'ASCII est un standard qui permet tous les ordinateurs de coder leurs
caractres de la mme faon. Ce standard ASCII utilise des nombres cods sur 7bits, et peut donc coder 128 symboles diffrents.
Notre table ASCII est donc une table de correspondance qui attribue un nombre chaque symbole. La voici dans son intgralit,
rien que pour vous.
www.openclassrooms.com
20/467
Si vous lisez en entier la table ASCII, vous remarquerez srement qu'il n'y a pas que des lettres codes par l'ASCII : il y tous les
caractres d'un clavier qui sont inscrits dans cette table.
On peut faire quelques remarques sur cette table ASCII :
Les lettres sont stockes dans l'ordre alphabtique, pour simplifier la vie des utilisateurs.
Le passage des minuscules aux majuscules se fait en changeant le 6me bit du caractre, ce qui est trs simple.
Les symboles 0 31 , ainsi que le 127me sont un peu bizarres...
Ces symboles prsents dans ce standard ASCII ne peuvent mme pas tre taps au clavier et ils ne sont pas affichables !
Mais quoi peuvent-ils bien servir ?
Il faut savoir que ce standard est assez ancien. A l'poque de la cration de ce standard, il existait de nombreuses imprimantes et
autres systmes qui l'utilisaient Et pour faciliter la conception de ces machines, on a plac dans cette table ASCII des symboles
qui n'taient pas destins tre affichs, mais dont le but tait de donner un ordre l'imprimante/machine crire... On trouve
ainsi des symboles de retour la ligne, par exemple.
Unicode
Le problme avec la table ASCII, c'est qu'on se retrouve assez rapidement limit avec nos 128 symboles. On n'arrive pas caser
les accents ou certains symboles particuliers certaines langues dedans. Impossible de coder un texte en grec ou en japonais :
les idogrammes et les lettres grecques ne sont pas dans la table ASCII. Pour combler ce genre de manque, de nombreuses
autres mthodes sont apparues qui peuvent coder bien plus de symboles que la table ASCII. Elles utilisent donc plus de 7 bits
pour coder leurs symboles : on peut notamment citer l'unicode. Pour plus de simplicit, l'unicode est parfaitement compatible
avec la table ASCII : les 128 premiers symboles de l'unicode sont ceux de la table ASCII, et sont rangs dans le mme ordre.
Si vous voulez en savoir plus sur ces encodages, sachez qu'il existe un tutoriel sur le sujet, sur le siteduzro. Le voici :
Comprendre les encodages.
www.openclassrooms.com
21/467
Codage NRZ
Pour compter en binaire , il faut travailler avec des bits qui peuvent prendre deux valeurs notes 0 et 1. Le tout est de savoir
comment reprsenter ces bits dans l'ordinateur. Pour cela, on utilise une grandeur physique nomme la tension. Pas besoin de
savoir ce que c'est, sachez juste que a se mesure en volts et que a n'est pas synonyme de courant lectrique.
Rien voir
avec un quelconque dplacement dlectrons, comme certains le pensent.
Avec cette tension, il y a diverses mthodes pour coder un bit : codage Manchester, NRZ, etc. Ces diverses mthodes ont
chacune leurs avantages et leurs dfauts. Autant trancher dans le vif tout de suite : la quasi-intgralit des circuits de notre
ordinateur se basent sur le codage NRZ.
Codage NRZ
Pour coder un 0 ou 1 en NRZ, si suffit de dire que si la tension est en-dessous d'un seuil donn, C'est un 0. Et il existe un autre
seuil au-dessus duquel la tension reprsente un 1. Du moins, c'est ainsi dans la majorit des cas : il arrive que ce soit l'inverse sur
certains circuits lctroniques : en-dessous d'un certain seuil, c'est un 1 et si c'est au-dessus d'un autre seuil c'est 0. Tout ce qu'il
faut retenir, c'est qu'il y a un intervalle pour le 0 et un autre pour le 1. En dehors de ces intervalles, on considre que le circuit est
trop imprcis pour pouvoir conclure sur la valeur de la tension : on ne sait pas trop si c'est un 1 ou un 0.
Il y a deux seuils, car les circuits qui manipulent des tensions n'ont pas une prcision parfaite, et qu'une petite perturbation
lectrique pourrait alors transformer un 0 en 1. Pour limiter la casse, on prfre sparer ces deux seuils par une sorte de marge de
scurit.
Tensions de rfrence
Ces tensions vont tre manipules par diffrents circuits lectroniques plus ou moins sophistiqus. Pour pouvoir travailler avec
des tensions, nos circuits ont besoin d'tre aliments en nergie. Pour cela, notre circuit possdera une tension qui alimentera le
www.openclassrooms.com
22/467
circuit en nergie, qui s'appelle la tension d'alimentation. Aprs tout, si un circuit doit coder des bits valant 1, il faudra bien qu'il
trouve de quoi fournir une tension de 2, 3, 5 volts : la tension codant notre 1 ne sort pas de nulle part ! De mme, on a besoin
d'une tension de rfrence valant zro volt, qu'on appelle la masse, qui sert pour le zro.
Dans tous les circuits lectroniques (et pas seulement les ordinateurs), cette tension d'alimentation varie gnralement entre 0 et
5 volts. Mais de plus en plus, on tend utiliser des valeurs de plus en plus basses, histoire d'conomiser un peu d'nergie. Et
oui, car plus un circuit utilise une tension leve, plus il consomme d'nergie et plus il chauffe.
Pour un processeur, il est rare que les modles rcents utilisent une tension suprieure 2 volts : la moyenne tournant autour de
1-1.5 volts. Mme chose pour les mmoires : la tension d'alimentation de celle-ci diminue au court du temps. Pour donner des
exemples, une mmoire DDR a une tension d'alimentation qui tourne autour de 2,5 volts, les mmoires DDR2 ont une tension
d'alimentation qui tombe 1,8 volts, et les mmoires DDR3 ont une tension d'alimentation qui tombe 1,5 volts. C'est trs peu :
les composants qui manipulent ces tensions doivent tre trs prcis.
Transistors
Pour commencer, nous allons devoir faire une petite digression et parler un peu dlectronique : sans cela, impossible de vous
expliquer en quoi est fait un ordinateur ! Sachez tout d'abord que nos ordinateurs sont fabriqus avec des composants
lectroniques que l'on appelle des transistors, relis pour former des circuits plus ou moins compliqus. Presque tous les
composants d'un ordinateur sont fabriqus avec un grand nombre de transistors, qui peut monter quelques milliards sur des
composants sophistiqus. Pour donner un exemple, sachez que les derniers modles de processeurs peuvent utiliser prs d'un
milliard de transistors. Et le tout doit tenir sur quelques centimtres carrs : autant vous dire que la miniaturisation a fait
dnormes progrs !
Transistors CMOS
Il existe diffrents types de transistors, chacun avec ses particularits, ses avantages et ses inconvnients. On ne va pas en
parler plus que a, mais il faut prciser que les transistors utiliss dans nos ordinateurs sont des transistors effet de champ
technologie CMOS. Si vous ne comprenez pas ce que a signifie, ce n'est pas grave, c'est un simple dtail sans grande
importance.
Mais qu'est-ce qu'un transistor CMOS ?
Il s'agit simplement d'un composant reli un circuit lectronique par trois morceaux de "fil" conducteur que l'on appelle
broches. On peut appliquer de force une tension lectrique sur ces broches (attention ne pas la confondre avec le courant
lectrique), qui peut reprsenter soit 0 soit 1 en fonction du transistor utilis.
Ces trois broches ont des utilits diffrentes et on leur a donn un nom pour mieux les reprer :
la grille ;
le drain ;
la source.
www.openclassrooms.com
23/467
Dans les processeurs, on utilise notre transistor comme un interrupteur qui ragit en fonction de sa grille : suivant la valeur de la
tension qui est applique sur la grille, le transistor conduira ou ne conduira pas le courant entre la source et le drain. En clair,
appliquez la tension adquate et la liaison entre la source et le drain se comportera comme un interrupteur ferm et conduira le
courant : le transistor sera alors dit dans l'tat passant. Par contre, si vous appliquez une tension la bonne valeur sur la grille,
cette liaison se comportera comme un interrupteur ouvert et le courant ne passera pas : le transistor sera dit dans l'tat bloqu.
Il existe deux types de transistors CMOS, qui diffrent entre autres par la tension qu'il faut mettre sur la grille pour les
ouvrir/fermer :
les transistors NMOS qui s'ouvrent lorsqu'on place une tension gale zro sur la grille et se ferment si la tension place
sur cette mme grille reprsente un 1 ;
et les PMOS pour qui s'est l'inverse : ils se ferment lorsque la tension sur la grille est nulle, et s'ouvrent si celle-ci
reprsente un 1.
Loi de Moore
De nos jours, le nombre de transistors des composants lectroniques actuels augmente de plus en plus, et les concepteurs de
circuits rivalisent d'ingniosit pour miniaturiser le tout.
En 1965, le cofondateur de la socit Intel, spcialise dans la conception des mmoires et de processeurs, a affirm que la
quantit de transistors prsents dans un processeur doublait tous les 18 mois. Cette affirmation porte aujourd'hui le nom de
premire loi de Moore. En 1975, le cofondateur d'Intel rvalua cette affirmation : ce n'est pas tous les 18 mois que le nombre de
transistors d'un processeur double, mais tous les 24 mois. Cette nouvelle version, appele la seconde loi de Moore, a
redoutablement bien survcue : elle est toujours valable de nos jours.
www.openclassrooms.com
24/467
Ce faisant, la complexit des processeurs augmente de faon exponentielle dans le temps et sont censs devenir de plus en plus
gourmands en transistors au fil du temps.
De plus, miniaturiser les transistors permet parfois de les rendre plus rapides : c'est un scientifique du nom de Robert Dennard
qui a dcouvert un moyen de rendre un transistor plus rapide en diminuant certains paramtres physiques d'un transistor. Sans
cette miniaturisation, vous pouvez tre certains que nos processeurs en seraient pas aussi complexes quaujourdhui. Mais
attention, cela ne signifie pas pour autant que le nombre de transistors soit un indicateur efficace de performances : avoir
beaucoup de transistors ne sert rien si on le les utilise pas correctement.
Mais cette miniaturisation a ses limites et elle pose de nombreux problmes dont on ne parlera pas ici. Sachez seulement que
cette loi de Moore restera valable encore quelques dizaines d'annes, et qu'au del, on ne pourra plus rajouter de transistors
dans nos processeurs aussi facilement que de nos jours.
Portes logiques
C'est bien beau de savoir coder des bits et d'avoir des transistors pour les manipuler, mais j'aimerais savoir comment on
fait pour triturer des bits avec des transistors ?
Et bien que vos vux soient exhausss ! La solution consiste rassembler ces transistors dans ce qu'on appelle des circuits
logiques.
Ce sont simplement des petits circuits, fabriqus avec des transistors, qui possdent des sorties et des entres, sur lesquelles on
va placer des bits pour les manipuler. Ces entres et ces sorties ne sont rien d'autre que des morceaux de "fil" conducteur sur
lesquelles on peut mesurer une tension qui reprsente un zro ou un 1. Sur chaque entre du composant, on peut forcer la valeur
www.openclassrooms.com
25/467
de la tension, histoire de mettre l'entre 0 ou 1. A partir de l, le circuit lectronique va ragir et dduire la tension placer sur
chacune de ses sorties en fonction de ses entres.
Autant vous le dire tout de suite, votre ordinateur est remplit de ce genre de choses. Quasiment tous les composants de notre
ordinateur sont fabriqus avec ce genre de circuits. Par exemple, notre processeur est un composant lectronique comme un
autre, avec ses entres et ses sorties.
Nanmoins, quelque soit la complexit du circuit crer, celui-ci peut tre construit en reliant quelques petits circuits de base
entre eux. Ces circuits de base sont nomms des portes logiques. Il existe trois portes logiques qui sont trs importantes et que
vous devez connaitre : les portes ET, OU et NON . Mais pour se faciliter la vie, on peut utiliser d'autres portes, plus ou moins
diffrentes. Voyons un peu quelles sont ces portes, et ce qu'elles font.
La porte NON
Le premier oprateur fondamental est la porte NON aussi appele porte inverseuse. Cette porte agit sur un seul bit.
Elle est symbolise par le schma suivant :
www.openclassrooms.com
26/467
Sur les schmas qui vont suivre, les entres des portes logiques seront gauche et les sorties droite !
Pour simplifier la comprhension, je vais rassembler les tats de sortie en fonction des entres pour chaque porte logique dans
un tableau qu'on appelle table de vrit. Voici celui de la porte NON :
Entre Sortie
0
Le rsultat est trs simple, la sortie d'une porte NON est exactement le contraire de l'entre.
Cblage
Cette porte est fabrique avec seulement deux transistors et son schma est diablement simple. Voici le montage en question.
www.openclassrooms.com
27/467
Si on met un 1 en entre de ce petit montage lectronique, le transistor du haut va fonctionner comme un interrupteur ouvert, et
celui du bas comme un interrupteur ferm. On se retrouvera donc avec notre sortie relie au zro volt, et donc qui vaut zro.
Inversement, si on met un 0 en entre de ce petit montage lectronique, le transistor du bas va fonctionner comme un
interrupteur ouvert, et celui du haut comme un interrupteur ferm. On se retrouvera donc avec notre sortie relie la tension
d'alimentation, qui vaudra donc 1.
Comme vous le voyez, avec un petit nombre de transistors, on peur russir crer de quoi inverser un bit. Et on peut faire pareil
avec toutes les autres portes lmentaires : on prend quelques transistors, on cble cela comme il faut, et voil une porte logique
toute neuve !
La porte ET
Maintenant une autre porte fondamentale : la porte ET.
Cette fois, diffrence avec la porte NON , la porte ET a 2 entres, mais une seule sortie.
Voici comment on la symbolise :
www.openclassrooms.com
28/467
Cette porte logique met sa sortie 1 quand toutes ses entres valent 1.
Porte NAND
La porte NAND est l'exact inverse de la sortie d'une porte ET. Elle fait la mme chose qu'une porte ET suivie d'une porte NON .
Sa table de vrit est :
Entre 1 Entre 2 Sortie
0
Cette porte a une particularit : on peut recrer les portes ET, OU et NON , et donc n'importe quel circuit lectronique, en
utilisant des montages composs uniquement de portes NAND. A titre d'exercice, vous pouvez essayez de recrer les portes ET,
OU et NON partir de portes NAND. Ce serait un petit entrainement assez sympathique. Aprs tout, si a peut vous occuper
lors d'un dimanche pluvieux.
On la symbolise par le schma qui suit.
Au fait, si vous regardez le schma de la porte NAND, vous verrez que son symbole est presque identique celui d'une
porte ET : seul le petit rond ajout sur la sortie de la porte a t rajout. Et bien sachez que ce petit rond est une sorte
de raccourci pour schmatiser une porte NON . Ainsi, si vous voyez un petit rond quelque part sur un schma (sur une
entre ou une sortie, peut importe), sachez que ce petit rond symbolise une porte NON .
www.openclassrooms.com
29/467
Cblage
Implmenter une porte NAND avec des transistors CMOS est un peu plus complexe qu'implmenter une porte NON . Mais qu'
cela ne tienne, voici en exclusivit : comment crer une porte NAND avec des transistors CMOS !
Ce schma peut s'expliquer trs simplement. Tout d'abord, vous verrez qu'il y a deux grands blocs de transistors dans ce circuit :
un entre la sortie et la tension dalimentation, et un autre entre la sortie et la masse. Tous les circuits CMOS suivent ce principe,
sans exception. Ensuite, on peut remarquer que tous les transistors placs entre la tension d'alimentation et la sortie sont des
transistors PMOS. De mme, tous les transistors placs entre la masse et la sortie sont des transistors NMOS. Ceci est encore
une fois vrai pour tous les circuits CMOS.
Regardons ces deux parties l'une aprs l'autre, en commenant par celle du haut.
Celle-ci sert connecter la sortie sur la tension d'alimentation du circuit. Nos deux transistors sur de type PMOS : ils se ferment
quand on leur met un 0 sur la grille. Or, les transistors sont mis en parallle : si un seul de ces deux transistors est ferm, la
tension d'alimentation sera relie la sortie et elle passera 1. Donc, si une seule des deux entres est 0, on se retrouve avec un
1 en sortie.
Passons maintenant l'autre bloc de transistors.
www.openclassrooms.com
30/467
Cette fois-ci, c'est l'inverse : nos transistors sont relis les uns la suite des autres : il faut que les deux soient ferms pour que la
masse soit connecte la sortie. Et les transistors sont cette fois des transistors NMOS : ils se ferment quand on leur met un 1
sur leur grille. Donc, pour avoir un zro en sortie, il faut que les deux entres soient 1. Au final on obtient bien une porte
NAND.
La porte OU
Maintenant une autre porte fondamentale : la porte OU.
Cette fois, comme la porte ET, elle possde 2 entres, mais une seule sortie.
On symbolise cette porte comme ceci :
Cette porte logique met sa sortie 1 quand au moins une de ses entres vaut 1.
Porte NOR
La porte NOR est l'exact inverse de la sortie d'une porte OU. Elle est quivalente une porte OU suivie d'une porte NON .
Sa table de vrit est :
Entre 1 Entre 2 Sortie
www.openclassrooms.com
31/467
On peut recrer les portes ET, OU et NON , et donc n'importe quel circuits lectronique, en utilisant des montages composs
uniquement de portes NOR. Comme quoi, la porte NAND n'est pas la seule avoir ce privilge. Cela a une consquence : on peut
concevoir un circuits en n'utilisant que des portes NOR. Pour donner un exemple, sachez que les ordinateurs chargs du pilotage
et de la navigation des missions Appollo taient intgralement conus uniquement avec des portes NOR.
A titre d'exercice, vous pouvez essayez de recrer les portes ET, OU et NON partir de portes NOR. Si vous en avez envie, hein
!
On la symbolise avec le schma qui suit.
Cblage
Implmenter une porte NOR avec des transistors CMOS ressemble ce qu'on a fait pour la prote NAND.
Ce schma peut s'expliquer trs simplement. Encore une fois, on va voir chacune des deux parties (celle du haut et celle du bas)
l'une aprs l'autre, en commenant par celle du haut.
www.openclassrooms.com
32/467
Celle-ci sert connecter la sortie sur la tension d'alimentation du circuit. Nos deux transistors sur de type PMOS : ils se ferment
quand on leur met un 0 sur la grille. Nos transistors sont relis les uns la suite des autres : il faut que les deux soient ferms
pour que la masse soit connecte la sortie. les deux entres doivent tre zro pour que l'on ait un 1 en sortie.
Passons maintenant l'autre bloc de transistors.
Les transistors sont des transistors NMOS : ils se ferment quand on leur met un 1 sur leur grille. Cette fois, les transistors sont
mis en parallle : si un seul de ces deux transistors est ferm, la tension d'alimentation sera relie la sortie et elle passera 0.
Donc, si une seule des deux entres est 1, on se retrouve avec un 1 en sortie. Au final on obtient bien une porte NOR.
Porte XOR
Avec une porte OU , deux ET et deux portes NON , on peut crer une porte nomme XOR. Cette porte est souvent appele porte
OU Exclusif .
Sa table de vrit est :
Entre 1 Entre 2 Sortie
0
On remarque que sa sortie est 1 quand les deux bits placs sur ses entres sont diffrents, et valent 0 sinon.
On la symbolise comme ceci :
www.openclassrooms.com
33/467
Porte NXOR
La porte XOR possde une petite soueur : la NXOR.
Sa table de vrit est :
Entre 1 Entre 2 Sortie
0
On remarque que sa sortie est 1 quand les deux bits placs sur ses entres sont diffrents, et valent 0 sinon. Cette porte est
quivalente une porte XOR suivie d'une porte NON .
On la symbolise comme ceci :
www.openclassrooms.com
34/467
Il faut avouer qu'on irait pas loin en sachant uniquement ce que sont les ET, NAND, et autres. Ce qu'il faudrait, c'est pouvoir
crer de vrais circuits. Et bien que vos vux soient exaucs (enfin presque) : nous allons enfin voir comment sont raliss les
circuits de nos ordinateurs. Du moins, nous allons voir comment crer des circuits simples, mais qui sont la base des circuits de
notre ordinateur.
Circuits combinatoires
Pour commencer, nous allons parler d'une classe de circuits assez simples : les circuits combinatoires. Ces circuits font comme
tous les autres circuits : ils prennent des donnes sur leurs entres, et fournissent un rsultat en sortie. Le truc, c'est que ce qui
est fourni en sortie ne dpend que du rsultat sur les entres, et de rien d'autre ! Cela peut sembler tre vident, mais on verra
que ce n'est pas le cas pour tous les circuits.
Pour donner quelques exemples de circuits combinatoires, on peut citer les circuits qui effectuent des additions, des
multiplications, ou d'autres oprations arithmtiques du genre. Par exemple, le rsultat d'une addition ne dpend que des
nombres additionner et rien d'autre. Pareil pour la division, la soustraction, la multiplication, etc. Notre ordinateur contient de
nombreux circuits de ce genre. Toutefois, nous ne verrons pas tout de suite les circuits capables d'effectuer ces calculs : ceux-ci
sont un peu plus compliqus que ce qu'on va voir ici et on va donc les laisser pour plus tard, dans la partie sur le processeur.
Tables de vrit
Bref, poursuivons. J'ai promis de vous apprendre concevoir des circuits, de faon "simple". Pour commencer, il va falloir dcrire
ce que notre circuit fait. Pour un circuit combinatoire, la tche est trs simple, vu que ce qu'on trouve sur ses sorties ne dpend
que de ce qu'on a sur les entres. Pour dcrire intgralement le comportement de notre circuit, il suffit donc de lister la valeur de
chaque sortie pour toute valeur possible en entre. Cela peut se faire simplement en crivant ce qu'on appelle la table de vrit
du circuit. Pour crer cette table de vrit, il faut commencer par lister toutes les valeurs possibles des entres dans un tableau, et
crire cot les valeurs des sorties qui correspondent ces entres. Cela peut tre assez long : pour un circuit ayant entres,
ce tableau aura
lignes.
Bit de parit
Pour donner un exemple, on va prendre l'exemple d'un circuit calculant la le bit de parit d'un nombre.
Le quoi ?
Ah oui, pardon !
Ce bit de parit est une technique qui permet de dtecter des erreurs de transmission ou dventuelles corruptions de donnes
qui modifient un nombre impair de bits. Si un, trois, cinq, ou un nombre impair de bits voient leur valeur s'inverser (un 1 devient
un 0, ou inversement), l'utilisation d'un bit de parit permettra de dtecter cette erreur. Par contre, il sera impossible de la corriger.
Le principe cach derrire un bit de parit est simple : il suffit d'ajouter un bit supplmentaire aux bits stocker. Le but d'un bit de
parit est de faire en sorte que le nombre de bits 1 dans le nombre stocker, bit de parit inclut, soit toujours un nombre pair.
Ce bit, le bit de parit vaudra :
zro si le nombre de bits 1 dans le nombre stocker (bit de parit exclu) est pair ;
1 si ce nombre est impair.
Dtecter une erreur est simple : on compte le nombre de bits 1 dans le nombre stocker, bit de parit inclut, et on regarde s'il est
pair. S'il est impair, on sait qu'au moins un bit t modifi.
www.openclassrooms.com
35/467
Sortie s0
quations logiques
Une fois qu'on a la table de vrit, une bonne partie du travail dj t fait. Il ne nous reste plus qu' transformer notre table en
ce qu'on appelle des quations logiques.
Mais que viennent faire les quations ici ?
Attention : il ne s'agit pas des quations auxquelles vous tes habitus. Ces quations logiques ne font que travailler avec des 1
et des 0, et n'effectuent pas d'oprations arithmtiques mais seulement des ET, des OU, et des NON . Ces quations vont ainsi
avoir des bits pour inconnues.
Chacune de ces quations logiques correspondra un circuit, et vice-versa : un circuit sera associ une quation qui permettra
de dcrire le circuit. Par exemple, prenons le circuit vu dans le QCM de la question prcdente.
www.openclassrooms.com
36/467
Syntaxe
Pour pouvoir commencer crire ces quations, il va falloir faire un petit point de syntaxe. Voici rsum dans ce tableau les
diffrentes oprations, ainsi que leur notation. Dans ce tableau, a et b sont des bits.
Voil, avec ce petit tableau, vous savez comment crire une quation logique...enfin presque, il ne faut pas oublier le plus
important : les parenthses ! Et oui, il faudra bien viter quelques ambiguts dans nos quations. C'est un peu comme avec des
quations normales :
donne un rsultat diffrent de
. Avec nos quations logiques, on peut trouver
des situations similaires : par exemple,
est diffrent de
. On est alors oblig d'utiliser des parenthses.
Premire tape
La premire tape consiste donc lister les lignes de la table de vrit dont la sortie est 1.
Sortie s0
www.openclassrooms.com
37/467
Deuxime tape
Ensuite, on doit crire l'quation logique de chacune des lignes slectionnes l'tape d'avant.
Pour crire l'quation logique d'une ligne, il faut simplement :
lister toutes les entres de la ligne ;
faire un NON sur chaque entre 0 ;
et faire un ET avec le tout.
Par exemple, prenons la premire ligne dont la sortie vaut 1, savoir la deuxime.
Il faut ensuite faire cela pour toutes les lignes dont la sortie vaut 1.
Seconde ligne :
Troisime ligne :
Quatrime ligne :
Troisime tape
On a alors obtenu nos quations logiques. Reste faire un bon gros OU entre toutes ces quations, et le tour est jou ! On
obtient alors l'quation logique suivante :
www.openclassrooms.com
38/467
A ce stade, vous pourriez traduire cette quation directement en circuit, mais il y a un petit inconvnient...
Simplifications du circuit
Comme on l'a vu, on fini par obtenir une quation logique qui permet de dcrire notre circuit. Mais quelle quation : on se
retrouve avec un gros paquet de ET et de OU un peu partout ! Autant dire qu'il serait sympathique de pouvoir simplifier cette
quation. Bien sr, on peut vouloir simplifier cette quation juste pour se simplifier la vie lors de la traduction de cette quation
en circuit, mais cela sert aussi autre chose : cela permet d'obtenir un circuit plus rapide et/ou utilisant moins de portes logiques.
Autant vous dire qu'apprendre simplifier ces quations est quelque chose de crucial, particulirement si vous voulez concevoir
des circuits un tant soit peu rapides.
Pour donner un exemple, sachez que la grosse quation logique obtenue auparavant :
; peut se simplifier en :
avec les rgles de
simplifications vues au-dessus. Dans cet exemple, on passe donc de 17 portes logiques seulement 3 !
Pour simplifier notre quation, on peut utiliser certaines proprits mathmatiques simples de ces quations. Ces proprits
forment ce qu'on appelle lalgbre de Boole, du nom du mathmaticien qui les a dcouvertes/inventes.
Rgle
Description
Commutativit
Associativit
Distributivit
Idempotence
Element nul
Element Neutre
;
Loi de De Morgan
Complmentarit
Description
www.openclassrooms.com
39/467
XOR
En utilisant ces rgles algbriques, on peut arriver simplifier une quation assez rapidement. On peut ainsi factoriser ou
dvelopper certaines expressions, comme on le ferait avec une quation normale, afin de simplifier notre quation logique. Le
tout est de bien faire ces simplifications en appliquant correctement ces rgles. Pour cela, il n'y a pas de recette miracle : vous
devez sortir votre cerveau, et rflchir !
Il existe d'autres mthodes pour simplifier nos circuits. Les plus connues tant les tableaux de Karnaugh et l'algorithme de
Quine Mc Cluskey. On ne parlera pas de ces mthodes, qui sont assez complexes et n'apporteraient rien dans ce tutoriel. Il faut
dire que ces mthodes risquent de ne pas vraiment nous servir : elles possdent quelques dfauts qui nous empchent de crer
de trs gros circuits avec. Pour le dire franchement, elles sont trop longues utiliser quand le nombre d'entre du circuit dpasse
5 ou 6.
Mais
Un des problmes des approches mentionnes plus haut est qu'elles ncessitent de crer une table de vrit. Et plus on a
d'entres, plus la table devient longue, et cela prend du temps pour la remplir. Cela ne pose aucun problmes pour crer des
circuits de moins de 5 ou 6 variables, mais au-del, il y a de quoi rendre les armes assez rapidement. Et si vous ne me croyez pas,
essayez de remplir la table de vrit d'un circuit qui additionne deux nombres de 32 bits, vous verrez : cela vous donnera une
table de vrit de 4 294 967 296 lignes. Je ne sais pas si quelqu'un a dj essay de crer une telle table et d'en dduire le circuit
correspondant, mais si c'est le cas, j'aurais de srieuses craintes sur sa sant mentale. Pour compenser, on doit donc ruser.
Pour cela, il n'y a qu'une seule solution : on doit dcouper notre circuit en circuits plus petits qu'on relie ensemble. Il suffit de
continuer ce dcoupage tant qu'on ne peut pas appliquer les techniques vues plus haut.
Circuits squentiels
Avec le premier chapitre, on sait coder de linformation. Avec le second chapitre et la partie sur les circuits combinatoires, on sait
traiter et manipuler de linformation. Il nous manque encore une chose : savoir comment faire pour mmoriser de l'information.
Les circuits combinatoires nont malheureusement pas cette possibilit et ne peuvent pas stocker de l'information pour l'utiliser
quand on en a besoin. La valeur de la sortie de ces circuits ne dpend que de l'entre, et pas de ce qui s'est pass auparavant :
les circuits combinatoires n'ont pas de mmoire. Ils ne peuvent qu'effectuer un traitement sur des donnes immdiatement
disponibles. On n'irait pas loin en se contentant de ce genre de circuits : il serait totalement impossible de crer un ordinateur.
www.openclassrooms.com
40/467
La transition effectue entre deux tats dpend souvent de ce qu'on met sur l'entre du circuit. Aussi bien l'tat du circuit (ce qu'il
a mmoris) que les valeurs prsentes sur ses entres, vont dterminer ce qu'on trouve sur la sortie. Par exemple, la valeur
prsente sur l'entre peut servir mettre jour l'tat ou donner un ordre au circuit pour lui dire : change d'tat de tel ou tel faon.
Dans la suite du tutoriel, vous verrez que certains composants de notre ordinateur fonctionnent sur ce principe : je pense
notamment au processeur, qui contient des mmoires internes dcrivant son tat (des registres), et que l'on fait changer d'tat via
des instructions fournies en entre.
Pour rendre possible les transitions, on doit mettre jour l'tat de notre circuit avec un circuit combinatoire qui dcide quel sera
le nouvel tat de notre circuit en fonction de l'ancien tat et des valeurs des entres. Un circuit squentiel peut donc (sans que
ce soit une obligation) tre dcoup en deux morceaux : une ou plusieurs mmoires qui stockent l'tat de notre circuit, et un ou
plusieurs circuits combinatoires chargs de mettre jour l'tat du circuit, et ventuellement sa sortie.
Pour la culture gnrale, il existe principalement deux types de circuits squentiels :
les automates de Moore ;
et les Automates de Mealy.
Automates de Moore
Avec les automates de Moore, ce qu'on trouve en sortie ne dpend que de l'tat de l'automate. On peut donc simplement placer
un circuit combinatoire qui se chargera de lire l'tat de l'automate et qui fournira un rsultat sur la sortie directement.
Pour mettre jour l'tat, on place un circuit combinatoire qui va prendre les entres du circuit, ainsi que l'tat actuel du circuit
(fourni sur la sortie), et qui dduira le nouvel tat, les nouvelles donnes mmoriser.
www.openclassrooms.com
41/467
Automates de Mealy
Autre forme de circuits squentiels : les automates de Mealy. Avec ceux-ci, la sortie dpend non seulement de l'tat du circuit,
mais aussi de ce qu'on trouve sur les entres.
Ces automates ont tendance utiliser moins de portes logiques que les automates de Moore.
Bascules
On a vu plus haut que la logique squentielle se base sur des circuits combinatoires, auxquels on a ajout des mmoires. Pour le
moment, on sait crer des circuits combinatoires, mais on ne sait pas faire des mmoires. Pourtant, on a dj tout ce qu'il faut :
avec nos portes logiques, on peut crer des circuits capables de mmoriser un bit. Ces circuits sont ce qu'on appelle des
bascules.
En assemblant plusieurs de ces bascules ensembles, on peut crer ce qu'on appelle des registres, des espces de mmoires
assez rapides qu'on retrouve un peu partout dans nos ordinateurs : presque tous les circuits prsents dans notre ordinateur
contiennent des registres, que ce soit le processeur, la mmoire, les priphriques, etc.
Principe
Une solution pour crer une bascule consiste boucler la sortie d'un circuit sur son entre, de faon ce que la sortie
rafrachisse le contenu de l'entre en permanence et que le tout forme une boucle qui s'auto-entretienne. Une bonne partie des
circuits squentiels contiennent des boucles quelque part, avec une entre relie sur une sortie. Ce qui est tout le contraire des
circuits combinatoires, qui ne contiennent jamais la moindre boucle !
Bien sur, cela ne marche pas avec tous les circuits : dans certains cas, cela ne marche pas, ou du moins cela ne suffit pas pour
mmoriser des informations. Par exemple, si je relie la sortie d'une porte NON son entre, le montage obtenu ne sera pas
capable de mmoriser quoique ce soit.
Et si on essayait avec deux portes NON ?
www.openclassrooms.com
42/467
Si on place l'entre de la premire porte NON zro, la sortie de celle-ci passera 1. Cette sortie sera relie l'entre de l'autre
porte NON , qui inversera ce 1, donnant un zro. Zro qui sera alors r-envoy sur l'entre initiale. L'ensemble sera stable : on
peut dconnecter l'entre du premier inverseur, celle-ci sera alors rafraichie en permanence par l'autre inverseur, avec sa valeur
prcdente. Le mme raisonnement fonctionne si on met un 1 en sortie.
Bascule RS NOR
Le seul problme, c'est qu'il faut bien mettre jour l'tat de ce bit de temps en temps. Il faut donc ruser. Pour mettre jour l'tat de
notre circuit, on va simplement rajouter une entre notre circuit qui servira le mettre jour, et remplacer notre porte NON par
une porte logique qui se comportera comme un inverseur dans certaines conditions. Le tout est de trouver une porte logique qui
inverse le bit venant de l'autre inverseur si l'autre entre est zro (ou 1, suivant la bascule). Des portes NOR font trs bien
l'affaire.
www.openclassrooms.com
43/467
On obtient alors ce qu'on appelle des bascules RS. Celles-ci sont des bascules qui comportent deux entres
sortie , sur laquelle on peut lire le bit stock.
et
, et une
Sortie Q
Interdit
Bascules RS NAND
On peut aussi utiliser des portes NAND pour crer une bascule.
www.openclassrooms.com
44/467
En utilisant des portes NAND, le circuit change un peu. Celles-ci sont des bascules qui comportent deux entres
sortie , sur laquelle on peut lire le bit stock.
et
, et une
Sortie Q
Interdit
Bascule D
Comme vous le voyez, notre bascule RS est un peu problmatique : il y a une combinaison d'entres pour laquelle on ne sait pas
ce que va faire notre circuit. On va devoir rsoudre ce lger dfaut.
Tout d'abord, il faut remarquer que la configuration problmatique survient quand on cherche mettre R et S 1 en mme temps.
Or, le bit R permet de mettre zro notre bascule, tandis que le bit S va la mettre 1. Pas tonnant que cela ne marche pas. Pour
rsoudre ce problme, il suffit simplement de remarquer que le bit R est cens tre l'exact oppos du bit S : quand on veut mettre
un bit 1, on ne le met pas zro, et rciproquement. Donc, on peut se contenter d'un bit, et ajouter une porte NON pour obtenir
l'autre bit.
Dans ce qui suit, on va choisir de garder le bit S. Pour une raison trs simple : en faisant cela, placer un 0 sur l'entre S fera
mmoriser un zro la bascule, tandis qu'y placer un 1 mmorisera un 1. En clair, l'entre S contiendra le bit mmoriser.
Image utilisateur
www.openclassrooms.com
45/467
Mais, il y a un petit problme. Si on regarde la table de vrit de ce nouveau circuit, on saperoit qu'il ne mmorise rien ! Si on
place un 1 sur l'entre R, la bascule sera mise 1, et si on met un zro, elle sera mise zro. Pour rgler ce petit problme, on va
rajouter une entre, qui permettra de dire notre bascule : ne prend pas en compte ce que tu trouve sur ton entre S. Cette
entre, on va l'appeler l'entre de validation d'criture. Elle servira autoriser l'criture dans la bascule.
Reste savoir quoi rajouter dans notre circuit pour ajouter cette entre. En rflchissant bien, on se souvient que notre bascule
RS effectuait une mmorisation quand ses bits R et S taient tous les deux 0. Ce qu'il faut rajouter, ce sont des portes, relies
ce qui tait autrefois les entres R et S, relies notre nouvelle entre. Il suffit que ces portes envoient un zro sur leur sortie
quand l'entre de validation d'criture est zro, et recopie son autre entre sur sa sortie dans le cas contraire. Ce qu'on vient de
dcrire est exactement le fonctionnement d'une porte ET. On obtient alors le circuit suivant.
Mmoires
A partir de ces petites mmoires de 1 bit, on peut crer des mmoires un peu plus consquentes. Grce cela, on saura
maintenant crer des circuits squentiels ! Pour commencer, il faut remarquer que la mmoire d'un circuit squentiel forme un tout
: on ne peut pas en modifier un morceau : lors d'une transition, c'est toute la mmoire de l'automate qui est modifi. Donc, on doit
faire en sorte que la mise de nos mmoire se fasse en mme temps. Rien de plus simple : il suffit de prendre plusieurs bascules D
pour crer notre mmoire, et de relier ensemble leurs entres de validation d'criture.
www.openclassrooms.com
46/467
C'est ainsi que son crer les mmoires qui sont internes nos circuits squentiels. Vous verrez que beaucoup des circuits d'un
ordinateur sont des circuits squentiels, et que ceux-ci contiennent toujours des petites mmoires, fabriques l'aide de
bascules. Ces petites mmoires, que l'on vient de crer, sont appeles des registres.
Temps de propagation
Tout circuit, quel qu'il soit, va mettre un petit peu de temps avant de ragir. Ce temps mit par le circuit pour s'apercevoir qu'il s'est
pass quelque chose sur son entre et modifier sa sortie en consquence s'appelle le temps de propagation. Pour faire simple,
c'est le temps que met un circuit faire ce qu'on lui demande. Pour en donner une dfinition plus complte, on peut dire que c'est
le temps entre le moment pendant lequel on modifie la tension sur une entre d'un circuit logique et le moment o cette
modification se rpercute sur les sorties.
Ce temps de propagation dpend fortement du circuit et peut dpendre de pas mal de paramtres. Mais il y a trois raisons
principales, qui sont l'origine de ce temps de propagation. Il va de soit que plus ce temps de propagation est lev, plus notre
circuit risque d'tre lent, et savoir sur quoi jouer pour le diminuer n'est pas un luxe. Voyons donc ce qu'il en est.
Critical Path
Le plus important de ces paramtres est ce qu'on appelle le Critical Path . Il s'agit du nombre maximal de portes logiques entre
une entre et une sortie de notre circuit.
Pour donner un exemple, nous allons prendre le schma suivant.
www.openclassrooms.com
47/467
Pour ce circuit, le Critical Path est le chemin dessin en rouge. En suivant ce chemin, on va traverser 3 portes logiques, contre
deux ou une dans les autres chemins. Pour information, tous les chemins possibles ne sont pas prsents sur le schma, mais
ceux qui ne sont pas reprsents passent par moins de 3 portes logiques.
De plus, on doit prciser que nos portes n'ont pas toute le mme temps de propagation : une porte NON aura tendance tre
plus rapide qu'une porte NAND, par exemple.
Fan Out
Autre facteur qui joue beaucoup sur ce temps de propagation : le nombre de composants relis sur la sortie d'une porte logique.
Plus on connecte de portes logiques sur un fil, plus il faudra du temps pour la tension l'entre de ces portes change pour
atteindre sa bonne valeur.
Wire Delay
Autre facteur qui joue dans le temps de propagation : le temps mis par notre tension pour se propager dans les "fils" et les
interconnexions qui relient les portes logiques entre elles. Ce temps dpend notamment de la rsistance (celle de la loi d'Ohm,
que vous avez surement dj vue il y a un moment) et de ce qu'on appelle la capacit des interconnexions. Ce temps perdu dans
les fils devient de plus en plus important au fil du temps, les transistors et portes logiques devenant de plus en plus rapides
force des les miniaturiser. Pour donner un exemple, sachez que si vous comptez crer des circuits travaillant sur des entres de
256 512 bits qui soient rapides, il vaut mieux modifier votre circuit de faon minimiser le temps perdu dans les interconnexions
au lieu de diminuer le Critical Path.
Circuits synchrones
Ce temps de propagation doit tre pris en compte quand on cre un circuit squentiel. Sans cela on ne sait pas quand mettre
jour la mmoire intgre dans notre circuit squentiel. Si on le fait trop tt, le circuit ne se comportera pas comme il faut : on peut
parfaitement sauter des tats. De plus, les diffrents circuits d'un ordinateur n'ont pas tous le mme temps de propagation, et
ceux-ci vont fonctionner des vitesses diffrentes. Si l'on ne fait rien, on peut se retrouver avec des dysfonctionnements : par
exemple, un composant lent peut donc rater deux ou trois ordres successifs envoyes par un composant un peu trop rapide.
Comment viter les ennuis dus l'existence de ce temps de propagation ?
Il existe diverses solutions. On peut notamment faire en sorte que les entres et le circuit combinatoire prvienne la mmoire
quand ils veulent la mettre jour. Quand l'entre et le circuit combinatoire sont prts, on autorise l'criture dans la mmoire. C'est
ce qui est fait dans les circuits asynchrones. Mais ce n'est pas cette solution qui est utilise dans nos ordinateur.
La majorit des circuits de nos ordinateur grent les temps de propagation diffremment. Ce sont ce qu'on appelle des circuits
synchrones. Pour simplifier, ces circuits vont mettre jour leurs mmoires intervalles rguliers. La dure entre deux mises jour
est constante et doit tre plus grande que le pire temps de propagation possible du circuit. Les concepteurs d'un circuit doivent
estimer le pire temps de propagation possible pour le circuit et ajouter une marge de suret.
L'horloge
Pour mettre jour nos circuits intervalles rguliers, ceux-ci sont commands par une tension qui varie de faon cyclique : le
signal d'horloge. Celle-ci passe de faon cyclique de 1 0. Cette tension effectue un cycle plusieurs fois par seconde. Le temps
que met la tension pour effectuer un cycle est ce qu'on appelle la priode. Le nombre de cycle, de priodes, en une seconde est
appel la frquence. Cette frquence se mesure dans une unit : le hertz.
www.openclassrooms.com
48/467
On voit sur ce schma que la tension ne peut pas varier instantanment : la tension met un certain temps pour passer de 0 1 et
de 1 0. On appelle cela un front. La passage de 0 1 est appel un front montant et le passage de 1 0 un front descendant.
Les circuits
Cette horloge est relie aux entres d'autorisation d'criture des bascules du circuit. Pour cela, on doit rajouter une entre sur
notre circuit, sur laquelle on enverra l'horloge.
En faisant cela, notre circuit logique va "lire" les entres et en dduire une sortie uniquement lorsqu'il voit un front montant (ou
descendant) sur son entre d'horloge ! Entre deux fronts montants (ou descendants), notre circuit est compltement autiste du
point de vue des entres : on peut faire varier autant de fois qu'on veut nos entres, il faudra attendre le prochain front montant
pour notre circuit ragisse.
Dans le cas o notre circuit est compos de plusieurs sous-circuits devant tre synchroniss via lhorloge, celle-ci est distribue
tous les sous-circuits travers un rseau de connections lectriques qu'on appelle l'arbre d'horloge.
Et dans nos PC ?
www.openclassrooms.com
49/467
Dans la pratique, une bonne partie des composants d'un ordinateur sont synchroniss par des horloges. Oui, j'ai bien dit DES
horloges. Par exemple, notre processeur fonctionne avec une horloge diffrente de l'horloge de la mmoire ! La prsence de
plusieurs horloges est justifie par un fait trs simple : certains composants informatiques sont plus lents que d'autres et ne sont
pas capables de fonctionner avec des horloges rapides. Par exemple, le processeur a souvent une horloge trs rapide compare
l'horloge des autres composants. Gnralement, plus un composant utilise une frquence leve, plus celui-ci est rapide. Cela
n'est toutefois pas un lment dterminant : un processeur de 4 gigahertz peut tre bien plus rapide qu'un processeur de 200
gigahertz, pour des raisons techniques qu'on verra plus tard dans ce tutoriel. De nos jours, c'est plus la faon dont notre
processeur va faire ses oprations qui sera dterminante : ne vous faites pas avoir par le Megahertz Myth !
En fait, il existe une horloge de base qui est "transforme" en plusieurs horloges dans notre ordinateur. On peut parfaitement
transformer un signal d'horloge en un autre, ayant une priode deux fois plus grande ou plus petite, grce des montages
lectroniques spcialiss. Cela peut se faire avec des composants appels des PLL ou encore avec des montages portes
logiques un peu particuliers, qu'on n'abordera pas ici.
Les premiers processeurs avaient une frquence assez faible et taient peu rapides. Au fil du temps, avec lamlioration des
mthodes de conception des processeurs, la frquence de ceux-ci a commence a augmenter. Ces processeurs sont devenus
plus rapides, plus efficaces. Pour donner un ordre de grandeur, le premier microprocesseur avait une frquence de 740 kilohertz
(740 000 hertz). De nos jours, les processeurs peuvent monter jusqu' plusieurs gigahertz : plusieurs milliards de fronts par
secondes !
Quoiqu'il en soit, cette monte en frquence est aujourd'hui termine : de nos jours, les concepteurs de
processeurs sont face un mur et ne peuvent plus trop augmenter la frquence de nos processeurs aussi simplement qu'avant.
Et pourquoi les concepteurs de processeurs ont-ils arrts d'augmenter la frquence de nos processeurs ?
Augmenter la frquence a tendance vraiment faire chauffer le processeur plus que de raison : difficile de monter en frquence
dans ces conditions. Une grande part de cette dissipation thermique a lieu dans l'arbre d'horloge : environ 20% 35%. Cela vient
du fait que les composants relis l'arbre horloge doivent continuer changer d'tat tant que l'horloge est prsente, et ce mme
quand ils sont inutiliss. C'est la premire limite la monte en puissance : la dissipation thermique est tellement importante
qu'elle limite grandement les amliorations possibles et la monte en frquence de nos processeurs.
Auparavant, un processeur tait refroidi par un simple radiateur. Aujourd'hui, on est oblig d'utiliser un radiateur et un
ventilateur, avec une pte thermique de qualit tellement nos processeurs chauffent. Pour limiter la catastrophe, tous les
fabricants de CPU cherchent au maximum diminuer la temprature de nos processeurs. Pour cela, ils ont invent diverses
techniques permettant de diminuer la consommation nergtique et la dissipation thermique d'un processeur. Mais ces
techniques ne suffisent plus dsormais. C'est ce qui est appel le Heat Wall .
Et voil, avec un cerveau en parfait tat de marche, et beaucoup de temps devant vous, vous pouvez construire n'importe quel
circuit imaginable et fabriquer un ordinateur. Du moins, en thorie : n'essayez pas chez vous.
Bon, blague part, avec ce
chapitre, vous avez tout de mme le niveau pour crer certains circuits prsents dans notre ordinateur comme l'ALU. Sympa, non
?
www.openclassrooms.com
50/467
Le codage
analogique
Le codage
numrique
Celui-ci utilise des nombres rels : il code linformation avec des grandeurs physiques (des trucs qu'on peut
mesurer par un nombre) comprises dans un intervalle.
Un codage analogique a une prcision thoriquement infinie : on peut par exemple utiliser toutes les valeurs
entre 0 et 5 pour coder une information. Celle-ci peut alors prendre une valeur comme 1 , 2.2345646, ou pire...
Celui-ci utilise uniquement des suites de symboles (qu'on peut assimiler des chiffres), assimilables des
nombres entiers pour coder les informations. Pour simplifier, le codage numrique va coder des informations
en utilisant des nombres entiers cods dans une base, qui peut tre 2, 3, 4, 16, etc. Les fameux symboles dont
je viens de parler sont simplement les chiffres de cette base.
Le codage numrique n'utilise qu'un nombre fini de valeurs, contrairement au codage analogique. Un code
numrique a une prcision fige et ne pourra pas prendre un grand nombre de valeurs (compar l'infini).
Cela donnera des valeurs du style : 0, 0.12 , 0.24 , 0.36, 0.48... jusqu' 2 volts.
Un calculateur analogique peut donc faire des calculs avec une prcision trs fine, et peut mme faire certains calculs avec une
prcision impossible atteindre avec un calculateur numrique : des drives, des intgrations, etc. Un calculateur numrique
peut bien sr effectuer des intgrations et drivations, mais ne donnera jamais un rsultat exact et se contentera de donner une
approximation du rsultat. Un calculateur analogique pourra donner un rsultat exact, du moins en thorie : un calculateur
analogique insensible aux perturbations extrieures et n'ayant aucune imperfection n'a pas encore t invent.
Pour les calculateurs numriques, les nombres manipuls sont cods par des suites de symboles (des "chiffres", si vous
prfrez), et un calculateur numrique ne fera que transformer des suites de symboles en d'autres suites de symboles. Vous
pouvez par exemple identifier chacun de ces symboles en un chiffre dans une base entire quelconque (pas forcment la base 10
ou 2).
Dans un ordinateur, les symboles utiliss ne peuvent prendre que deux valeurs : 0 ou 1. De tels symboles ne sont rien d'autre que
les fameux bits du chapitre prcdent, ce qui fait que notre ordinateur ne manipule donc que des bits : vous comprenez
maintenant l'utilit du premier chapitre.
L'immunit au bruit
www.openclassrooms.com
51/467
Vu ce qui a t dit prcdemment, nos calculateurs numriques ne semblent pas vraiment trs intressants. Et pourtant, la grande
majorit de nos composants et appareils lectroniques (dont nos ordinateurs) sont des machines numriques ! C'est du au fait
que les calculateurs analogiques ont un gros problme : ils ont une faible immunit au bruit.
Explication : un signal analogique peut facilement subir des perturbations qui vont changer sa valeur, de faon parfois assez
drastique. Autant vous dire que si une de ces perturbations un peu violente arrive, le rsultat qui arrive en sortie n'est vraiment
pas celui attendu. Si un systme est peu sensible ces perturbations, on dit qu'il a une meilleure immunit au bruit.
Un signal numrique n'a pas trop ce problme : les perturbations ou parasites vont moins perturber le signal numrique et vont
viter de trop modifier le signal original : l'erreur sera beaucoup plus faible qu'avec un signal analogique.
Mais pourquoi avoir choisi la base 2 dans nos ordinateurs ?
La question est parfaitement lgitime : on aurait tout aussi bien pu prendre la base 10 ou n'importe quelle autre base. Il aurait t
bien plus facile pour les humains qui doivent programmer ces machines d'utiliser la base 10. D'ailleurs, il existe de nombreuses
machines qui manipulent des donnes numriques en base 10, en base 3, etc. Et on a dj invent des ordinateurs qui comptaient
en base 3 : l'ordinateur SETUN, par exemple, fabriqu et conu pour l'universit de Moscou. Et rien nempche de crer des
ordinateurs qui compteraient en base 10, 16, ou tout autre base. Mais il y a plusieurs raisons qui font que le binaire a t choisi
comme base pour le codage de l'information dans un ordinateur.
La plus importante de toutes, c'est qu'une perturbation n'aura pas le mme effet sur un nombre cod en base 2 et sur un nombre
cod en base 10.
En effet, supposons que nous utilisions, par exemple, une tension comprise entre 0 et 9 volts, qui code un chiffre/symbole allant
de 0 9 (on utilise donc la base 10). Le moindre parasite peut changer la valeur du chiffre cod par cette tension.
Avec cette tension qui code seulement un 0 ou un 1 (de 0volts pour un 0 et 10 pour un 1), un parasite de 1 volt aura nettement
moins de chance de modifier la valeur du bit cod ainsi.
www.openclassrooms.com
52/467
Le parasite aura donc un effet nettement plus faible : la rsistance aux perturbations lectromagntiques extrieure est meilleure.
Architecture de base
Une fois notre information code, il faut ensuite pouvoir la manipuler et la stocker. Ce traitement de notre information peut tre
fait de diffrentes faons. Pour transformer cette information et en faire quelque chose, il va falloir effectuer une srie d'tapes. La
premire tape, c'est de coder cette information sous une forme utilisable. Mais a ne fait pas tout, il faut encore traiter cette
information.
I/O et traitement
Pour cela, on va donc devoir :
recevoir une information code par un nombre,
modifier ce nombre et effectuer des calculs avec (de faon en faire quelque chose),
envoyer le rsultat sur une sortie pour l'exploiter.
Toute machine traitant de l'information est donc compos par :
Une entre sur laquelle on envoie une information.
Une unit de traitement, qui va manipuler l'information une fois code et donner un rsultat cod sous la forme d'une
suite de symboles ou d'un nombre.
Une sortie, qui va prendre le rsultat et en faire quelque chose (crire sur une imprimante ou sur un moniteur, mettre du
son,...).
Notre ordinateur contient pas mal d'entres et de sorties. Par exemple, votre cran est une sortie : il reoit des informations, et les
www.openclassrooms.com
53/467
transforme en image affiche l'cran. On pourrait aussi citer des dispositifs comme des imprimantes, ou des haut-parleurs.
Comme entre, vous avez votre clavier, votre souris, pour ne citer qu'eux.
Automates
Cette unit de traitement peut trs bien consister en un vulgaire circuit combinatoire, ou tout autre mcanisme, sans mmoire.
Mais d'autres units de traitement ont une certaine capacit de mmorisation, comme les circuits squentiels. Tout systme dont
l'unit de traitement possde cette capacit de mmorisation, et fonctionne comme un circuit lectronique squentiel, est appel
un automate.
Principe
Celui-ci contiendra donc des mmoires internes en plus de lunit de traitement, qui reprsenteront l'tat de lautomate (les
informations qu'il a mmorises). Bien sr, cet tat peut tre mis jour, et on peut changer l'tat de notre automate pour modifier
ces informations, les manipuler, etc. Notre unit de traitement pourra donc manipuler directement le contenu de nos mmoires.
Notre automate passera donc d'tats en tats, via des suites d'tapes qui transformeront un tat en un autre : on modifiera les
informations contenues dans notre automate tapes par tapes jusqu' arriver au rsultat voulu. Ces changements d'tat sont
bien sur gouverns par l'unit de traitement.
Attention : ce schma est un schma de principe. Il existe des automates pour lesquels il n'y a pas de sparation nette entre
mmoire et circuits de traitement. Il est possible de crer des circuits dans lesquels la mmorisation des informations est
entremle avec les circuits chargs de traiter l'information. Toutefois, dans nos ordinateurs, les deux sont relativement bien
spars, mme si ce n'est pas totalement le cas. D'ailleurs, nos ordinateurs sont des automates spciaux, composs partir de
composants plus petits qui sont eux-mme des automates.
Pour information, on peut trs bien crer des automates avec un peu n'importe quoi. Du genre, des dispositifs hydrauliques, ou
lectriques, magntiques, voire air comprim. Pour citer un exemple, on peut citer le calculateur hydraulique MONIAC. Quant
nos ordinateurs, ils sont fabriqus avec des dispositifs lectroniques, comme des portes logiques ou des montages base de
transistors et de condensateurs. videment, il existe des automates numriques, et des automates analogiques, voire des
automates hybrides mlangeant des circuits analogiques et des circuits numriques.
Automate numrique
Dans un automate numrique (un ordinateur par exemple), linformation place sur l'entre est code sous la forme d'une suite de
symboles avant d'tre envoye l'unit de traitement ou en mmoire. Nos informations seront codes par des suites de
symboles, des nombres cods dans une certaine base, et seront stockes ainsi en mmoire. Les suites de symboles manipules
sont appeles des donnes. Dans nos ordinateurs, les symboles utiliss tant des zros et des uns, nos donnes sont donc de
simples suites de bits.
Reste que ces donnes seront manipules par notre automate, par son unit de traitement. Tout ce que peut faire la partie
traitement d'un automate numrique, c'est modifier l'tat de l'automate, savoir modifier le contenu des mmoires de l'automate.
Cela peut permettre de transformer une (ou plusieurs) donne en une (ou plusieurs) autre(s), ou de configurer l'automate pour
qu'il fonctionne correctement. Ces transformations lmentaires qui modifient l'tat de l'automate sont appeles des instructions.
Un automate numrique est donc une machine qui va simplement appliquer une suite d'instructions dans un ordre bien prcis sur
les donnes. Cest cette suite d'instructions qui va dfinir le traitement fait par notre automate numrique, et donc ce quoi il
www.openclassrooms.com
54/467
peut servir.
Programme
Dans certains automates, la suite d'instructions effectue est toujours la mme. Une fois conus, ceux-ci ne peuvent faire que ce
pourquoi ils ont t conus. Ils ne sont pas programmables. C'est notamment le cas pour les calculateurs analogiques : une fois
qu'on a cbl un automate analogique, il est impossible de lui faire faire autre chose que ce pour quoi il a t conu sans modifier
son cblage. A la rigueur, on peut le reconfigurer et faire varier certains paramtres via des interrupteurs ou des boutons, mais
cela sarrte l. D'autres automates numriques ont le mme problme : la suite d'instruction qu'ils excutent est impossible
changer sans modifier les circuits de l'automate lui-mme. Et cela pose un problme : chaque problme qu'on veut rsoudre en
utilisant un automate, on doit recrer un nouvel automate. Autant dire que a peut devenir assez embtant !
Mais il existe une solution : crer des automates dont on peut remplacer la suite d'instructions qu'ils effectuent par une autre
sans avoir modifier leur cblage. On peut donc faire ce que l'on veut de ces automates : ceux-ci sont rutilisables volont et il
est possible de modifier leur fonction du jour au lendemain et leur faire faire un traitement diffrent. On dit qu'ils sont
programmables. Ainsi, pour programmer notre ordinateur, il suffira de crer une suite d'instructions qui va faire ce que l'on
souhaite. Et c'est bien plus rapide que de crer un automate complet de zro. Cette suite d'instruction sera alors appele le
programme de l'automate.
La solution utilise pour rendre nos automates programmables consiste stocker le programme dans une mmoire, qui sera
modifiable loisir. C'est ainsi que notre ordinateur est rendu programmable : on peut parfaitement modifier le contenu de cette
mmoire (ou la changer, au pire), et donc changer le programme excut par notre ordinateur sans trop de problmes. Mine de
rien, cette ide d'automate stockant son programme en mmoire est ce qui a fait que linformatique est ce qu'elle est aujourdhui.
C'est la dfinition mme d'ordinateur : automate programmable qui stocke son programme dans sa mmoire.
Ordinateurs
Tous nos ordinateurs sont plus ou moins organiss sur un mme modle de base, une organisation commune. Notre ordinateur
est ainsi dcoup en composants bien distincts, qui ont chacun une utilit particulire. Dans ce dcoupage en composant, on
retrouve plus ou moins l'organisation qu'on a vue au-dessus, avec son entre, sa sortie, son unit de traitement, sa mmoire, etc.
Organisation
Notre ordinateur contient donc :
des entres et des sorties, pour communiquer avec l'extrieur ;
un truc qui va effectuer les instructions du programme : le processeur ;
un machin qui va conserver nos donnes et le programme : la mmoire ;
et enfin, de quoi faire communiquer le tout : le Bus.
Cela ressemble fortement l'organisation vue plus haut, avec son entre, sa sortie, son unit de traitement et sa mmoire. Rien
d'tonnant cela, notre ordinateur est un automate comme un autre, et il n'est pas tonnant qu'il reprenne une organisation
commune pas mal d'automates (mais pas tous : certains fusionnent la mmoire et l'unit de traitement dans un seul gros
circuit, ce que ne font pas nos ordinateurs). Rien nempche notre ordinateur (ou tout autre automate d'ailleurs) d'utiliser
plusieurs processeurs, plusieurs mmoires, plusieurs bus, plusieurs entres ou plusieurs sorties.
Priphriques
Cet ensemble de composants, ainsi que la faon dont ils communiquent entre eux est la structure minimum que tout ordinateur
possde, le minimum syndical. Tout ce qui n'appartient pas la liste du dessus est obligatoirement connect sur les ports
www.openclassrooms.com
55/467
d'entre-sortie et est appel priphrique. On peut donner comme exemple le clavier, la souris, l'cran, la carte son, etc.
Microcontroleurs
Parfois, on dcide de regrouper la mmoire, les bus, le CPU et les ports d'entre-sortie dans un seul botier, histoire de rassembler
tout cela dans un seul composant lectronique nomm microcontrleur. Dans certains cas, qui sont plus la rgle que l'exception,
certains priphriques sont carrment inclus dans le microcontrleur ! On peut ainsi trouver dans ces microcontrleurs, des
compteurs, des gnrateurs de signaux, des convertisseurs numriques-analogiques... On trouve des microcontrleurs dans les
disques durs, les baladeurs mp3, dans les automobiles, et tous les systmes embarqus en gnral. Nombreux sont les
priphriques ou les composants internes un ordinateur qui contiennent des microcontrleurs.
Maintenant qu'on connait un peu mieux l'organisation de base, voyons plus en dtail ces diffrents composants.
Mmoire
La mmoire est, je me rpte, le composant qui se chargera de stocker notre programme xecuter, ainsi que les donnes qu'il va
manipuler. Son rle est donc de retenir que des donnes ou des instructions stockes sous la forme de suites de bits, afin qu'on
puisse les rcuprer et les traiter.
ROM et RWM
Pour simplifier grandement, on peut grossirement classer nos mmoire en deux types : les Read Only Memory, et les Read
Write Memory.
Pour les mmoires ROM (les Read Only Memory), on ne peut pas modifier leur contenu. On peut rcuprer une donne ou une
instruction dans notre mmoire : on dit qu'on y accde en lecture. Mais on ne peut pas modifier les donnes qu'elles
contiennent. On utilise de telles mmoires pour stocker des programmes ou pour stocker des donnes qui ne peuvent pas varier.
Par exemple, votre ordinateur contient une mmoire ROM spciale qu'on appelle le BIOS, qui permet de dmarrer votre
ordinateur, le configurer l'allumage, et dmarrer votre systme d'exploitation.
Quand aux mmoire RWM (les Read Write Memory), on peut accder celle-ci en lecture, et donc rcuprer une donne stocke
en mmoire, mais on peut aussi y accder en criture : on stocke une donne dans la mmoire, ou on modifie une donne
existante. Ces mmoires RWM sont dj plus intressantes, et on peut les utiliser pour stocker des donnes. On va donc
forcment trouver au moins une mmoire RWM dans notre ordinateur.
Pour l'anecdote, il n'existe pas de Write Only Memory.
Adressage
Pour utiliser cette mmoire, le processeur va pouvoir rapatrier des donnes depuis celle-ci. Pour viter de semmler les pinceaux,
et confondre une donne avec une autre, le processeur va devoir utiliser un moyen pour retrouver une donne dans notre
mmoire. Il existe plusieurs solutions, mais une de ces solutions est utilise dans la grosse majorit des cas.
Dans la majorit des cas, notre mmoire est dcoupe en plusieurs cases mmoires, des blocs de mmoire qui contiennent
chacun un nombre fini et constant de bits. Chaque case mmoire se voit attribuer un nombre binaire unique, l'adresse, qui va
permettre de la slectionner et de l'identifier celle-ci parmi toutes les autres. En fait, on peut comparer une adresse un numro de
tlphone (ou une adresse d'appartement) : chacun de vos correspondants a un numro de tlphone et vous savez que pour
appeler telle personne, vous devez composer tel numro. Ben les adresses mmoires, c'est pareil !
Exemple : on demande notre mmoire de slectionner la case mmoire d'adresse 1002 et on rcupre son contenu (ici, 17).
www.openclassrooms.com
56/467
Il existe des mmoires qui ne fonctionnent pas sur ce principe, mais passons : ce sera pour la suite du tutoriel.
Anatomie
Une mmoire est un composant assez simple. Dans les grandes lignes, une mmoire est compose de deux trois grands circuits.
Le premier circuit contient toutes les cases mmoires : il s'agit du plan mmoire. C'est la mmoire proprement dite, l o sont
stockes les donnes/instructions. Il existe diffrentes faons pour concevoir des cases mmoires. Pour information, dans le
chapitre prcdent, on avait vu comment crer des registres partir de bascules D : on avait alors cre une case mmoire d'une
mmoire RWM.
Ces cases mmoires ne nous servent rien si l'on ne peut pas les slectionner. Heureusement, les mmoires actuelles sont
adressables, et on peut prciser quelle case mmoire lire ou crire en prcisant son adresse. Cette slection d'une case partie de
son adresse ne se fait pas toute seule : on a besoin de circuits supplmentaires pour grer l'adressage. Ce rle est assur par un
circuit spcialis qu'on appelle le contrleur mmoire.
Et enfin, on doit relier notre mmoire au reste de l'ordinateur via un bus. On a donc besoin de connexions avec le bus. Ces
connexions nous permettent aussi de savoir dans quel sens transfrer les donnes (pour une mmoire RWM).
www.openclassrooms.com
57/467
Bus de communication
Maintenant qu'on a une mmoire ainsi que nos entres-sorties, il va bien falloir que notre processeur puisse les utiliser. Pour
cela, le processeur est reli la mmoire ainsi qu'aux entres-sorties par un ou plusieurs bus. Ce bus n'est rien d'autre qu'un
ensemble de fils lectriques sur lesquels on envoie des zros ou des uns. Ce bus relie le processeur, la mmoire, les entres et les
sorties ; et leur permet dchanger des donnes ou des instructions.
Pour permettre au processeur (ou aux priphriques) de communiquer avec la mmoire, il y a trois prrequis que ce bus doit
respecter :
pouvoir slectionner la case mmoire (ou l'entre-sortie) dont on a besoin,
prciser la mmoire s'il s'agit d'une lecture ou d'une criture,
et enfin pouvoir transfrer la donne.
Pour cela, on doit donc avoir trois bus spcialiss, bien distincts, qu'on nommera le bus de commande, le bus d'adresse, et le bus
de donne. Ceux-ci relieront les diffrents composants comme indiqu dans le schma qui suit.
www.openclassrooms.com
58/467
Vous l'avez surement dj devin grce leur nom, mais je vais quand mme expliquer quoi servent ces diffrents bus.
Bus
Utilit
Bus
d'adresse
Le bus d'adresse permet au processeur de slectionner l'entre, la sortie ou la portion de mmoire avec qui il
veut changer des donnes.
Bus de
donne
Le bus de donne est un ensemble de fils par lequel s'changent les donnes (et parfois les instructions) entre
le processeur et le reste de la machine.
Bus de
commande
Ce bus de commande va permettre de grer l'intgralit des transferts entre la mmoire et le reste de
l'ordinateur. Il peut transfrer au moins un bit prcisant si on veut lire ou crire dans la mmoire.
Gnralement, on considre par convention que ce bit vaut :
1 si on veut faire une lecture,
0 si c'est pour une criture.
Processeur
C'est un composant qui va prendre en entre une ou plusieurs donnes et xecuter des instructions. Ces instructions peuvent
tre des additions, des multiplications, par exemple, mais qui peuvent aussi faire des choses un peu plus utiles. Ce processeur
est aussi appel Central Processing Unit , abrvi en CPU.
Un processeur ne peut qu'effectuer une suite d'instructions dans un ordre bien prcis. C'est cette proprit qui fait que notre
ordinateur est un automate particulier, programmable : on lui permet de faire des instructions indpendantes, et on peut organiser
ces instructions dans l'ordre que l'on souhaite : en clair, crer un programme. Pour vous donner une ide de ce que peut tre une
instruction, on va en citer quelques-unes.
Instructions arithmtiques
Les instructions les plus communes sont des instructions arithmtiques et logiques, qui font simplement des calculs sur des
nombres. On peut citer par exemple :
www.openclassrooms.com
59/467
ET logique entre deux nombres (consiste effectuer un ET entre les bits de mme rang de deux nombres) ;
OU logique entre deux nombres (consiste effectuer un OU entre les bits de mme rang de deux nombres) ;
NON logique : inverse tous les bits d'un nombre ;
XOR logique entre deux nombres (consiste effectuer un XOR entre les bits de mme rang de deux nombres) ;
addition de deux nombres;
multiplication ;
division ;
modulo ;
soustraction ;
...
Ces instructions sont des instructions dont le rsultat ne dpend que des donnes traiter. Elle sont gnralement prises en
charge par un circuit combinatoire indpendant, qui s'occupe exclusivement du calcul de ces instructions : l'unit de calcul.
Registres
Pour pouvoir fonctionner, tout processeur va devoir stocker un certain nombre dinformations ncessaires son fonctionnement
: il faut qu'il se souvienne quel instruction du programme il en est, qu'il connaisse la position en mmoire des donnes
manipuler, qu'il manipule certaines donnes, etc. Pour cela, il contient des registres. Ces registres sont de petites mmoires ultrarapides fabriques avec des bascules.
Ces registres peuvent servir plein de choses : stocker des donnes afin de les manipuler plus facilement, stocker l'adresse de la
prochaine instruction, stocker l'adresse d'une donne aller chercher en mmoire, etc. Bref, suivant le processeur, ces registres
peuvent servir tout et n'importe quoi.
www.openclassrooms.com
60/467
Program Counter
Il est vident que pour excuter une suite d'instructions dans le bon ordre, notre ordinateur doit savoir quelle est la prochaine
instruction excuter. Il faut donc que notre processeur se souvienne de cette information quelque part : notre processeur doit
donc contenir une mmoire qui stocke cette information. C'est le rle du registre d'adresse d'instruction, aussi appel Program
Counter.
Ce registre stocke l'adresse de la prochaine instruction excuter. Cette adresse permet de localiser l'instruction suivante en
mmoire. Cette adresse ne sort pas de nulle part : on peut la dduire de l'adresse de l'instruction en cours dexcution par divers
moyens plus ou moins simples qu'on verra dans la suite de ce tutoriel.
Ce calcul peut tre fait assez simplement. Gnralement, on profite du fait que ces instructions sont excutes dans un ordre bien
prcis, les unes aprs les autres. Sur la grosse majorit des ordinateur, celles-ci sont places les unes la suite des autres dans
l'ordre o elles doivent tre excutes. L'ordre en question est dcid par le programmeur. Un programme informatique n'est donc
qu'une vulgaire suite d'instructions stocke quelque part dans la mmoire de notre ordinateur.
Adresse
Instruction
...
...
5464
Instruction d'arrt
En faisant ainsi, on peut calculer facilement l'adresse de la prochaine instruction en ajoutant la longueur de l'instruction juste
charge (le nombre de case mmoire qu'elle occupe) au contenu du registre d'adresse d'instruction. Dans ce cas, l'adresse de la
prochaine instruction est calcule par un petit circuit combinatoire coupl notre registre d'adresse d'instruction, qu'on appelle
le compteur ordinal.
L'intrieur de notre processeur ressemble donc plus ce qui est indiqu dans le schma du dessous.
Mais certains processeurs n'utilisent pas cette mthode. Sur de tels processeurs, chaque instruction va devoir prciser quelle est
www.openclassrooms.com
61/467
la prochaine instruction. Pour ce faire, une partie de la suite de bit reprsentant notre instruction excuter va stocker cette
adresse. Dans ce cas, ces processeurs utilisent toujours un registre pour stocker cette adresse, mais ne possdent pas de
compteur ordinal, et n'ont pas besoin de calculer une adresse qui leur est fournie sur un plateau.
Prise de dcision
Notre processeur peut donc excuter des instructions les unes la suite des autres grce notre registre d'adresse d'instruction
(le Program Counter). C'est bien, mais on ne pas bien loin avec ce genre de choses. Il serait videmment mieux si notre
processeur pouvait faire des choses plus volues et s'il pouvait plus ou moins s'adapter aux circonstances au lieu de ragir
machinalement. Par exemple, on peut souhaiter que celui-ci n'excute une suite d'instructions que si une certaine condition est
remplie et ne lexcute pas sinon. Ou faire mieux : on peut demander notre ordinateur de rpter une suite d'instructions tant
qu'une condition bien dfinie est respecte.
Pour ce faire, on a cre des instructions un peu spciales, qui permettent de "sauter" directement une instruction dans notre
programme, et poursuivre l'excution partir de cette instruction. Cela permet au programme de passer directement une
instruction situe plus loin dans le droulement normal du programme, voir de revenir une instruction antrieure. Ces
instructions sont ce qu'on appelle des branchements.
Pour ce faire, elles modifient le contenu du registre d'adresse d'instruction, et y place l'adresse de l'instruction laquelle on veut
sauter. Ces instructions sont appeles des branchements. Elles sont trs utiles pour crer nos programmes informatiques, et il
serait vraiment difficle, voire impossible de vous passer d'elles. Tout programmeur utilise des branchements quand il programme :
il ne s'en rend pas compte, mais ces branchements sont souvent cachs derrire des fonctionnalits basiques de nos langages
de programmation usuels (les if, tests, boucles, et fonctions sont fabriques avec des branchements).
Squenceur
Quoiqu'il en soit, toutes nos instructions sont stockes en mmoire sous la forme de suites de bits. A telle instruction
correspondra telle suite de bit. Notre processeur devra donc dcider quoi faire de ces suites de bits, et les interprter, en dduire
quoi faire. Par exemple, est-ce que la suite de bit que je viens de lire me demande de charger une donne depuis la mmoire, estce qu'elle me demande de faire une instruction arithmtique, etc. Une fois cela fait, il faut ensuite aller configurer la mmoire pour
grer les instructions d'accs mmoire (lire la bonne adresse, prciser le sens de transferts, etc), ou commander l'unit de calcul
afin qu'elle fasse une addition et pas une multiplication, ou mettre jour le registre d'adresse d'instruction si c'est un
branchement, etc.
Pour ce faire, notre processeur va contenir un circuit squentiel spcial, qui dduit quoi faire de la suite d'instruction charge, et
qui commandera les circuits du processeur. Ce circuit spcialis s'appelle le squenceur.
www.openclassrooms.com
62/467
www.openclassrooms.com
63/467
La gestion de la mmoire
On a vu que notre programme tait stock dans la mmoire de notre ordinateur. Les instructions du programme excut par le
processeur sont donc stockes comme toutes les autres donnes : sous la forme de suites de bits dans notre mmoire, tout
comme les donnes qu'il va manipuler. Dans ces conditions, difficile de faire la diffrence entre donne et instruction. Mais
rassurez-vous : le processeur intgre souvent des fonctionnalits qui empchent de confondre une donne avec une instruction
quand il va chercher une information en mmoire.
Ces fonctionnalits ne sont pas totalement fiables, et il arrive assez rarement que le processeur puisse confondre une instruction
ou une donne, mais cela est rare. Cela peut mme tre un effet recherch : par exemple, on peut crer des programmes qui
modifient leurs propres instructions : cela s'appelle du self modifying code , ce qui se traduit par code automodifiant en franais.
Ce genre de choses servait autrefois crire certains programmes sur des ordinateurs rudimentaires (pour grer des tableaux et
autres fonctionnalits de base utilises par les programmeurs), pouvait aussi permettre de rendre nos programmes plus rapides,
servait compresser un programme, ou pire : permettait de cacher un programme et le rendre indtectable dans la mmoire (les
virus informatiques utilisent beaucoup de genre de procds). Mais passons !
Contenu
du bloc
Mmoire programme
Mmoire de travail
Il faut toutefois prciser que ce dcoupage en mmoire programme et mmoire de travail n'est pas une obligation. En effet,
certains ordinateurs s'en passent compltement : je pense notamment aux architectures dataflow, une classe dordinateur assez
spciale, qui ne sera pas traite dans ce tutoriel, mais qui est nanmoins abordes dans un article assez compliqu sur ce site.
Mais remettons cela plus tard, pour quand vous aurez un meilleur niveau.
Le processeur ne traitera pas de la mme faon les instructions en mmoire programme et les donnes prsentes en mmoire de
travail, afin de ne pas faire de confusions. Nos instructions sont en effet interprtes par le squenceur, tandis que nos donnes
sont manipules par l'unit de calcul. Et tout cela, c'est grce l'existence du Program Counter, le fameux registre d'adresse
d'instruction vu prcdemment. En regroupant nos instructions dans un seul bloc de mmoire, et en plaant nos instructions les
unes la suite des autres, on est sur que le registre d'adresse d'instruction passera d'une instruction l'autre en restant dans un
bloc de mmoire ne contenant que des instructions. Sauf s'il dborde de ce bloc, ou qu'un branchement renvoie notre processeur
n'importe o dans la mmoire, mais passons.
Quoiqu'il en soit, ce dcoupage entre mmoire programme et mmoire de travail est quelque chose d'assez abstrait qui peut tre
mis en pratique de diffrentes manires. Sur certains ordinateurs, on utilise deux mmoires spares : une pour le programme, et
une pour les donnes. Sur d'autres, on utilisera une seule mmoire, dont une portion stockera notre programme, et l'autre servira
de mmoire de travail. Il faut bien faire la diffrence entre le dcoupage de notre mmoire en mmoires de programmes et de
travail, purement "conceptuelles" ; et les diffrentes mmoires qu'on trouvera dans nos ordinateurs. Rassurez-vous, vous allez
comprendre en lisant la suite. Dans ce qui suit, on va voir comment des deux mmoires sont organises dans nos ordinateurs.
www.openclassrooms.com
64/467
Avec cette sparation dans deux mmoires spares, la mmoire programme est gnralement une mmoire de type ROM, c'est
dire accessible uniquement en lecture : on peut rcuprer les informations conserves dans la mmoire (on dit qu'on effectue une
lecture), mais on ne peut pas les modifier. Par contre, la mmoire travail est une mmoire RWM : on peut lire les informations
conserves, mais on peut aussi modifier les donnes qu'elle contient (criture). On peut ainsi effectuer de nombreuses
manipulations sur le contenu de cette mmoire : supprimer des donnes, en rajouter, les remplacer, les modifier, etc.
www.openclassrooms.com
65/467
Avantages
Inconvnients
Architecture Harvard
Permet de charger une instruction et une donne
simultanment : on charge la donne sur le bus qui relie
la mmoire de travail au processeur, et l'instruction sur le
bus qui relie processeur et mmoire programme. Les
deux bus tant spars, on peut le faire simultanment.
On se retrouve donc avec un gain de vitesse
Architecture modifie
Sur d'autres, on a besoin de modifier certains paramtres du programmes pour qu'il s'adapte certaines circonstances. Pour ce
faire, il faut donc modifier certaines parties de la mmoire programme. On ne peut donc stocker ces paramtres en ROM, et on
prfre plutt les stocker dans une RWM : la mmoire programme est donc compose d'une ROM et d'une partie de la RWM.
www.openclassrooms.com
66/467
Avec cette organisation, une partie ou la totalit du programme est stock dans une mmoire cense stocker des donnes. Rien
de choquant cela : programme et donnes sont tous les deux stocks sous la forme de suites de bits dans la mmoire. Rien
n'empche de copier l'intgralit du programme de la mmoire ROM vers la mmoire RWM, mais ce cas est assez rare.
www.openclassrooms.com
67/467
La mmoire de travail statique est une partie de la mmoire de travail dans laquelle on stocke des donnes dfinitivement. En
clair, on ne peut pas supprimer l'espace mmoire utilis par une donne dont on n'a plus besoin pour l'utiliser pour stocker une
autre donne. On peut donc lire ou modifier la valeur d'une donne, mais pas la supprimer. Et c'est pareil pour la mmoire
programme : on ne peut pas supprimer tout un morceau de programme en cours dexcution (sauf dans quelques cas particuliers
vraiment tordus).
A l'inverse, on peut utiliser le reste de la mmoire pour stocker temporairement des donnes et les effacer lorsqu'elles deviennent
inutiles. Cela permet de limiter l'utilisation de la mmoire. Cette partie de la mmoire utilisable au besoin peut tre utilise de deux
faon :
Soit avec une pile
Soit avec un tas.
La diffrence principale entre le tas et la pile est la faon dont sont organises les donnes dedans. Une autre diffrence est leur
utilisation : le tas est intgralement gr par le logiciel (par le programme en cours dexcution et ventuellement le systme
d'exploitation), tandis que la pile est en partie, voire totalement, gre par le matriel de notre ordinateur. Dans ce qui va suivre,
on va parler de la pile. Pourquoi ? Et bien parce que celle-ci est en partie gre par notre matriel, et que certains processeurs
l'utilisent abondamment. Il existe mme des processeurs qui utilisent systmatiquement cette pile pour stocker les donnes que
notre processeur doit manipuler. Ces processeurs sont appels des machines pile, ou stack machines.
La pile
Comme je l'ai dit plus haut, la pile est une partie de la mmoire de travail. Mais cette portion de la RAM a une particularit : on
stocke les donnes l'intrieur d'une certaine faon. Les donnes sont regroupes dans la pile dans ce qu'on appelle des stack
frame ou cadres de pile. Ces stack frames regroupent plusieurs cases mmoires contigus (places les unes la suite des
autres). On peut voir ces stack frames comme des espces de blocs de mmoire.
www.openclassrooms.com
68/467
Sur les stack machines, ces stack frames stockent gnralement un nombre entier, des adresses, des caractres, ou un nombre
flottant ; mais ne contiennent gure plus. Mais sur d'autres processeurs un peu plus volus, on utilise la pile pour stocker autre
chose, et il est alors ncessaire d'avoir des stack frame pouvant stocker des donnes plus volues, voire stocker plusieurs
donnes htrognes dans une seule stack frame. Ce genre de choses est ncessaire pour implmenter certaines fonctionnalits
de certains langages de haut niveau.
www.openclassrooms.com
69/467
Machines pile
Les machines pile, aussi appeles stack machines en anglais, utilisent la pile pour stocker les donnes manipules par leurs
instructions. Sur ces machines, les cadres de pile ne peuvent contenir que des donnes simples. Par donnes simples, il faut
comprendre donnes manipulables de base par le processeur, comme des nombres, ou des caractres. Leur taille est donc facile
dterminer : elle est de la taille de la donne manipuler.
Exemple avec des entiers de 4 octets.
Ces machines ont besoin d'un registre pour fonctionner : il faut bien stocker l'adresse du sommet de la pile. Je vous prsente
donc le Stack Pointer, qui n'est autre que ce fameux registre qui stocke l'adresse du sommet de la pile. Ce registre seul suffit :
nos cadres de pile ayant une taille bien prcise, on peut se passer de registre pour stocker leur taille ou leur adresse de dbut/fin
www.openclassrooms.com
70/467
en se dbrouillant bien.
Sur certaines machines pile trs simples, la pile n'est pas tout fait stocke dans une portion de la mmoire : elle est stocke
directement dans le processeur. Le processeur contient ainsi un grand nombre de registres, qui seront utiliss comme une pile.
Ces registres tant plus rapides que la mmoire principale de l'ordinateur, les oprations manipulant uniquement la pile et ne
devant pas manipuler la mmoire seront donc beaucoup plus rapides (les autres instructions tant aussi acclres, mais moins).
Push Et Pop
Bien videmment, les donnes traiter ne s'empilent pas toutes seules au sommet de la pile. Pour empiler une donne au sommet
de la pile, notre processeur fourni une instruction spcialement ddie. Cette instruction s'appelle souvent Push. Elle permet de
copier une donne vers le sommet de la pile. Cette donne peut tre aussi bien dans la mmoire statique que dans le tas, peu
importe. Cette instruction va prendre l'adresse de la donne empiler, et va la stocker sur la pile. Bien videmment, le contenu du
Stack Pointer doit tre mis jour : on doit additionner (ou soustraire, si on fait partir la pile de la fin de la mmoire) la taille de la
donne qu'on vient d'empiler.
Bien videmment, on peut aussi ranger la donne lace au sommet de la pile dans la mmoire, une certaine adresse. Dans ce
cas, on utilise l'instruction Pop, qui dpile la donne au sommet de la pile et la stocke l'adresse indique dans l'instruction.
Encore une fois, le Stack Pointer est mis jour lors de cette opration, en soustrayant (ou additionnant si on fait partir la pile de
la fin de la mmoire) la taille de la donne qu'on vient d'enlever de la pile.
www.openclassrooms.com
71/467
Pour faciliter la vie des programmeurs, le processeur peut aussi fournir d'autres instructions qui peuvent permettre de manipuler
la pile ou de modifier son organisation. On peut par exemple citer l'instruction swap, qui change deux donnes dans la pile.
www.openclassrooms.com
72/467
Avantages et dsavantages
Avec une telle architecture, les programmes utilisent peu de mmoire. Les instructions sont trs petites : on n'a pas besoin
d'utiliser de bits pour indiquer la localisation des donnes dans la mmoire, sauf pour Pop et Push. Vu que les programmes
cres pour les machines pile sont souvent trs petits, on dit que la code density (la densit du code) est bonne. Les machines
pile furent les premires tre inventes et utilises : dans les dbuts de linformatique, la mmoire tait rare et chre, et
l'conomiser tait important. Ces machines pile permettaient d'conomiser de la mmoire facilement, et taient donc bien vues.
Ces machines n'ont pas besoin d'utiliser beaucoup de registres pour stocker leur tat : un Stack Pointer et un Program Counter
suffisent. A peine deux registres (avec ventuellement d'autres registres supplmentaires pour faciliter la conception du
processeur).
Par contre, une bonne partie des instructions de notre programmes seront des instructions Pop et Push qui ne servent qu'
dplacer des donnes dans la mmoire de notre ordinateur. Une bonne partie des instructions ne sert donc qu' manipuler la
mmoire, et pas faire des calculs. Sans compter que notre programme comprendra beaucoup d'instructions compar aux autres
types de processeurs.
www.openclassrooms.com
73/467
passons : ces architectures sont un peu compliques, alors autant les passer sur le tapis pour le moment.
Machines registres
Certaines machines accs alatoire assez anciennes ne faisaient que manipuler la mmoire RAM. Les fameuses rfrences
mentionnes plus haut taient donc des adresses mmoires, qui permettaient de prciser la localisation de la donne manipuler
dans la mmoire principale (la ROM ou la RWM). Pour diminuer encore plus les accs cette mmoire, les concepteurs
d'ordinateurs ont invents les machines registres.
Ces machines peuvent stocker des donnes dans des registres intgrs dans le processeur, au lieu de devoir travailler en
mmoire. Pour simplifier, ces registres stockent des donnes comme la pile le faisait sur les machines pile. Ces registres vont
remplacer la pile, mais d'une manire un peu plus souple : on peut accder chacun de ces registres individuellement, alors qu'on
ne pouvait quaccder une seule donne avec la pile (celle qui tait au sommet de la pile).
Reste savoir comment charger nos donnes manipuler dans ces registres. Aprs tout, pour la pile, on disposait des
instructions Push et Pop, qui permettaient d'changer des donnes entre la pile et la mmoire statique. Sur certains
processeurs, on utilise une instruction tout faire : le mov. Sur d'autres, on utilise des instructions spares suivant le sens de
transfert et la localisation des donnes (dans un registre ou dans la mmoire). Par exemple, on peut avoir des instructions
diffrentes selon qu'on veuille copier une donne prsente en mmoire dans un registre, copier le contenu d'un registre dans un
autre, copier le contenu d'un registre dans la mmoire RAM, etc.
Avantages et inconvnients
L'utilisation de registres est plus souple que l'utilisation d'une pile. Par exemple, une fois qu'une donne est charge dans un
registre, on peut la rutiliser autant de fois qu'on veut tant qu'on ne l'a pas efface. Avec une pile, cette donne aurait
automatiquement efface, dpile, aprs utilisation : on aurait du la recharger plusieurs fois de suite. De manire gnrale, le
nombre total d'accs la mmoire diminue fortement compar aux machines pile.
Et on retrouve les mmes avantages pour les machines accs alatoires n'ayant pas de registres, mme si c'est dans une
moindre mesure. Il faut dire que nos registres sont souvent des mmoires trs rapides, bien plus rapides que la mmoire
principale. Utiliser des registres est donc une bonne manire de gagner en performances. C'est pour ces raisons que nos
ordinateurs actuels sont souvent des machines accs alatoires utilisant des registres.
Le seul problme, c'est qu'il faut bien faire de la place pour stocker les rfrences. Comme je l'ai dit, ces rfrences sont places
dans les instructions : elles doivent prciser o sont stockes les donnes manipuler. Et cela prend de la place : des bits sont
utiliss pour ces rfrences. La code density est donc moins bonne. De nos jours, cela ne pose pas vraiment de problmes : la
taille des programmes n'est pas vraiment un sujet de proccupation majeur, et on peut s'en accommoder facilement.
Les hybrides
De nos jours, on pourrait croire que les machines accs alatoire l'ont emport. Mais la ralit est plus complexe que : nos
ordinateurs actuels sont certes des machines accs alatoire, mais ils possdent de quoi grer une pile. Le seul truc, c'est que
cette pile n'est pas une pile simple comme celle qui est utilise sur une machine pile : la pile de nos ordinateurs utilise des
cadres de pile de taille variable. On peut ainsi mettre ce qu'on veut dans ces cadres de pile, et y mlanger des tas de donnes
htrognes.
www.openclassrooms.com
74/467
Pour localiser une donne dans cette Stack Frame, il suffit de la reprer en utilisant un dcalage par rapport au dbut ou la fin de
celle-ci. Ainsi, on pourra dire : la donne que je veux manipuler est place 8 adresses aprs le dbut de la Stack Frame, ou 16
adresses aprs la fin de celle-ci. On peut donc calculer l'adresse de la donne manipuler en additionnant ce dcalage avec le
contenu du Stack Pointer ou du Frame Pointer. Une fois cette adresse connue, nos instructions vont pouvoir manipuler notre
donne en fournissant comme rfrence cette fameuse adresse calcule.
Utiliser des piles aussi compliques a une utilit : sans cela, certaines fonctionnalits de nos langages de programmation actuels
n'existeraient pas ! Pour les connaisseurs, cela signifierait qu'on ne pourrait pas utiliser de fonctions rentrantes ou de fonctions
rcursives. Mais je n'en dis pas plus : vous verrez ce que cela veut dire d'ici quelques chapitres.
Bon, c'est bien beau, mais ces cadres de pile de taille variables, on les dlimite comment ?
Pour cela, on a besoin de sauvegarder deux choses : l'adresse laquelle commence notre Stack Frame en mmoire, et de quoi
connaitre l'adresse de fin. Et il existe diverses faons de faire.
Frame Pointer
Pour ce faire, on peut rajouter un registre en plus du Stack Pointer, afin de pouvoir grer ces cadres de pile. Ce registre s'appelle
le Frame Pointer, et sert souvent dire quelle adresse commence (ou termine, si on fait grandir notre pile de la fin de la
mmoire) la Stack Frame qui est au sommet de la pile. La cration d'une Stack Frame se base sur des manipulations de ces deux
registres: le Stack Pointer, et le Frame Pointer.
www.openclassrooms.com
75/467
Certains processeurs possdent un registre spcialis qui sert de Frame Pointer uniquement : on ne peut pas l'utiliser pour autre
chose. Si ce n'est pas le cas, on est oblig de stocker ces informations dans deux registres normaux, et se dbrouiller avec les
registres restants.
www.openclassrooms.com
76/467
Instructions
Pour rappel, le rle d'un processeur est dexcuter des programmes. Un programme informatique est une suite d'instructions
excuter dans l'ordre. Celles-ci sont places dans la mmoire programme les unes la suite des autres dans l'ordre dans lequel
elles doivent tre excutes.
Utilit
Ces instructions font simplement des calculs sur des nombres. On peut citer par exemple :
Les
instructions
arithmtiques
L'addition ;
la multiplication ;
la division ;
le modulo ;
la soustraction ;
la racine carre ;
le cosinus ;
et parfois d'autres.
Les
instructions
logiques
Les
instructions
Le ET logique.
Le OU logique.
Le XOR.
Le NON , qui inverse tous les bits d'un nombre : les 1 deviennent des 0 et les 0 deviennent des 1.
Pour rappel, cela permet de calculer le complment 1 d'un nombre (rappelez-vous le chapitre sur
le binaire)
Les instructions de dcalage droite et gauche, qui vont dcaler tous les bits d'un nombre d'un
cran vers la gauche ou la droite. Les bits qui sortent du nombre sont considrs comme perdus.
Les instructions de rotation, qui font la mme chose que les instructions de dcalage, la
diffrence prs que les bits qui "sortent d'un ct du nombre" aprs le dcalage rentrent de
l'autre.
Certains processeurs intgrent des instructions capables de manipuler ces chaines de caractres
www.openclassrooms.com
instructions
de
manipulation
de chaines de
caractres
Les
instructions
de test
77/467
Les
instructions
de contrle
Elles permettent de contrler la faon dont notre programme sexcute sur notre ordinateur. Elle
permettent notamment de choisir la prochaine instruction excuter, histoire de rpter des suites
d'instructions, de ne pas excuter des blocs d'instructions dans certains cas, et bien d'autres choses.
Les
instructions
daccs
mmoire
Elles permettent d'changer des donnes entre le processeur et la mmoire, ou encore permettent de grer
la mmoire et son adressage.
Les
instructions
de gestion de
l'nergie
Il existe une grande quantit d'autres instructions, qui sont fournies par certains processeurs pour des
besoins spcifiques.
Les
inclassables
Ainsi, certains processeurs ont des instructions spcialement adapts aux besoins des OS
modernes.
Il arrive aussi qu'on puisse trouver des instructions qui permettent des programmes de partager
des donnes, d'changer des informations (via Message Passing ), etc. etc.
On peut aussi trouver des instructions spcialises dans les calculs cryptographiques : certaines
instructions permettent de chiffrer ou de dchiffrer des donnes de taille fixe.
De mme, certains processeurs ont une instruction permettant de gnrer des nombres alatoires.
Certains processeurs sont aussi capables d'effectuer des instructions sur des structures de
donnes assez complexes, comme des listes chaines ou des arbres.
Et on peut trouver bien d'autres exemples...
Ces types d'instructions ne sont pas les seuls : on peut parfaitement trouver d'autres instructions diffrentes, pour faciliter la
cration de systmes d'exploitation, pour manipuler des structures de donnes plus complexes comme des arbres ou des
matrices, etc.
www.openclassrooms.com
78/467
se retrouver avec d'autres cas de ce genre, pour lequel le "type" de la donne sur laquelle on va instructionner est important.
Dans ce cas, le processeur dispose souvent d'une instruction par type manipuler. On se retrouve donc avec des instructions
diffrentes pour effectuer la mme opration mathmatique, chacune de ces instructions tant adapte une reprsentation
particulire : on peut avoir une instruction de multiplication pour les flottants, une autre pour les entiers cods en complment
un, une autre pour les entiers cods en Binary Coded Decimal , etc.
Sur d'anciennes machines, on stockait le type de la donne (est-ce un flottant, un entier cod en BCD, etc...) dans la mmoire.
Chaque nombre, chaque donne naturellement manipule par le processeur incorporait un tag , une petite suite de bit qui
permettait de prciser son type. Le processeur ne possdait pas d'instruction en plusieurs exemplaires pour faire la mme chose,
et utilisait le tag pour dduire quoi faire comme manipulation sur notre donne.
Par exemple, ces processeurs n'avaient qu'une seule instruction d'addition, qui pouvait traiter indiffremment flottants, nombres
entiers cods en BCD, en complment deux, etc. Le traitement effectu par cette instruction dpendait du tag incorpor dans la
donne. Des processeurs de ce type s'appellent des Tagged Architectures. De nos jours, ces processeurs n'existent plus que
dans quelques musums : ils ont faits leur temps, laissons-les reposer en paix.
Jeux d'instruction
Au fait, on va mettre les choses au clair tout de suite : certains processeurs peuvent faire des instructions que d'autres ne
peuvent pas faire. Ainsi, les instructions excutables par un processeur dpendent fortement du processeur utilis. La liste de
toute les instructions qu'un processeur peut excuter s'appelle son jeu d'instruction. Ce jeu d'instruction va dfinir quelles sont
les instructions supportes, ainsi que les suites de bits correspondant chaque instruction.
RISC vs CISC
Il existe diffrents jeux d'instructions : le X86 , le PPC, etc. Et tout ces jeux d'instructions ont leurs particularits. Pour s'y
retrouver, on a grossirement class ces jeux d'instructions en plusieurs catgories. La premire classification se base sur le
nombre d'instructions et classe nos processeurs en deux catgories :
les RISC (reduced instruction set computer) qui peuvent excuter trs peu d'instructions ;
et les CISC (complex instruction set computer) avec pleins d'instructions.
CISC
CISC est l'acronyme de Complex Instruction Set Computer . Traduit de l'anglais cela signifie Ordinateur jeu d'instruction
complexe. Les processeurs CISC ont un jeu d'instruction toff, avec beaucoup d'instructions. De plus, certaines de ces
instructions sont assez complexes et permettent de faire des oprations assez volues.
Par exemple, ces processeurs peuvent :
calculer des fonctions mathmatiques compliques comme des sinus, cosinus, logarithmes, etc ;
ont des instructions pour traiter du texte directement ;
peuvent grer des structures de donnes complexes, comme des tableaux ;
etc.
Ces jeux d'instructions sont les plus anciens : ils taient la mode jusqu' la fin des annes 1980. A cette poque, on programmait
rarement avec des langages de haut niveau et beaucoup de programmeurs devaient utiliser l'assembleur. Avoir un jeu
d'instruction complexe, avec des instructions de "haut niveau" qu'on ne devait pas refaire partir d'instructions plus simples,
tait un gros avantage : cela facilitait la vie des programmeurs.
www.openclassrooms.com
79/467
Cette complexit des jeux d'instructions n'a pas que des avantages "humains", mais a aussi quelques avantages techniques. Il
n'est pas rare qu'une grosse instruction complexe puisse remplacer une suite d'instructions plus lmentaires.
Cela a quelques effets plutt bnfiques :
une grosse instruction lente peut tre plus rapide excuter que plusieurs instructions rapides ;
un programme crit pour un processeur CISC comportera moins d'instructions.
Vu qu'un programme crit pour des processeurs CISC utilise moins d'instructions, il prendra donc moins de place en mmoire
programme. A l'poque des processeurs CISC, la mmoire tait rare et chre, ce qui faisait que les ordinateurs n'avaient pas
plusieurs gigaoctets de mmoire : conomiser celle-ci tait crucial.
Mais ces avantages ne sont pas sans contreparties :
on a besoin de beaucoup de circuits pour cbler toutes ces instructions ;
ces circuits ont tendance chauffer ;
ces circuits consomment de l'nergie ;
le processeur est plus compliqu concevoir ;
etc.
www.openclassrooms.com
80/467
RISC ou l'inverse : chacun a des avantages et des inconvnients, qui rendent le RISC/CISC adapt ou pas selon la situation.
Par exemple, on mettra souvent un processeur RISC dans un systme embarqu, devant consommer trs peu. Par contre, le CISC
semble mieux adapt dans certaines conditions, en raison de la taille plus faible des programmes, ou quand les programmes
peuvent faire un bon usage des instructions complexes du processeur.
Au final, tout dpend d'un tas de paramtres :
suivant les besoins du programme excuter ;
le langage de programmation utilis ;
la qualit du compilateur ;
la faon dont est conue le processeur ;
les instructions disponibles ;
les spcificits du jeu d'instruction ;
l'age du capitaine.
Tout ces paramtres jouent beaucoup dans la faon dont on pourra tirer au mieux parti d'un processeur RISC ou CISC, et ils sont
bien plus importants que le fait que le processeur soit un RISC ou un CISC.
De plus, de nos jours, les diffrences entre CISC et RISC commencent s'estomper. Les processeurs actuels sont de plus en plus
difficiles ranger dans des catgories prcises. Les processeurs actuels sont conus d'une faon plus pragmatiques : au lieu de
respecter la lettre les principes du RISC et du CISC, on prfre intgrer les techniques et instructions qui fonctionnent, peut
importe qu'elles viennent de processeurs purement RISC ou CISC. Les anciens processeurs RISC se sont ainsi garnis
d'instructions et techniques de plus en plus complexes et les processeurs CISC ont intgr des techniques provenant des
processeurs RISC (pipeline, etc). Au final, cette guerre RISC ou CISC n'a plus vraiment de sens de nos jours.
Les DSP
Parmi ces jeux d'instructions spcialiss, on peut citer les fameux jeux d'instructions Digital Signal Processor , aussi appels des
DSP. Ces DSP sont des processeurs chargs de faire des calculs sur de la vido, du son, ou tout autre signal. Ds que vous avez
besoin de traiter du son ou de la vido, vous avez un DSP quelque part, que ce soit une carte son ou une platine DVD.
Ces DSP ont souvent un jeu d'instruction similaire aux jeux d'instructions RISC, avec peu d'instructions, toutes spcialises pour
faire du traitement de signal. On peut par exemple citer l'instruction phare de ces DSP, l'instruction MAD (qui multiplie deux
nombres et additionne un 3me au rsultat de la multiplication). De nombreux algorithmes de traitement du signal (filtres FIR,
transformes de Fourier) utilisent massivement cette opration. Ces DSP possdent aussi des instructions permettant de faire
rpter rapidement une suite d'instruction (pour les connaisseurs, ces instructions permettent de crer des boucles), ou des
instructions capables de traiter plusieurs donnes en parallle (en mme temps).
Ces instructions manipulent le plus souvent des nombres entiers, et parfois (plus rarement) des nombres flottants. Ceci dit, ces
DSP utilisent souvent des nombres flottants assez particuliers qui n'ont rien voir avec les nombres flottants que l'on a vu dans
le premier chapitre. Il supportent aussi des formats de nombre entiers assez exotiques, mme si c'est assez rare.
Ces DSP ont souvent une architecture de type Harvard. Pour rappel, cela signifie qu'ils sont connects deux bus de donnes :
un pour les instructions du programme, et un autre reli la mmoire de travail, pour les donnes. Certains DSP vont mme plus
loin : ils sont relis plusieurs bus mmoire. Au bout de ces bus mmoire, on retrouve souvent plusieurs mmoires spares.
Nos DSP sont donc capables de lire et/ou d'crire plusieurs donnes simultanment : une par bus mmoire reli au DSP.
Il y a pire
On peut aussi citer les jeux d'instructions de certains processeurs particulirement adapts un systme d'exploitation en
particulier. Un exemple serait les processeurs multics, spcialement ddis au systme d'exploitation du mme nom. Il faut avouer
que ces processeurs sont assez rares et ddis des marchs de niche.
Dans le mme genre, certains processeurs sont spcialement conus pour un langage en particulier. Il existe ainsi des
processeurs possdant des instructions permettant dacclrer le traitement des oprations de base fournies par un langage de
www.openclassrooms.com
81/467
programmation, ou encore d'implmenter celle-ci directement dans le jeu d'instruction du processeur, transformant ainsi ce
langage de haut niveau en assembleur. On appelle de tels processeurs, des processeurs ddis.
Historiquement, les premiers processeurs de ce type taient des processeurs ddis au langage LISP, un vieux langage
fonctionnel autrefois utilis, mais aujourd'hui peu usit. De tels processeurs datent des annes 1970 et taient utiliss dans ce
qu'on appelait des machines LISP. Ces machines LISP taient capables dexcuter certaines fonctions de base du langage
directement dans leur circuits : elles possdaient notamment un garbage collector cbl dans ses circuits ainsi que des
instructions machines supportant un typage dtermin lexcution. D'autres langages fonctionnels ont aussi eu droit leurs
processeurs ddis : le prolog en est un bel exemple.
Autre langage qui a eu l'honneur d'avoir ses propres processeurs ddis : le FORTH, un des premiers langages pile de haut
niveau. Ce langage possde de nombreuses implmentations hardware et est un des rares langages de haut niveau avoir t
directement cbl en assembleur sur certains processeurs. Par exemple, on peut citer le processeur FC16, capable dexcuter
nativement du FORTH.
En regardant dans les langages de programmation un peu plus connus, on peut aussi citer des processeurs spcialiss pour
JAVA, qui intgrent une machine virtuelle JAVA directement dans leurs circuits : de quoi excuter nativement du bytecode !
Certains processeurs ARM, qu'on trouve dans des systme embarqus, sont de ce type.
Registres architecturaux
Nos instructions manipulent donc des donnes, qui sont forcment stockes quelques part dans la mmoire de notre ordinateur.
En plus d'avoir accs aux donnes places dans la mmoire RAM, le processeur possde plusieurs mmoires internes trs
rapides qui peuvent stocker trs peu de donnes : des registres. Ces registres servent stocker temporairement des
informations dont le processeur peut avoir besoin, aussi bien instructions, adresses ou donnes. Il s'agit bien des registres vus
dans les chapitres prcdents, fabriqus avec des bascules.
Mais pourquoi utiliser des registres pour stocker des donnes alors que l'on a dj une mmoire RAM ?
C'est trs simple : la mmoire RAM est une mmoire assez lente, et y accder en permanence rendrait notre ordinateur vraiment
trop lent pour tre utilisable. Par contre, les registres sont des mmoires vraiment trs rapides. En stockant temporairement des
donnes dans ces registres, le processeur pourra alors manipuler celle-ci trs rapidement, sans avoir attendre une mmoire
RAM la lenteur pachydermique. Typiquement, ds qu'une donne doit tre lue ou modifie plusieurs fois de suite, on a tout
gagner la mettre dans un registre.
Registres spcialiss
Certains processeurs disposent de registres spcialiss, qui ont une utilit bien prcise. Leur fonction est ainsi prdtermine
une bonne fois pour toute. Le contenu de nos registres est aussi fix une bonne fois pour toute : un registre est conu pour
stocker soit des nombres entiers, des flottants, des adresses, etc; mais pas autre chose. Pour donner quelques exemples, voici
quelques registres spcialiss qu'on peut trouver sur pas mal de processeurs.
Registre
Utilit
www.openclassrooms.com
82/467
Pour rappel, un processeur doit effectuer une suite d'instructions dans un ordre bien prcis. Dans ces
conditions, il est vident que notre processeur doit se souvenir o il est dans le programme, quelle est
la prochaine instruction excuter : notre processeur doit donc contenir une mmoire qui stocke cette
information. C'est le rle du registre d'adresse d'instruction.
Le registre
d'adresse
d'instruction
Ce registre stocke l'adresse de la prochaine instruction excuter. Cette adresse permet de localiser
l'instruction suivante en mmoire. Cette adresse ne sort pas de nulle part : on peut la dduire de
l'adresse de l'instruction en cours dexcution par divers moyens plus ou moins simples qu'on verra
dans la suite de ce tutoriel. Cela peut aller d'une simple addition quelque chose d'un tout petit peu
plus complexe. Quoiqu'il en soit, elle est calcule par un petit circuit combinatoire coupl notre registre
d'adresse d'instruction, qu'on appelle le compteur ordinal.
Ce registre d'adresse d'instruction est souvent appel le Program Counter. Retenez bien ce terme, et ne
l'oubliez pas si vous voulez lire des documentations en anglais.
Le registre d'tat contient plusieurs bits qui ont chacun une utilit particulire. Ce registre est trs
diffrent suivant les processeurs, mais certains bits reviennent souvent :
Le registre
d'tat
divers bits utiliss lors d'oprations de comparaisons ou de tests qui servent donner le
rsultat de celles-ci ;
le bit d'overflow, qui prvient quand le rsultat d'une instruction est trop grand pour tenir dans
un registre ;
le bit null : prcise que le rsultat d'une instruction est nul (vaut zro) ;
le bit de retenue, utile pour les additions ;
le bit de signe, qui permet de dire si le rsultat d'une instruction est un nombres ngatif ou
positif.
Le Stack
Pointer, et
ventuellement
le Frame
Pointer
Ces deux registres sont utiliss pour grer une pile, si le processeur en possde une. Pour ceux qui
auraient oublis ce qu'est la pile, le chapitre 5 est l pour vous.
Registres
entiers
Certains registres sont spcialement conus pour stocker des nombres entiers. On peut ainsi effectuer
des instructions de calculs, des oprations logiques dessus.
Registres
flottants
Certains registres sont spcialement conus pour stocker des nombres flottants. Lintrt de placer les
nombres flottants part des nombres entiers, dans des registres diffrents peut se justifier par une
remarque trs simple : on ne calcule pas de la mme faon avec des nombres flottants et avec des
nombres entiers. La faon de grer les nombres flottants par nos instructions tant diffrente de celle
des entiers, certains processeurs placent les nombres flottants part, dans des registres spars.
On peut ainsi effectuer des instructions de calculs, des oprations logiques dessus.
Registres de
constante
Ces registres de constante contiennent des constantes assez souvent utilises. Par exemple, certains
processeurs possdent des registres initialiss zro pour acclrer la comparaison avec zro ou
l'initialisation d'une variable zro. On peut aussi citer certains registres flottants qui stockent des
nombres comme , ou pour faciliter l'implmentation des calculs trigonomtriques).
Registres
d'Index
Autrefois, nos processeurs possdaient des registres d'Index, qui servait calculer des adresses, afin
de manipuler rapidement des donnes complexes comme les tableaux. Ces registres d'Index taient
utiliss pour effectuer des manipulations arithmtiques sur des adresses. Sans eux, accder des
donnes places des adresses mmoires conscutives ncessitait souvent d'utiliser du self-modifying
code : le programme devait tre conu pour se modifier lui-mme en partie, ce qui n'tait pas forcment
idal pour le programmeur.
Pour rappel, le Stack Pointer stocke l'adresse du sommet de la pile. Tout processeur qui possde une
pile en possde un. Par contre, le Frame Pointer est optionnel : il n'est prsent que sur les processeurs
qui grent des Stack Frames de taille variable. Ce registre stocke l'adresse laquelle commence la Stack
Frame situe au sommet de la pile.
Sur certains processeurs, certains des registres cits plus bas ne sont pas prsents ! Il existe ainsi des processeurs qui
se passent des registres chargs de grer la pile : tout processeur n'utilisant pas de pile le peut. De mme, il est possible
de se passer du registre d'tat, etc.
Registres gnraux
www.openclassrooms.com
83/467
Malheureusement, fournir des registres trs spcialiss n'est pas trs flexible. Prenons un exemple : j'ai un processeur disposant
d'un Program Counter, de 4 registres entiers, de 4 registres d'Index pour calculer des adresses, et de 4 registres flottants. Si
jamais jexcute un morceau de programme qui manipule beaucoup de nombres entiers, mais qui ne manipule pas d'adresses ou
de nombre flottants, j'utiliserais juste les 4 registres entiers. Une partie des registres du processeur sera inutilis : tous les
registres flottants et d'Index. Le problme vient juste du fait que ces registres ont une fonction bien fixe.
Pourtant, en rflchissant, un registre est un registre, et il ne fait que stocker une suite de bits. Il peut tout stocker : adresses,
flottants, entiers, etc. Pour plus de flexibilit, certains processeurs ne fournissent pas de registres spcialiss comme des
registres entiers ou flottants, mais fournissent la place des Les registres gnraux utilisables pour tout et n'importe quoi. Ce
sont des registres qui n'ont pas d'utilit particulire et qui peuvent stocker toute sorte dinformation code en binaire. Pour
reprendre notre exemple du dessus, un processeur avec des registres gnraux fournira un Program Counter et 12 registres
gnraux, qu'on peut utiliser sans vraiment de restrictions. On pourra s'en servir pour stocker 12 entiers, 10 entiers et 2 flottants,
7 adresses et 5 entiers, etc. Ce qui sera plus flexible et permettra de mieux utiliser les registres.
Dans la ralit, nos processeurs utilisent souvent un espce de mlange entre les deux solutions. Gnralement, une bonne
partie des registres du processeur sont des registres gnraux, part quelques registres spcialiss, accessibles seulement
travers quelques instructions bien choisies. C'est le cas du registre d'adresse d'instruction, qui est manipul automatiquement
par le processeur et par les instructions de branchement.
La catastrophe
Ceci dit, certains processeurs sont trs laxistes : tous les registres sont des registres gnraux, mme le Program Counter. Sur
ces processeurs, on peut parfaitement lire ou crire dans le Program Counter sans trop de problmes. Ainsi, au lieu d'effectuer
des branchements sur notre Program Counter, on peut simplement utiliser une instruction qui ira crire l'adresse laquelle
brancher dans notre registre. On peut mme faire des calculs sur le contenu du Program Counter : cela n'a pas toujours de sens,
mais cela permet parfois d'implmenter facilement certains types de branchements avec des instructions arithmtiques usuelles.
Registres architecturaux
Un programmeur (ou un compilateur) qui souhaite programmer en langage machine peut manipuler ces registres. A ce stade, il
faut faire une petite remarque : tous les registres d'un processeur ne sont pas forcment manipulables par le programmeur. Il
existe ainsi deux types de registres : les registres architecturaux, manipulables par des instructions, et d'autres registres
internes au processeurs. Ces registres peuvent servir simplifier la conception du processeur ou permettre l'implmentation
d'optimisations permettant de rendre notre ordinateur plus rapide.
Le nombre de registres architecturaux varie suivant le processeur. Gnralement, les processeurs RISC et les DSP possdent un
grand nombre de registres. Sur les processeurs CISC, c'est l'inverse : il est rare d'avoir un grand nombre de registres
architecturaux manipulables par un programme. Quoiqu'il en soit, tous les registres cits plus haut sont des registres
architecturaux.
a doit tre du sport pour se retrouver dans un processeur avec tout ces registres ! Comment notre programmeur fait-il
pour slectionner un registre parmi tous les autres ?
Noms de registres
Dans le premier cas, chaque registre se voit attribuer une rfrence, une sorte d'identifiant qui permettra de le slectionner parmi
tous les autres. C'est un peu la mme chose que pour la mmoire RAM : chaque byte de la mmoire RAM se voit attribuer une
adresse bien prcise. Et bien pour les registres, c'est un peu la mme chose : ils se voient attribuer quelque chose d'quivalent
une adresse, une sorte d'identifiant qui permettra de slectionner un registre pour y accder.
Cet identifiant est ce qu'on appelle un nom de registre. Ce nom n'est rien d'autre qu'une suite de bits attribue chaque registre,
chaque registre se voyant attribuer une suite de bits diffrente. Celle-ci sera intgre toutes les instructions devant manipuler
www.openclassrooms.com
84/467
ce registre, afin de slectionner celui-ci. Ce numro, ou nom de registre, permet d'identifier le registre que l'on veut, mais ne sort
jamais du processeur : ce nom de registre, ce numro, ne se retrouve jamais sur le bus d'adresse. Les registres ne sont donc pas
identifis par une adresse mmoire.
Toutefois, tous les registres n'ont pas forcment besoin d'avoir un nom. Par exemple, les registres chargs de grer la pile n'ont
pas forcment besoin d'un nom : la gestion de la pile se fait alors via des instructions Push et Pop qui sont les seules pouvoir
manipuler ces registres. Toute manipulation du Frame Pointer et du Stack Pointer se faisant grce ces instructions, on n'a pas
besoin de leur fournir un identifiant pour pouvoir les slectionner. C'est aussi le cas du registre d'adresse d'instruction : sur
certains processeurs, il est manipul automatiquement par le processeur et par les instructions de branchement. Dans ces cas
bien prcis, on n'a pas besoin de prciser le ou les registres manipuler : le processeur sait dj quels registres manipuler et
comment, de faon implicite. Quand on effectue un branchement, le processeur sait qu'il doit modifier le Program Counter : pas
besoin de lui dire. Pareil pour les instructions de gestion de la pile.
Ces noms de registres posent un petit problme. Quand une instruction voudra manipuler des donnes, elle devra fatalement
donner une adresse ou un nom de registres qui indiquera la position de la donne en mmoire. Ces adresses et noms de registres
sont cods sous la forme de suites de bits, incorpores dans l'instruction. Mais rien ne ressemble plus une suite de bits qu'une
autre suite de bits : notre processeur devra viter de confondre suite de bits reprsentant une adresse, et suite de bits
reprsentant un nom de registre. Pour viter les confusions, chaque instruction devra prciser quoi correspondra la suite de
bits prcisant la localisation des donnes manipuler : est-ce un registres ou une adresse, ou autre chose encore. Cette prcision
(cet-ce une adresse ou un nom de registres) sera indique par ce qu'on appelle un mode d'adressage. Nous reviendront dessus
tout l'heure.
Registres adressables
Mais il existe une autre solution, assez peu utilise. Sur certains processeurs assez rares, on peut adresser les registres via une
adresse mmoire. Il est vrai que c'est assez rare, et qu' part quelques vielles architectures ou quelques micro-contrleurs, je n'ai
pas d'exemples donner. Mais c'est tout fait possible ! C'est le cas du PDP-10.
www.openclassrooms.com
85/467
Derrire cette appellation qu'on retrouve souvent dans la presse ou comme argument commercial se cache un concept simple. Il
s'agit de la quantit de bits qui peuvent tre stocks dans chaque registre gnraux.
Attention : on parle bien des registres gnraux, et pas forcment des autres registres. Notre processeur contient pas mal de
registres et certains peuvent contenir plus de bits que d'autres. Par exemple, dans certains processeurs, les registres gnraux
sont spars des registres stockant des flottants et ces deux types de registres peuvent avoir une taille diffrente. Exemple : dans
les processeurs x86, il existe des registres spcialement ddis aux nombres flottants et d'autres spcialement ddis aux
nombres entiers (ce sont les registres gnraux qui servent pour les entiers). Les registres pour nombres entiers n'ont pas la
mme taille que les registres ddis aux nombres flottants. Un registre pour les nombres entiers contient environ 32 bits tandis
qu'un registre pour nombres flottants contient 80 bits.
Ce nombre de bits que peut contenir un registre est parfois diffrent du nombre de bits qui peuvent transiter en mme temps sur
le bus de donne de votre ordinateur. Cette quantit peut varier suivant l'ordinateur. On l'appelle la largeur du bus de donnes.
Exemple : sur les processeurs x 86 - 32 bits, un registre stockant un entier fait 32bits. Un registre pour les flottants en fait
gnralement 64. Le bus de donne de ce genre d'ordinateur peut contenir 64 bits en mme temps. Cela a une petite incidence sur
la faon dont une donne est transfre entre la mmoire et un registre. On peut donc se retrouver dans deux situations
diffrentes :
Situation
Consquence
Le bus de donne peut charger en une seule fois le nombre de bits que peut
contenir un registre.
Reprsentation en binaire
On peut de demander comment notre ordinateur fait pour stocker ces instructions dans sa mmoire. On a dj vu il y a quelques
chapitres que les instructions sont stockes dans la mmoire programme de l'ordinateur sous la forme de suites de bits.
Exemple : ici, les valeurs binaires sont compltement fictives.
www.openclassrooms.com
86/467
Instruction
Valeur Binaire
0110 1111
Addition : ADD
Mais j'ai volontairement pass sous silence quelque chose : cette suite de bits n'est pas organise n'importe comment.
Opcode
La suite de bits de notre instruction contient une portion qui permet d'identifier l'instruction en question. Cette partie permet
ainsi de dire s'il s'agit d'une instruction d'addition, de soustraction, d'un branchement inconditionnel, d'un appel de fonction,
d'une lecture en mmoire, etc. Cette portion de mmoire s'appelle l'opcode.
Pour la mme instruction, l'opcode peut tre diffrent suivant le processeur, ce qui est source d'incompatibilit. Ce qui fait que
pour chaque processeur, ses fabricants donnent une liste qui recense l'intgralit des instructions et de leur opcode : l'opcode
map.
Petit dtail : il existe certains processeurs qui utilisent une seule et unique instruction. Ces processeurs peuvent donc se passer
d'opcode : avec une seule instruction possible, pas besoin d'avoir un opcode pour prciser quelle instruction excuter. Mais
autant prvenir : ces processeurs sont totalement tordus et sont vraiment trs rares. Inutile de s'attarder plus longtemps sur ces
processeurs.
Oprandes
Il arrive que certaines instructions soient composes d'un Opcode, sans rien d'autre. Elles ont alors une reprsentation en binaire
qui est unique. Mais certaines instructions ne se contentent pas d'un opcode : elles utilisent une partie variable. Cette partie
variable peut permettre de donner des informations au processeur sur l'instruction, sur ses donnes, ou permettre dautres
choses encore. Mais le plus frquemment, cette partie variable permet de prciser quelles sont les donnes manipuler. Sans
cela, rien ne marche !
Quand je dis "prciser quelles sont les donnes manipuler", cela veut vouloir dire plusieurs choses. On peut parfois mettre la
donne directement dans l'instruction : si la donne est une constante, on peut la placer directement dans l'instruction. Mais
dans les autres cas, notre instruction va devoir prciser la localisation des donnes manipuler : est-ce que la donne
manipuler est dans un registre (et si oui, lequel), dans la mmoire (et quelle adresse ?). De mme, o enregistrer le rsultat ?
Bref, cette partie variable est bien remplie.
Modes d'adressage
Reste savoir comment interprter cette partie variable : aprs tout, c'est une simple suite de bits qui peut reprsenter une
adresse, un nombre, un nom de registre, etc. Il existe diverses faons pour cela : chacune de ces faon va permettre dinterprter
le contenu de la partie variable comme tant une adresse, une constante, un nom de registre, etc, ce qui nous permettra de
localiser la ou les donne de notre instruction. Ces diverses manires dinterprter notre partie variable pour en exploiter son
contenu s'appellent des modes d'adressage. Pour rsumer, ce mode d'adressage est une sorte de recette de cuisine capable de
dire o se trouve la ou les donnes ncessaires pour excuter une instruction. De plus, notre mode d'adressage peut aussi
prciser o stocker le rsultat de l'instruction.
www.openclassrooms.com
87/467
Ces modes d'adressage dpendent fortement de l'instruction qu'on veut faire excuter et du processeur. Certaines instructions
supportent certains modes d'adressage et pas d'autres, voir mixent plusieurs modes d'adressages : les instructions manipulant
plusieurs donnes peuvent parfois utiliser un mode d'adressage diffrent pour chaque donne. Dans de tels cas, tout se passe
comme si l'instruction avait plusieurs parties variables, nommes oprandes, contenant chacune soit une adresse, une donne ou
un registre. Pour comprendre un peu mieux ce qu'est un mode d'adressage, voyons quelques exemples de modes d'adressages
assez communs et qui reviennent souvent.
Je vais donc parler des modes d'adressages suivants :
implicite ;
immdiat ;
registre ;
absolus ;
indirects registres ;
indirect avec auto-incrment ;
indirect avec auto-dcrment ;
indexed absolute ;
base + index ;
base + offset ;
base + index + offset.
Adressage implicite
Avec l'adressage implicite, la partie variable n'existe pas ! Il peut y avoir plusieurs raisons cela. Il se peut que l'instruction n'aie
pas besoin de donnes : une instruction de mise en veille de l'ordinateur, par exemple. Ensuite, certaines instructions n'ont pas
besoin qu'on leur donne la localisation des donnes d'entre et "savent" o est la ou les donne(s). Comme exemple, on pourrait
citer une instruction qui met tous les bits du registre d'tat zro. Certaines instructions manipulant la pile sont adresses de
cette manire : on connait d'avance l'adresse de la base ou du sommet de la pile. Pour rappel, celle-ci est stocke dans quelques
registres du processeur.
Adressage immdiat
Avec l'adressage immdiat, la partie variable est une constante. Celle-ci peut tre un nombre, un caractre, un nombre flottant,
etc. Avec ce mode d'adressage, notre donne est charge en mme temps que l'instruction et est place dans la partie variable.
Adressage direct
Passons maintenant l'adressage absolu, aussi appel adressage direct. Avec lui, la partie variable est l'adresse de la donne
laquelle accder.
www.openclassrooms.com
88/467
Cela permet parfois de lire une donne directement depuis la mmoire sans devoir la copier dans un registre.
Ce mode d'adressage ne sert que pour les donnes dont l'adresse est fixe une bonne fois pour toute. Les seules donnes qui
respectent cette condition sont les donnes places dans la mmoire statique (souvenez-vous du chapitre prcdent : on avait
parl des mmoires programme, statique, de la pile et du tas). Pour les programmeurs, cela correspond aux variables globales et
aux variables statiques, ainsi qu' certaines constantes (les chaines de caractres constantes, par exemple). Bien peu de donnes
sont stockes dans cette mmoire statique, ce qui fait que ce mode d'adressage a tendance devenir de plus en plus marginal.
Adressage inhrent
Avec le mode d'adressage inhrent, la partie variable va identifier un registre qui contient la donne voulue.
www.openclassrooms.com
89/467
Mais identifier un registre peut se faire de diffrentes faons. On peut soit utiliser des noms de registres, ou encore identifier nos
registres par des adresses mmoires. Le mode d'adressage inhrent n'utilise que des noms de registres.
Si on regarde uniquement l'instruction telle qu'elle est en mmoire, on ne voit aucune diffrence avec le mode d'adressage
inhrent vu juste au-dessus. La diffrence viendra de ce qu'on fait de ce nom de registre : le nom de registre n'est pas interprt
de la mme manire. Avec le mode d'adressage inhrent, le registre indiqu dans l'instruction contiendra la donne manipuler.
Avec le mode d'adressage indirect registre, la donne sera place en mmoire, et le registre contiendra l'adresse de la donne.
www.openclassrooms.com
90/467
Le mode d'adressage indirect registre permet d'implmenter de faon simple ce qu'on appelle les pointeurs. Au dbut de
l'informatique, les processeurs ne possdaient pas d'instructions ou de modes d'adressages pour grer les pointeurs. On pouvait
quand mme grer ceux-ci, en utilisant l'adressage direct. Mais dans certains cas, forait l'utilisation de self-modifying code, c'est
dire que le programme devait contenir des instructions qui devaient modifier certaines instructions avant de les excuter ! En
clair, le programme devait se modifier tout seul pour faire ce qu'il faut. L'invention de ce mode d'adressage a permit de faciliter le
tout : plus besoin de self-modifying code.
Pour donner un exemple, on peut citer l'exemple des tableaux. Un tableau est un ensemble de donnes de mme taille ranges les
unes la suite des autres en mmoire.
Premire chose : chaque donne (on dit aussi lment) d'un tableau prend un nombre d'octets fix une fois pour toute.
Gnralement, une donne prend entre 1, 2, 4, 8 octets : ce sont des nombres qui sont une puissance de deux.
Deuxime chose, ces donnes sont ranges les unes cot des autres en mmoire : on ne laisse pas le moindre vide. Les
unes cot des autre signifie dans des adresses mmoires conscutives.
www.openclassrooms.com
91/467
www.openclassrooms.com
92/467
Indexed Absolute
D'autres modes d'adressage permettent de faciliter la manipulations des tableaux. Ces modes d'adressage permettent de faciliter
le calcul de l'adresse d'un lment du tableau. Reste savoir comment ce calcul d'adresse est fait. Sachez que pour cela, chaque
lment d'un tableau reoit un nombre, un indice, qui dtermine sa place dans le tableau : llment d'indice 0 est celui qui est
plac au dbut du tableau, celui d'indice 1 est celui qui le suit immdiatement aprs dans la mmoire, etc. On doit donc calculer
son adresse partir de l'indice et d'autres informations. Pour cela, on utilise le fait que les lments d'un tableau ont une taille fixe
et sont rangs dans des adresses mmoires conscutives.
Prenons un exemple : un tableau d'entiers, prenant chacun 4 octets. Le premier lment d'indice zro est plac l'adresse : c'est
l'adresse laquelle commence le tableau en mmoire. Le second lment est plac 4 octets aprs (vu que le premier lment prend
4 octets) : son adresse est donc
. Le second lment est plac 4 octets aprs le premier lment, ce qui donne l'adresse
.
Si vous continuez ce petit jeu pour quelques valeurs, on obtiendrait quelque chose dans le genre :
Indice i Adresse de l'lment
0
A+4
A+8
A+12
A+16
A+20
...
...
Vous remarquerez surement quelque chose sur l'adresse de l'lment d'indice i, si vous vous souvenez que l'entier de notre
www.openclassrooms.com
93/467
A + (0 * 4)
A + (1 * 4)
A + (2 * 4)
A + (3 * 4)
A + (4 * 4)
A + (5 * 4)
...
...
On peut formaliser cette remarque mathmatiquement en posant la longueur d'un lment du tableau, l'indice de cet lment,
et l'adresse de dbut du tableau (l'adresse de llment d'indice zro).
l'adresse de llment d'indice vaut toujours
Pour viter d'avoir calculer les adresses la main avec le mode d'adressage register indirect, on a invent un mode d'adressage
pour combler ce manque : le mode d'adressage Indexed Absolute.
Celui-ci fournit l'adresse de base du tableau, et un registre qui contient l'indice.
A partir de ces deux donnes, l'adresse de llment du tableau est calcule, envoye sur le bus d'adresse, et llment est
rcupr.
www.openclassrooms.com
94/467
Le processeur calcule alors l'adresse de llment voulu partir du contenu de ces deux registres, et accde notre lment. En
clair : notre instruction ne fait pas que calculer l'adresse de llment : elle va aussi le lire ou l'crire.
www.openclassrooms.com
95/467
Ce mode d'adressage possde une variante qui permet de vrifier qu'on ne "dborde pas" du tableau, en calculant par erreur une
adresse en dehors du tableau, cause d'un indice erron, par exemple. Accder llment 25 d'un tableau de seulement 5
lment n'a pas de sens et est souvent signe d'une erreur. Pour cela, l'instruction peut prendre deux oprandes supplmentaires
(qui peuvent tre constantes ou places dans deux registres). Si cette variante n'est pas supporte, on doit faire ces vrifications
la main. Parfois, certains processeurs implmentent des instructions capables de vrifier si les indices des tableaux sont
corrects. Ces instructions sont capables de vrifier si un entier (l'indice) dpasse d'indice maximal autoris, et qui effectuent un
branchement automatique si l'indice n'est pas correct. L'instruction BOUND sur le jeu d'instruction x86 en est un exemple.
Base + Offset
Les tableaux ne sont pas les seuls regroupements de donnes utiliss par les programmeurs. Nos programmeurs utilisent
souvent ce qu'on appelle des structures. Ces structures servent crer des donnes plus complexe que celles que le processeur
peut supporter. Comme je l'ai dit plus haut, notre processeur ne gre que des donnes simples : des entiers, des flottants ou des
caractres. Pour crer des types de donnes plus complexe, on est oblig de regrouper des donnes de ce genre dans un seul
bloc de mmoire : on cre ainsi une structure.
Par exemple, voici ce que donnerais une structure compose d'un entier, d'un flottant simple prcision, et d'un caractre :
Octet 1
Octet 2
Octet 3
Octet 4
Octet 5
Octet 6
Octet 7
Octet 8
Octet 9
Adresse Adresse
A
A+ 1
Adresse
A+ 2
Adresse
A+ 3
Adresse A + 4
Adresse A + 5
Adresse A + 6
Adresse A + 7
Adresse
A+ 8
Flottant simple
prcision
Flottant simple
prcision
Flottant simple
prcision
Flottant simple
prcision
Caractre
8 bits
Entier
32 bits
Mais le processeur ne peut pas manipuler ces structures : il est oblig de manipuler les donnes lmentaires qui la constituent
unes par unes. Pour cela, il doit calculer leur adresse. Ce qui n'est pas trs compliqu : une donne a une place prdtermine
dans une structure. Elle est donc a une distance fixe du dbut de la structure.
Calculer l'adresse d'un lment de notre structure se fait donc en ajoutant une constante l'adresse de dpart de la structure. Et
www.openclassrooms.com
96/467
c'est ce que fait le mode d'adressage Base + Offset. Celui-ci spcifie un registre qui contient l'adresse du dbut de la structure, et
une constante.
Ce mode d'adressage va non seulement effectuer ce calcul, mais il va aussi aller lire (ou crire) la donne adresse.
Autres
D'autres modes d'adressages existent, et en faire une liste exhaustive serait assez long. Ce serait de plus inutile, vu que la plupart
sont de toute faon obsoltes. Des modes d'adressage comme le Memory indirect ne servent plus grand chose de nos jours.
97/467
Dans le paragraphe du dessus, on a vu les divers modes d'adressages les plus utiliss. Mais nous n'avons pas encore parl de
quelque chose de fondamental : comment prciser quel mode d'adressage notre instruction utilise ? Et bien sachez que cela se
fait de diverses manires suivant les instructions.
Explicite
Nous allons voir un premier cas : celui des instructions pouvant grer plusieurs modes d'adressages par oprandes. Prenons un
exemple : je dispose d'une instruction d'addition. Les deux oprandes de mon instruction peuvent tre soit des registres, soit un
registre et une adresse, soit un registre et une constante. La donne utiliser sera alors charge depuis la mmoire ou depuis un
registre, ou prise directement dans l'instruction, suivant l'oprande utilise. Dans un cas pareil, je suis oblig de prciser quel est
le mode d'adressage utiliser. Sans cela, je n'ai aucun moyen de savoir si la seconde oprande est un registre, une constante, ou
une adresse. Autant je peux le savoir pour la premire oprande : c'est un registre, autant le mode d'adressage de la seconde
m'est inconnu.
On est dans un cas dans lequel certaines oprandes ont plusieurs modes d'adressage. Pour ces instructions, le mode
dadressage doit tre prcis dans notre instruction. Quelques bits de l'instruction doivent servir prciser le mode d'adressage.
Ces bits peuvent tre placs dans l'opcode, ou dans quelques bits part, spars de l'opcode et des oprandes (gnralement,
ces bits sont intercals entre l'opcode et les oprandes).
Implicite
Dans le second cas, notre instruction ne peut grer qu'un seul mode d'adressage par oprande, toujours le mme. Prenons un
exemple : j'ai un processeur RISC dont toutes les instructions arithmtiques ne peuvent manipuler que des registres. Pas de mode
d'adressage immdiat, ni absolu ni quoique ce soit : les oprandes des instructions arithmtiques utilisent toutes le mode
d'adressage registre.
Prenons un autre exemple : l'instruction Load. Cette instruction va lire le contenu d'une adresse mmoire et stocker celui-ci dans
un registre. Cette instruction a deux oprandes prdfinies : un registre, et une adresse mmoire. Notre instruction utilise donc le
mode d'adressage absolu pour la source de la donne lire, et un nom de registre pour la destination du rsultat. Et cela ne
change jamais : notre instruction a ses modes d'adressages prdfinis, sans aucune possibilit de changement.
Dans un cas pareil, si chaque oprande a un mode d'adressage prdtermin, pas besoin de le prciser vu que celui-ci ne change
jamais. Celui-ci peut tre dduit automatiquement en connaissant l'instruction : il est plus ou moins implicite. On n'a pas besoin
d'utiliser des bits de notre instruction pour prciser le mode d'adressage, qui peut tre dduit partir de l'Opcode.
www.openclassrooms.com
98/467
Longueur variable
Sur certains processeurs, cette longueur est variable : toutes les instructions n'ont pas la mme taille. Ainsi, une instruction
d'addition prendra moins de bits qu'une instruction de branchement, par exemple. Cela permet de gagner un peu de mmoire :
avoir des instructions qui font entre 2 et 3 octets est plus avantageux que de tout mettre sur 3 octets. En contrepartie, calculer
l'adresse de la prochaine instruction est assez compliqu : la mise jour du Program Counter ncssite pas mal de travail.
Les processeurs qui utilisent ces instructions de longueur variable sont souvent des processeurs CISC. Il faut dire que les
processeurs CISC ont beaucoup d'instructions, ce qui fait que l'opcode de chaque instruction est assez long et prend de la
mmoire. Avoir des instructions de longueur variable permet de limiter fortement la casse, voir mme d'inverser la tendance. La
taille de l'instruction dpend aussi du mode d'adressage : la taille d'une oprande varie suivant sa nature (une adresse, une
constante, quelques bits pour spcifier un registre, voire rien).
Longueur fixe
Sur d'autres processeurs, cette longueur est gnralement fixe. 2videmment, cela gche un peu de mmoire compar des
instructions de longueur variable. Mais cela permet au processeur de calculer plus facilement ladresse de l'instruction suivante
en faisant une simple addition. Et cela a d'autres avantages, dont on ne parlera pas ici.
Les instructions de longueur fixe sont surtout utilises sur les processeurs RISC. Sur les processeurs RISC, l'opcode prend peu
www.openclassrooms.com
99/467
de place : il y a peu d'instructions diffrentes coder, donc l'opcode est plus court, et donc on prfre simplifier le tout et utiliser
des instructions de taille fixe.
Classes d'architectures
Tous ces modes d'adressage ne sont pas supports par tous les processeurs ! En fait, il existe plusieurs types d'architectures,
dfinies par leurs modes d'adressages possibles. Certaines ne supportent pas certains modes d'adressage. Et pour s'y reprer, on
a dcider de classifier un peu tout a.
Il existe donc 5 classes d'architectures :
accs mmoires strict ;
accumulateur ;
a pile ;
Load-Store ;
registres-mmoire.
A pile
Dans les architectures pile, il n'y a pas de registres stockant de donnes : les instructions n'accdent qu' la mmoire principale,
exactement comme pour les architectures accs mmoire strict. Nanmoins, ces machines fonctionnent diffremment. Ces
processeurs implmentent une pile, et crivent donc tous leurs rsultats en mmoire RAM. Et oui, vous ne vous tes pas
tromps : il s'agit bien de nos bonnes vielles machines pile, vues il y a quelques chapitres.
Push et Pop
Ces architectures ont besoin d'instructions pour transfrer des donnes entre la pile et le reste de la mmoire. Pour cela, ces
processeurs disposent d'instructions spcialises pour pouvoir empiler une donne au sommet de la pile : push ; et une
instruction pour dpiler la donne au sommet de la pile et la sauvegarder en mmoire : pop.
Les instructions push et pop vont aller lire ou crire une adresse mmoire bien prcise. Cette adresse spcifie l'adresse de la
donne charger pour push et l'adresse laquelle sauvegarder le sommet de la pile pour pop. Cette adresse peut tre prcise
via diffrents modes d'adressages : absolus, Base + Index, etc. L'instruction push peut ventuellement empiler une constante, et
utilise dans ce cas le mode d'adressage immdiat.
Instructions arithmtiques
Toutes les instructions arithmtiques et logiques vont aller chercher leurs oprandes sur le sommet de la pile. Ces instructions
vont donc dpiler un certain nombre d'oprandes (1 ,2 voire 3), et vont stocker le rsultat au sommet de la pile. Le sommet de la
pile est adress de faon implicite : le sommet de la pile est toujours connu (son adresse est stocke dans un registre ddi et on
n'a donc pas besoin de la prciser par un mode d'adressage).
Notre instructions arithmtiques et logiques se contentent d'un opcode, vu que les oprandes sont adresses implicitement.
C'est pour cela que sur ces processeurs, la mmoire utilise par le programme est trs faible.
Sur un ordinateur qui n'est pas bas sur une architecture pile, on aurait d prciser la localisation des donnes en ajoutant une
partie variable l'opcode de l'instruction, augmentant ainsi la quantit de mmoire utilise pour stocker celle-ci.
www.openclassrooms.com
100/467
A accumulateur unique
Sur certains processeurs, les rsultats d'une opration ne peuvent tre enregistrs que dans un seul registre, prdfini l'avance
: l'accumulateur. Cela ne signifie pas qu'il n'existe qu'un seul registre dans le processeur. Mais vu qu'une instruction ne peut pas
modifier leur contenu, le seul moyen d'crire dans ces registres est de lire une donne depuis la mmoire et de stocker le rsultat
de la lecture dedans. Toute instruction va obligatoirement lire une donne depuis cette accumulateur, et y crire son rsultat. Si
l'instruction a besoin de plusieurs oprandes, elle va en stocker une dans cet accumulateur et aller chercher les autres dans la
mmoire ou dans les autres registres.
Dans tous les cas, l'accumulateur est localis grce au mode d'adressage implicite. De plus, le rsultat des instructions
arithmtiques et logiques est stock dans l'accumulateur, et on n'a pas besoin de prciser o stocker le rsultat : pas de mode
d'adressage pour le rsultat.
Architectures 1-adresse
Historiquement, les premires architectures accumulateur ne contenaient aucun autre registre : l'accumulateur tait seul au
monde. Pour faire ses calculs, notre processeur devait stocker une oprande dans l'accumulateur, et aller chercher les autres en
mmoire. En consquence, le processeur ne pouvait pas grer certains modes d'adressages, comme le mode d'adressage
registre. Sur ces processeurs, les modes d'adressages supports taient les modes d'adressages implicite, absolus, et immdiat.
Ces architectures sont parfois appeles architectures 1-adresse. Cela vient du fait que la grosse majorit des instructions n'ont
besoin que d'une oprande. Il faut dire que la majorit des instructions d'un processeur n'a besoin que de deux oprandes et ne
fournissent qu'un rsultat : pensez aux instructions d'addition, de multiplication, de division, etc. Pour ces oprations, le rsultat
ainsi qu'une des oprandes sont stocks dans l'accumulateur, et adresss de faon implicite. Il y a juste prciser la seconde
oprande l'instruction, ce qui prend en tout une oprande.
Architectures 2,3-adresse
Ensuite, ces architectures samliorrent un petit peu : on leur ajouta des registres capables de stocker des donnes.
Laccumulateur n'tait plus seul au monde. Mais attention : ces registres ne peuvent servir que doprande dans une instruction,
et le rsultat d'une instruction ira obligatoirement dans l'accumulateur. Ces architectures supportaient donc le mode d'adressage
registre.
Architectures registre-mmoire
C'est la mme chose que l'architecture accumulateur, mais cette fois, le processeur peut aussi contenir plusieurs autres registres
gnraux qui peuvent servir stocker pleins de donnes diverses et varies. Le processeur peut donc utiliser plusieurs registres
pour stocker des informations (gnralement des rsultats de calcul intermdiaires), au lieu d'aller charger ou stocker ces
donnes dans la mmoire principale.
Ces architectures registres gnraux (ainsi que les architectures Load-store qu'on verra juste aprs) sont elles-mme divises
en deux sous-classes bien distinctes : les architectures 2 adresses et les architectures 3 adresses. Cette distinction entre
architecture 2 et 3 adresses permet de distinguer les modes d'adressages des oprations arithmtiques manipulant deux donnes
: additions, multiplications, soustraction, division, etc. Ces instructions ont donc besoin d'adresser deux donnes diffrentes, et
de stocker le rsultat quelque part. Il leur faut donc prciser trois oprandes dans le rsultat : la localisation des deux donnes
manipuler, et l'endroit o ranger le rsultat.
www.openclassrooms.com
101/467
Architectures 2 adresse
Sur les architectures deux adresses, l'instruction possde seulement deux oprandes pour les donnes manipuler, l'endroit o
ranger le rsultat tant adress implicitement. Plus prcisment, le rsultat sera stock au mme endroit que la premire donne
qu'on manipule : cette donne sera remplace par le rsultat de l'instruction.
Mnmonique/Opccode
DIV (Division)
Oprande 1
Oprande 2
Avec cette organisation, les instructions sont plus courtes. Mais elle est moins souple, vu que l'une des donnes utilise est
crase : si on a encore besoin de cette donne aprs lexcution de notre instruction, on est oblig de copier cette donne dans
un autre registre et faire travailler notre instruction sur une copie.
Architectures 3 adresse
Sur les architectures trois adresses, l'instruction possde trois oprandes : deux pour les donnes manipuler, et une pour le
rsultat.
Mnmonique/Opccode Oprande 1 Oprande 2 Oprande 3
DIV
Dividende
Diviseur
Rsultat
Les instructions de ce genre sont assez longues, mais on peut prciser quel endroit ranger le rsultat. On n'est ainsi pas oblig
d'craser une des deux donnes manipules dans certains cas, et stocker le rsultat de l'instruction dans un registre inutilis,
prfrer craser une autre donne qui ne sera pas rutilise, etc. Ce genre d'architecture permet une meilleure utilisation des
registres, ce qui est souvent un avantage. Mais par contre, les instructions deviennent trs longues, ce qui peut devenir un vrai
problme. Sans compter que devoir grer trois modes d'adressages (un par oprande) au lieu de deux risque d'tre assez couteux
en circuits et en transistors : un circuit aussi complexe sera plus lent et coutera cher. Et ces dsavantages sont souvent assez
ennuyeux.
Load-store
Cette fois, la diffrence n'est pas au niveau du nombre de registres. Dans cette architecture, toutes les instructions arithmtiques
et logiques ne peuvent aller chercher leurs donnes que dans des registres du processeurs.
Accs mmoires
Seules les instructions load et store peuvent accder la mmoire. load permet de copier le contenu d'une (ou plusieurs)
adresse mmoire dans un registre, tandis que store copie en mmoire le contenu d'un registre. load et store sont des
instructions qui prennent comme oprande le nom d'un registre et une adresse mmoire. Ces instructions peuvent aussi utiliser
l'adressage indirect registre ou tout autre mode d'adressage qui fournit une adresse mmoire.
www.openclassrooms.com
102/467
Un peu de programmation !
Notre processeur va excuter des programmes, fabriqus l'aide de ce qu'on appelle un langage de programmation. Ces
langages de programmations sont des langages qui permettent un humain de programmer plus ou moins facilement un
ordinateur pour que celui-ci fasse ce qu'on veut. Ces langages de programmations ont influencs de faon notable les jeux
d'instructions des processeurs modernes : de nombreux processeurs implmentent des instructions spcialement conues pour
faciliter la traduction des "briques de base" de certains langages de programmation en une suite d'instructions machines. Ces
fameuses "briques de base" sont ce que l'on appelle les structures de contrle.
Autant prvenir tout de suite : j'ai fait en sorte que mme quelqu'un qui ne sait pas programmer puisse comprendre cette partie.
Ceux qui savent dj programmer auront quand mme intrt lire ce chapitre : il leur permettra de savoir ce qui se passe quand
leur ordinateur excute du code. De plus, ce chapitre expliquera beaucoup de notions concernant les branchements et les
instructions de test, survoles au chapitre prcdent, qui serviront plus tard quand on abordera la prdiction de branchement et
d'autres trucs du mme acabit. Et c'est sans compter que vous allez apprendre des choses intressantes, comme l'utilit de la pile
dans les architectures actuelles.
Program Counter
Il est vident que pour xecuter une suite d'instructions dans le bon ordre, notre ordinateur doit savoir quelle est la prochaine
instruction excuter. Il faut donc que notre processeur se souvienne de cette information quelque part : notre processeur doit
donc contenir une mmoire qui stocke cette information. C'est le rle du registre d'adresse d'instruction, aussi appel Program
Counter. Ce registre stocke l'adresse de la prochaine instruction excuter. Cette adresse permet de localiser l'instruction
suivante en mmoire. Cette adresse ne sort pas de nulle part : on peut la dduire de l'adresse de l'instruction en cours dexcution
par divers moyens plus ou moins simples qu'on verra dans la suite de ce tutoriel.
Ce calcul peut tre fait assez simplement. Gnralement, on profite du fait que ces instructions sont excutes dans un ordre bien
prcis, les unes aprs les autres. Sur la grosse majorit des ordinateur, celles-ci sont places les unes la suite des autres dans
l'ordre o elles doivent tre excutes. L'ordre en question est dcid par le programmeur. Un programme informatique n'est donc
qu'une vulgaire suite d'instructions stocke quelque part dans la mmoire de notre ordinateur.
Par exemple :
Adresse
Instruction
...
...
5464
Instruction d'arrt
www.openclassrooms.com
103/467
En faisant ainsi, on peut calculer facilement l'adresse de la prochaine instruction en ajoutant la longueur de l'instruction juste
charge (le nombre de case mmoire qu'elle occupe) au contenu du registre d'adresse d'instruction. Dans ce cas, l'adresse de la
prochaine instruction est calcule par un petit circuit combinatoire coupl notre registre d'adresse d'instruction, qu'on appelle
le compteur ordinal.
Les exceptions
Mais certains processeurs n'utilisent pas cette mthode. Mais il s'agit de processeurs particulirement rares. Sur de tels
processeurs, chaque instruction va devoir prciser o est la prochaine instruction. Pour ce faire, une partie de la suite de bits
reprsentant notre instruction xecuter va stocker cette adresse.
Dans ce cas, ces processeurs utilisent toujours un registre pour stocker cette adresse, mais ne possdent pas de compteur
ordinal, et n'ont pas besoin de calculer une adresse qui leur est fournie sur un plateau.
Et que ca saute !
En gros, un processeur est sacrment stupide s'il ne fait qu'excuter des instructions dans l'ordre. Certains processeurs ne
savent pas faire autre chose, comme le Harvard Mark I, et il est difficile, voire impossible, de coder certains programmes sur de
tels ordinateurs. Mais rassurez-vous : on peut faire mieux ! Il existe un moyen permettant au processeur de faire des choses plus
volues et de pouvoir plus ou moins s'adapter aux circonstances au lieu de ragir machinalement. Pour rendre notre ordinateur
"plus intelligent", on peut par exemple souhaiter que celui-ci n'excute une suite d'instructions que si une certaine condition est
remplie. Ou faire mieux : on peut demander notre ordinateur de rpter une suite d'instructions tant qu'une condition bien
dfinie est respecte.
Diverses structures de contrle de ce type ont donc ts inventes. Voici les plus utilises et les plus courantes : ce sont celles
qui reviennent de faon rcurrente dans un grand nombre de langages de programmation actuels. On peut bien sur en inventer
dautres, en spcialisant certaines structures de contrle des cas un peu plus particuliers ou en combinant plusieurs de ces
structures de contrles de base, mais cela dpasse le cadre de ce tutoriel : ce tutoriel ne va pas vous apprendre programmer.
Nom de la structure de
contrle
Ce qu'elle fait
SI...ALORS
SI...ALORS...SINON
excute une suite d'instructions si une condition est respecte ou excute une autre suite
d'instructions si elle ne l'est pas.
Boucle WHILE...DO
rpte une suite d'instructions tant qu'une condition est respecte. La diffrence, c'est que la
boucle DO...WHILE excute au moins une fois cette suite d'instructions.
Boucle FOR
Concevoir un programme (dans certaines langages de programmation), c'est simplement crer une suite d'instructions, et utiliser
ces fameuses structures de contrle pour l'organiser. D'ailleurs, ceux qui savent dj programmer auront reconnu ces fameuses
structures de contrle.
Reste adapter notre ordinateur pour que celui-ci puisse supporter ces fameuses structures. Et pour cela, il suffit simplement de
rajouter quelques instructions.
Pour que notre ordinateur puisse excuter ces structures de contrle basiques, il utilise :
des instructions de test, qui vrifient si une condition est respecte ou pas ;
et les instructions de saut ou branchements.
Instructions de test
www.openclassrooms.com
104/467
Ces instructions sont des instructions assez simples : elles permettent de comparer deux valeurs. Elles permettent gnralement
de comparer des nombres entiers. Mais certains processeurs fournissent des instructions pour comparer des nombres virgule
flottante, des caractres, ou des donnes plus complexes.
Ces instructions permettent souvent d'effectuer les comparaisons suivantes :
A < B (est-ce que A est suprieur B ?) ;
A > B (est-ce que A est infrieur B ?) ;
A == B (est-ce que A est gal B ?) ;
A != B (est-ce que A est diffrent de B ?.
Ces instructions dites de test ou de comparaison vont chacune fournir un rsultat qui est cod sur un bit, qui permettra de dire si
la condition teste est vraie ou fausse. Dans la majorit des cas, ce bit vaut 1 si la condition teste est vraie, et 0 sinon. Dans de
rares cas, c'est l'inverse.
Bien sur, ce bit de rsultat n'est pas plac n'importe o : notre processeur incorpore un registre spcialis, qui stocke ces
rsultats des comparaisons, ces bits. Il s'agit du registre d'tat. Ce registre d'tat est un registre, qui ne stocke pas de donnes
comme des nombres entiers, ou des nombres flottants, mais stocke des bits individuels. Chacun de ces bits a une signification
propre, prdtermine lors de la conception du processeur. Le bit du registre d'tat qui est modifi par une instruction de test
dpendent de l'instruction utilise. Par exemple, on peut utiliser un bit qui indiquera si l'entier test est gal un autre, un autre
bit qui indiquera si le premier entier test est suprieur gal l'autre, etc.
Il arrive que certaines de ces instructions de test effectuent plusieurs comparaisons en mme temps et fournissent plusieurs
rsultats : l'instruction de test modifie plusieurs bits du registre d'tat en une seule fois. Par exemple, un processeur peut trs
bien possder une instruction cmp capable de vrifier si deux valeurs A et B sont gales, diffrentes, si A est infrieure B, et si
A est suprieur B, en mme temps.
Branchements
Quoiqu'il en soit, ces instructions de test ne permettent pas de crer des structures de contrle elles seules. Elles doivent
imprativement tre combines avec d'autres instructions spciales, qu'on appelle des branchements. Ces branchements sont
des instructions qui modifient la valeur stocke dans le registre d'adresse d'instruction.
Elles permettent de sauter directement une instruction autre que l'instruction immdiatement suivante et poursuivre l'excution
partir de cette instruction. Cela permet au programme de passer directement une instruction situe plus loin dans le
droulement normal du programme, voire de revenir une instruction antrieure, plutt que d'excuter les instructions dans
l'ordre.
www.openclassrooms.com
105/467
Modes d'adressage
Ces branchements peuvent avoir trois modes d'adressages :
direct,
par offset,
indirect registre.
Dans le premier cas, l'oprande est simplement l'adresse de l'instruction laquelle on souhaite reprendre.
Dans le second cas, l'oprande est un nombre. Il suffit d'ajouter ce nombre l'adresse dj prsente dans le registre d'adresse
d'instruction pour tomber sur l'adresse voulue. On appelle ce nombre un Offset. De tels branchements sont appels des
branchements relatifs.
www.openclassrooms.com
106/467
Les branchements bass sur des dcalages permettent de localiser un branchement par rapport l'instruction en cours
dexcution : par exemple, cela permet de dire "le branchement est 50 instructions plus loin". Cela facilite la cration de
programmes qui se moquent compltement de l'adresse laquelle on les charge en mmoire. Sur certains ordinateurs capables
dexcuter plusieurs programmes "en mme temps", un programme n'est presque jamais charg en mmoire au mme endroit et
les adresses changent chaque excution.
Par dfaut, les branchements qui ne sont pas des branchements relatifs considrent que le programme commence l'adresse zro
et localisent leurs instructions partir de la premire adresse d'un programme. Pour localiser l'adresse de destination, on est
oblig de la calculer lexcution du programme, partir de l'adresse de base du programme, en effectuant une addition. Les
branchements relatifs ne sont pas concerns par ce genre de problme : ceux-ci ne reprent pas l'adresse de destination du
branchement par rapport l'adresse laquelle est place le branchement, contenue dans le registre d'adresse d'instruction.
Il existe un dernier mode d'adressage pour les branchements : l'adresse vers laquelle on veut brancher est stocke dans un
registre. L'oprande du branchement est donc un registre. Avec de tels branchements, l'adresse vers laquelle on souhaite
brancher peut varier au cours de lexcution du programme. On appelle de tels branchements des branchements indirects.
Ces branchements indirects sont opposer aux autre branchements qui sont ce qu'on appelle des branchements directs : avec
ces derniers, l'adresse vers laquelle il faut brancher est constante et ne peut en aucun cas varier (sauf cas particuliers utilisant du
Self-modifying code). Les branchemetns directs sont souvent utiliss pour crer les structures de contrle dont j'ai parl plus
haut. Par contre, les branchements indirects sont souvent camoufls dans des fonctionnalits un peu plus complexes de nos
langages de programmation (pointeurs sur fonction, chargement dynamique de DLL, structure de contrle Switch, etc) et il n'est
pas si rare d'en utiliser sans en avoir conscience.
Le Si...Alors
www.openclassrooms.com
107/467
Implmenter un simple Si...Alors est assez intuitif : il suffit de tester la condition, et de prendre une dcision suivant le rsultat du
branchement.
Voici ce que cela peut donner :
Avec cette organisation, on utilise un branchement tel que si la condition teste soie vraie, alors on poursuit lexcution sans
reprendre la suite du programme : on excute alors la suite d'instruction du Si...Alors, avant de reprendre la suite du
programme. Dans le cas o la condition teste est fausse, on reprend directement la suite du programme, sans xecuter la suite
d'instruction du Si...Alors.
Et a marche ! Enfin presque, i y a un problme : comment faire pour que le branchement conditionnel puisse faire ce qu'on lui
demande ? Et oui, j'ai dit plus haut qu'un branchement est excute quand la condition teste est vraie, valide, et pas autrement.
Pour cela il y a, deux solutions. La premire solution est assez intuitive : il suffit de tester la condition inverse celle ncessaire
pour faire excuter notre suite d'instruction de la structure de contrle Si...Alors. Pour la seconde solution, quelques explications
s'imposent. Comme je l'ai dit plus haut, notre branchement va sexcuter si certains bits du registre d'tat sont placs une
certaine valeur. Sur certains processeurs, il peut exister des branchements diffrents qui vrifient le mme bit du registre d'tat.
Seul diffrence : ces branchements sexcutent pour des valeurs diffrentes de ce bit. Ainsi, pour chaque test possible, il existe
un branchement qui sexcute quand une condition est valide, et un autre qui sexcute quand la condition n'est pas valide. Il
suffit de choisir un branchement qui sexcute quand une condition teste n'est pas valide pour viter d'avoir inverser le test.
Si...Alors...Sinon
Cette structure de contrle sert effectuer un traitement diffrent selon que la condition est respecte ou non : si la condition est
respecte, on effectue une suite d'instruction ; tandis que si elle ne l'est pas, on effectue une autre suite d'instruction diffrente.
C'est une sorte de Si...Alors contenant un second cas. Pour implmenter cette structure de contrle, on peut donc amliorer le
Si...Alors vu plus haut. La seule diffrence, c'est l'endroit vers lequel le branchement conditionnel va nous envoyer.
L'astuce est de placer les deux suites d'instructions les unes aprs les autres. Le branchement conditionnel enverra sur la suite
excuter quand la condition voulue par le programmeur n'est pas ralise. Dans le cas contraire, on poursuit lexcution du
programme aprs le branchement et on retombe sur le cas du Si...Alors.
www.openclassrooms.com
108/467
Pour viter dexcuter les deux suites les unes aprs les autres, on place un branchement inconditionnel la fin de la suite
d'instruction excuter quand la solution est vraie. Ce branchement renverra sur la suite du programme.
Je tiens signaler qu'on est pas limit seulement deux suites dinstructions : on peut imbriquer des structures de contrle
Si...Alors...Sinon les unes dans les autres, si le besoin s'en fait sentir. Dans ce cas, il faut bien penser mettre un branchement
inconditionnel branchant sur la suite du programme aprs chaque suite d'instruction (sauf la dernire, qui est immdiatement
suivie par la suite du programme).
Boucles
Voyons maintenant comment un CPU fait pour excuter une boucle. Pour rappel, une boucle consiste rpter une suite
d'instructions CPU tant qu'une condition est valide (ou fausse). En gros, les boucles peuvent tre vues comme des variantes de
la structure de contrle Si...Alors. Plutt que de reprendre l'excution du programme aprs la suite d'instructions excute quand
la condition est valide (cas du Si...Alors), on reprend l'excution du programme l'instruction de test. Histoire de rpter les
instructions dj excutes.
Boucle Do...While
www.openclassrooms.com
109/467
Je vais tout d'abord commencer par la boucle la plus simple qui soit : la boucle Do...While. Dans la boucle Do...While, on
souhaite que la suite d'instructions soit rpte tant qu'une certaine condition est vrifie, et qu'en plus, elle soit excute au
moins une fois !
Pour cela, la suite d'instructions excuter est place avant les instructions de test et de branchement.
En faisant ainsi, notre suite d'instruction est excute une fois, avant de rencontrer une instruction de test qui va tester la
condition de la boucle. Si jamais la condition teste est vrifie (valide), alors notre branchement va renvoyer notre processeur
vers la premire instruction de la suite d'instruction rpter. Si jamais la condition teste est fausse, on passe tout simplement
la suite du programme. Si on regarde bien, c'est bien le comportement qu'on attend d'une boucle Do...While.
While...Do, le retour !
Une boucle While...Do est identique une boucle Do...While un dtail prt : la suite d'instruction de la boucle n'a pas forcment
besoin d'tre excute. On peut trs bien ne pas rentrer dans la boucle dans certaines situations.
On peut donc adapter une boucle Do...While pour en faire une boucle While...Do : il suffit de tester si notre boucle doit tre
excute au moins une fois, et excuter une boucle Do...While quivalente si c'est le cas. Si la boucle ne doit pas tre excute,
on poursuit partir de la suite du programme directement. Et pour cela, il suffit de placer une instruction qui teste si on doit
renter dans la boucle, accouple un branchement qui renvoie sur la suite du programme si jamais on n rentre pas dans la
boucle.
www.openclassrooms.com
110/467
Boucle FOR
Une boucle For n'est qu'une boucle While...Do un peu spciale. Aucune diffrence particulire dans la faon de crer une boucle
for et une boucle While...Do n'existe dans la faon dont notre ordinateur excute la boucle : c'est seulement ce qui est test qui
change et rien d'autre.
A quoi a sert ?
Lorsque vous crez un programme, le rsultat sera une grosse suite d'instructions codes en langage machine, avec des 0 et des
1 partout : c'est une horreur ! Et parmi cette gigantesque suite d'instructions, il y a souvent des "sous-suites", des paquets
d'instructions qui reviennent rgulirement et qui sont prsents en plusieurs exemplaires dans le programme final. Ces soussuites servent quasiment toujours excuter une tache bien prcise et ont presque toujours une signification importante pour le
programmeur. Par exemple, il va exister une de ces sous-suite qui va servir calculer un rsultat bien prcis, communiquer avec
un priphrique, crire un fichier sur le disque dur, ou autre chose encore.
Sans sous-programmes
www.openclassrooms.com
111/467
Sans utiliser de sous-programmes, ces suites d'instructions sont prsentes en plusieurs exemplaires dans le programme. Le
programmeur doit donc recopier chaque fois ces suites d'instructions, ce qui ne lui facilite pas la tache (sauf en utilisant
lanctre des sous-programmes : les macros). Et dans certains programmes, devoir recopier plusieurs fois la squence
d'instruction qui permet d'agir sur un priphrique ou de faire une action spciale est franchement barbant ! De plus, ces suites
d'instructions sont prsentes plusieurs fois dans le programme final, excut par l'ordinateur. Et elles prennent de la place
inutilement !
On a donc cherch un moyen qui ferait que ces suites d'instructions soient prsentes une seule fois dans le programme et
utilisables au besoin. On a donc invent les sous-programmes.
www.openclassrooms.com
112/467
www.openclassrooms.com
113/467
La solution : sauvegarder l'adresse de l'instruction laquelle il faut reprendre ! Notre programme doit donc reprendre
l'instruction qui est juste aprs le branchement qui pointe vers notre sous-programme. Pour cela, on doit sauvegarder cette
adresse appele l'adresse de retour.
Cette sauvegarde peut tre faite de deux manires :
soit le processeur possde une instruction spciale, capable de sauvegarder l'adresse de retour et de brancher vers le
sous-programme voulu en une seule instruction ;
soit on doit muler cette instruction avec une instruction qui sauvegarde l'adresse de retour, suivie d'un branchement
inconditionnel qui pointera vers notre sous-programme.
Pour le premier cas, cette instruction spciale est capable de sauvegarder automatiquement l'adresse de retour et de brancher
vers le sous-programme. On appelle cette instruction une instruction d'appel de fonction.
Reprenons l o on en tait
Une fois le sous-programme fini, il suffit de charger l'adresse de retour dans le registre pointeur d'instruction pour reprendre
lexcution de notre programme principal l o il s'tait arrt pour laisser la place au sous-programme. L encore, deux solutions
sont possibles pour faire cela.
Sur certains processeurs, cela est fait par l'instruction situe la fin du sous-programme, qu'on nomme instruction de retour.
C'est un branchement inconditionnel. Cette instruction a pour mode d'adressage, l'adressage implicite (l'adresse vers laquelle
brancher est place au sommet de la pile, pas besoin de la prciser).
Sur d'autres, cette instruction spciale n'existe pas et il faut encore une fois l'muler avec les moyens du bord. L'astuce consiste
souvent charger l'adresse de retour dans un registre et utiliser un branchement inconditionnel vers cette adresse.
Paramtres et arguments
Notre sous-programme va parfois modifier des donnes en mmoire RAM. Cela peut poser problme dans certains cas : on peut
avoir besoin de conserver les anciennes donnes manipules par le sous-programme. Pour cela, le sous-programme va devoir
www.openclassrooms.com
114/467
manipuler une copie de ces donnes pour que notre sous-programme puisse les manipuler loisir. Ces copies seront appeles
des arguments ou encore des paramtres. Ces paramtres sont choisis par le programmeur qui cre le sous-programme en
question.
Pour cela deux solutions :
soit on les passe par la pile ;
soit on passe les arguments dans les registres.
La premire solution utilise la pile. Vu que notre pile est une simple portion de la mmoire RAM, on peut stocker ce qu'on veut
dans une stack frame, et pas seulement une adresse de retour. On va donc, dans certains cas, copier les donnes manipuler
dans la pile. C'est ce qu'on appelle le passage par la pile.
Seconde solution : stocker directement les arguments dans les registres du processeur si ils sont peu nombreux, sans avoir
utiliser la pile. Comme cela, le processeur pourra les manipuler directement sans devoir les charger depuis la RAM ou les stocker
dans le cache. C'est le passage par registre.
Suivant le langage de programmation, le compilateur, le systme d'exploitation ou le processeur utilis, les sous-programmes
utiliseront soit le passage par la pile, soit le passage par registre, ou encore un mlange des deux. Gnralement, le passage par la
pile est trs utilis sur les processeurs CISC, qui ont peu de registres. Par contre, les processeurs RISC privilgient le passage
par les registres : il faut dire que les processeurs RISC ont souvent un grand nombre de registre, ce qui permet de passer
beaucoup d'arguments sans trop de problmes.
Fentrage de registres
Quoiqu'il en soit, excuter un sous-programme prend du temps : il faut sauvegarder l'adresse de retour, empiler les arguments,
empiler une copie des registres du processeur, etc. Pour limiter le temps mit grer la sauvegarde des registres, certains
processeurs utilisent une petite astuce assez sympa nomme le fentrage de registres.
Les processeurs utilisant le fentrage de registres possdent des registres supplmentaires cachs, invisibles pour le
programmeur. Par exemple, si notre processeur possde 8 registres architecturaux, (ce sont des registres qui possdent un nom et
qui sont donc manipulables par notre programme), alors le fentrage de registre impose la prsence de 2, 3, 4, 8 fois plus de
registres. Dans le cas du fentrage de registre, seule une petite partie de ces registres peut tre manipulable par un programme ou
un sous-programme : on appelle cette partie une fentre de registre. Ces fentres ont toute la mme taille, et contiennent autant
de registres qu'il y a de registres architecturaux.
Prenons un exemple : un processeur dont le jeu d'instruction contient 3 registres architecturaux, et qui contient en ralit 12
registres. Ces 12 registres sont regroups dans des paquets, des fentres de 3 registres : cela nous fait donc 4 fentres
diffrentes.
www.openclassrooms.com
115/467
Lorsque notre programme sexcute, il va utiliser 3 registres en tout : une fentre sera donc utilis par notre programme principal.
Si un sous-programme veut sexcuter, notre processeur va faire en sorte que notre sous-programme utilise une fentre (un
paquet) de registres inutilise : pas besoin de sauvegarder les 3 registres principaux, vu que notre sous-programme ne les
utilisera pas et manipulera 3 registres diffrents appartenant une autre fentre !
Bien sr, cela fonctionne pour chaque sous-programme qui cherche sexcuter : on lui attribue une fentre de registres vierge,
inutilise, qu'il pourra utiliser loisir, au lieu d'utiliser une fentre dj prise. videmment, cela ne marche que s'il reste une fentre
inutilise. Dans le cas contraire, on est oblig de sauvegarder les registres d'une fentre dans la pile. Avec notre exemple 4
fentres, on peut donc excuter un programme, et 3 sous-programmes imbriqus.
Au fait : vous avez remarqu ? Un sous-programme est cens manipuler des registres architecturaux, mais utilisera en fait des
registres cachs, localiss dans une autre fentre. Le fait est que chaque registre architectural est prsent en plusieurs
exemplaires, un dans chaque fentre. Ainsi, deux registres placs dans des fentres diffrentes peuvent avoir le mme nom.
Lorsqu'un sous-programme sexcute, il manipulera le registre architectural localis dans la fentre qui lui a t attribue. On voit
bien que les registres utilisables en assembleur sont diffrents des registres rellement prsent dans le processeur. Et ce n'est
pas la seule situation dans laquelle certains registres architecturaux seront prsents en double, comme on le verra dans la suite
du tutoriel.
Valeur de retour
Un sous-programme peut parfois servir calculer un rsultat, et qu'il faut bien fournir ce rsultat quelque part. On pourra donc le
rcuprer pour faire quelque chose avec. Gnralement, c'est le programmeur qui dcide de conserver une donne. Celui-ci peut
avoir besoin de conserver le rsultat d'un calcul pour pouvoir l'utiliser plus tard, par exemple. Ce rsultat dpend fortement du
sous-programme, et peut tre n'importe quelle donne : nombre entier, nombre flottant, tableau, objet, ou pire encore. Cette
donne est appele la valeur de retour du sous-programme.
Cette donne, aprs avoir t "calcule" par le sous-programme, devra tre conserve quelque part : calculer une valeur de retour
www.openclassrooms.com
116/467
Variables automatiques
Un sous-programme doit gnralement manipuler des donnes temporaires qui lui permettent de faire ce qu'on lui demande. Ces
donnes sont des donnes internes au sous-programme, que lui seul doit manipuler et qui ne doivent gnralement pas tre
accessibles dautres programmes ou sous-programmes. Dans certains langages de programmation, on appelle ces variables des
variables locales.
Une solution pour grer ces variables pourrait consister rserver une portion de la mmoire chaque sous-programme,
spcialement ddie au stockage de ces variables. Mais cela prendrait trop de mmoire, et rserver dfinitivement de la mmoire
pour stocker des donnes temporaires de faon occasionnelle serait du gchis. Sans compter le cas dans lequel un sousprogramme s'appelle lui-mme : il vaut mieux que ces appels de sous-programmes aient des donnes places dans des
emplacements mmoires bien spars, pour viter des catastrophes.
Pour cela, ces donnes sont cres pendant l'excution du sous-programme, restent en mmoire tant que le sous-programme
s'excute, et sont effaces ds que le sous-programme termine. La solution consiste rserver une partie d'une stack frame pour
stocker ces donnes durant l'excution du sous-programme. En effet, quand on dpile une stack frame la fin de lexcution d'un
sous-programme, le contenu de celle-ci est compltement perdu. On appelle de telles donnes temporaires, stockes sur la pile
des variables automatiques.
On peut aussi stocker ces donnes internes que le sous-programme doit manipuler dans les registres du processeur, si elles sont
peu nombreuses. Comme cela, le processeur pourra les manipuler directement sans devoir les charger depuis la RAM ou les
stocker dans le cache.
Pour manipuler ces variables automatiques, ainsi que les arguments/paramtres, notre processeur dispose parfois de modes
d'adressages spcialiss, qui permettent de slectionner une donne dans une Stack Frame. Gnralement, ces modes
d'adressage permettent d'ajouter une constante l'adresse du dbut de la Stack Frame (cette adresse tant stocke dans un
registre).
Plusieurs piles
Certains processeurs ne possdent qu'une seule pile dans laquelle un programme mettra la fois les adresses de retour, les
variables locales, les paramtres, et le reste des informations ncessaires pour excuter notre sous-programme sans accros.
Nanmoins, certaines processeurs sont plus malins et possdent deux ou plusieurs piles, chacune tant spcialise.
On peut ainsi avoir :
www.openclassrooms.com
117/467
www.openclassrooms.com
118/467
Instruction Cycle
Il va d'abord devoir passer par une premire tape : l'tape de Fetch. Lors de cette premire tape, le processeur va charger
l'instruction depuis la mmoire et la stocker dans un registre spcialis pour la manipuler. A la fin de cette tape, l'instruction est
alors stocke dans un registre : le registre d'instruction.
Ensuite, notre processeur va passer par lire l'instruction dans le registre d'instruction et va en dduire comment configurer les
circuits du processeur pour que ceux-ci excutent l'instruction voulue : on dit que notre processeur va devoir dcoder
l'instruction. Une fois que c'est fait, le processeur va commander les circuits du processeur pour qu'ils excutent l'instruction.
Notre instruction va sexcuter. C'est l'tape dexcution. Cette excution peut tre un calcul, un change de donne avec la
mmoire, des dplacements de donnes entre registres, ou un mlange des trois.
Ces deux tapes forment ce qu'on appelle l'Instruction Cycle. Tout processeur doit au minimum effectuer ces deux tapes dans
l'ordre indiqu au dessus : Fetch, puis excution. Il se peut que certains processeurs rajoutent une tape en plus, pour grer
certaines erreurs, mais on n'en parlera pas pour le moment.
Micro-instructions
Si tous les processeurs doivent grer ces deux tapes, cela ne veut pas dire que chaque tape s'effectue d'un seul bloc. Chacune
de ces tapes est elle-mme dcoupe en plusieurs sous-tapes. Chacune de ces sous-tapes va aller changer des donnes
entre registres, effectuer un calcul, ou communiquer avec la mmoire. Pour l'tape de Fetch , on peut tre sr que tous les
processeurs vont faire la mme chose : il n'y a pas 36 faons pour lire une instruction depuis la mmoire. Mais cela change pour
l'tape dexcution : toutes les instructions n'ont pas les mmes besoins suivant ce qu'elles font ou leur mode d'adressage.
Voyons cela avec quelques exemples.
tape 1
tape 2
Fetch
Lecture de la donne
en mmoire
Mais si l'on utilise des modes d'adressages plus complexes, les choses changent un petit peu. Reprenons notre instruction Load,
mais en utilisant une mode d'adressage utilis pour des donnes plus complexe. Par exemple, on va prendre un mode d'adressage
du style Base + Index. Avec ce mode d'adressage, l'adresse doit tre calcule partir d'une adresse de base, et d'un indice, les
deux tant stocks dans des registres. En plus de devoir lire notre donne, notre instruction va devoir calculer l'adresse en
fonction du contenu fourni par deux registres.
tape 1
tape 3
tape 4
www.openclassrooms.com
119/467
Fetch
Calcul d'adresse
Lecture de la donne
en mmoire
Notre instruction s'effectue dornavant en trois tapes, pas deux. Qui plus est, ces tapes sont assez diffrentes : une implique
un calcul, et les autres impliquent un accs la mmoire.
Instruction de calcul
Prenons maintenant le cas d'une instruction d'addition. Celle-ci va additionner deux oprandes, qui peuvent tre soit des
registres, soit des donnes places en mmoires, soit des constantes. Si les deux oprandes sont dans un registre et que le
rsultat doit tre plac dans un registre, alors la situation est assez simple. Il suffit simplement d'aller rcuprer les oprandes
dans les registres, effectuer notre calcul, et enregistrer le rsultat. Suivant le processeur, cela peut se faire en une ou plusieurs
tapes.
On peut ainsi avoir une seule tape qui effectue la rcupration des oprandes dans les registres, le calcul, et l'enregistrement du
rsultat dans les registres.
tape 1 tape 2
Fetch
tape 3
Decode
Mais il se peut que sur certains processeurs, cela se passe en plusieurs tapes.
tape 1 tape 2
Fetch
Decode
tape 3
tape 4
tape 5
Rcupration
des oprandes
Calcul
Enregistrement
du rsultat
Maintenant, autre exemple : une oprande est aller chercher dans la mmoire, une autre dans un registre, et le rsultat doit tre
enregistr dans un registre. On doit alors rajouter une tape : on doit aller chercher la donne en mmoire.
tape 1 tape 2
Fetch
Decode
tape 3
tape 4
Et on peut aller plus loin en allant cherche notre premire oprande en mmoire : il suffit d'utiliser le mode d'adressage Base +
Index pour celle-ci. On doit alors rajouter une tape de calcul d'adresse en plus. Ne parlons pas des cas encore pire du style : une
oprande en mmoire, l'autre dans un registre, et stocker le rsultat en mmoire.
tape 1 tape 2
Fetch
tape 3
tape 4
tape 5
Conclusion
www.openclassrooms.com
120/467
Bref, on voit bien que lexcution d'une instruction s'effectue en plusieurs sous-tapes bien distinctes. Chacune de ces tapes
s'appelle une micro-opration. Chacune de ces micro-opration va : soit effectuer une lecture ou criture en mmoire RAM, soit
effectuer un calcul, soit changer des donnes entre registres. Chaque instruction machine est quivalente une suite de
micro-oprations excute dans un ordre prcis. C'est ainsi que fonctionne un processeur : chaque instruction machine est
traduite en suite de micro-oprations lors de son excution, chaque fois qu'on lexcute.
Pour crer un processeur qui fonctionne, on doit imprativement crer de quoi effectuer des micro-oprations, de quoi demander
d'effectuer une micro-opration parmi toutes les autres, et de quoi les cadencer dans le bon ordre en fonction de l'instruction
excuter. Pour cela, notre processeur va devoir tre organis d'une certaine faon, en plusieurs circuits.
Le Datapath
Notre processeur dispose donc d'un ou de plusieurs circuits chargs d'effecteur des calculs : ce sont des units de calcul. Ils
servent pour effecteur des instructions de calcul, ou pour calculer des adresses mmoires (dans le mode dadressage Base +
Index, par exemple).
De mme, notre processeur possde un circuit qui lui permet de communiquer avec la mmoire. notre processeur peut ainsi aller
configurer des bus d'adresse, lire ou crire sur le bus de donne, etc. Sur les processeurs modernes, ce circuit s'appelle la
Memory Management Unit .
Notre processeur dispose aussi de registres. Et il faut bien faire communiquer ces registres avec la mmoire, l'unit de calcul, ou
faire communiquer ces registres entre eux ! Pour cela, notre processeur incorpore un bus permettant les changes entre tout ce
beau mode.
L'intrieur de notre processeur ressemble donc ceci :
Cet ensemble minimal de composants ncessaire pour effectuer nos instructions s'appelle le Datapath, ou chemin de donnes.
On l'appelle ainsi parce qu'il regroupe tous les composants qui doivent manipuler des donnes.
Chaque micro-opration va effectuer une manipulation sur ce Datapath. Par exemple, une micro-opration pourra relier des
registres sur les entres de lunit de calcul, demander celle-ci de faire un calcul, et relier sa sortie sur un registre. Ou alors, une
micro-opration pourra relier des registres sur le circuit permettant de communiquer avec le bus pour effecteur une lecture ou
criture. Ou alors, on pourra configurer notre bus de faon copier le contenu d'un registre dans un autre. Bref, chacune des
micro-oprations vue plus haut s'effectuera en configurant notre unit de calcul, en configurant notre bus, ou en configurant
notre unit de communication avec la mmoire.
www.openclassrooms.com
121/467
Le squenceur
Mais pour pouvoir effectuer une instruction, il faut non seulement savoir effectuer chaque micro-opration de celle-ci, mais il
faut aussi effectuer les bonnes micro-oprations dans le bon ordre. Par exemple, on ne doit pas actionner l'unit de calcul pour
une lecture. Et il ne faut pas effectuer de calcul d'adresse pour une lecture en mode d'adressage absolu. Bref, il doit configurer le
Datapath, et il doit effectuer les bonnes configurations les unes aprs les autres dans le bon ordre. Pour ce faire, notre
processeur contient un circuit qui se charge d'effecteur chaque micro-opration ncessaire lexcution de notre instruction
dans le bon ordre en fonction de l'instruction : c'est le squenceur.
Ce squenceur va envoyer des ordres aux autres circuits, afin de les configurer comme il faut. Ces ordres, ce sont des signaux de
commande. L'intrieur de notre processeur ressemble donc quelque chose dans le genre :
L'organisation illustre dans le schma est une organisation minimale, que tout processeur doit avoir. On peut la modifier et
l'amliorer. On peut ainsi y rajouter des registres spcialiss comme un registre d'tat, rajouter une connexion entre le Program
Counter et le bus interne pour permettre les branchements relatifs ou indirects, rajouter des bus internes, etc. On peut aussi
penser aux processeurs communiquant avec la mmoire par deux bus spars : un pour une mmoire ddie aux instructions, et
un autre pour les donnes, etc. Bref, on ne va pas tout citer, il y en aurait pour une heure !
Maintenant qu'on sait quels sont les grands circuits prsents dans notre processeur, on va voir ceux-ci plus en dtail. Nous
allons commencer par voir l'unit de calcul, et voir quoi celle-ci ressemble de lextrieur. Ensuite, nous verrons les registres du
processeur, ainsi que l'interface avec la mmoire. Et enfin, nous regarderons l'organisation du bus interne, avant de passer au
squenceur, ainsi qu' l'unit de Fetch. Un beau programme en perspective !
www.openclassrooms.com
122/467
comparaisons).
Les instructions effectues par ces units de calcul sont donc le plus souvent :
des additions ;
des soustractions ;
des multiplications ;
des divisions ;
des changements de signe ;
des dcalages logiques ;
des dcalages arithmtiques ;
des rotations ;
des NON logiques ;
des ET logiques ;
des OU logiques ;
des XOR logiques ;
des comparaisons ;
des test d'galit ;
etc.
Certaines units de calculs sont assez rudimentaires, et ne peuvent pas effectuer beaucoup d'instructions : on peut parfaitement
crer des units de calcul ne sachant faire que des oprations simples comme des ET, OU, et NON logiques. Par contre, d'autres
units de calcul sont plus volues et peuvent faire normment d'instructions diffrentes : certaines units de calcul sont
capables d'effectuer toutes les instructions cites au-dessus, et quelques autres comme calculer des racines carres, des
tangentes, arc-tangentes, cosinus, etc.
Vu de lextrieur
Nos instructions de comparaisons sont prises en charge par l'unit de calcul et elles doivent mettre jour le registre d'tat. Et
c'est sans compter sur certaines oprations de calcul qui doivent mettre jour le registre d'tat : prenez l'exemple du bit NULL,
cit il y a quelques chapitres. On peut donc en dduire que le registre d'tat est obligatoirement reli certaines sorties de
lunit de calcul.
De plus, il faudra bien spcifier l'instruction effectuer notre unit de calcul parmi toutes celles qu'elle est capable de faire.
Aprs tout, il faut bien prvenir notre unit de calcul qu'on veut faire une addition et pas une multiplication : elle ne peut pas le
deviner toute seule ! Il faut donc configurer notre unit de calcul pour que celle-ci excute l'instruction voulue et pas une autre.
Pour cela, notre unit de calcul possde une entre permettant de la configurer convenablement. Cette entre supplmentaire
s'appelle l'entre de slection de l'instruction.
Sur cette entre, on va mettre un nombre cod en binaire qui prcise l'instruction effectuer. Suivant le nombre qu'on va placer
sur cette entre de slection de l'instruction, notre unit de calcul effectuera une addition, une multiplication un dcalage, etc.
Pour chaque unit de calcul, il existe donc une sorte de correspondance entre le nombre qu'on va placer sur l'entre de slection
de l'instruction, et l'instruction excuter :
Entre de slection de l'instruction Instruction effectue par l'unit de calcul
0000
NOP
0111
Addition
1111
Multiplication
0100
ET logique
1100
Dcalage droite
...
...
Pour votre culture gnrale, voici comment sont gnralement schmatises ces fameuses units de calcul :
www.openclassrooms.com
123/467
Ce schma montre une unit de calcul effectuant des instructions sur une ou deux donnes la fois : elle possde trois entres
et deux sorties.
www.openclassrooms.com
124/467
Bien sr, ces multiplexeurs doivent tre commands pour se mettre dans la bonne position : l'entre de slection sert cela.
Unit configurer
Utiliser un circuit pour chaque instruction semble tre une solution assez sympathique. Mais si on regarde bien, elle possde un
dfaut assez important : certains morceaux de circuits sont prsents en double dans notre unit de calcul. Cela ne se voit pas
dans les schmas du haut, mais vous allez rapidement comprendre par un bref exemple.
Supposons que j'aie une ALU qui soit capable d'effectuer des additions et des soustractions. En utilisant la technique vue audessus, j'aurais donc besoin de deux circuits : un pour les additions et un pour les soustractions. Visiblement, il n'y a pas de
duplications, premire vue. Mais si on regarde bien le circuit qui effectue la soustraction, on remarque que certains circuits
sont prsents en double. Notre soustracteur est compos de deux circuits, relis en srie. Il est compos d'un circuit qui inverse
tous les bits de notre oprande, et d'un additionneur. On verra pourquoi au prochain chapitre.
L'additionneur est donc prsent en double : une fois dans le circuit charg des soustractions et une autre fois dans celui capable
d'effectuer les additions. Bien videmment, il est plus conome en terme de circuits de ne pas avoir placer deux additionneurs
dans notre processeur. Pour viter ce problme, on regroupe l'additionneur et l'inverseur dans un seul circuit et on slectionne
l'inverseur quand on veut effectuer une soustraction. Et ce qui peut tre fait pour un additionneur peut aussi tre fait pour
d'autres circuits. Pour cela, certaines units de calcul sont composes de circuits lmentaires qui sont slectionns ou dslectionns au besoin, suivant l'instruction excuter. Le choix des circuits activer ou dsactiver peut se faire de deux faons
diffrentes.
Avec la premire faon, ce choix est fait grce des "interrupteurs lectroniques" (des transistors ou des multiplexeurs) qui
connecteront entre eux les circuits utiliser et dconnecteront les circuits qui sont inutiles pour effectuer l'instruction choisie.
Suivant la valeur de l'entre de slection de l'instruction, quelques petits circuits internes l'unit de calcul se chargeront de
fermer ou d'ouvrir ces "interrupteurs" convenablement. Dans notre exemple, ce la reviendrait faire ceci :
www.openclassrooms.com
125/467
Pour spcifier qu'on veut faire une addition ou une soustraction, il faut alors placer une entre charge de spcifier s'il faut
connecter ou dconnecter le circuit inverseur : cette entre permettra de configurer le circuit. Ce qu'il faut mettre sur cette entre
sera dduit partir de l'entre de slection d'instruction de l'ALU.
Une autre solution peut tre de placer en srie des circuits, qu'on va activer ou dsactiver au besoin. Ces circuits possdent une
entre qui leur demandera de fonctionner. Suivant la valeur de cette entre, ces circuits vont agir diffremment : soit ils vont faire
ce qu'on leur demandent, soit ils recopieront leur entre sur leur sortie (il ne feront rien, quoi).
Ce qu'il faut mettre sur cette entre sera dduit partir de l'entre de slection d'instruction de l'ALU.
Dans la ralit
www.openclassrooms.com
126/467
les units de calcul de nos processeurs actuels sont un mlange de tout ce qui a t vu au-dessus. Les units de calcul les plus
compltes sont en effet dcoupes en pleins de circuits, certains devant tre configurs, d'autres relis, etc. Tout ce passe
comme si ces circuits se comportaient comme des sous-units de calculs inclues dans une unit de calcul plus grosse. Par
exemple, on peut avoir une sous-unit de calcul qui se charge des dcalages et des rotations (un barrel shifter), une autre qui se
charge des oprations logiques (ET, OU, NON, XOR), une autre pour les additions, soustractions et comparaisons, une autre
pour la multiplication, etc.
Autant dire que l'intrieur d'une unit de calcul est assez sympathique. Dans ce genre de cas, une partie seulement de l'entre de
slection sert slectionner un circuit, le reste servant configurer le circuit slectionn.
Bit Slicing
Sur certains processeurs assez anciens, l'ALU est elle-mme dcoupe en plusieurs ALU plus petites, chacune capable
d'effectuer toutes les instructions de l'ALU, relies entre elles, qui traitent chacune un petit nombre de bits. Par exemple, l'ALU
des processeurs AMD's Am2900 est une ALU de 16 bits compose de plusieurs sous-ALU de 4 bits. Cette technique qui
consiste crer des units de calcul plus grosses partir dunits de calcul plus lmentaires s'appelle en jargon technique du
Bit Slicing.
Units annexes
Il y a au moins une unit de calcul dans un processeur. Ceci dit, il n'est pas rare qu'un processeur possde plusieurs units de
calcul. Cela peut avoir diverses raisons : cela peut-tre pour des raisons de performance, pour simplifier la conception du
processeur, ou pour autre chose.
FPU
Dans certains cas, le processeur disposent d'units de calcul supplmentaires, capables d'effectuer des calculs sur des nombres
flottants. Il faut dire que les circuits pour faire un calcul sur un entier ne sont pas les mmes que les circuits faisant la mme
opration sur des flottants. Certains processeurs s'en moquent et utilisent une seule unit de calcul capable d'effectuer la fois
des calculs sur des entiers que des calculs sur des flottants.
Mais dans d'autres processeurs, les circuits calculant sur les entiers et ceux manipulant des flottants sont places dans des
units de calculs spares. On se retrouve donc avec une unit de calcul spcialise dans le traitement des nombres flottants :
cette unit s'appelle la Floating Point Unit . On utilise souvent l'abrviation FPU pour dsigner cette Floating Point Unit .
Les instructions supportes par les FPU et une unit de calcul sur des entiers sont souvent diffrentes. Les FPU peuvent
effectuer d'autres instructions supplmentaires en plus des traditionnelles oprations arithmtiques : des racines carres, des
sinus, des cosinus, des logarithmes, etc. Et c'est normal : les rsultats de ces oprations sont souvent des nombres virgules et
www.openclassrooms.com
127/467
ALU spcialises
Un processeur peut aussi disposer dunits de calcul spcialises, spares de l'unit de calcul principale. Par exemple, un
processeur peut contenir des units charges d'effectuer des instructions de dcalage, des units spcialises dans le calcul de
certaines instructions, etc. Pour donner un exemple, les divisions sont parfois excutes dans des circuits part. Cette
sparation est parfois ncessaire : certaines oprations sont assez compliques insrer dans une unit de calcul normale, et les
garder part peut simplifier la conception du processeur.
Registres simples
Comme on l'a vu il y a quelques chapitre, un registre est fabriqu partir de mmoires de 1 bits qu'on appelle des bascules. Ces
bascules possdent une entre sur laquelle on place un bit mmoriser, et une sortie sur laquelle le bit mmoris est disponible
en permanence. En regroupant plusieurs de ces bascules ensembles, et en reliant les entres d'autorisation d'criture ensembles,
on obtient un registre tout ce qu'il y a de plus simple.
Ce registre devra tre lu et crit, quel qu'il soit. Peut importe sa fonction dans le processeur, peu importe qu'il stocke une donne,
une adresse, une instruction, etc. Il devra pouvoir tre crit, lu, mais aussi tre dconnect du Datapath : il arrive qu'on ne
veuille ni lire, ni crire dans notre registre. Pour cela, on doit pouvoir connecter ou dconnecter notre registre au Datapath,
suivant les besoins. De plus, on veut pouvoir spcifier si on effectue une lecture ou une criture.
Pour cela, les entres et les sorties de nos registres sont relies au Datapath par des transistors. En ouvrant ou fermant ceux-ci,
on peut dconnecter nos registres du Datapath , connecter les sorties des bascules sur le bus pour effectuer une lecture, ou
connecter les sorties sur le bus pour une criture.
On le voit sur ce schma, certains transistors sont intercals entre les sorties du registre et le reste du Datapath : ceux-ci servent
autoriser la lecture du registre. Les transistors intercals entre les entres et le reste du Datapath servent pour l'criture.
www.openclassrooms.com
128/467
Chacun de ses ensemble de transistor va tre regroup au Datapath par un ensemble de fils qu'on appelle un port. Avec les
registres de notre processeur, on dispose d'un au moins un port pour la lecture, et d'un port pour l'criture pour chaque registre.
Tout les transistors d'un port sont commands en mme temps par un seul signal. Ce signal est gnr par le squenceur, en
fonction de l'instruction excuter et du registre prcis par le mode d'adressage de linstruction. Suivant la complexit du
processeur, le nombre de registre, et l'architecture, gnrer les signaux pour chaque registre peut tre plus ou moins complexe.
Registres non-rfrencables
De nombreux registres d'un processeur n'ont pas de noms de registres ou d'adresse. C'est le cas du Program Counter sur la
majorit des processeurs. Idem pour le registre d'tat, ou certains autres registres. Ceux-ci sont obligatoirement slectionns
implicitement par certaines instructions, seules autorises en modifier le contenu. Ces registres sont simplement implments
comme indiqu au-dessus, directement avec des bascules. Ils sont relis au Datapath d'une faon ou d'une autre, et le
squenceur se charge de fournir les signaux de lecture et d'criture aux transistors.
On peut citer le cas du registre accumulateur, prsent sur les architectures accumulateur. Cet accumulateur est implment le
plus simplement du monde : il s'agit d'un regroupement de bascules, sans rien d'autre. A chaque fois qu'une instruction doit
utiliser l'accumulateur, le squenceur va autoriser les critures dans celui-ci, en mettant 1 le signal d'criture. Celui-ci est relie
l'unit de calcul de cette faon :
Register File
Mais un processeur se contente rarement d'un simple accumulateur. Dans la plupart des cas, notre processeur incorpore des tas
de registres plus ou moins varis. Dans ce cas, on devra pouvoir slectionner les registres manipuler parmi tous les autres. Cela
se fait en utilisant des noms de registres (ou ventuellement des adresses, mais passons).
Sur les processeurs utilisant des noms de registres, on rassemble nos registres dans un seul grand composant qu'on appelle le
Register File. On peut voir ce Register File comme une sorte de grosse mmoire dont chaque case mmoire serait un registre. Il
s'agit rellement d'une mmoire : ce Register File contient des entres qui permettent de slectionner un registre, des entres de
commande, et des entres sur lesquelles on envoie des donnes lire ou crire.
www.openclassrooms.com
129/467
Comme ce schma l'indique, ce Register File contient une entre d'adresse sur laquelle on place une suite de bit qui permet
d'identifier le registre slectionner. Et oui, vous avez devins : cette suite de bit n'est autre que le nom du registre en question.
Sur les processeurs avec un Register File, on peut voir le nom d'un registre comme une sorte d'adresse permettant d'identifier un
registre dans le Register File.
Bien sr, il y a des exceptions. Il ne faut pas oublier que certains registres n'ont pas de noms : le Program Counter, le registre
d'tat, etc. Ceux-ci ne sont pas forcment rassembls avec les autres registres et sont souvent intgrs dans des circuits
spcialiss ou mis part des autres registres. Ce n'est toutefois pas systmatique : on peut placer ces registres dans un Register
File, mais c'est rarement utilis. Dans ce cas, on doit jouer un peu sur les noms de registre avant de les envoyer sur les entres
d'adresse du Register File. Rien de bien mchant.
Mmoire multiports
Comme vous l'avez remarqu sur le schma, le Register File a une petite particularit : les critures et les lectures ne passent pas
par les mmes ensembles de fils. On a un ensemble de fils pour la lecture, et un autre pour les critures. Tout se passe comme si
notre Register File tait reli deux bus de donnes : un pour les lectures, et un pour les critures. Ces ensembles de fils
sappellent des ports. Vu que notre Register File possde plusieurs de ces ports, on dit que c'est une mmoire multiports.
Mais cette technique, qui consiste fournir plusieurs ensembles de fils pour des lectures ou criture va souvent plus loin : on ne
se limite pas deux ports : on peut en avoir bien plus ! On peut avoir plusieurs ports pour les lectures, voire plusieurs ports pour
les critures. Cela permet d'effectuer plusieurs lectures ou critures simultanment.
www.openclassrooms.com
130/467
Cela permet de lire ou d'crire dans plusieurs registres en une seule fois si le reste du processeur est adapt. Mine de rien,
beaucoup d'instructions ont besoin de lire plusieurs registres la fois : une addition a besoin de deux oprandes, pareil pour la
soustraction, la comparaison, la multiplications, etc. Beaucoup d'instructions de nos processeurs ont besoin de lire deux
donnes pour donner leur rsultat : elles sont dites dyadiques. Et ne parlons pas des (rares) instructions ayant besoin de trois
oprandes. Autant dire que crer des mmoires permettant de lire plusieurs registres la fois sont un plus apprciable.
Implmentation
Ce Register File est un circuit qui est tout de mme assez facile fabriquer. Dans celui-ci, on trouve des registres, des
transistors, et un nouveau composant qu'on appelle un dcodeur. Voyons tout cela en dtail. L'ide de base drrire notre
Register File est de rassembler plusieurs registres ensembles, et de les connecter au mme Datapath via leurs ports. On se
retrouve avec nos registres, ainsi que les transistors relis chaque port. Pour viter les conflits, un seul registre par port devra
tre slectionn. Pour cela, on devra commander correctement les transistors qui relient les registres au Datapath.
Ici, exemple avec un port de lecture
En slectionnant un registre par son nom, on doit activer un seul de ces signaux de commande la fois. On a donc une
correspondance entre un nom de registre, et un de ces signal. Cette correspondance est unique : un signal, un nom de registre,
et rciproquement. La traduction entre nom de registre et signaux de commande est effectue par un circuit spcialis. Celui-ci
doit rpondre plusieurs exigences :
Il doit partir d'un nom de registre cod sur
entres ;
www.openclassrooms.com
131/467
Ce dcodeur est, comme tous les autres circuits lectroniques, conu avec des portes logiques. Dans sa version la plus nave, on
peut crer un dcodeur en utilisant les techniques vues au chapitre 3 : on tablit une table de vrit, qu'on transforme en
quations logiques, et on traduit le tout en circuit. Vous tes donc cens savoir le faire. J'ai donc l'honneur de vous annoncer que
vous savez comment implmenter un port d'un Register File : il suffit de prendre des registres, des transistors, un dcodeur, et
roulez jeunesse !
Pour un Register File utilisant plusieurs ports, on devra utiliser plusieurs dcodeurs, et multiplier les transistors relis sur la
sortie ou l'entre de chaque registre. Il faut savoir que plus un Register File a de ports, plus il utilisera de circuits : les dcodeurs
et transistors supplmentaires ne sont pas gratuits. En consquence, il aura tendance consommer du courant et chauffer. La
quantit d'nergie consomme par une mmoire est proportionnelle son nombre de ports : plus on en met, plus notre mmoire
va consommer de courant et chauffer. Et notre Register File ne fait pas exception la rgle. Les concepteurs de processeurs sont
donc obligs de faire des compromis entre le nombre de ports du Register File (et donc la performance du processeur), et la
chaleur dgage par le processeur.
Unification flottants/entiers
Par exemple, c'est le cas des Pentium Pro, Pentium II, Pentium III, ou des Pentium M : ces processeurs ont des registres spars
www.openclassrooms.com
132/467
pour les flottants et les entiers, mais ils sont regroups dans un seul Register File. Avec cette organisation, un registre flottant et
un registre entier peuvent avoir le mme nom de registre. Et il faudra faire la distinction. Pour cela, des bits vont tre ajouts au
nom de registre. L'ensemble formera un nouveau nom de registre, qui sera envoy sur un port du Register File. Ces bits
supplmentaires sont fournis par le squenceur, qui dduit leur valeur en fonction de l'instruction qu'il a dcod.
Sur certains processeurs, cette technique va encore plus loin : le Program Counter et/ou le registres d'tat sont placs
directement dans le Register File, avec ventuellement d'autres registres spcialiss, comme le Stack Pointer. Il va de soit que
ce genre de technique est tout de mme relativement malfique.
Register Windowing
L'utilisation d'un Register File qui regroupe tous les registres du processeur permet d'implmenter facilement le fentrage de
registres. Il suffit pour cela de regrouper tous les registres des diffrentes fentres dans un seul Register File.
www.openclassrooms.com
133/467
Avec l'organisation indique dans ce schma, le numro d'un registre, tel qu'il est prcis par une instruction, n'est pas le nom de
registre que l'on va envoyer sur le Register File. On devra rajouter quelques bits pour faire la diffrence entre les fentres. Cela
implique de se souvenir dans quelle fentre de registre on est actuellement. Pour cela, toutes nos fentres sont numrotes. Avec
ca, il ne nous reste plus qu' ajouter un registre dans lequel on stocke le numro de la fentre courante. Le contenu de ce registre
sera concatn au numro du registre accder, afin de forer le numro de registre envoyer sur le Register File.
www.openclassrooms.com
134/467
Pour changer de fentre, on doit modifier le contenu de ce registre. Cela peut se faire assez simplement : il suffit de passer la
fentre suivante ou prcdente chaque appel ou retour de fonction. En considrant que la fentre initiale est la fentre 0, la
suivante sera 1, puis la 2, puis la 3, etc. Bref, il suffit d'ajouter 1 pour passer la fentre suivante, et retrancher 1 pour passer la
fentre prcdente. Cela se fait grce un petit circuit combinatoire reli ce registre, qui est activ par le squenceur chaque
appel/retour de fonction.
Bien sr, il faut aussi prendre en compte le cas o ce registre dborde : si toutes les fentres sont occupes, il faut bien faire
quelque chose ! Cela ncessite de rajouter des circuits qui s'occuperont de grer la situation.
www.openclassrooms.com
135/467
Si je dis au moins une, c'est parce qu'il est possible que la lecture et l'criture ne se fassent pas par les mmes ports.
Ces ports peuvent tre relis directement aux bus d'adresse, de commande ou de donnes. On peut aussi insrer des
multiplexeurs entre les ports de notre unit de communication et les bus, histoire d'aiguiller les informations du bon port vers le
bon bus. Bref.
www.openclassrooms.com
136/467
Voil quoi ressemble notre unit de communication avec la mmoire. Certaines units sont un peu plus intelligentes et sont
capables de faire les calculs d'adresses ncessaires pour certains modes d'adressages. Au lieu d'utiliser notre ALU pour faire ces
calculs, on peut la librer pour en faire autre chose. Mais cela ncessite de dupliquer des circuits, ce qui n'est pas gratuit.
AGU
Enfin, il faut savoir que certaines unit de communication avec la mmoire ne prennent pas qu'une adresse en entre. Elles
peuvent grer directement certains modes d'adressages elle-mmes, et la calculer partir d'une adresse, d'un indice, et
ventuellement d'un dcalage.
Ce calcul se fait alors soit dans l'unit de communication avec la mmoire, soit directement lors de l'accs mmoire lui-mme.
Dans le cas o c'est l'unit de communication avec la mmoire qui s'occupe de faire ce calcul d'adresse, celle-ci contient une
petite unit de calcul interne, l'Adress Generation Unit. Dans l'autre cas, le calcul d'adresse s'effectue directement lors de l'accs
mmoire : la mmoire fusionne les circuits de calcul d'adresse avec le dcodeur.
Le chemin de donnes
Pour changer des informations entre les composants du Datapath, on utilise un ou plusieurs bus internes au processeur qui
relie tous les registres et lunit de calcul entre eux. Bien videmment, il faudra bien grer ce bus correctement pour pouvoir
changer des informations entre units de calculs et registres. Ce serait dommage de se tromper de registre et d'crire au mauvais
endroit, ou de choisir la mauvaise instruction excuter. Cette gestion du bus interne sera dlgue au squenceur (qui ne fait
pas que , bien sr).
137/467
Imaginons que je souhaite excuter une instruction qui recopie le contenu du registre R0 dans R2 : il va me falloir slectionner les
deux registres correctement via ce bus. De mme, si je veux excuter une instruction comme une racine carre sur le contenu d'un
registre, je dois fatalement connecter le bon registre sur l'entre de l'ALU. Bref, quelque soit la situation, je dois relier certains
composants sur le bus correctement, et dconnecter tous les autres.
Pour cela, chaque composant d'un processeur est reli au bus via des interrupteurs. Il nous suffit d'intercaler un interrupteur sur
chaque fil qui spare le bus de notre composant. Pour slectionner le bon registre ou l'unit de calcul, il suffira de fermer les bons
interrupteurs et d'ouvrir les autres. Le principe de gestion du chemin de donne reste le mme : pour excuter une tape d'une
instruction, il faut commander des interrupteurs correctement, et ventuellement configurer l'ALU et le register file pour
choisir la bonne instruction et les bons registres. Tout cela est gr par le squenceur.
On remarque immdiatement une chose : chaque interrupteur doit tre command : on doit lui dire s'il doit se fermer ou s'ouvrir.
Oui, vous avez vus o je veux en venir : cet interrupteur n'est rien d'autre qu'un transistor (on utilise aussi des multiplexeurs dans
certaines situations).
Mais comment on fait pour prciser le sens de transfert des donnes sur le bus ?
En fait, on a pas vraiment besoin de prciser le sens de transfert. L'criture et la lecture ne se font pas par les mmes broches,
quelque soit le composant slectionner : cela et vrai pour les ALU ou pour les registres. On a un ensemble dentres pour la
lecture, et un ensemble de sorties spcialement ddies pour l'criture. Ces ensembles d'entre-sortie forment ce qu'on appelle un
port dentre ou de sortie. Tout ce qu'il faut faire, c'est ouvrir ou fermer les interrupteurs reliant le bon port au bus interne.
tape 1
tape 2
tape 3
tape 4
Fetch
Rcupration
des oprandes
Calcul
Enregistrement
du rsultat
Cela arrive quand notre instruction doit effectuer un calcul ncessitant plusieurs oprandes.
Prenons un exemple : imaginez qu'on souhaite effectuer une addition entre deux registres. Il faut deux nombres pour que notre
addition fonctionne. Il va nous falloir relier l'ALU ces deux registres, ce qui impossible avec un seul bus : on ne peut envoyer
qu'une seule donne la fois sur le bus ! On pourra donc avoir accs une donne, mais pas l'autre. Pour rsoudre ce
problme, on a pas vraiment le choix : on doit utiliser un registre temporaire, directement reli notre ALU, qui stockera une des
deux donne ncessaire notre instruction. De mme, il est prfrable d'utiliser un registre temporaire pour stocker le rsultat :
comme cela, on vite que celui-ci se retrouve immdiatement sur le bus de donne en mme temps que la seconde oprande.
www.openclassrooms.com
138/467
Le droulement d'une addition est donc simple : il faut recopier la premire donne dans le registre temporaire, connecter le
registre contenant la deuxime donne sur lentre de lunit de calcul, lancer l'adddition en envoyant le bon code sur lentre de
slection de l'instruction de l'ALU, et recopier le rsultat dans le bon registre. Cela se fait donc en plusieurs tapes, chacune
d'entre elle devant configurer le chemin de donnes.
tape 1
tape 2
Fetch
Pour cela, il suffit d'utiliser trois bus, relis sur nos registres, l'ALU et le bus de donnes comme indiqu dans le schma qui suit.
www.openclassrooms.com
139/467
Avec cette organisation, notre processeur peut grer les modes d'adressage absolus, et registre, pas plus. C'est en quelque
sorte l'architecture minimale de tout processeur utilisant des registres. Avec une organisation plus complexe, on peut grer
d'autres modes d'adressage plus facilement.
Adressage immdiat
Pour grer l'adressage immdiat, on n'a pas vraiment le choix : on doit placer la constante inscrite dans l'instruction sur l'entre de
notre ALU. Cette constante est fournie par le squenceur : lorsque celui-ci dcode l'instruction, il va savoir qu'un morceau de
l'instruction est une constante, et il va pouvoir l'envoyer directement sur l'ALU. Pour ce faire, une sortie du squenceur va tre
reli sur l'entre de notre ALU via un des bus. Seul problme : on ne va pas pouvoir rajouter un bus exprs pour le squenceur.
Gnralement, on rutilise un bus qui sert pour relier les registres l'entre de l'ALU, et on lui permet d'tre connect soit sur
cette sortie du squenceur, soit sur nos registres. On utilise pour cela un gros paquet de multiplexeurs.
www.openclassrooms.com
140/467
Sur certains processeurs, cette constante n'est pas toujours positive, et peut aussi tre ngative. Elle est gnralement code en
complment deux, et ne prend pas autant de bits que ce qu'un registre permet de stocker. Ces constantes sont souvent codes
sur 8 ou 16 bits : aller au del serait inutile vu que la quasi-totalit des constantes manipules par des oprations arithmtiques
sont trs petites et tiennent dans un ou deux octets. Le seul problme, c'est que pour tre envoye en entre de l'unit de calcul,
une constante doit tre convertie en un nombre de mme taille que ce que peut manipuler notre ALU. Par exemple, si notre ALU
manipule des donnes sur 32 bits et que nos registres font 32 bits, une constante code sur 8 ou 16 bits devra tre convertie en
un nombre de 32 bits. Cela se fait en recopiant le bit de signe dans les bits de poids fort supplmentaires (rappelez-vous, on a vu
a dans le premier chapitre).
Pour effectuer cette extension de signe, on peut soit implanter un circuit spcialis qui s'occupera d'effectuer cette extension de
signe directement, soit on utilise l'ALU pour effectuer cette extension de signe, on enregistre notre constante convertie dans un
registre, et on effectue notre calcul.
www.openclassrooms.com
141/467
www.openclassrooms.com
142/467
Conclusion
Bref, je suppose que vous voyez le principe : on peut toujours adapter lorganisation des bus internes de notre processeur pour
grer de nouveaux modes d'adressages, ou pour amliorer la gestion des modes d'adressages existants. On peut ainsi diminuer le
nombre d'tapes ncessaires pour xecuter une instruction en ajoutant des bus ou en modifiant leur configuration.
Par exemple, on peut faire en sorte que les instructions manipulant une seule de leurs oprandes en mmoire et qui stockent leur
rsultat dans un registre s'effectuent en une seule tape : il suffit d'adapter l'organisation vue au-dessus en reliant le bus de
donne sur l'entre de l'unit de calcul. On peut aussi grer des instructions manipulant toutes leurs oprandes en mmoire en
utilisant plusieurs registres dinterfaage, qui peuvent tre relis aux entres des units de calcul, etc. Bref, lorganisation du
chemin de donne d'un processeur dpend fortement de ses modes d'adressage, et de sa conception : deux processeurs avec
des modes d'adressage identiques seront conus diffremment, et n'effectueront pas forcment les mme tapes pour xecuter la
mme instruction.
Le squenceur
Comme on l'a vu plus haut, notre chemin de donne est remplit d'interrupteurs et de multiplexeurs configurer. Suivant
l'interruption excuter, il faut configurer ceux-ci d'une certaine manire pour que notre chemin de donne soit configur
correctement. Il faut de plus configurer l'entre de slection de l'instruction de notre ALU, ainsi que placer ce qu'il faut sur les
entres d'adresses du register file.
Il faut donc dduire les bons bits envoyer sur les entres correspondantes, en fonction de l'opcode et du mode d'adressage de
l'instruction excuter. C'est le rle du squenceur ! Notre squenceur doit donc grer le chemin de donnes pour que celui-ci
excute correctement l'instruction voulue et pas une autre, en tenant compte des diffrents modes d'adressage et de l'opcode de
l'instruction : on dit qu'il dcode l'instruction. Cette instruction sera traduite en une suite de micro-oprations, excutes les unes
aprs les autres. Chaque micro-opration va configurer le chemin de donnes pour lui faire faire ce qu'il faut.
Pour effectuer une micro-opration, notre squenceur va donc envoyer des "ordres" qui vont configurer les circuits du chemin
de donne (ALU, register file, interrupteurs, multiplexeurs, etc) et leur faire faire ce qu'il faut pour excuter notre instruction. Ces
ordres sont des bits individuels ou des groupes de bits qu'il faut placer sur les entres des units de calcul, du register file, ou
des circuits de gestion du bus interne au processeur (les fameux interrupteurs vus plus haut) dans un ordre bien prcis : on les
appelle des signaux de commande. Lorsque nos units de calculs (ou d'autres circuits du processeur) reoivent un de ces
signaux de commande, elles sont conues pour effectuer une action prcise et dtermine.
www.openclassrooms.com
143/467
Dcoder une instruction est simple : partir l'opcode et de la partie variable de notre instruction, il faut dduire le ou les signaux
de commande envoyer au chemin de donnes ou la Memory Management Unit, et parfois dduire l'ordre dans lequel envoyer
ces signaux de commande. Pour cela, notre processeur intgre un circuit spcialement ddi cette tape de dcodage : l'unit
de dcodage d'instruction.
Un des signaux de commande gnr par notre squenceur est donc le mot binaire placer sur l'entre de slection d'instruction
de l'unit de calcul choisie. Bien sr, il y a d'autres signaux de commandes envoyer dans le processeur, mais tout dpend de
son architecture et il est trs compliqu de faire des gnralits sur ce sujet.
Une des entres de notre squenceur est relie au registre d'instruction, afin d'avoir accs linstruction dcoder. Le registre
d'tat est aussi reli sur une entre du squenceur : sans cela, pas de branchements !
Squenceurs cbls
Il existe des processeurs dans lesquels chaque instruction est dcode par un circuits lectronique fabriqu uniquement avec
des portes ET, NON et OU relies entre elles : on appelle ce genre de squenceur un squenceur cbl. Ce genre de squenceur
va se contenter de gnrer automatiquement les signaux de commande dans le bon ordre pour configurer le chemin de donne et
excuter notre instruction.
Squenceur combinatoire
Sur certains processeurs, une instruction sexcute en une seule micro-opration, chargement depuis la mmoire inclus. C'est trs
rare, et cela ncessite des conditions assez particulires. Tout d'abord, chaque instruction du processeur ne doit effectuer qu'une
seule modification du Datapath. Sans cela, on doit effectuer un micro-opration par modification du Datapath. Ensuite, la
mmoire dans laquelle sont stockes les instructions doit tre physiquement spare de la mmoire dans laquelle on stocke les
donnes. Si ces conditions sont runies, le squenceur se rsume alors un simple circuit combinatoire.
www.openclassrooms.com
144/467
Dans une telle situation, le processeur effectue chaque instruction en un seul cycle d'horloge. Mais autant le dire tout de suite :
ces processeurs ne sont pas vraiment pratiques. Avec eux, un accs mmoire prendra autant de temps qu'une addition, ou qu'une
multiplication, etc. Pour cela, la dure d'un cycle d'horloge doit se caler sur l'instruction la plus lente. Disposer d'instructions
prenant des temps variables permet d'viter cela : au lieu que toutes nos instructions soient lente, il vaut mieux avoir certaines
instructions rapides, et d'autres lentes. Ce qui ncessite d'avoir des instructions dcoupes en plusieurs micro-oprations.
Squenceur squentiel
Sur la majorit des processeurs, nos instructions sont dcoupes en plusieurs micro-oprations, qu'il faudra enchainer dans un
certain ordre. Le nombre de micro-oprations peut parfaitement varier suivant linstruction sans que cela ne pose le moindre
problme : certaines seront lentes, d'autres rapides. Certaines instructions prendront plusieurs cycles d'horloge, d'autres non.
Pour enchainer les micro-oprations correctement, notre squenceur doit savoir quelle micro-opration il en est rendu dans
l'instruction. Il est oblig de mmoriser cette information dans une petite mmoire interne, intgre dans ses circuits. En
consquence, ces squenceurs cbls sont obligatoirement des circuits squentiels. Ils sont composs d'une petite mmoire, et
d'un gros circuit combinatoire. Ce circuit combinatoire est charg de dduire les signaux de commandes en fonction de
l'instruction place en entre, et du contenu de la mmoire intgre au squenceur.
Plus le nombre d'instructions cbler est important, plus le nombre de portes utilises pour fabriquer notre squenceur
augmente. Si le nombre d'instructions cbler est trop grand, on a besoin de tellement de portes que le cblage devient un
vritable enfer, sans compter le prix de toutes ces portes qui devient important. Autant dire que les processeurs CISC n'utilisent
pas trop ce genre de squenceurs et prfrent utiliser des squenceurs diffrents. Par contre, les squenceurs cbls sont
souvent utiliss sur les processeurs RISC, qui ont peu d'instructions, pour lequel la complexit du squenceur et le nombre de
portes est assez faible et est supportable.
www.openclassrooms.com
145/467
Mais ce n'est pas la seule consquence : notre squenceur doit viter de changer d'instruction chaque cycle. Et pour cela, il y a
deux solutions, suivant que le processeur dispose de mmoires spares pour les programme et les instructions ou non. Si la
mmoire des instructions est spare de la mmoire des donnes, le processeur doit autoriser ou interdire les modifications du
Program Counter tant qu'il est en train de traiter une instruction. Cela peut se faire avec un signal de commande reli au
Program Counter.
Mais sur les processeurs ne disposant que d'une seule mmoire (ou d'un seul bus pour deux mmoires), on est oblig de faire
autrement. On doit stocker notre instruction dans un registre. Sans cela, pas d'accs mmoire aux donnes : le bus mmoire serait
occup en permanence par l'instruction en cours dexcution, et ne pourrait pas servir charger ou crire de donnes.
Squenceur micro-cod
www.openclassrooms.com
146/467
Crer des squenceurs cbls est quelque chose de vraiment complexe. On est oblig de dterminer tous les tats que peut
prendre le circuit, et dterminer toutes les transitions possibles entre ces tats. Bref, c'est quelque chose de vraiment compliqu,
surtout quand le processeur doit grer un grand nombre d'instructions machines diffrentes. Pour limiter la complexit du
squenceur, on a dcid de remplacer le circuit combinatoire intgr dans le squenceur par quelque chose de moins complexe
fabriquer.
L'ide derrire ce remplacement, c'est que tout circuit combinatoire peut tre remplac par une petite mmoire ROM. Un circuit
combinatoire est trs simple : il renvoie toujours le mme rsultat pour des entres identiques. Dans ces conditions, pourquoi ne
pas pr-calculer tout ces rsultats et les conserver dans une mmoire ROM ? Cela a un avantage : remplir une mmoire ROM est
beaucoup plus simple faire que crer un circuit combinatoire. Au lieu de dterminer lexcution quelle est la suite de microoprations quivalente une instruction machine, on va pr-calculer cette suite de micro-oprations dans notre mmoire ROM.
C'est ainsi qu'on a invent les squenceurs micro-cods.
Control store
Un squenceur micro-cod contient donc une petite mmoire, souvent de type ROM. Cette mmoire s'appelle le Control Store.
Cette mmoire va stocker, pour chaque instruction micro-code, la suite de micro-oprations quivalente. Les suites de microoprations contenues dans ce Control Store s'appelle le Micro-code. le contenu du control store est parfois stock dans une
EEPROM et est ainsi modifiable : on peut ainsi changer son contenu et donc modifier ou corriger le jeu d'instruction du
processeur si besoin. Idal pour corriger des bugs ou ajouter des instructions, voire optimiser le jeu d'instruction du processeur
si besoin est. On parle alors de Writeable Control Store.
Comment notre squenceur va faire la correspondance entre une instruction micro-code et la suite de micro-oprations
correspondante dans ce control store ?
Pour retrouver la suite de micro-oprations correspondante, notre squenceur considre l'opcode de l'instruction micro-code
comme une adresse. Le control store est conu pour que cette adresse pointe directement sur la suite de micro-oprations
correspondante dans la mmoire ROM.
La micro-opration est alors recopie dans un registre, le registre de micro-opration, qui est aux micro-oprations ce que le
registre d'instruction est aux instructions machines. Il sert stocker une micro-oprations pour que le squenceur puisse
dcoder celle-ci.
Squencement du micro-code
www.openclassrooms.com
147/467
Bien sr, pour ne pas se contenter d'excuter une seule micro-opration et passer la suivante, le squenceur micro-cod
contient un registre dadresse de micro-opration qui stocke l'adresse de la micro-opration en cours dexcution.
Lorsque le dcodage d'une instruction machine commence, l'instruction machine, localise dans le registre d'instruction, est
recopie dans ce micro-registre d'adresse d'instruction. Ce registre dadresse de micro-opration joue le mme rle que la
mmoire qui intgre dans un squenceur cbl. Puis, le contenu du registre d'adresse d'instruction est alors augment de faon
pointer sur la micro-opration suivante, et ainsi de suite jusqu' ce qu'on aie excut toute la suite de micro-oprations.
Pour cela, ce registre d'adresse de micro-opration est coupl un micro-compteur ordinal, qui augmente l'adresse de ce registre
d'adresse de micro-opration de faon passer la micro-opration suivante, jusqu' pointer sur la fin de la suite de microoprations correspondant l'instruction machine. On peut mme fabriquer ce micro-compteur ordinal de faon permettre les
branchements entre micro-oprations : une instruction machine peut ainsi tre mule par une boucle de micro-oprations, par
exemple.
www.openclassrooms.com
148/467
signaux de commande envoyer aux units de calcul. Il suffit d'envoyer les bits sur les bons fils pour faire en sorte que le chemin
de donnes fasse ce qu'il faut. Le micro-code horizontal est le plus utilis de nos jours, du fait de sa simplicit et ses avantages
sur le micro-code vertical.
Avec un micro-code vertical, ce n'est pas le cas : il faut traduire les micro-oprations en signaux de commande l'aide d'un
squenceur cbl. Un squenceur micro-cod utilisant un micro-code vertical est divis en deux parties : un micro-squenceur, et
une unit de dcodage cble de micro-oprations qui dcode les micro-oprations en signaux de commandes.
Le micro-code vertical a un gros dsavantage : il faut placer une unit de dcodage cble supplmentaire dans le processeur.
Cette unit est malgr tout trs simple et utilise peu de portes logiques, ce qui est souvent supportable. Le principal dsavantage
est le temps mis par cette unit pour traduire une micro-opration en signaux de commande n'est pas ngligeable. L'avantage,
c'est qu'on peut rduire le nombre de bits utiliss pour chaque micro-opration : il n'est pas rare que les instructions d'un microcode horizontal fassent plus d'une centaine de bits ! De nos jours, nos processeurs utilisent tous un micro-code horizontal, pour
conomiser en circuits.
Avantages et inconvnients
Les squenceurs micro-cods sont plus simples concevoir : ils n'utilisent pas un grand nombre de portes logiques qu'il faudrait
relier entre elles, et cela simplifie beaucoup le travail des concepteurs de processeurs.
De plus, le micro-code est stock dans une mmoire qu'on peut reprogrammer. Cela a un avantage norme : on peut conserver le
mme jeu d'instruction et amliorer les circuits du processeur sans avoir recrer tout un processeur. Il suffit souvent de rcrire
le micro-code, sans avoir refaire tout un squenceur.
On peut aussi corriger plus facilement les erreurs de conception d'un processeur. Quand on cre un processeur, on commet
souvent des erreurs plus ou moins graves. Et bien sachez que ce certains bugs peuvent tre corrigs plus facilement avec un
squenceur micro-cod : il suffit de mettre jour le micro-code. Avec un squenceur cbl, il faudrait refaire une grande partie du
squenceur ou des units de calcul, ce qui prendrait un temps fou.
Mais il y a aussi des inconvnients qui ne sont pas ngligeables. Un squenceur micro-cod est plus lent qu'un squenceur
cbl : une mmoire ROM est bien plus lente qu'un circuit combinatoire fabriqu directement avec des portes logiques. Cela se
ressent sur la frquence d'horloge du processeur.
Squenceurs hybrides
Comme je l'ai dit plus haut, un squenceur micro-cod est plus conome en transistors et en portes logiques, tandis qu'un
squenceur cbl est plus rapide. Le squenceurs hybrides sont une sorte de compromis entre ces deux extrmes : ils sont en
partie cbls et en partie micro-cods.
Gnralement, une partie des instructions est dcode par la partie cble du squenceur, pour plus de rapidit tandis que les
autres instructions sont dcodes par la partie micro-code du squenceur. Cela permet d'viter de cbler une partie du
squenceur qui prendrait beaucoup de portes pour dcoder des instructions complexes, gnralement rarement utilises, tout en
gardant un dcodage rapide pour les instructions simples, souvent utilises.
Parfois, cette technique est adapte en scindant les parties cbles et les parties micro-codes en plusieurs units de dcodage
d'instructions bien spares. Notre processeur contient ainsi plusieurs units de dcodage d'instruction, l'une d'entre elle tant
cble, et l'autre est micro-code.
www.openclassrooms.com
149/467
Par exemple, un processeur de ce type peut contenir trois registres Add.oprande.1, Add.dclenchement et Add.rsultat . Le
premier registre servira stocker la premire oprande de l'addition. Pour dclencher l'opration d'addition, il suffira d'crire la
seconde oprande dans le registre Add.trigger, et l'instruction sexcutera automatiquement. Une fois l'instruction termine, le
rsultat de l'addition sera automatiquement crit dans le registre Add.resultat . Il existera des registres similaires pour la
multiplication, la soustraction, les comparaisons, etc.
Sur certains de ces processeurs, on a besoin que d'une seule instruction qui permet de copier une donne d'un emplacement
(registre ou adresse mmoire) un autre. Pas d'instructions Load, Store, etc : on fusionne tout en une seule instruction
supportant un grand nombre de modes d'adressages. Et donc, on peut se passer compltement d'opcode, vu qu'il n'y a qu'une
seule instruction : pas besoin de prciser quelle est celle-ci, on le sait dj. Sympa, non ?
L'utilit de ces architectures n'est pas vidente. Leur raison d'exister est simplement la performance : manipuler le bus interne au
processeur directement au lieu de laisser faire les circuits du processeur permet de faire pas mal de raccourcis et permet quelques
petites optimisations. On peut ainsi travailler directement avec des micro-instructions au lieu de devoir manipuler des
instructions machines, ce qui permet parfois de ne pas utiliser de micro-instructions en trop. Mais lintrt est assez faible.
L'tape de fetch
On a donc nos units de calcul bien fonctionnelles, bien comme il faut. Notre processeur ne peut malgr tout pas encore
effectuer d'instructions. Ben oui : on doit grer l'tape de Fetch. Cette tape est assez simple, et est effectue de la mme faon
sur tous les processeurs.
Elle est dcompose en trois grandes tapes :
envoyer le contenu du Program Counter sur le bus d'adresse ;
rcuprer l'instruction sur le bus de donne et la copier dans un registre qu'on appelle le registre d'instruction ;
modifier le Program Counter pour pointer sur l'instruction suivante.
Il faut noter que certains processeurs vont simultanment rcuprer l'instruction sur le bus de donne et modifier le Program
Counter. Il faut dire que ces deux tapes sont indpendantes : elles ne touchent pas aux mme registres et n'utilisent pas les
mmes circuits. On peut donc effectuer ces deux tapes en parallles, sans aucun problme. Les deux premires tapes sont
assez simples effectuer : il s'agit d'une simple lecture, qui peut tre prise en charge par notre Datapath. Mais la troisime est un
peu plus intrigante, et peut tre implmente de plusieurs faons diffrentes.
Compteur ordinal
On sait donc o est localise notre instruction dans la mmoire. C'est super, une partie du problme est rsolue. Reste la seconde
partie.
Et l'instruction suivante, c'est quoi son adresse ?
Aie ! Les ennuis commencent. Excuter une suite d'instructions sans savoir o est la suivante risque d'tre un peu compliqu.
www.openclassrooms.com
150/467
Pour rpondre : on ne sait pas o est la prochaine instruction, mais on peut le calculer !
Le fait que les instructions soient toutes stockes dans l'ordre dans la mmoire nous arrange bien. Pour calculer l'adresse
suivante facilement, il faut que toutes les instructions soient places les unes cot des autres en mmoire et surtout qu'elles y
soient classes dans l'ordre dans lesquelles on veut les excuter. Quand on dit "classes les unes cot des autres et dans
l'ordre", a veut dire ceci :
Adresse
Instruction
...
...
5464
Instruction d'arrt
Dans cet exemple, une instruction peut tre stocke dans une seule adresse. En fait, ce n'est pas toujours le cas : parfois, une
instruction peut tenir dans plusieurs cellules mmoire, mais le principe reste le mme.
Avec ce genre d'organisation des instructions en mmoire, on peut alors calculer l'adresse de l'instruction suivante en mmoire
avec des additions. Cette addition peut tre effectue de deux manires : soit on utilise notre ALU pour effectuer cette addition,
soit on dlgue cette tache un circuit spcialis.
Avec la premire solution, il suffit de rajouter une tape pour excuter notre instruction : en plus des tapes de Fetch, de
dcodage, et les autres, dpendantes du mode d'adressage ou de l'instruction, on rajoute une ou plusieurs tapes qui vont
modifier le registre d'adresse d'instruction pour le faire pointer sur l'instruction suivante. Le registre d'adresse d'instruction est
reli au chemin de donne et le calcul de l'adresse suivante est ainsi ralise par l'ALU.
Avec la seconde solution, le calcul de l'adresse de l'instruction suivante est le rle d'un petit circuit nomm le compteur ordinal.
Ainsi, pas besoin de rajouter des tapes supplmentaires pour effectuer notre calcul d'adresse : celui-ci est effectu en parallle
de lexcution de notre instruction, automatiquement, sans avoir utiliser le chemin de donne. Cette solution demande de
rajouter un circuit, mais ce circuit est assez rudimentaire, et ne prend presque pas de place : on a tout gagner utiliser cette
deuxime solution sur de gros processeurs.
Une fois cette adresse calcule, il suffira de l'envoyer sur le bus d'adresse, configurer le bus de commande en lecture, et
connecter le registre d'instruction sur le bus de donne pour la charger dans le registre d'instruction.
www.openclassrooms.com
151/467
Exemple : l'instruction en cours est stock l'adresse 12, et fait 4 bytes de long. On voit bien que l'instruction suivante est place
l'adresse 12 + 4 (ce qui fait 16). L'adresse de l'instruction suivante est donc gale l'adresse de l'instruction en cours, plus la
longueur de cette instruction.
L'adresse de l'instruction en cours est connue : elle est stocke dans le registre d'adresse d'instruction avant sa mise jour. Reste
connaitre la longueur cette instruction.
www.openclassrooms.com
152/467
Calculer l'adresse de l'instruction suivante est trs simple lorsque les instructions ont toutes la mme taille. La longueur tant
connue, on sait d'avance quoi ajouter l'adresse d'une instruction pour obtenir l'adresse de l'instruction suivante.
Notre compteur ordinal peut ainsi tre conu assez simplement, en utilisant un vulgaire circuit combinatoire encore plus simple
qu'un additionneur.
La dernire instruction dborde : elle est cheval entre deux blocs. Dans ce cas, on a pas trop le choix : on doit charger le
prochain bloc avant de faire quoique ce soit. Ceci dit, au del de ce petit inconvnient, cette technique a un gros avantage : on
peut parfaitement charger plusieurs instructions en une fois, si elles sont regroupes dans un seul bloc. Et cela arrive trs
souvent : on vite de nombreux accs la mmoire.
Les branchements
Lors d'un branchement, l'adresse de destination du branchement va tre copie dans le registre d'adresse d'instruction. Pour cela,
il va falloir permettre l'accs en criture dans ce registre, sous certaines conditions.
Pour les branchements directs (dont l'adresse est fournie par l'instruction), on permet au squenceur de fournir l'adresse de
destination sur une de ses sorties relie plus ou moins indirectement sur notre registre d'adresse d'instruction. Pour les
branchements indirects (ceux dont l'adresse de destination est stocke dans un registre), il suffit de relier le registre d'adresse
d'instruction et le registre contenant l'adresse de destination du branchement via le bus interne au processeur. Il faudra alors
www.openclassrooms.com
153/467
choisir entre l'adresse calcule par notre compteur ordinal et l'adresse fournie par le squenceur, suivant loccurrence d'un
branchement ou non. Ce choix est ralis par un certain nombre de multiplexeurs.
Comme vous le voyez sur ce schma, s'il n'y a pas de branchement, le multiplexeur se contente de relier la sortie du compteur
ordinal sur le registre d'adresse d'instruction. On va donc crire cette adresse calcule dans le registre d'adresse d'instruction et
on va directement passer l'instruction suivante.
En cas de branchement, le multiplexeur va relier la sortie du squenceur ou le registre (en cas de branchements indirects) dans
lequel se trouve l'adresse du branchement : l'adresse calcule par notre compteur ordinal est perdue et on se retrouve avec
l'adresse de notre branchement dans le registre d'adresse d'instruction. C'est le squenceur qui configure correctement le
multiplexeur comme il faut, suivant loccurrence d'un branchement ou non.
www.openclassrooms.com
154/467
C'est le squenceur qui configure correctement les multiplexeurs comme il faut, et qui fourni le dcalage, suivant loccurrence
d'un branchement ou non, et suivant la localisation de l'adresse de destination (registre ou fournie par l'instruction).
On remarque aussi qu'on pourrait faire cette addition du dcalage en utilisant l'ALU : il suffit de relier notre registre d'adresse
d'instruction sur l'entre et la sortie de l'ALU (mais pas par les mme ports), et d'envoyer le dcalage sur une autre entre : tout se
passe comme si l'on utilisait le mode d'adressage immdiat pour le dcalage, et le mode d'adressage implicite pour le registre
d'adresse d'instruction.
Branchements indirects
Enfin, il faut encore grer les branchements indirects. Pour cela, il suffit simplement de relier notre registre d'adresse d'instruction
sur un bus interne du processeur (via le chemin de donne, donc). On peut alors copier le contenu d'un registre dans notre
registre d'adresse d'instruction, ce qui est exactement ce que fait un branchement indirect.
Les processeurs de ce type contiennent toujours un registre d'adresse d'instruction : la partie de l'instruction stockant l'adresse
de la prochaine instruction est alors recopie dans ce registre, pour faciliter sa copie sur le bus d'adresse. Mais le compteur
ordinal n'existe pas. Sur des processeurs aussi bizarres, pas besoin de stocker les instructions en mmoire dans l'ordre dans
lesquelles elles sont censes tre excutes. Mais ces processeurs sont trs trs rares et peuvent tre considrs comme des
exceptions qui confirment la rgle.
www.openclassrooms.com
155/467
Le seul problme, c'est qu'avec cette technique, la taille de la mmoire augmente un peu trop vite pour pouvoir tenir dans un
processeur. Par exemple, si je veux pr-calculer tous les rsultats d'une addition effectue sur deux nombres de 32 bits, j'aurais
besoin d'une mmoire ROM plus grosse que votre disque dur ! Autant dire que ce genre de technique ne marche que pour des
calculs dont les oprandes sont codes sur trs peu de bits. Pour le reste, on va devoir crer des circuits capables d'effectuer
nos calculs.
On pourrait penser utiliser les mthodes vues au chapitre 3. Mais les tables de vrit qu'on aurait crire seraient dmesurment
grandes. Crer une ALU 32 bits ncessiterait des tables de vrit comprenant plus de 4 milliards de lignes ! A la place, nous
allons devoir ruser...
Dcalages et rotations
On va commencer par les circuits capables dexcuter des instructions de dcalage et de rotation. On en a trs brivement parl
dans les chapitres prcdents, mais vous ne savez peut-tre pas ce qu'elles font. Vu la situation, une petite explication sur ces
instructions ne fera pas de mal.
Dcalages et rotations
Il existe plusieurs types de dcalages, dont deux vont nous intresser particulirement : les dcalages logiques, et les dcalages
arithmtiques.
Logical shift
Le dcalage logique, aussi appel logical shift, est le dcalage le plus simple comprendre. Effectuer un dcalage logique sur un
nombre consiste simplement dcaler tout ses chiffres d'un ou plusieurs crans vers la gauche ou la droite.
Exemple avec un dcalage d'un cran.
www.openclassrooms.com
156/467
Comme vous le voyez, vu que nos nombres sont de taille fixe, certains bits sortent du nombre. Pour le dcalage droite, c'est le
bit de poids faible qui sort du nombre, tandis que pour le dcalage gauche, c'est le bit de poids fort qui est perdu. On remarque
aussi que certains bits du rsultat sont "vides" : ils ne peuvent pas tre dduits de la valeur du nombre dcaler. Ces vides sont
remplis par des zros.
Grce ce remplissage par des zros, un dcalage vers la gauche d'un rang est quivalent une multiplication par 2 pour des
entiers non-signs ou pour des entiers signs positifs. Mme chose pour le dcalage vers la droite qui revient diviser un
nombre entier par 2. Avec des nombres signs, ce n'est pas le cas : on obtient un rsultat qui n'a pas grand sens
mathmatiquement. De mme, pour des entiers non-signs ou positifs, on peut gnraliser avec un dcalage de rangs vers la
droite/gauche : un tel dcalage correspond une multiplication ou division entire par . Cette proprit est souvent utilise
par certains compilateurs, qui prfrent utiliser des instructions de dcalages (qui sont des instructions trs rapides) la place
d'instructions de multiplication ou de division qui ont une vitesse qui va de moyenne (multiplication) particulirement lente
(division).
Il faut remarquer un petit dtail : lorsqu'on effectue une division par
- un dcalage droite -, certains bits de notre nombre
vont sortir du rsultat et tre perdus. Cela a une consquence : le rsultat est tronqu ou arrondi. Plus prcisment, le rsultat
d'un dcalage droite de rangs sera gal la partie entire du rsultat de la division par .
Arithmetical shift
Pour pouvoir effectuer des divisons par
sur des nombres ngatifs en utilisant un dcalage, on invent les dcalages
arithmtiques ou arithmtical shift. Ces dcalages sont similaires aux logical shift, un dtail prt : pour les dcalages droite,
le bit de signe de notre nombre n'est pas modifi, et on remplit les vides laisss par le dcalage avec le bit de signe.
Ces instructions sont quivalentes une multiplication/division par , que le nombre soit sign ou non, un dtail prt :
l'arrondi n'est pas fait de la mme faon pour les nombres positifs et ngatifs. Cela pose un problme avec les nombres cods en
complment deux (ceux cods en complment un ne sont pas concerns).
www.openclassrooms.com
157/467
Pour les nombres positifs ou nuls, un arithmtical shift donne toujours le mme rsultat qu'un logical shift et on n'a pas de
problme : le rsultat est arrondi vers zro quelque soit le dcalage. Mais la situation change pour les nombres ngatifs qui sont
arrondis vers moins l'infini. Pour donner un exemple,
sera arrondi en
problme, on peut corriger le rsultat en utilisant quelques instructions supplmentaires. Mais cela reste au minimum 6 26 fois
plus rapide que d'effectuer la division.
Rotations
Les instructions de rotation sont similaires aux logical shift, part que les bits qui sortent du nombre d'un cot rentrent de l'autre
et servent boucher les trous.
Multiplexeurs
Pour commencer, les circuits capables d'effectuer des dcalages et des rotations sont fabriqus avec des composants
lectroniques qu'on appelle des multiplexeurs, aussi appels des MUX. Un multiplexeur possde plusieurs entres et une sortie.
Par plusieurs entres, on veut dire que suivant le multiplexeur, le nombre dentres peut varier. Le rle d'un multiplexeur est de
recopier le contenu d'une des entres sur sa sortie. Bien sr, il faut bien choisir l'entre qu'on veut recopier sur la sortie : pour
cela, notre multiplexeur contient une entre de commande qui permet de spcifier quelle entre doit tre recopie. Dans la suite de
ce chapitre, on ne va utiliser que des multiplexeurs qui possdent deux entres et une sortie. Aprs tout, nous travaillons en
binaire, n'est-ce pas.
La table de vrit d'un multiplexeur est assez simple, comme vous pourrez en juger. Dans ce qui suit, on prendra nommera les
deux entres du multiplexeur E1 et E2, sa sortie S, et son entre de commande C. La table de vrit du circuit ressemble donc
cela :
Sortie S
www.openclassrooms.com
158/467
0
En utilisant la mthode vue au chapitre 3, on arrive alors trouver l'quation logique suivante :
Cela nous donne donc le circuit suivant :
Sachez toutefois que les multiplexeurs utiliss dans nos ordinateurs ne sont pas forcment fabriqus avec des portes logiques.
Ils sont fabriqus directement avec des transistors, afin de faire des conomies.
Dcaleur logique
Voyons maintenant comment crer un dcaleur simple vers la droite. Ce dcaleur va pouvoir dcaler un nombre, vers la droite,
d'un nombre de rang variable. En effet, on pourra dcaler notre nombre de 2 rangs, de 3 rangs, de 4 rangs, etc.
Comment grer ce nombre de rangs variables ?
Tout d'abord, il faudra prciser ce nombre de rangs duquel on veut dcaler notre circuit. Celui-ci devra donc comporter des
entres pour spcifier de combien on veut dcaler notre nombre. Reste savoir comment crer notre circuit.
Principe
Ensuite, on peut faire une remarque simple : dcaler vers la droite de 6 rangs, c'est quivalent dcaler notre nombre vers la
droite de 4 rangs, et re-dcaler le tout de 2 rangs. Mme chose pour 7 rangs : cela consiste dcaler de 4 rangs, re-dcaler de 2
rangs et enfin re-dcaler d'un rang. En suivant notre ide jusqu'au bout, on se rend compte qu'on peut crer un dcaleur partir
www.openclassrooms.com
159/467
de dcaleur plus simples, relis en cascade, qu'il suffira d'activer ou dsactiver suivant la valeur du nombre de rangs qu'il faut
dcaler.
Le nombre de rangs par lequel on va devoir dcaler est un nombre, qui est videmment stock en binaire dans notre ordinateur.
Celui s'crit donc sous la forme d'une somme de puissances de deux (relisez le premier chapitre si vous avez oubli). On peut
donc utiliser la mthode suivante : chaque bit de ce nombre servira actionner le dcaleur qui dplace d'un nombre de rangs
gal la valeur du bit. Cela permet d'utiliser des dclaeurs qui dcalent par 1, 2,4, 8, ou toute autre puissance de 2.
Dcaleur lmentaire
Reste savoir comment crer ces dcaleurs qu'on peut activer ou dsactiver la demande. On va prendre comme exemple un
dcaleur par 4, pour se simplifier la vie. Mais ce que je vais dire pourra tre adapt pour crer des dcaleurs par 1, par 2, par 8, etc.
Commenons par dcrire le comportement de ce dcaleur. Celui-ci prend en entre un nombre dcaler (ici, ce sera un nombre de
8 bits qu'on nommera A). Sa sortie vaudra : soit le nombre tel qu'il est pass en entre (le dcaleur est inactif), soit le nombre
dcal de 4 rangs.
Ainsi, si je prend un nombre A, compos des bits a7, a6, a5, a4, a3, a2, a1, a0 ; (cits dans l'ordre), mon rsultat sera :
soit le nombre compos des chiffres a7, a6, a5, a4, a3, a2, a1, a0 : on n'effectue pas de dcalage ;
soit le nombre compos des chiffres 0, 0, 0, 0, a7, a6, a5, a4 : on effectue un dcalage par 4.
On voit donc qu'il existe deux choix possibles pour chaque bit de sortie : par exemple, le bit de poids fort peut prend deux valeurs
: soit 0, soit a7. Pareil pour le 4me bit en partant de la droite du rsultat : celui-ci vaut soit a7, soit a3. On se retrouve donc avec
deux choix pour chaque bit de sortie, qu'on doit slectionner au besoin. Je ne sais pas si vous avez remarqu, mais c'est
exactement ce que va faire notre multiplexeur : il va choisir deux entres possibles et en recopier une sur sa sortie en fonction de
son entre de commande. Il nous suffira donc dutiliser des multiplexeurs pour effectuer ce choix.
Par exemple, pour le choix du bit de poids faible du rsultat, celui-ci vaut soit a7, soit 0 : il suffit dutiliser un multiplexeur prenant
le bit a7 sur son entre 1, et un 0 sur son entre 0. Il suffira de rgler le multiplexeur pour choisir le bon bit. Il suffit de faire la
mme chose pour tous les autres bits, et le tour est jou. Vous devriez avoir compris le principe et tes maintenant censs
pouvoir crer un dcaleur tout seul, en faisant la mme chose pour les bits qui restent.
Dcaleur par 4
www.openclassrooms.com
160/467
Dcaleur par 2
Dcaleur par 1
Dcaleur arithmtique
Un dcaleur arithmtique peut tre cre de la mme faon. Plus intressant, on peut modifier le schma vu au-dessus pour lui
permettre d'effectuer des dcalages arithmtiques en plus des dcalages logiques. Il suffit simplement d'ajouter un ou plusieurs
multiplexeurs pour chaque dcaleur lmentaire par 1, 2, 4, etc. Il suffit simplement que ce ou ces multiplexeurs choisisse quoi
envoyer sur l'entre de l'ancienne couche : soit un 0 (dcalage logique), soit le bit de signe (dcalage arithmtique).
Exemple avec un dcaleur par 4
www.openclassrooms.com
161/467
Rotateur
Et ce qui peut tre fait pour le dcalage arithmtique peut aussi l'tre pour les rotations. On peut transformer notre circuit en
circuit encore plus gnraliste, capable de faire des rotations en plus des dcalages en rajoutant quelques multiplexeurs pour
choisir les bits envoyer sur les entres des dcaleurs.
Par exemple, on peut rajouter une couche de multiplexeurs pour faire en sorte que notre dcaleurs par 4 puisse faire la fois des
dcalages par 4 et des rotations par 4. Pour cela, il suffit de choisir quoi mettre sur les 4 bits de poids fort. Si c'est un dcalage par
4, notre circuit devra mettre ces bits de poids fort 0, tandis qu'il devra recopier les 4 bits de poids faible si c'est une rotation.
Pour choisir entre un zro ou le bit voulu du nombre d'entre, il suffit de rajouter des multiplexeurs.
www.openclassrooms.com
162/467
Bien videmment, on peut faire la mme chose pour les rotateurs par 2, 1 , etc. Et ainsi obtenir de quoi effectuer des rotations en
plus des dcalages.
Barell shifter
Avec tout ce qui a t dit plus haut, on est donc arriv crer un circuit capable d'effectuer aussi bien des rotations que des
dcalages : ce fameux circuit s'appelle un barrel shifter, et est utilis dans certains processeurs modernes, dans une version un
peu plus amliore. Il existe d'autres types de Barrel shifter qu'on a pas voqus dans ce chapitre : ce sont les mask barrel
shifter. Pour ceux qui sont intresss, voici un peu de documentation sur ces dcaleurs un peu spciaux : Mask Barrel Shifters.
Addition
Voyons maintenant un circuit capable d'additionner deux nombres : l'additionneur. Dans la version qu'on va voir, ce circuit
manipulera des nombres strictement positifs ou des nombres cods en compltement deux, ou en complment un.
Additionneur complet
Pour effectuer notre addition, tout repose sur l'addition de deux bits, et d'une ventuelle retenue : on va devoir crer un circuit
pour. Notre circuit possdera deux sorties : une pour le rsultat, et une pour la retenue. En plus de pouvoir additionner deux bits,
il faut prendre en compte la retenue de l'addition des bits prcdents, qui viendra s'ajouter nos deux bits.
Pour cela, on va crer un circuit capable d'additionner trois bits qu'on appellera : l'additionneur complet. Ce circuit comprendra
trois entres : les deux bits a et b additionner, et une entre Cin, pour la retenue de l'addition des bits prcdents. Il aura aussi
deux sorties : une pour la retenue du rsultat, qu'on nommera Cout, et une autre pour le rsultat de l'addition, qu'on nommera
Sum.
Bit a Bit b Cin
Sum Cout
www.openclassrooms.com
163/467
En utilisant les techniques vues au chapitre 3 de ce tutoriel, on peut alors trouver que le cblage de notre additionneur complet.
Il existe de nombreuses faons d'implmenter un additionneur complet. On peut parfaitement crer un additionneur complet sans
utiliser de portes logiques, mais en travaillant directement avec des transistors : cela permet d'avoir quelques opportunits
d'amliorations assez sympathiques. On peut ainsi crer des additionneurs complets comprenant bien moins de transistors que
celui vu au-dessus.
Circuit complet
Maintenant, on a tout ce qu'il faut pour crer ce qu'on appelle un additionneur propagation de retenue. Il suffit de cabler nos
additionneurs les uns la suite des autres. Par exemple, pour additionner deux nombres de 4 bits, on obtiendra le circuit suivant.
Notez la prsence de lentre de retenue C. Presque tous les additionneurs de notre ordinateur on une entre de retenue
comme celle-ci, afin de faciliter l'implmentation de certaines oprations comme l'inversion de signe, l'incrmentation,
etc.
Performances
Pour votre information, ce circuit a un gros problme : chaque additionneur doit attendre que la retenue de l'addition prcdente
soit disponible pour donner son rsultat. Pour obtenir le rsultat, Les retenues doivent se propager travers le circuit, du premier
additionneur jusqu'au dernier. Et a prend du temps, ce qui fait que ce circuit naf ne convient pas pour des processeurs destins
tre rapides.
Or, l'addition est une opration trs frquente dans nos programmes. De plus, ces additionneurs sont utiliss dans d'autres
circuits, pour calculer d'autres oprations arithmtiques, comme les multiplications, les soustractions, etc. La rapidit de ces
oprations, dont certaines sont trs complexes, dpend fortement de la rapidit des additionneurs qu'elles vont utiliser. Il nous
faut donc crer des additionneurs un peu plus rapides.
www.openclassrooms.com
164/467
Principe
Cet additionneur va dcouper nos deux nombres additionner en blocs, qui se feront additionner en deux versions : une avec la
retenue du bloc prcdent valant zro, et une autre version avec la retenue du bloc prcdent valant 1. Il suffira alors de choisir
le bon rsultat une fois cette retenue connue. On gagne ainsi du temps en calculant l'avance les valeurs de certains bits du
rsultat, sans connaitre la valeur de la retenue.
Bloc de base
Un tel additionneur slection de retenue est compos de briques de base, capables de pr-calculer un morceau du rsultat de
l'addition et de choisir le bon rsultat. Chacune de ces briques de base sera compos de deux additionneurs : bl'un calculant la
somme des bits (retenue incluse) passs en entre si lentre de retenue est zro ; et l'autre faisant la mme chose mais avec
l'entre de retenue 1. La slection du bon rsultat se fait en fonction de l'entre de retenue : il suffit de relier lentre de retenue
sur l'entre de commande d'un multiplexeur.
www.openclassrooms.com
165/467
Circuit
En faisant ainsi, il suffira juste de relier les entres de retenues d'un bloc de base aux sorties de retenues du bloc prcdents.
Petit dtail : sur certains additionneurs slection de retenue, les blocs de base n'ont pas la mme taille. Cela permet de tenir
compte des temps de propagation des retenues entre les blocs.
Additionneurs
Ceux-ci utilisent les concepts de gnration et de propagation de retenue. Leurs additionneurs complets sont lgrement
modifis, et possdent deux sorties qui remplacent la sortie de retenue. Ces deux entres vont servir indiquer si notre
additionneur complet va gnrer ou propager une retenue.
www.openclassrooms.com
166/467
Le fait que notre additionneur gnre une retenue sera indiqu par sa sortie G. Un additionneur complet va gnrer une retenue
si on se retrouve avec un 1 sur la sortie de retenue, quelque soit la retenue envoye en entre. Pour cela, il faut que les deux bits
qu'il additionne soient 1. La valeur mettre sur cette sortie est donc un simple ET entre les deux bits additionner.
Le fait que notre additionneur propage une retenue sera indiqu par sa sortie P. Un additionneur complet va propager une
retenue si la retenue en sortie vaut 1 si et seulement si la retenue place en entre vaut 1. Cela est possible si un des deux bits
plac en entre vaut 1. La valeur mettre sur cette sortie est donc un simple OU entre les deux bits additionner.
Notre additionneur ressemble donc ceci :
Anticipation de retenue
La retenue finale d'un additionneur complet est gale 1 si celui-ci gnre une retenue ou s'il en propage une. Il s'agit donc d'un
simple OU entre les sorties P et G. Ainsi, l'addition des bits de rangs i va produire une retenue Ci, qui est gale Gi + ( Pi . Ci-1).
L'astuce des additionneurs anticipation de retenue consiste remplacer le terme Ci-1 par sa valeur calcule avant.
Par exemple, je prends un additionneur 4 bits. Je dispose de deux nombres A et B, contenant chacun 4 bits : A3, A2, A1, et A0
pour le nombre A, et B3, B2, B1, et B0 pour le nombre B. Si j'effectue les remplacements, j'obtiens les formules suivantes :
C1 = G0 + ( P0 . C0 ) ;
C2 = G1 + ( P1 . G0 ) + ( P1 . P0 . C0 ) ;
C3 = G2 + ( P2 . G1 ) + ( P2 . P1 . G0 ) + ( P2 . P1 . P0 . C0 ) ;
C4 = G3 + ( P3 . G2 ) + ( P3 . P2 . G1 ) + ( P3 . P2 . P1 . G0 ) + ( P3 . P2 . P1 . P0 . C0 ) ;
Ces formules nous permettent de dduire la valeur d'une retenue directement partir des sorties de nos additionneurs. On
effectue les calculs de nos sommes et des bits P et G pour chaque additionneur en parallle, et on en dduit directement les
retenues sans devoir les propager.
Bien sr, il faut un certain temps pour dduire la retenue en fonction des bits P et G adquats. Mais ce temps est nettement
infrieur au temps qui serait mit pour propager une retenue avec un additionneur propagation de retenue. Plus prcisment, ce
temps de propagation des retenues est proportionnel au nombre de bits des nombres additionner. Pour un additionneur
www.openclassrooms.com
167/467
Additionneur
Notre additionneur anticipation de retenue est donc compos d'une couche d'additionneurs, et d'un paquet de portes logiques
qui permettent de dduire les retenues de faon anticipe. Ce paquet de portes logiques est souvent rassembl dans une unit
spciale, l'unit d'anticipation de retenue, aussi appele Carry Lookahead Unit .
Amliorations
Ceci dit, utiliser un additionneur anticipation de retenue sur des nombres trs grands (16/32bits) serait du suicide : cela
utiliserait trop de portes logiques, et poserait quelques problmes techniques assez difficiles rsoudre. Pour viter tout
problme, nos additionneurs anticipation de retenue sont souvent dcoups en blocs, capables d'additionner N bits. Suivant
l'additionneur, on peut avoir une anticipation de retenue entre les blocs et une propagation de retenue dans les blocs, ou
l'inverse.
Les Overflows
Les instructions arithmtiques et quelques autres manipulent des entiers de taille fixe, qui ne peuvent prendre leurs valeurs que
dans un intervalle dtermin par une valeur minimale et une valeur maximale. Si le rsultat d'un calcul sur des nombres entiers
sort de cet intervalle, il ne pas tre reprsent dans notre ordinateur : il se produit ce qu'on appelle un integer overflow. Et quand
un integer overflow a eu lieu, il vaut mieux prvenir ! Sur certains processeurs, on dtecte ces integer overflow de faon
logicielle, ou en utilisant des instructions spcialises. Mais sur certains processeurs, cette dtection se fait automatiquement
lors de l'addition. Pire : ils peuvent parfois corriger ces integer overflow automatiquement. Dans ce qui va suivre, on voir
comment. Malheureusement, la gestion des integer overflow dpend de la reprsentation des nombres utilise.
www.openclassrooms.com
168/467
Une fois dtect, cet integer overflow peut tre gr par le processeur ou par le logiciel.
Gestion logicielle
Si il est gr par le logiciel, celui-ci peut dcider de passer outre, ou de le corriger. Encore faut-il qu'il sache qu'il y a eu un integer
overflow. Dans la plupart des cas, un bit du registre d'tat est ddi cette gestion logicielle des integer overflow. Ce bit est mit
automatiquement 1 en cas d' integer overflow. Un programme qui veut grer cet integer overflow a juste utiliser un
branchement conditionnel qui agira en fonction de la valeur de ce bit. Ce branchement renverra le processeur vers un sousprogramme de gestion d'integer overflow. Ce bit est reli directement sur la sortie de l'additionneur qui indique loccurrence d'un
integer overflow.
Si l'Overflow n'est pas corrig automatiquement par le processeur, celui-ci ne conserve que les bits de poids faibles du rsultat :
les bits en trop sont simplement ignors. Le problme avec ce genre d'arithmtique, c'est qu'une opration entre deux grand
nombres peut donner un rsultat trs petit. Par exemple, si je dispose de registres 4 bits et que je souhaite faire l'addition
(ce qui donne 15 + 2), le rsultat est cens tre
(17), ce qui est un rsultat plus grand que la taille d'un
registre. En conservant les 4 bits de poids faible, jobtiens
(1). En clair, un rsultat trs grand est transform en un rsultat
trs petit. Si vous regardez bien, les circuits vus au-dessus sont dans ce cas.
Gestion matrielle
D'autres processeurs utilisent ce qu'on appelle l'Arithmtique_sature : si un rsultat est trop grand au point de gnrer un
integer overflow, on arrondi le rsultat au plus grand entier support par le processeur. Les processeurs qui utilisent
l'arithmtique sature sont souvent des DSP, qui doivent manipuler du signal ou de la vido. Certaines instructions de nos
processeurs x86 (certaines instructions SSE) font leurs calculs en arithmtique sature.
Par contre, les circuits capables de calculer en arithmtique sature sont un peu tout petit peu plus complexes que leurs
collgues qui ne travaillent pas en arithmtique sature. Il est toutefois assez simple de modifier nos additionneurs du dessus
pour qu'ils fonctionnent en arithmtique sature. Il suffit pour cela de rajouter une couche de multiplexeurs, qui enverra sur sa
sortie :soit le rsultat de l'addition, soit le plus grand nombre entier gr par le processeur. Cette couche de multiplexeurs est
commande par le signal d'Overflow, disponible en sortie de notre additionneur.
www.openclassrooms.com
169/467
Nanmoins, il faut se mfier de nos intuitions : certains integer overflow peuvent arriver et produire des bugs assez ennuyeux.
On peut prciser que cette rgle s'applique aussi pour les nombres cods en complment 1, pour les mmes raisons que pour le
codage en complment deux. Cette rgle est aussi valable pour d'autres oprations, comme les multiplications.
Circuit
Modifier les circuits d'au-dessus pour qu'ils dtectent les Overflows en complment deux est simple comme bonjour : il suffit
crer un petit circuit combinatoire qui prenne en entre les bits de signe des oprandes et du rsultat, et qui fasse le calcul de
l'indicateur d'Overflow. Voici ce que cela donne.
Correction
Encore une fois, corriger cet Overflow peut se faire logiciellement, ou en utilisant de l'arithmtique sature. Mais il y a une petite
subtilit avec l'arithmtique sature : quelle est la valeur envoyer sur la sortie ? Avec les entiers positifs, le choix tait simple : il
suffisait d'envoyer le plus grand entier possible. Mais en complment deux, il faut tenir compte de deux possibilits : celle o
les deux oprandes sont positives, et celle o les deux sont ngatives. Dans le premier cas, on doit renvoyer le plus grand entier,
et le plus petit dans le cas contraire. On a donc besoin d'une seconde couche de multiplexeurs, et on rajouter des portes pour
activer chaque couche dans les bonnes circonstances.
www.openclassrooms.com
170/467
Soustraction
On sait maintenant effectuer une addition. C'est pas mal, mais pas question de sarrter en chemin. Si on sait cbler une addition,
cbler une soustraction n'est pas trs compliqu. On va commencer par un circuit capable de soustraire deux nombres
reprsents en complment deux ou en complment un. La raison : se faciliter la vie, vu que travailler avec des entiers
reprsents en signe-valeur absolue est souvent plus compliqu.
Soustraction
Notre circuit doit donc
inverser tous les bits du nombre soustraire ;
ajouter 1 au rsultat de cette inversion ;
ajouter la seconde oprande au rsultat calcul l'tape 2 (l'autre nombre : celui auquel on soustrait) au rsultat.
le circuit capable d'inverser tous les bits d'un nombre est vident : il s'agit d'un circuit compos uniquement de portes NON ,
chacune d'entre elle tant relie un bit du nombre inverser. Il ne nous reste plus qu'a additionner la premire oprande (le
nombre auquel on soustrait), augmente de 1.
Navement, on pourrait se dire qu'il faudrait utiliser deux additionneurs propagation de retenue, ou un additionneur suivi d'un
circuit capable d'incrmenter (augmenter de 1) cette oprande. Mais il y a moyen de faire nettement mieux en rusant juste un
choua. La majorit des additionneurs possde une entre de retenue (la fameuse entre de retenu C que je vous ais fait
remarquer plus haut), pour simplifier la conception de certaines instructions. Pour additionner la seconde oprande augmente
de 1, il suffira de positionner ce bit de retenue 1 et envoyer les oprandes sur les entres de notre additionneur.
www.openclassrooms.com
171/467
Notre circuit soustracteur est donc trs simple : il est constitu du circuit inverseur vu au-dessus, auquel on relie une des deux
entres d'un additionneur sur sa sortie. Il faut juste faire en sorte de positionner la retenue de l'additionneur 1 pour que tout
fonctionne. Au fait, le circuit utilis pour soustraire deux nombres reprsents en complment un est identique part un dtail :
il n'y a pas besoin de positionner l'entre de retenue de notre additionneur 1 et on doit laisser celle-ci zro.
Addition et soustraction
Comme je l'ai dit dans le chapitre prcdent, le circuit charg de la soustraction et celui ddi l'addition peuvent tre fusionns
dans un seul et unique circuit, capable de faire les deux. La raison est simple : l'additionneur est prsent la fois dans le circuit
ddi l'addition (normal..), et dans celui ddi aux soustractions. Il est donc possible de crer un circuit capable d'effectuer soit
une addition, soit une soustraction. L'opration effectuer est choisit par un bit plac sur une entre supplmentaire. Reste
savoir comment crer ce circuit.
La seule diffrence entre le circuit charg de l'addition et celui de la soustraction tient dans l'inverseur, ainsi que dans la retenue
place sur l'entre de l'additionneur. Pour crer notre circuit, on va donc faire en sorte que notre inverseur puisse tre dsactiv
ou court-circuit, afin de laisser l'additionneur tranquille. Une solution consiste crer un inverseur spcial, sur lequel on rajoute
une entre d'activation. Si cette entre vaut 1, l'inverseur inversera l'oprande qui lui fournie en entre. Dans le cas contraire, cet
inverseur ne fera rien et recopiera l'oprande passe en entre sur sa sortie.
www.openclassrooms.com
172/467
Pour cela, rien de plus simple : il suffit de remplacer chaque porte NON de l'inverseur par une porte XOR. Une entre de cette
porte XOR doit tre relie un bit de l'oprande, et l'autre sera relie l'entre d'activation.
Qui plus est, on peut remarquer que l'entre de retenue de l'additionneur doit tre mise 1 dans un seul cas: quand l'inverseur est
actif. Vu que ces deux circuits doivent imprativement fonctionner ensemble, on peut fusionner les deux signaux censs les
commander en un seul.
Signe-magnitude
Maintenant que l'on sait effectuer des additions et des soustractions sur des nombres cods en complment deux ou sur des
nombres non-signs, on va voir ce qui se passe pour les nombres cods en signe--valeur absolue. La gestion de ces nombres est
un peu plus complique cause des bits de signe : on doit en tenir compte dans nos calculs. Par exemple, notre circuit doit
www.openclassrooms.com
173/467
pouvoir additionner deux nombres positifs, mais aussi un ngatif et un positif, ou deux ngatifs.
Addition
Une solution simple consiste convertir nos nombres cods en signe-valeur absolue vers du complment un, faire l'addition en
complment un, et retraduire le tout en reprsentation signe-magnitude. Il nous faut donc un circuit capable de convertir les
valeurs absolues de nos nombres en complment un, et un autre pour traduire le rsultat du calcul. Avec un additionneur en
plus, bien sr. Ces circuits de traduction sont de simples inverseurs commandables. Ces inverseurs sont identiques celui vu
au-dessus : ils disposent d'une entre de commande qui dit d'inverser ou non leurs entres. La commande des inverseurs devra
tre dduite des bits de signes. Sans compter qu'il faudra dduire le bit de signe du rsultat.
Cela donne ce circuit :
En rusant un petit peu, on peut se passer d'un inverseur. Mais dans ce cas, le circuit devient plus compliqu.
Comparaison
Je tiens signaler que les comparaisons sont souvent "fabriques" partir de soustractions. Pour comparer deux nombres, il
suffit simplement de soustraire les deux nombres, de comparer le rsultat avec zro et de regarder le signe du rsultat :
si le rsultat est positif, le nombre auquel on a soustrait l'autre est plus grand ;
si le rsultat est ngatif, le nombre auquel on a soustrait l'autre est plus petit ;
si le rsultat est nul, les deux nombres sont gaux.
Une fois que l'on a fait ces tests, le rsultat peut alors tre oubli et n'a pas tre conserv. Il suffit juste de rajouter quelques
circuits base de portes XOR, ET, OU, et NON notre soustracteur, et relier ceux-ci au registre d'tat pour le mettre jour. Par
exemple, pour tester si le rsultat est nul, il suffit de regarder la valeur de ses bits : un rsultat vaut zro si et seulement si tous
ses bits sont zro. Faire un vulgaire NOR sur tous les nombres du rsultat permet ainsi de savoir si celui-ci est nul ou non. Pour
voir si un rsultat est positif ou ngatif, il suffit de regarder son bit de signe (son bit de poids fort).
Multiplication
Aprs avoir vu quelques oprations simples, comme les dcalages/rotations, les additions et les soustractions, il est temps de
www.openclassrooms.com
174/467
passer des oprations un peu plus gourmandes en terme de temps et de circuits. Nous allons aborder la multiplication,
effectue par un circuit nomm le multiplieur.
Entiers non-signs
Pour commencer, petite prcision de vocabulaire : une multiplication s'effectue sur deux nombres, dont le premier est appel
multiplicande, et l'autre multiplieur. Dans ce qui va suivre, on va supposer que les deux sont positifs. Comme pour l'addition,
nous allons calculer une multiplication de la mme faon qu'on a appris le faire en primaire, avec un petit dtail : nous allons
travailler en binaire. Pour effectuer une multiplication en binaire, on fait comme en dcimal :
on multiplie le multiplicande par le premier chiffre du multiplieur ;
on recommence et on multiplie par le deuxime chiffre du multiplieur, mais en dcalant le rsultat d'un cran ;
on recommence et on multiplie par le troisime chiffre, mais en dcalant le rsultat de deux crans ;
on continue ainsi de suite jusqu' avoir puis tous les chiffres du multiplieur... ;
et enfin, on additionne tous les rsultats temporaires obtenus lors des tapes du dessus.
Exemple avec la multiplication de deux nombres de 4 bits A et B, composs respectivement des bits a3, a2, a1, a0 pour A et b3, b2,
b1, b0 pour B.
Produit partiel n1
Produit partiel n2
Produit partiel n3
Produit partiel n4
Comme on le voit, notre multiplication gnre un grand nombre de rsultats temporaires, chacun provenant de la multiplication
de notre multiplicande par un chiffre du multiplieur, auquel on aura appliqu un dcalage. Ces rsultats temporaires sont appels
des produits partiels. Ce sont les lignes dans le tableau du dessus. Gnrer ces produits partiels ncessite donc de quoi
multiplier des bits entre eux. Il suffira ensuite d'avoir un additionneur pour additionner tout ces produits partiels, et le tour est
jou.
Circuit
Dans les multiplieurs les plus simples, on gnre ces produits partiels les uns aprs les autres, et on les additionne au fur et
mesure qu'ils sont calculs. Pour cela, on utilise un registre qui stocke le rsultat. Celui-ci est initialis zro au commencement
de la multiplication. De mme, le multiplieur et le multiplicande sont aussi placs dans des registres. Dans ce qui va suivre, on
effectuera notre multiplication de droite gauche : on multiplie d'abord le multiplicande par le bit de poids faible du multiplieur,
puis par le bit suivant, et ainsi de suite. Le circuit est le suivant :
www.openclassrooms.com
175/467
Le fonctionnement de ce circuit est simple comprendre. On commence par initialiser nos registres leurs valeurs respectives.
Ensuite, on gnre le produit partiel et on l'additionne au registre rsultat. Aprs cela, on dcale le contenu du registre du
multiplicande d'un cran vers la gauche, et on dcale celui du multiplieur vers la droite. Et on recommence.
www.openclassrooms.com
176/467
Bien sr, cet enchainement d'additions doit se terminer quand tous les bits du multiplieur ont ts passs en revue. Pour terminer
notre addition au bon moment, notre circuit doit contenir un petit compteur, qui contient le nombre de bits du multiplieur qu'il
reste traiter. Quand ce compteur atteint la bonne valeur, la multiplication est termine. Il faut aussi prvoir un petit circuit qui se
chargera de l'initialisation de nos registres.
Dcalages automatiques
Comme vous l'avez remarqu, les deux registres du multiplicande et du multiplieur sont dcals d'un cran chaque cycle
d'horloge. Pour effectuer ce dcalage automatique, on utilise ce qu'on appelle un registre dcalage. Un registre dcalage est
un composant lectronique qui fonctionne comme (j'ai pas dit qui est) un registre coupl un dcaleur, ce dcaleur se chargeant
de dcaler les bits du nombre stock dans le registre quand on lui demande.
L'implmentation la plus simple d'un registre dcalage consiste prendre des bascules D, et les relier en srie : la sortie d'une
bascule allant sur l'entre de la suivante. Toutes ces bascules sont ensuite relies la mme horloge. Ainsi, le contenu de ce
registre est dcal d'un cran chaque cycle d'horloge. On en dduit que ce circuit est tout de mme lent : notre multiplication
s'effectuera en autant de cycles qu'il y a de bits dans le multiplieur.
Exemple avec un registre qui dcale d'un cran vers la droite
www.openclassrooms.com
177/467
Opration Rsultat
Quel dommage que l'on ne compte pas naturellement en binaire : vous n'auriez pas eus vous farcir une dizaine de tables de
multiplications compltement indigestes !
Cette table de vrit ressemble fortement une table de vrit d'une porte ET, et
pour cause : c'est la table de vrit d'une porte ET ! Ainsi, notre circuit est donc trs simple : il suffit d'effectuer un ET entre les
bits du multiplicande, et le bit du multiplieur qu'on a slectionn juste avant.
Inversion
le circuit vu au-dessus est franchement amliorable. En rflchissant bien, on peut trouver une petite astuce assez sympathique
qui permet de gagner pas mal en circuits. Avec le circuit du haut, on stockait le rsultat de l'addition dans les bits de poids faible
du registre du rsultat. Sachez qu'on peut aussi le stocker dans les bits de poids forts, et dcaler ce rsultat d'un cran droite
chaque cycle. Cela donnera le mme rsultat. On se retrouve alors avec un circuit un peu diffrent : cette fois, le multiplicande
n'est pas dcal chaque cycle. Mais le rsultat le sera sa place, ainsi que le multiplieur (cela ne change pas) : les deux tant
dcals vers la droite.
www.openclassrooms.com
178/467
Prenons un exemple : on veut multiplier deux nombres de 32 bits. Avec la technique du dessus, on devrait utiliser des
additionneur 64 bits, et un registre rsultat de 64 bits. Mais avec ce nouveau circuit, on peut se contenter d'un additionneur 32
bits. On gagne ainsi pas mal en circuits.
www.openclassrooms.com
179/467
Il est mme possible de ruser encore plus : on peut se passer du registre pour le multiplieur. Il suffit pour cela d'initialiser les bits
de poids faible du registre rsultat avec le multiplieur au dmarrage de la multiplication, et de prendre le bit de poids faible du
rsultat.
www.openclassrooms.com
180/467
Entiers signs
Tous les circuits qu'on a vu plus haut sont capables de multiplier des nombres entiers positifs. Mais nous n'avons pas encore vu
comment traiter des entiers signs.
Commenons par le cas le plus simple : les entiers en signa-valeur absolue. Pour eux, la multiplication est trs simple : il suffit de
multiplier les valeurs absolues, et de dduire le bon signe. La multiplication des valeurs absolues peut s'effectuer avec les
circuits vus au-dessus sans aucun problme. Quand la dtermination du signe, il s'agit d'un vulgaire XOR entre les bits de
signe des deux nombres multiplier.
Pour les nombres cods en complment 1, la solution se base sur le mme principe. Comme avec les nombres en signe-valeur
absolue, on va multiplier les valeurs absolues des deux oprandes, et on va en dduire le signe en fonction des signes des deux
oprandes. On va donc devoir calculer la valeur absolue du multiplicande et de multiplieur, les multiplier, et ventuellement
inverser le rsultat si besoin.
le calcul des valeurs absolues des oprandes s'effectue avec un inverseur commandable. Si l'oprande est ngative, on actionne
cet inverseur pour qu'il inverse notre oprande : on obtient bien la valeur absolue. Ensuite, on effectue la multiplication, et on
www.openclassrooms.com
181/467
traite le rsultat pour qu'il aie le bon signe. Cela se fait en inversant le rsultat s'il doit tre ngatif, et en faisant rien sinon.
Pour la multiplication en complment deux, les choses se compliquent. Tenter de multiplier les valeurs absolues et de corriger le
rsultat est une solution, mais obtenir la valeur absolue d'un nombre en complment deux ncessitera l'intervention d'un
additionneur. Le circuit qu'on obtiendrait serait alors un peu trop complexe. Nous allons donc devoir adapter notre circuit pour
qu'il gre les multiplieurs et multiplicandes ngatifs. Pour commencer, nous pouvons vous faire une petite remarque : les circuits
vus au-dessus fonctionnent parfaitement quand les deux oprandes sont ngatives. Elles donnent alors le bon rsultat, et il n'y a
rien faire. Reste grer les autres situations.
Multiplicande ngatif
Nous allons commencer par regarder ce qui se passe quand le multiplicande est ngatif, et le multiplieur positif.
Produit partiel n1
Produit partiel n2
Produit partiel n3
Produit partiel n4
Maintenant, regardez les produits partiels 1 et 3. Ce sont des " copies " du multiplicande, codes sur 4 bits, qu'on a dcales d'un
ou plusieurs crans vers la gauche. Seul problme : ce multiplicande est cens tre un entier ngatif. Hors, on se retrouve avec un
vides gauche de ces produits partiels : le produit partiel est cod sur moins de bits que le rsultat. Avec l'algorithme d'avant,
ces vides taient remplis avec des zros : les produits partiels taient devenus positifs, au lieu d'tre ngatifs ! D'o un rsultat
www.openclassrooms.com
182/467
faux.
Pour rsoudre ce problme, il suffit de remplir les vides gauche du produit partiel par la bonne valeur, afin de traduire notre
produit partiel en un entier suffisamment long pour remplir totalement un produit partiel. Cette conversion d'un entier cod en
complment deux en un autre entier, cod sur plus de bits s'appelle la Sign Extension. Si vous vous rappelez le premier
chapitre, vous vous souvenez que pour effectuer cette conversion, on doit remplir ces vides par le bit de signe du nombre pour
obtenir un rsultat correct.
Produit partiel n1
Produit partiel n2
Produit partiel n3
Produit partiel n4
Idalement, cette conversion doit se faire entre la gnration du produit partiel, et l'addition. Avec le premier circuit, qui dcale
automatiquement le multiplicande, cette Sign Extension n'est pas faite automatiquement, et doit tre effectue par un circuit
supplmentaire. Mais dans ce cas, la Sign Extension est trs dure effectuer : il faut se souvenir o est le bit de signe, vu que le
multiplicande est dcal automatiquement chaque cycle d'horloge. Et cela utilise un compteur.
Par contre, les circuits qui ne modifient pas les multiplicande permettent d'effectuer celle-ci beaucoup plus simplement. Il suffit
simplement de faire en sorte que le dcalage du rsultat soit un dcalage arithmtique. On doit donc modifier quelque peu le
registre dcalage qui stocke le rsultat, et tout fonctionnera merveille.
Multiplieur ngatif
Pour traiter le cas d'un multiplieur ngatif, le circuit vu au-dessus ne fonctionne pas parfaitement. Mais il y a moyen de le corriger
pour qu'il fonctionne merveille. L'ide est simple : si le multiplieur est ngatif, on ne va pas ajouter le produit partiel calcul
partir du bit de signe du multiplieur. A la place, on va le soustraire. C'est magique : on a juste faire cela, et a marche ! Et oui,
que vous le vouliez ou non, c'est comme cela. On peut se demander pourquoi cela fonctionne, mais l'explication est assez
mathmatique et franchement dure comprendre, aussi je vous pargne les dtails.
Pour adapter notre circuit, il suffit d'ajouter un circuit combinatoire au compteur intgr au circuit : ce circuit servira dtecter le
produit partiel inverser, et demandera notre additionneur soustracteur d'effectuer ou non une soustraction.
www.openclassrooms.com
183/467
Array Multipliers
Disons les choses franchement : les circuits vus au-dessus sont des bouses totalement innommables. La raison : ils sont lents !
La raison cela est trs simple : ces multiplieurs calculent et additionnent les produits partiels uns par uns, au rythme d'un
produit partiel par cycle d'horloge. Il y a tout de mme moyen de faire mieux. Au lieu de calculer tous les produits partiels uns par
uns et les additionner au mme rythme, on peut les calculer en parallle. Pour cela, rien de plus simple : on a juste crer un
circuit qui calcule ces produits partiels en parallle, et qui les additionne.
Dans sa version la plus simple, notre circuit va simplement enchainer ses additionneurs les uns la suite des autres.
www.openclassrooms.com
184/467
Pour implmenter cette technique, on peut calculer le produit partiel de deux faons. On peut utiliser des portes ET, dont les
sorties sont reli un dcaleur par 1, 2, 4, etc suivant le produit partiel. Mais on peut aussi se passer du dcaleur en rusant un
peu sur le cblage du circuit et en mettant certaines entres des additionneurs zro.
www.openclassrooms.com
185/467
On pourrait penser qu'utiliser des additionneurs aussi lents serait un dsavantage. Mais curieusement, cela ne nuit pas trop aux
performances du multiplieur. Utiliser des additionneurs anticipation de retenue ou des additionneurs slection de retenue
donnerait des gains relativement faibles. Par contre, utiliser des additionneurs propagation de retenue permet d'conomiser
beaucoup de portes logiques et de transistors.
Le rsultat peut tre interprt comme tant compos de deux rsultats : un nombre compos des sommes des bits, et un autre
compos des retenues. En additionnant convenablement les deux, on peut retrouver le rsultat de l'addition, cod en binaire
normal.
Cette addition de trois nombres en Carry Save n'est pas complique faire. Il suffit de crer un petit circuit capable d'additionner
trois bits et d'en placer plusieurs les uns cot des autres. Or, on connais dj ce circuit capable d'additionner trois bits : c'est
l'additionneur complet. On obtient alors le circuit ci-dessous :
www.openclassrooms.com
186/467
Ainsi, au lieu d'utiliser deux additionneurs normaux, on utilise un additionner Carry Save, et un additionneur normal.
L'additionneur Carry Save tant bien plus rapide que tout autre additionneur, on gagne beaucoup en performances.
Mais le mme principe peut tre adapt pour la somme de trois, quatre, cinq nombres ou plus. Cela peut se faire de diverses
facons, mais la plus simple consiste rutiliser notre additionneur Carry Save trois oprandes. Il suffit d'en enchainer plusieurs
les uns aprs les autres, pour additionner nos produits partiels.
www.openclassrooms.com
187/467
Tree Multipliers
Les additionneurs vus au-dessus peuvent encore subir quelques amliroations. Tou d'abord, il faut savoir qu'enchainer les
additionneurs les uns la suite des autres n'est pas la meilleur solution. Le mieux est de les organiser comme ceci :
Avec cette organisation "en arbre", on arrive effectuer certaines additions en parallles d'autres, ce qui permet de gagner du
temps. Il existe divers types d'organisations en arbres, dont les deux plus connues sont les arbres de Wallace, des arbres Dadda.
Ces arbres utilisent tous des additionneurs Carry-Save.
Division
Aprs la multiplication, nous allons voir comment effectuer des divisions. Autant prvenir tout de suite : la division est une
oprations trs complexe et particulirement lente, bien plus qu'une addition ou une multiplication. Pour information, sur les
processeurs actuels, la division est entre 20 80 fois plus lente qu'une addition/soustraction, et presque 7 26 fois plus lente
qu'une multiplication.
Mais on a de la chance : c'est aussi une opration assez rare. Un programme effectue rarement des divisions, les plus rares tant
les divisions entires tandis que les divisions les plus frquentes sont les divisons entre deux nombres flottants.
Souvent, les divisions les plus couramment utilises dans un programme sont des divisions par une constante : un programme
devant manipuler des nombres dcimaux aura tendance effecteur des divisons par 10, un programme manipulant des dures
pourra faire des divisions par 60 (gestion des minutes/secondes) ou 24 (gestion des heures). Diverses astuces permettent de
remplacer ces oprations de divisions par des suites d'instructions plus simples mais donnant le mme rsultat.
J'ai parl plus haut des dcalages, qui permettent de remplacer de divisons par . Mais il existe d'autres mthodes, qui
fonctionnent pur un grand nombre de constantes. Par exemple, on peut remplacer une division par une constante par une
multiplication un peu bizarre : la multiplication par un entier rciproque).
Sachant cela, certains processeurs ne possdent pas d'instruction de division. Inclure une instruction de division n'acclrerait
qu'un faible nombre d'instructions, et ne donnerait pas lieu des gains assez importants en terme de performance : acclrer 1%
des instructions d'un programme (ici, les divisions) en implmentant un circuit complexe et gourmand en transistors alors qu'on
pourrait utiliser ces circuits pour cbler des instructions plus utiles serait du gchis. Certains processeurs implmentent toutefois
la division dans une instruction machine, disposant souvent d'un circuit ddi. Les gains ne sont pas forcment faramineux, mais
ne sont pas forcment ngligeables non plus.
Division restauration
L'algorithme le plus simple que l'on puisse crer pour excuter une division consiste faire la division exactement comme en
dcimal, mais d'une faon un peu diffrente.
www.openclassrooms.com
188/467
Algorithme
Prenons un exemple. Nous allons cherche diviser 100011001111 (2255 en dcimal) par 111 (7 en dcimal). Pour commencer, nous
allons commencer par slectionner le bit de poids fort du dividende (le nombre qu'on veut diviser par le diviseur), et voir combien
de fois on trouve le diviseur dans ce bit. Pour ce faire, on soustraire le diviseur ce bit, et voir le signe du rsultat. Si le rsultat
de cette soustraction est ngatif, alors le diviseur est plus grand que ce qu'on a slectionn dans notre dividende. On place alors
un zro dans le quotient. Dans notre exemple, cela fait zro : on pose donc un zro dans le quotient.
Ensuite, on abaisse le bit juste cot du bit qu'on vient de tester, et on recommence. On continue ainsi tant que le rsultat de la
soustraction obtenue est ngatif.
www.openclassrooms.com
189/467
Quand le rsultat de la soustraction n'est pas ngatif, on met un 1 la droite du quotient, et on recommence en partant du reste.
Et on continue ainsi de suite.
Circuit
Notre algorithme semble se dessiner peu peu : on voir qu'on devra utiliser des dcalages et des soustractions, ainsi que des
comparaisons. L'implmentation de cet algorithme dans un circuit est super simple : il suffit de prendre trois registres : un pour
conserver le "reste partiel" (ce qui reste une fois qu'on a soustrait le diviseur dans chaque tape), un pour le quotient, et un pour
le diviseur. L'ensemble est second par un additionneur/soustracteur, et par un peu de logique combinatoire. Voici ce que cela
donne sur un schma (la logique combinatoire est omise).
www.openclassrooms.com
190/467
Notre algorithme se droule assez simplement. Tout d'abord, on initialise les registres, avec le registre du reste partiel qui est
initialis avec le dividende.
Ensuite, on soustrait le diviseur de ce "reste" et on stocke le rsultat dans le registre qui stocke le reste. Deux cas de figure se
prsentent alors : le reste partiel est ngatif ou positif. Dans les deux cas, on russit trouver le signe du reste partiel en regardant
simplement le bit de signe du rsultat. Reste savoir quoi faire.
Le rsultat est ngatif.
En clair, cela signifie que le reste est plus petit que le diviseur et qu'on aurait pas du soustraire. Vu que notre soustraction
a t effectue par erreur, on doit remettre le reste tel qu'il tait. Ce qui est fait en effectuant une addition. Il faut aussi
mettre le bit de poids faible du quotient zro et le dcaler d'un rang vers la gauche.
Le rsultat est positif.
Dans ce cas, on met le bit de poids faible du quotient 1, puis on dcale celui-ci et on ne fait rien de plus.
Ensuite, il faut encore dcaler le reste partiel. On dcale de reste partiel pour mettre le diviseur la bonne place sous le reste
partiel lors des soustractions. Et on continue ainsi de suite jusqu' ce que le reste partiel soit infrieur au diviseur.
La division SRT
On peut encore amliorer cette mthode en ne traitant pas notre dividende bit par bit, mais en le manipulant par groupe de deux,
trois, quatre bits, voire plus encore. Ce principe est (en partie) la base de l'algorithme de division SRT. C'est cette mthode qui
est utilise dans les circuits de notre processeur pour la division entire.
Sur certains processeurs, le rsultat de la division de deux groupes de bits est pr-calcul et stock dans une petite mmoire : pas
besoin de le recalculer chaque fois avec un circuits, il suffit juste de lire cette mmoire, ce qui va beaucoup plus vite ! Pour
information, on peut signaler que sur les processeurs les plus rcents l'heure o j'cris ce tutoriel, on peut traiter au maximum 4
bits la fois. C'est notamment le cas sur les processeurs Core 2 duo.
Bien sr, il faut faire attention quand on remplit cette mmoire : si vous oubliez certaines possibilits ou que vous y mettez des
rsultats errons, vous obtiendrez un quotient faux pour votre division. Et si vous croyez que les constructeurs de processeurs
n'ont jamais fait cette erreur, vous vous trompez : cela arrive mme aux meilleurs !
www.openclassrooms.com
191/467
Intel en a d'ailleurs fait les frais sur le Pentium 1. L'unit en charge des divisions flottantes utilisait un algorithme similaire celui
vu au-dessus (les mantisses des nombres flottants taient divises ainsi), et la mmoire qui permettait de calculer les bits du
quotient contenait quelques valeurs fausses. Rsultat : certaines divisions donnaient des rsultats incorrects !
Fabriquer ces circuits de calcul n'est pas une mince affaire et les constructeurs de processeurs, ainsi que des chercheurs en
arithmtique des ordinateurs, travaillent d'arrache-pied pour trouver des moyens de rendre nos circuits plus rapides et plus
conomes en nergie. Autant vous dire que les circuits que vous venez de voir sont vraiment des gamineries sans grande
importance compar ce que l'on peut trouver dans un vrai processeur commercial !
www.openclassrooms.com
192/467
Partie 4 : Mmoires
Comme son nom l'indique, ce chapitre va tenter de vous expliquer ce qu'est une mmoire et comment elle fonctionne. Nous allons
voir en dtail ce qu'est une mmoire, comment fait-elle pour retenir des bits, et quelles sont les amliorations apportes sur les
mmoires rcentes.
Mmoires
Mmoire.
Ce mot signifie dans le langage courant le fait de se rappeler quelque chose, de pouvoir s'en souvenir. La mmoire d'un
ordinateur fait exactement la mme chose (vous croyez qu'on lui a donn le nom de mmoire par hasard ?
) mais dans notre
ordinateur. Son rle est donc de retenir que des donnes stockes sous la forme de suites de bits, afin qu'on puisse les rcuprer
si ncessaire et les traiter.
Capacit mmoire
Pour commencer, on va commencer par enfoncer des portes ouvertes : on ne peut pas stocker autant de donnes qu'on veut
dans une mmoire. Vous avez surement dj du en faire l'exprience : qui n'a jamais eu un disque dur, une disquette, un CD-ROM
ou DVD, ou une cl USB pleine ? Et ce qui vaut pour les mmoires que je viens de citer au-dessus marche pour toutes les
mmoires.
Et ce petit jeu l, toutes les mmoires ne sont pas gales : certaines peuvent contenir plus de donnes que d'autres. C'est la
premire diffrence entre nos mmoires : la quantit de donnes qu'elles peuvent stocker. Vu que toutes nos donnes sont
stockes sous la forme de suites de bits, on peut facilement valuer la capacit d'une mmoire stocker un nombre plus ou moins
de donnes : il suffit de compter le nombre maximal de bits qu'elle peut contenir. Ce nombre de bits que notre mmoire peut
stocker porte un nom : c'est la capacit de la mmoire. Pour rsumer, nos mmoires n'ont pas la mme capacit, qui est le nombre
maximal de bits qu'elle peut stocker.
Dans la majorit des mmoires, les bits sont regroups en "paquets" contenant une quantit fixe de bits : des "cases mmoires",
aussi appeles bytes.
Gnralement, nos mmoires utilisent un byte de 8 bits. Autrefois, certaines mmoires avaient des cases mmoires de 6 ou 5 bits,
parfois plus. Mais maintenant, la situation s'est un peu normalise et la grosse majorit des mmoires utilisent un byte de 8 bits.
Au fait : un groupe de 8 bits s'appelle un octet.
H, une minute ! Je croyais que byte et octet c'tait la mme chose ?
Rassurez-vous cher lecteur, c'est une erreur courante. Il faut vraiment connaitre le truc pour ne pas se faire avoir. En effet, un byte
n'est pas un octet ! Vu que de nos jours nos mmoires utilisent des bytes d'un octet, on utilise souvent les deux termes de faon
interchangeable. Mais a reste tout de mme un abus de langage.
Le fait que nos mmoires aient presque toutes des bytes faisant un octet nous arrange pour compter la capacit d'une mmoire.
Au lieu de compter cette capacit en bits, on prfre mesurer la capacit d'une mmoire en donnant le nombre d'octets que celleci peut contenir. Cela permet d'avoir des nombres plus petits et donne des quantits plus simples manipuler.
www.openclassrooms.com
Partie 4 : Mmoires
193/467
Prfixe
Quantit
Puissance de deux
Kio
1024
octets
Mio
1 048 576
octets
Gio
octets
Ainsi,
un kibioctet correspond 1024 octets ;
un mbioctet correspond 1 1 048 576 octets ;
un gibioctet correspond 1 073 741 824 octets.
De mme,
un kibibit correspond 1024 bits ;
un mbibit correspond 1 1 048 576 bits ;
un gibibit correspond 1 073 741 824 bits.
Ainsi, un kibioctet vaut
, un gibioctet vaut
octets, etc.
Pourquoi utiliser des puissances de 1024, et ne pas utiliser des puissances un peu plus communes ?
Dans la majorit des situations, les lectroniciens prfrent manipuler des puissances de deux pour se faciliter la vie, et c'est
aussi le cas pour les mmoires : il est plus simple de concevoir des mmoires qui contiennent un nombre de cases mmoires qui
soit une puissance de deux. Par convention, on utilise souvent des puissances de 1024, qui est la puissance de deux la plus
proche de 1000.
Bizarre, j'ai toujours entendu parler de kilo-octets, mga-octets, gigaoctets, etc. C'est normal ?
Et bien non ! Logiquement, on ne devrait pas parler de kilo-octets, mga-octets ou gigaoctets : c'est encore une fois un abus de
langage.
Dans le langage courant, kilo, mga et giga sont des multiples de 1000. Quand vous vous pesez sur votre balance et que celle-ci
vous indique 58 kilogrammes (dsol mesdames), cela veut dire que vous pesez 58000 grammes. De mme, un kilomtre est gal
mille mtres, et non 1024 mtres.
Autrefois, on utilisait les termes kilo, mga et giga la place de nos kibi, mebi et gibi, par abus de langage : les termes kibi, mbi
et gibi nexistaient pas. Pour viter les confusions, de nouvelles units (les kibi, gibi et autres) ont fait leur apparition.
Malheureusement, peu de personnes sont au courant de l'existence de ces nouvelles units, et celles-ci sont rarement utilises.
Aussi, ne vous tonnez pas si vous entendez parler de gigaoctets en lieu et place de gibioctets : cette confusion est trs
courante.
Saviez-vous que cette confusion permet aux fabricants de disques durs de nous "arnaquer" ? Ceux-ci donnent la capacit des
disques durs qu'ils vendent en kilo, mega ou giga octets. Lacheteur croit implicitement avoir une capacit exprim en kibi, mebi
ou gibi octets, et se retrouve avec un disque dur qui contient moins de mmoire que prvu. C'est pas grand chose de perdu, mais
il faut avouer que c'est tout de mme de l'arnaque !
www.openclassrooms.com
Partie 4 : Mmoires
194/467
Trs simple : vos programmes et le systme d'exploitation sont placs sur une mmoire qui ne s'efface pas quand on coupe le
courant, pas votre document Word. On dit que la mmoire dans laquelle votre OS et vos programmes taient placs est une
mmoire non-volatile, tandis que celle qui stockait votre document Word tait une mmoire volatile.
Mmoires Non-volatiles
Mmoires Volatiles
Conservent leurs informations quand on coupe le courant Perdent leurs informations lors d'une coupure de l'alimentation
Comme exemple de mmoire non-volatile, on peut citer le disque dur. Tous vos programmes et votre systme d'exploitation sont
stocks dessus. Et quand vous dbranchez votre ordinateur, ils ne s'effacent pas. Notre disque dur est donc une mmoire nonvolatile.
Au fait : Les mmoires volatiles ne volent pas et n'ont pas de plumes !
RWM ou ROM
Une autre diffrence concerne la faon dont on peut accder aux informations stockes dans la mmoire. Cette autre diffrence
classe les mmoires en mmoires RWM, et ROM.
Mmoires ROM
Mmoires RWM
A l'heure actuelle, les mmoires non-volatiles prsentes dans nos ordinateurs sont toutes des mmoires ROM, (sauf le disque
dur qui est accessible en lecture et criture).
Attention aux abus de langage : le terme mmoire RWM est souvent confondu dans le langage commun avec les
mmoires RAM.
PROM
Nanmoins, il existe des mmoires ROM un peu spciales : on ne peut pas accder en criture une donne bien prcise et ne
modifier que celle-ci, mais on peut rcrire intgralement son contenu. On dit qu'on reprogramme la mmoire, ce qui est diffrent
d'une criture. Ce terme de programmation vient du fait que les mmoires ROM sont souvent utilises pour stocker des
programmes sur certains ordinateurs assez simples : modifier le contenu de ces mmoires revient donc modifier le programme
contenu dans la mmoire et donc reprogrammer l'ordinateur.
Nanmoins, il faut bien comprendre la diffrence entre
crire dans une mmoire : je slectionne une case mmoire et je modifie son contenu, mais je ne touche pas aux autres
cases mmoires ;
reprogrammer : on efface tout et on recommence !
Ces mmoires sont appeles des mmoires PROM. Il existe plusieurs versions de ces mmoires PROM, qui ont chacune leurs
caractristiques.
On peut par exemple mentionner les FROM, qui sont fournies intgralement vierges, et on peut les reprogrammer une seule et
unique fois. Ces mmoires sont souvent fabriques avec des diodes ou des transistors qui serviront stocker un bit. La
programmation d'une telle ROM est trs simple : pour crire un zro, il suffit de faire claquer la diode ou le transistor
correspondant au bit qu'on veut modifier ! Pour stocker un un, on laisse notre diode ou transistor indemne. Vu qu'une diode ou
un transistor ne se rparent pas tout seuls, on ne pourra pas changer le bit enregistr : impossible de transformer un zro en un :
notre mmoire est programme dfinitivement.
Viennent ensuite les EPROM, qui peuvent tre effaces et reprogrammes plusieurs fois de suite sans problmes, contrairement
aux FROM. En effet, ces mmoires s'effacent lorsqu'on les soumet des rayonnements UV : autant dire que l'effacement n'est pas
www.openclassrooms.com
Partie 4 : Mmoires
195/467
trs rapide.
D'autres mmoires ROM peuvent tre effaces par des moyens lectriques : ces mmoires sont appeles des mmoires
EEPROM. Pour donner des exemples de mmoires EEPROM, sachez que vous en avez surement une dans votre poche. Et oui,
votre cl USB est fabrique avec une mmoire qu'on appelle de la mmoire FLASH, qui est une sorte d'EEPROM.
Le temps d'accs
Imaginons que l'on souhaite accder une donne localise dans une mmoire. On peut vouloir la lire, voire l'crire si c'est une
mmoire RWM, peu importe. Que ce soit une lecture ou une criture, il va falloir attendre un certain temps que notre mmoire aie
finie de lire ou d'crire notre donne. Et ce temps, c'est ce qu'on appelle le temps d'accs.
Sur certaines mmoires, lire une donne ne prend pas le mme temps que l'crire. On se retrouve alors avec deux temps d'accs :
un temps l'accs en lecture et un temps d'accs en criture. Gnralement, la lecture est plus rapide que l'criture. Il faut dire qu'il
est beaucoup plus frquent de lire dans une mmoire qu'y crire, et les fabricants prfrent donc diminuer au maximum le temps
d'accs en lecture que toucher aux temps d'criture.
Ce temps daccs varie beaucoup suivant le type de mmoire. De plus, sur certaines mmoires, le temps d'accs dpend parfois
de la position de la donne en mmoire. C'est le cas sur les disques durs, par exemple, ou sur les mmoires accs squentiel.
Mmoires RAM
Les mmoires RAM sont des mmoires qui sont adressables. Mais en plus, les mmoires RAM ont une particularit : le temps
d'accs est toujours le mme, quelle que soit l'adresse de la donne que l'on souhaite consulter ou modifier. Toutes les mmoires
n'ont pas cette particularit : ce n'est pas le cas d'un disque dur, par exemple, dont le temps d'accs dpend de l'emplacement de
l'information sur le disque dur et de la position de la tte de lecture.
Toutes les mmoires RAM actuelles sont des mmoires volatiles. Nanmoins, il existe des projets de recherche qui travaillent sur
la conception d'une mmoire nomme la MRAM qui serait une mmoire RAM non-volatile. Reste finir le travail de recherche, ce
qui n'est pas pour tout de suite !
Il existe deux types de RAM : les SRAM ou ram statiques et les DRAM ou RAMs dynamiques
Les SRAM
Les donnes d'une SRAM ne s'effacent pas tant qu'elles sont alimentes en courant.
Ces mmoires sont souvent (bien que ce ne soit aps une obligation) fabriques avec des bascules, ces fameux circuits de
mmorisation qu'on a vu il y a de cela quelques chapitres. Vu que ces fameuses bascules utilise pas mal de transistors (au
minimum 6, voire plus), nos cellules mmoires auront tendance prendre un peu de place. En consquence, une cellule mmoire
de SRAM est plus grosse qu'une cellule de mmoire DRAM (qui n'utilise qu'un seul transistor, et un autre composant
lctronique : un condensateur), ce qui signifie qu'on peut mettre beaucoup moins de cellules de SRAM que de cellules de
DRAM sur une surface donne. Pour cette raison, on dit souvent que nos mmoires SRAM ne peuvent contenir beaucoup de
bits. Cette mmoire SRAM est donc utilise lorsque l'on souhaite avoir une mmoire rapide, mais en faible quantit.
Elle sont assez rapides, mais trs chres. Pour info, votre processeur contient beaucoup de mmoires directement intgres dans
ses circuits (les registres et les caches) qui sont toutes faites avec de la SRAM. Il faut dire que les mmoires intgres au
processeur ont absolument besoin d'tre rapides, et qu'on a rarement besoin d'en mettre beaucoup, ce qui fait que la SRAM est
un choix assez adapt.
Les DRAM
Avec les DRAM, les bits stocks en mmoire s'effacent tout seul en quelques millimes ou centimes de secondes (mme si l'on
n'y touche pas). Et c'est sans compter que lire une donne stocke en mmoire va obligatoirement effacer son contenu. Il faut
donc rcrire chaque bit de la mmoire rgulirement, ou aprs chaque lecture, pour viter qu'il ne s'efface. On appelle cela le
rafrachissement mmoire.
Ce rafrachissement prend du temps, et a tendance lgrement diminuer l'efficacit des DRAM. Autrefois, ce rafraichissement
tait effectu par un circuit plac sur la carte mre de notre ordinateur, qui tait charg de toute la gestion de la mmoire (on
l'appelle le contrleur mmoire). Dans une telle situation, les ordres de rafrachissement de la mmoire transitent donc par le bus,
le rendant temporairement incapable de transfrer des donnes. Ce dfaut, autrefois trs pnalisant ne l'est plus de nos jours : de
nos jours, les mmoires RAM contient un circuit qui se charge de rafraichir automatiquement les donnes prsente dans notre
mmoire DRAM. Les pertes de performances sont ainsi plus mitiges.
www.openclassrooms.com
Partie 4 : Mmoires
196/467
Les DRAM sont donc plus lentes que les SRAM, mais peuvent stocker beaucoup plus de bits pour une surface ou un prix
identique. Il faut dire qu'une cellule mmoire de DRAM prend beaucoup moins de place qu'une cellule de SRAM, ce qui fait que
les mmoires DRAM ont souvent une grande capacit compar aux SRAM. C'est ce qui fait qu'elles sont utilises pour la
mmoire principale de nos PC : quand on lance plusieurs programmes assez gourmand en mme temps en plus du systme
d'exploitation, il vaut mieux avoir suffisamment de RAM.
Donne, o es-tu ?
Nos mmoires se diffrencient aussi par l'ordre dans lequel on peut accder leurs donnes.
Mmoires Squentielles
Sur les anciennes mmoires, comme les bandes magntiques, on tait oblig d'accder aux donnes dans un ordre prdfini. On
parcourait ainsi notre mmoire dans l'ordre, en commenant par la premire donne, et en passant la donne suivante aprs une
lecture ou une criture : c'est ce qu'on appelle l'accs squentiel.
Pour lire ou crire une donne, il fallait visiter toutes les cases mmoires prcdentes avant de tomber sur la donn recherche. Et
impossible de revenir en arrire ! Sauf reprendre le lecture/criture depuis le dbut de la mmoire. Des mmoires dans le genre
se passent compltement d'adressage : on n'a pas le besoin, ni la possibilit de slectionner une donne dans la mmoire avec
une adresse.
De nos jours, l'accs squentiel est obsolte et presque compltement inutilise : seules quelques vielles mmoires utilisaient ce
genre daccs.
On peut accder n'importe quelle donne dans notre mmoire, sans trop se soucier de l'ordre d'accs. Pour accder une
donne, on est oblig d'indiquer notre mmoire la position de celle-ci dans la mmoire.
Et on fait comment ?
www.openclassrooms.com
Partie 4 : Mmoires
197/467
0
11101010 01011010
01111111 01110010
00000000 01111100
01010101 0000000
10101010 00001111
00000000 11000011
En fait, on peut comparer une adresse un numro de tlphone (ou une adresse d'appartement) : chacun de vos
correspondants a un numro de tlphone et vous savez que pour appeler telle personne, vous devez composer tel numro. Ben
les adresses mmoires, c'est pareil !
Exemple : on demande notre mmoire de slectionner la case mmoire d'adresse 1002 et on rcupre son contenu (ici, 17).
Mmoires FIFO
Nous avons donc deux mthodes d'accs assez extrmes : les mmoires accs squentielles, et les mmoires accs alatoires.
Ceci dit, les mmoires accs squentielles ne sont pas les seules imposer un ordre d'accs aux donnes. Il existe deux autres
types de mmoire qui forcent l'ordre d'accs. Ce sont les mmoires FIFO et LIFO. Commenons par voir les mmoires FIFO.
Ces mmoires sont des mmoires dans lesquelles les donnes sont tries par ordre d'arrive. Les donnes sont donc crites dans
la mmoire unes par unes, et places dedans au fur et mesure. Une lecture ne renverra que la donne la plus ancienne prsente
dans cette mmoire. De plus, la lecture sera destructrice : une fois la donne lue, elle est efface.
On trouve ces mmoires l'intrieur de nos processeurs : diverses structures matrielles sont conues partir de mmoires FIFO.
Il est facile de crer ce genre de mmoire partir d'une mmoire RAM : il suffit juste de rajouter des circuits pour grer les
ajouts/retraits de donnes. On a notamment besoin de deux registres : un pour stocker la dernire donne ajoute, et un autre
pour localiser la donne la plus ancienne.
Mmoires LIFO
Poursuivons maintenant avec les mmoires LIFO. Ces mmoires sont des mmoires dans lesquelles les donnes sont tries par
ordre d'arrive. Les donnes sont donc crites dans la mmoire unes par unes, et places dedans au fur et mesure. Une lecture
ne renverra que la donne la plus rcente prsente dans cette mmoire. De plus, la lecture sera destructrice : une fois la donne
lue, elle est efface.
On peut voir ces mmoires LIFO comme des mmoires qui fonctionnent sur le mme principe qu'une pile. En clair, toute criture
www.openclassrooms.com
Partie 4 : Mmoires
198/467
empilera une donne au sommet de cette mmoire LIFO. Toute lecture dpilera la donne situe au sommet de la mmoire LIFO.
D'ailleurs, je tiens signaler qu'il est facile de crer ce genre de mmoire partir d'une mmoire RAM : il suffit juste de rajouter un
registre qui stocke l'adresse du sommet de la pile, ainsi que quelques circuits pour grer les empilements/dpilements.
On trouve ces mmoires l'intrieur de nos processeurs : diverses structures matrielles sont conues partir de mmoires FIFO.
Adress Return
Tout d'abord, il existe un premier type de mmoires : les mmoires Adress Return. Sur ces mmoires, on fait peu-prt la mme
chose qu'avec une mmoire accs alatoire, mais dans le sens inverse. Au lieu d'envoyer l'adresse pour accder la donne, on
va envoyer la donne pour rcuprer son adresse.
Cela peut paraitre bizarre, mais ces mmoires sont assez utiles dans certains cas de haute vole. Ds que l'on a besoin de
rechercher rapidement des informations dans un ensemble de donne, ou de savoir si une donne est prsente dans un
ensemble, ces mmoires sont reines. Certaines circuits internes au processeur ont besoin de mmoires qui fonctionnent sur ce
principe. Mais laissons cela plus tard.
Pour ceux qui sont intresss, sachez que j'ai crit un tutoriel sur le sujet, disponible ici : Les mmoires associatives. Je vous
conseille de lire celui-ci une fois que vous aurez termin de lire ce tutoriel.
Hash table
Ensuite, on trouve un deuxime type de mmoire adressable par contenu : les mmoires correspondance. Sur ces mmoires,
chaque donne se voit attribuer un identifiant, qu'on appelle le Tag. Une mmoire correspondance stocke des couples Tag /
Donne. Il est possible que plusieurs donnes diffrentes aient le mme Tag, ou rciproquement, que des donnes identiques
aient des Tags diffrents.
www.openclassrooms.com
Partie 4 : Mmoires
199/467
A chaque accs mmoire, on envoie le Tag de la donne modifier, et la mmoire accde alors directement la donne.
Ce principe est trs utilis dans nos ordinateurs. Certaines mmoires intgres au processeur utilisent ce mode d'accs. On utilise
aussi ce genre de mmoire dans des applications utilisant des bases de donnes ou pour simuler des rseaux de neurones.
Bus de commande
Commenons par le bus de commandes. Dans sa version minimale, il sert indiquer les sens de transferts des donnes la
mmoire : s'agit-il d'une criture, d'une lecture, etc. Pour les mmoires ROM, on sait d'avance que le composant qui va adresser la
mmoire ne peut que faire une lecture : il n'y a pas besoin de prciser que c'est une lecture. Il est donc parfois possible de s'en
passer.
Mais pour les mmoires RWM, c'est autre chose : on peut aussi bien y accder en criture qu'en lecture. On peut accder une
adresse de deux faons :
soit on enregistre une information dans la mmoire : c'est une criture.
soit on rcupre une information stocke dans la mmoire : c'est une lecture.
www.openclassrooms.com
Partie 4 : Mmoires
200/467
Pour prciser le sens de transfert la mmoire, on utilise un bit du bus de commande nomm R/W. Il est souvent admis par
convention que R/W 1 correspond une lecture, tandis que R/W vaut 0 pour les critures.
Bus d'adresse
Pour choisir la case mmoire laquelle on veut accder, il faut bien pouvoir spcifier son adresse notre mmoire. Pour cela,
notre mmoire contient des entres sur laquelle on peut placer notre adresse mmoire, relis au reste du circuit par des fils. Les
fils du bus qui transmettent l'adresse vers la mmoire sont regroups dans une sorte de "sous-bus" qu'on appelle le bus
d'adresses.
Memory Map
Ainsi, quelle que soit la case mmoire laquelle on souhaite accder, il suffit d'envoyer son adresse sur le bus d'adresse et la
mmoire slectionnera cette case pour nous. Peu importe que cette case mmoire soit en RAM, un registre, ou un registre qui
permet la communication avec les priphriques. En effet, sur certains ordinateurs, on utilise un seul bus d'adresse pour grer
plusieurs mmoires diffrentes : certaines adresses sont attribues la mmoire RAM, d'autres la mmoire ROM, d'autres des
priphriques, etc.
Par exemple, certains priphriques possdent des mmoires internes. Ces mmoires internes possdent parfois des adresses, et
sont donc adressables directement par le processeur. Ce qui fait, par exemple, que la mmoire de votre carte graphique se
retrouve dans l'espace d'adressage du processeur.Et oui, votre processeur peut s'occuper d'une partie de la gestion de la
mmoire de votre carte graphique.
Il existe une table pour chaque ordinateur qui dfinit quels composants lectroniques sont attribues les adresses. C'est la
memory map.
Voici un exemple :
Adresse
Composant lctronique
Registres De communication
Avec le priphrique 1
La gestion de l'adressage (et donc du contenu du bus d'adresse) est ralise dans la majorit des cas par le processeur, qui
possde des units permettant de grer les bus de commande et d'adresse. Mais il arrive que les priphriques puissent accder
directement la mmoire : il suffit que ces priphriques et le processeur de l'ordinateur utilisent une technologie nomme Direct
Memory Acces. On en reparlera plus tard dans la suite de ce tutoriel.
Et bien voil l'explication : en utilisant 8 bits par case mmoire, on utilise 8 fois moins d'adresse qu'en utilisant des cases
mmoires de 1 bit. Cela diminue donc le nombre de fil cbler sur le bus d'adresse.
Mais attention : toutes les mmoires n'ont pas des cases mmoires d'une taille de 8 bits. Si vous regardez les anciens ordinateurs,
vous verrez qu'autrefois, nos mmoires utilisaient des cases mmoires plus petites, contenant 2, 3, 4, 7 bits. Il est mme arriv que
certaines mmoires soient bit-adressables, c'est dire qu'on pouvait adresser chaque bit individuellement. De mme, rien
www.openclassrooms.com
Partie 4 : Mmoires
201/467
nempche d'aller au del de 8 bits : certains ordinateurs ont, ou avaient, des cases mmoires de 16 ou 18 bits. Mais pour tre
franc, ce genre de chose est assez rare de nos jours.
La mmoire contient donc des broches sur lesquels brancher nos bus, avec des broches rserves au bus d'adresse, d'autres
rserves au bus de donne, et une rserve au bit R/W.
On remarque que les informations prsentes sur le bus dadresse et sur le fil R/W vont dans un seul sens : du bus vers la
mmoire, mais pas l'inverse. Une mmoire n'a pas envoyer une adresse sur ce bus, ou demander une lecture/criture qui que
ce soit : les bits qui se trouvent sur ces broches serviront commander la mmoire, mais ne pourra pas tre modifi par celle-ci.
Nos broches sur lesquelles on connecte nos bus d'adresse et notre bit R/W sont donc des entres : ce qui se trouve dessus va
renter dans le composant qui fera ce qu'il faut avec, mais le composant ne pourra pas modifier le contenu de ces broches.
Pour les broches relies au bus de donne, le cas est plus litigieux et dpend de l'accs effectu. Si c'est une criture, ces broches
seront des entres : la donne sera lue par la mmoire sur ces entres. Dans le cas d'une lecture,la mmoire va modifier le contenu
du bus de donne, et ces broches vont donc se comporter comme des sorties.
www.openclassrooms.com
Partie 4 : Mmoires
202/467
Bus multiplex
Nanmoins, on peut remarquer que cela fait beaucoup de fils et beaucoup de broches. Cela peut poser problme : les
lectroniciens qui conoivent ce genre de circuits essayent au maximum de limiter le nombre de fils pour viter les problmes. Il y
a des raisons cela : un processeur possde lui aussi des entres et des sorties. Parfois, on peut vouloir cbler un grand nombre
de composants dessus : on utilise alors beaucoup d'entres et il n'en reste plus pour cbler un bus complet dessus. Sans
compter le bordel pour cbler un grand nombre de fils sur une carte d'une taille limite.
Il existe alors une petite astuce pour conomiser des fils : utiliser un seul bus qui servira alternativement de bus de donne ou
d'adresse. Cela s'appelle multiplexer le bus d'adresse et de donne. Voici quoi ressemble donc l'ensemble bus-mmoire :
On a donc :
un seul bus qui sert successivement de bus de donnes et de bus mmoire ;
un bus de commande, avec ventuellement un bits R/W ;
un bit ALE : celui-ci vaut 1 quand une adresse transite sur le bus, et 0 si le bus contient une donne (ou l'inverse!).
Ce genre de bus est plus lent qu'un bus qui ne serait pas multiplex lors des critures : lors d'une criture, on doit en effet
envoyer en mme temps l'adresse et la donne crire. Avec un bus multiplex, on ne peut pas envoyer la fois l'adresse, et une
donne (pour une criture, par exemple). Cela doit tre fait en deux passes : on envoie l'adresse d'abord, puis la donne ensuite.
Sur un bus qui n'est pas multiplex, on peut envoyer l'adresse et la donne en une seule tape, ce qui est plus rapide que de le
faire en deux tapes.
Par contre, les lectures ne posent pas de problmes : quelque soit le type de bus utilis, on envoie d'abord l'adresse, et on
rcupre la donne lue aprs l'envoi de l'adresse. Vu que ces deux oprations ne se font pas en mme temps et qu'il n'y a pas
www.openclassrooms.com
Partie 4 : Mmoires
203/467
besoin d'envoyer la fois une adresse et une donne sur le bus, le bus multiplex ne pose pas de problmes. Heureusement, les
lectures en mmoire sont bien plus courantes que les critures, ce qui fait que la perte de performance due l'utilisation d'un bus
multiplex est souvent supportable.
Mmoire multiports
Aprs avoir vu des mmoires cherchant limiter le nombre de fils en payant le prix en terme de performances, je suis oblig de
mentionner le cas inverse : des mmoires qui n'hsitent pas cbler un maximum de fils pour gagner en performances. Ces
mmoires possdent plusieurs bus de donnes, d'adresse et de commande : chaque bus est prsent en deux, trois ou quatre
exemplaires. Ainsi, on pourra relier la mmoire plusieurs bus, qui permettront de transfrer chacun une donne. Ces mmoires
sont appeles des mmoires multiports. Ce nom vient simplement du fait que chaque bus (je parle d'un bus complet, avec bus
d'adresse + bus de donne + bus de commande) s'appelle un port, et que ces mmoires en ont plusieurs.
Cela permet de transfrer plusieurs donnes en une seule fois : une sur chaque bus. On peut ainsi slectionner plusieurs cases
mmoires, et transfrer des donnes avec chacune de ces cases simultanment (via chaque bus de donne). Je suppose que
vous voyez quel point cela peut tre plus rapide que d'envoyer chacune de ces donne en une tape.
Certaines mmoires multiports possdent des bus spcialiss pour l'criture ou le lecture. Par exemple, certaines mmoires
multiports peuvent tre relies seulement deux bus : un sur lequel on ne peut que lire une donne, et un autre sur lequel on ne
peut qu'crire. Les registres de nos processeurs sont de ce type : cela permet de simplifier la conception de notre processeur.
Ces bus pourront tre relis des composants diffrents, ce qui fait que plusieurs composants pourront accder en mme temps
la mmoire. On peut aussi dcider de relier la mmoire avec un seul composant, en utilisant tous les bus : le composant pourra
alors modifier ou lire le contenu de tous les bus en mme temps. De quoi effectuer plusieurs lectures/critures en mme temps.
videmment, cela fait normment de fils cbler, vu que certains bus sont en double, triple ou quadruple. Cela a un cout en
terme de prix, mais aussi en terme de consommation nergtique : plus une mmoire a de ports, plus elle chauffe et consomme de
llectricit. Mais on peut gagner normment en performances en utilisant de telles mmoires. Pour donner un exemple
d'utilisation, les mmoires multi-ports sont utilises dans les cartes graphiques actuelles, et pour fabriquer les registres du
processeur.
Pourquoi ?
www.openclassrooms.com
Partie 4 : Mmoires
204/467
La raison cela est trs simple : plus une RAM a une capacit importante, plus elle est grosse. Et plus elle est grosse, plus elle
contient de portes logiques et plus les fils qui relient les divers composants de notre mmoire seront longs. Hors, le temps que
met un signal lectrique (un bit, quoi) pour aller d'un point un autre du circuit gne la monte en frquence. Ce temps s'appelle
le temps de propagation, et on en a dj parl dans les chapitres au dbut de ce tutoriel. Ce temps de propagation dpend de pas
mal de facteurs, dont le nombre maximal de portes que notre signal doit traverser (le Critical Path), ainsi que de la longueur des
fils. Le fait est que plus la mmoire est grosse, plus ce temps de propagation est long. Un temps de propagation trop long aura
des effets pas trs reluisants : la frquence de la mmoire sera faible, et notre mmoire sera lente. Alors certes, la capacit d'une
mmoire ne fait pas tout et d'autres paramtres entrent en jeu, mais on ne peut pas passer ce problme sous le tapis.
Hirarchie mmoire
Le fait est que si l'on souhaitait utiliser une seule grosse mmoire dans notre ordinateur, celle-ci serait donc fatalement trs lente.
Malheureusement, un composant trs rapide ne peut attendre durant plusieurs millisecondes que la donne soit charge de la
mmoire sans rien faire, ce serait gaspiller beaucoup trop de temps de calcul. On ne peut donc utiliser une seule grosse mmoire
capable de stocker toutes les donnes voulues. Ce problme s'est pose ds les dbut de l'informatique. Les inventeurs des
premiers ordinateurs modernes furent rapidement confronts ce problme.
Pour ceux qui ne me croient pas, regardez un peu cette citation des annes 1940, provenant d'un rapport de recherche portant sur
un des premiers ordinateurs existant au monde :
Citation : Burks, Goldstine, et Von Neumann
Idalement, nous dsirerions une mmoire d'une capacit indfiniment large tel que n'importe quel byte soit immdiatement
accessible. Nous sommes forcs de reconnaitre la possibilit de la construction d'une hirarchie de mmoire, chacune ayant
une capacit plus importante que la prcdente, mais accessible moins rapidement.
Comme on le voit, cette citation (traduite de l'anglais), montre le problme, mais voque aussi la solution adopte face ce
problme. Pour rsoudre ce problme, il suffit de segmenter la mmoire de l'ordinateur en plusieurs sous-mmoires, de taille et
de vitesse diffrentes qu'on utilise suivant les besoins. On aura donc des mmoires pouvant contenir peu de donnes dans
lesquelles on pourra lire et crire rapidement et des mmoires plus importante, mais plus lentes. Cette solution a t la premire
solution invente pour rsoudre ce problme et est encore massivement utilise l'heure actuelle : on n'a pas encore fait mieux !
Gnralement, un ordinateur contient plusieurs mmoires de taille et de vitesse diffrentes.
Ces mmoires peuvent tre classes en quatre grands types :
Les mmoires de masse qui stockent des informations qui doivent tre conserves mme aprs extinction du systme et
qui sont accde trs rarement.
La mmoire principale qui stocke toutes les informations temporaires auxquelles le processeur doit accder peu souvent
mais qui doivent tre conserves suffisamment longtemps.
les mmoires caches, qui acclrent l'accs la mmoire principale.
les registres, trs rapides contenant des instructions ou donnes que le processeur doit manipuler.
www.openclassrooms.com
Partie 4 : Mmoires
205/467
Localit de rfrence
On voit bien que les mmoires d'un ordinateur sont organises de la plus lente la moins lente. Le but de cette organisation est
de placer les donnes accdes souvent, ou qui ont de bonnes chances d'tre accdes dans le futur, dans une mmoire qui soit
la plus rapide possible. Le tout est faire en sorte de placer les donnes intelligemment, et les rpartir correctement dans cette
hirarchie des mmoires.
Ce placement se base sur deux principes qu'on appelle les principe de localit spatiale et temporelle. Pour simplifier :
un programme a tendance rutiliser les instructions et donnes qui ont ts accdes dans le pass : c'est la localit
temporelle ;
et un programme qui s'excute sur un processeur tendance utiliser des instructions et des donnes qui ont des
adresses mmoires trs proches, c'est la localit spatiale.
Ces deux principes semblent trs simples, mais sont lourds de consquence. On peut exploiter ces deux principes pour placer
correctement nos donnes dans la bonne mmoire. Par exemple, si on a accde une donne rcemment, il vaut mieux la copier
dans une mmoire plus rapide, histoire d'y accder rapidement les prochaines fois : on profite de la localit temporelle. On peut
ainsi placer des donnes consultes ou modifies frquemment dans les registres ou la mmoire cache au lieu de les laisser en
mmoire RAM. On peut aussi profiter de la localit spatiale : si on accde une donne, autant prcharger aussi les donnes
juste cot, au cas o elles seraient accdes.
Placer les bonnes donnes au bon endroit (dans le cache plutt qu'en RAM) permet d'avoir de sacrs gains de performances. Ce
placement des donnes dans la bonne mmoire peut tre gr par le matriel de notre ordinateur, par la faon dont sont
construits nos programmes, ou grable par le programmeur.
Par exemple :
la mmoire cache est souvent gre directement par le matriel de notre ordinateur, d'une faon qui peut tre prise en
compte par le programmeur ;
les registres sont grs par le programmeur (s'il programme ne assembleur ou en langage machine), ou par son langage de
programmation (par le compilateur pour tre prcis) ;
la RAM est implicitement gre par le programmeur, etc.
Bref, sachez qu'un programmeur peut parfaitement prendre en compte le fait que les mmoires d'un ordinateur ne vont pas la
mme vitesse, et peut concevoir ses programmes de faon placer un maximum de donnes utiles dans la bonne mmoire. En
effet, la faon dont est conue un programme joue normment sur la faon dont celui-ci accdera ses donnes, et sur sa
localit spatiale et temporelle. Vu que de nos jours, nos programmes passent de plus en plus de temps attendre que les
donnes manipuler soient lues ou crites depuis la mmoire, ce genre de choses commence devenir une ncessit. Bref, un
programmeur peut, et doit, prendre en compte les principes de localits vus plus haut ds la conception de ses programmes. Et
cette contrainte va se faire de plus en plus forte quand on devra passer aux architectures multicurs.
Maintenant que cette petite remarque est faite, parlons un peu des diffrentes mmoires. Commenons par ces fameux registres.
Registres
Les registres sont fabriqus avec des mmoire SRAM. Ces registres sont trs souvent intgrs dans le processeur de votre
ordinateur, mais quelques priphriques possdent eux aussi des registres. La diffrence, c'est que les registres de notre
processeur vont stocker temporairement des donnes pour pouvoir les manipuler rapidement. Les priphriques utilisent des
registres pour communiquer avec le processeur, bien plus rapide qu'eux.
Noms de registres
Sur les processeurs x86 ainsi que sur la grosse majorit des processeurs existants ou ayant exist, les registres ne sont pas
adressables. Sur de tels processeurs, chaque registre est identifi par un numro qui n'a rien voir avec une adresse ! Ce
numro, ou nom de registre, permet d'identifier le registre que l'on veut, mais ne sort jamais du processeur : ce nom de registre, ce
numro, ne se retrouve jamais sur le bus d'adresse.
www.openclassrooms.com
Partie 4 : Mmoires
206/467
Quand une instruction voudra manipuler des donnes, elle devra fatalement donner leur position dans la mmoire. Pour
manipuler une case mmoire, elle donne gnralement son adresse, et pour un registre, elle donnera un nom de registre. Ces
adresses et noms de registres seront cods sous la forme de suites de bits, incorpores dans l'instruction. Mais rien ne
ressemble plus une suite de bits qu'une autre suite de bits : notre processeur devra viter de confondre suite de bits
reprsentant une adresse, et suite de bits reprsentant un nom de registre. Pour viter les confusions, chaque instruction devra
prciser quoi correspondra la suite de bits prcisant la localisation des donnes manipuler. On peut ainsi utiliser diverses
instructions diffrentes suivant qu'on veut manipuler des registres ou des adresses mmoires, par exemple.
Registres adressables
Mais il existe quelques processeurs sur lesquels on peut adresser les registres via une adresse mmoire. Il est vrai que c'est
assez rare, et qu' part quelques vielles architectures ou quelques micro-contrleurs, je n'ai pas d'exemples donner. Mais c'est
tout fait possible ! C'est le cas du PDP-10.
www.openclassrooms.com
Partie 4 : Mmoires
207/467
Cache
Un cache est une mmoire qui doit tre assez rapide, et est donc fabriqu avec de la SRAM, assez vloce. Ce cache est
gnralement intgr dans le processeur de votre ordinateur, mais quelques priphriques possdent eux aussi des caches,
comme certains disques durs.
Un cache n'est jamais adressable ! Cela est du au fait que chaque donne prsente dans la mmoire cache est une copie d'un
emplacement de la mmoire RAM. Le contenu du cache est gr par un circuit particulier qui dcide quoi charger dedans et
quand. Lorsque le processeur veut ainsi accder une case mmoire en RAM (en lecture ou en criture), il va envoyer l'adresse
de cette case sur le bus. Celle-ci sera intercepte par les circuits chargs de grer le cache qui regarderont alors si le cache
contient une copie de la case manipuler. Si c'est le cas, on lit ou crit la donne dans le cache. Dans le cas contraire, on accde
la mmoire RAM. Cela explique qu'on aie pas besoin de donner des adresses aux cases mmoires du cache : les circuits de
gestion du cache savent quelle case mmoire en RAM correspond chaque case mmoire du cache.
Local Stores
Sur certains processeurs, les mmoires caches sont remplaces par des mmoires qui fonctionnent diffremment mais remplissent
le mme rle : fournir un intermdiaire plus rapide entre les registres et la mmoire principale. A la place de mmoire cache, on
utilise la place ce qu'on appelle un Local Store. Ce sont des mmoires RAM, identique la moire RAM principale, sauf que
nos Local Stores sont plus petites et donc plus rapides. Contrairement aux mmoires caches, il s'agit de mmoires adressables !
Et cela change tout : vu que ces Local Store sont adressables, ils ne sont plus grs automatiquement par le processeur. Ainsi,
rien nempche le programmeur de dcider quoi placer dans cette mmoire et quand : il peut s'en servir de mmoires tampon pour
stocker des donnes qui seront rutilises assez souvent et dans un intervalle de temps assez proche, sans avoir stocker ces
donnes en RAM.
Les transferts de donnes entre Local Store et mmoire RAM sont effectus par un circuit spcial, spar du processeur. C'est le
processeur qui configure ce circuit pour que celui-ci effectue le transfert dsir automatiquement, sans intervention du
processeur. Dans ce genre de cas, la gestion d'un Local Store pose les mmes problmes que la gestion d'une mmoire cache : il
faut notamment prendre en compte la localit spatiale et temporelle. Dans de telles conditions, on peut voir notre Local Store
comme une sorte de mmoire cache gre par le programmeur, qui dcide quand lancer le transfert, quoi transfrer, et o.
Avantages/inconvnients
Ces Local Stores consomment moins d'nergie que les caches taille quivalente. En effet, ceux-ci sont de simples mmoires
RAM, et on n'a pas besoin de circuits compliqus pour les grer automatiquement. Ces circuits grant le cache prennent
beaucoup de place sur le processeur et ont un certain temps de latence. Les Local Store n'ont pas ces problmes et peuvent tre
trs avantageux.
www.openclassrooms.com
Partie 4 : Mmoires
208/467
Ces Local Stores peuvent aussi tre trs avantageux quand il s'agit de partager des donnes entre plusieurs processeurs
efficacement. Dans ce genre de cas, l'utilisation de toute une hirarchie de mmoires caches L1, L2, L3, etc ; pose des problmes
assez consquents dont je ne parlerais pas ici (Ces fameuses histoires de cohrence des caches voque dans le chapitre
prcdent), qui peuvent fortement diminuer les performances. Les Local Stores, eux, ne posent presque aucun problme, et sont
donc mieux adapts ce genre de situations.
Cot inconvnients, ces Local Stores peuvent entrainer des problmes de compatibilit : que faire si jamais on souhaite changer
leur taille ? On est oblig de changer certains programmes pour que ceux-ci puissent profiter de local stores plus grands, ou
simplement pour que ceux-ci s'adaptent une organisation de la mmoire un peu diffrente. Au final, on utilise ces Local Stores
dans des situations pour lesquels on se moque de la compatibilit et pour lesquelles on veut un ordinateur qui chauffe peu et
consomme assez peu d'nergie.
Mmoires principales
La mmoire principale sert de mmoire de travail, et parfois de mmoire programme. C'est dedans qu'on va stocker les donnes
manipuler et ventuellement le ou les programmes excuter (sur les architectures Von Neumann ou sur les architectures Harvard
modifies). Par consquent, on va devoir accder son contenu assez souvent et pouvoir grer cela de faon manuelle : toutes
les mmoires RAM sont donc adressables.
La mmoire principale est fabrique avec de la DRAM, qui peut contenir plus de donnes sur une surface gale que la SRAM. Il
faut dire que contenir un systme d'exploitation moderne et plusieurs programmes en mme temps ncessite au moins quelques
centaines de mga-octets. L'utilisation de DRAM au lieu de SRAM permet notre mmoire d'atteindre les 2 4 gigaoctets sans
frmir, ce qui fait tout de mme 4 milliards de cases mmoires adressables pour 4 gigaoctets.
Nanmoins, il existe des exceptions qui confirment la rgle : la gamecube et la Wii possdent toutes les deux une mmoire
principale de 24 mgas-octets de SRAM. Il s'agit toutefois d'une mmoire SRAM, amliore de faon augmenter sa densit (le
nombre de Bytes qu'on peut placer sur une surface donne).
Mmoires de masse
Ces mmoires servent surtout stocker de faon permanente des donnes ou des programmes qui ne doivent pas tre effacs :
ce seront donc des mmoires non-volatiles, souvent fabriques avec de la ROM ou des dispositifs magntiques. Les mmoires
de masse servent toujours stocker un programme ou quelques paramtres/constantes utiles. On doit donc accder leur
contenu et elles sont donc adressables, part certaines vielles mmoires magntiques qui font exception. Vu que ces mmoires
doivent souvent stoker une grande quantit de bits (un programme prend souvent beaucoup de place), elles doivent avoir une
capacit norme compar aux autres types de mmoires, et sont donc trs lentes.
Parmi ces mmoires de masse, on trouve notamment
les disques durs ;
les mmoires FLASH, utilises dans les cls USB, voire dans les disques durs SSD ;
les disques optiques, comme les CD-ROM, DVD-ROM, et autres CD du genre ;
les fameuses disquettes, totalement obsoltes de nos jours ;
mais aussi quelques mmoires trs anciennes et rarement utilises de nos jours, comme les rubans perfors et quelques
autres.
www.openclassrooms.com
Partie 4 : Mmoires
209/467
Mmoriser un bit
Dans les grandes lignes, les mmoires RAM, ROM, et autres EEPROM actuelles sont toutes composes de cellules mmoires
capables de retenir un bit. En mettant pleins de ces cellules dans un seul composant, et en mettant quelques circuits
lectroniques pour grer le tout, on obtient une mmoire. L'ensemble des cellules mmoires utilises pour stocker des donnes
s'appelle le plan mmoire, et c'est lui qui est l'objet de ce chapitre.
De nos jours, ces cellules mmoires sont fabriques avec des composants lectroniques et il nous faudra imprativement passer
par une petite tude de ces composants pour comprendre comment fonctionnent nos mmoires. Dans ce chapitre, nous allons
voir ce qu'il y a l'intrieur d'une mmoire RAM et apprendre crer nos propres bits de mmoires partir de composants
lmentaires : des transistors. Mais tout d'abord, ce chapitre se limitera aux mmoires de type RAM. En effet, les cellules
mmoires de mmoires ROM, PROM, ou EEPROM sont fabriques d'une faon trs diffrente. Et ne parlons mme pas des
disques durs qui utilisent le magntisme pour stocker des donnes et non des composants lectroniques ! Vous verrez aussi que
les cellules mmoires des mmoires SRAM et DRAM ne sont pas conues de la mme faon. Bref, commenons !
Mmoire SRAM
Les composants principaux d'une mmoire SRAM sont ce qu'on appelle des bascules. Et oui, il s'agit des fameuses bascules
vues au troisime chapitre de ce tutoriel, dans la partie sur les circuits squentiels. Ce sont de petits composants lectroniques
capables de mmoriser un bit, et qui peuvent le mettre jour si besoin. Il existe diffrents types de bascules qui peuvent tre
utilises pour mmoriser des bits (JK, RS NOR, RS NAND, RSH, etc), mais on va mettre les choses au point tout de suite : nos
mmoires SRAM utilisent toutes une bascule nomm bascule D.
Notre bascule est un circuit enferm dans un boitier, qui contient tout ce qu'il faut pour mmoriser un bit. Mais ce bit ne vient pas
de nulle part : notre bascule doit recevoir celui-ci de quelque part. Pour cela, notre bascule possde une entre sur laquelle on va
placer le bit mmoriser. De mme, le bit mmoris doit pouvoir tre lu quelque part et notre bascule va mettre disposition celuici sur une sortie.
Notre bascule commence se dessiner peu peu. Voici exactement quoi elle ressemble.
Le fonctionnement d'une bascule est trs simple : quand l'entre E passe de 1 0 (de 0 1 sur certaines bascules), le contenu du
bit D est recopi sur la sortie Q.
Cette bascule n'est rien d'autre qu'une cellule mmoire de SRAM, qu'on peut lire et crire loisir. Si on veut lire le contenu de la
bascule, il suffit de lire le bit prsent sur la sortie Q. Pour crire, il faut placer le bit crire sur l'entre D, et faire passer l'entre E
de 0 1 : le contenu du bit (la sortie Q) sera alors mit jour.
Mais quoi sert l'entre E ?
Cela permet d'viter que le bit contenu dans notre cellule de mmoire SRAM soit modifi quand on ne souhaite pas : il faut
d'abord autoriser l'criture (ou la lecture) avec l'entre E.
Maintenant que l'on sait quoi ressemble une cellule mmoire vu de l'extrieur, il est temps de passer aux choses srieuses.
Ouvrons cette bascule et regardons ce qu'elle a dans le ventre ! Mais avant de commencer la dissection, autant prvenir tout de
suite : il existe plusieurs faons de concevoir une bascule. Aussi, on ne verra que les plus simples.
www.openclassrooms.com
Partie 4 : Mmoires
210/467
rien mmoriser. Bien sur, cela ne marche pas avec tous les circuits : dans certains cas, cela ne marche pas, ou du moins cela ne
suffit pas pour mmoriser des informations. Par exemple, si je relie la sortie d'une porte NON son entre, le montage obtenu ne
sera pas capable de mmoriser quoique ce soit.
Et si on essayait avec deux portes NON ?
Ah, c'est plutt bien vu ! En effet, en utilisant deux portes NON , et en les reliant comme indiqu sur les schma juste en dessous,
on peut mmoriser un bit.
Le premier inverseur va lire le bit mmoris, et va fournir l'inverse sur sa sortie. Puis, le second inverseur va prendre cet inverse et
le r-inverser encore une fois : on va retrouver le bit de dpart sur sa sortie. Cette sortie tant relie directement sur la sortie Q,
on retrouve donc notre bit mmoriser sur la sortie. L'ensemble sera stable : on peut dconnecter l'entre du premier inverseur,
celle-ci sera alors rafraichie en permanence par l'autre inverseur, avec sa valeur prcdente.
Bascule RS NOR
Le seul problme, c'est qu'il faut bien mettre jour l'tat de ce bit de temps en temps. Il faut donc ruser. Pour mettre jour l'tat de
notre circuit, on va simplement rajouter une entre notre circuit qui servira le mettre jour, et remplacer notre porte NON par
une porte logique qui se comportera comme un inverseur dans certaines conditions. Le tout est de trouver une porte logique qui
inverse le bit venant de l'autre inverseur si l'autre entre est zro (ou 1, suivant la bascule). Des portes NOR font trs bien
www.openclassrooms.com
Partie 4 : Mmoires
211/467
l'affaire.
On obtient alors ce qu'on appelle des bascules RS. Celles-ci sont des bascules qui comportent deux entres
sortie , sur laquelle on peut lire le bit stock.
et
, et une
Sortie Q
Interdit
Bascules RS NAND
On peut aussi utiliser des portes NAND pour crer une bascule.
www.openclassrooms.com
Partie 4 : Mmoires
212/467
En utilisant des portes NAND, le circuit change un peu. Celles-ci sont des bascules qui comportent deux entres
sortie , sur laquelle on peut lire le bit stock.
et
, et une
Sortie Q
Interdit
Bascule D
C'est partie de cette bascule RS qu'on va crer une bascule D. Pour crer une bascule D, il suffit simplement de prendre une
bascule RS, et de l'amliorer de faon en faire une bascule D.
Exemple avec une bascule RS utilisant des portes NOR.
www.openclassrooms.com
Partie 4 : Mmoires
213/467
Ce circuit combinatoire est assez simple. Pour le concevoir, il suffit d'crire sa table de vrit et d'en dduire son quation
logique, qu'on traduira en circuit.
Entre E Entre D
Sortie R Sortie S
Ceux qui sont observateurs verront qu'on peut dduire immdiatement l'quation de chaque sortie, R et S. S est gale au rsultat
d'un simple ET entre les entres E et D, tandis que R est gale
.
On obtient donc ce circuit :
On pourrait faire de mme avec une bascule RS utilisant des portes NAND. Il existe de nombreuses autres faons de crer des
bascules D avec des portes logiques, mais on ne poursuivra pas plus loin dans cette voie. Il faut dire que les mmoires SRAM de
nos ordinateurs ne sont pas vraiment conues comme ceci.
www.openclassrooms.com
Partie 4 : Mmoires
214/467
Ce montage a dj t vu auparavant. Il se contente d'inverser la tension place sur lentre : si cette tension reprsente un 1,
alors la sortie vaut zro. Et inversement, si l'entre vaut zro, la sortie vaut 1. Il s'agit d'un circuit inverseur, aussi appel une porte
NON . Avec ce circuit, la sortie sera connecte soit la tension d'alimentation et fournira un 1 en sortie, soit la masse de faon
fournir un zro en sortie.
Mais ce circuit, tout seul, ne fait qu'inverser le bit pass en entre. Pour conserver le bit pass en entre, on utilise deux
inverseurs, la sortie du premier tant relie l'entre du second. Et oui, c'est le mme principe que pour la cration de bascules
avec des portes logiques !
Les transistors nots M5 et M6 vont servir d'interrupteur, et relient la cellule mmoire (les 4 transistors du milieu) l'entre D.
Lors d'une lecture ou d'une criture, les deux transistors vont s'ouvrir. Cela permet de positionner la sortie des deux inverseurs
la bonne valeur, afin de raliser une opration d'criture. Pour une lecture, il suffira de lire le bit voulu sur la sortie Q en fermant
www.openclassrooms.com
Partie 4 : Mmoires
215/467
"linterrupteur" M5. Les mmoires multiports utilisent des transistors supplmentaires, qui ont exactement le mme rle que les
transistors M5 et M6, mais qui sont relis des entres et des sorties diffrentes.
Et l, il faut remarquer un truc : le bit est stock, mais cela ne fonctionne que tant que nos inverseurs sont aliments. Si on coupe
la tension d'alimentation, la tension l'intrieur du fil qui distribuait celle-ci dans nos circuit s'annule. En regardant notre montage
vu plus haut, on remarque que dans ce cas, la sortie sera relie soit au zro volt, soit une tension d'alimentation nulle : il vaudra
toujours zro et le bit stock dans ce montage est perdu. Cela explique pourquoi les mmoires SRAM sont des mmoires
volatiles.
Mmoire DRAM
3T-DRAM
Les premires mmoires DRAM fabriques commercialement utilisaient 3 transistors. Ceux-ci taitent relis de cette faon :
Mmorisation
Le bit est mmoris dans le transistor du milieu, celui qui est indiqu en bleu sur le schma :
Cela peut paraitre bizarre : un transistor n'est pas cens pouvoir stocker un bit ! Pour comprendre ce qui se passe, il faut savoir
comment fonctionne un transistor CMOS. l'intrieur du transistor, on trouve simplement une plaque en mtal relie la grille
appele l'armature, un bout de semi-conducteur entre la source et le drain, et un morceau d'isolant entre les deux.
www.openclassrooms.com
Partie 4 : Mmoires
216/467
Suivant la tension qu'on envoie sur la grille, l'armature va se remplir dlectrons ou se vider. Et cela nous permet de stocker un bit
: il suffit de dire qu'une grille pleine compte pour un 1, et qu'une grille vide compte pour un 0. Bien sr, cette armature n'est pas
parfaite : c'est mme une vraie passoire. Celle-ci a tendance se vide rgulirement et on est oblig de la remettre jour de temps
en temps.
Il faut remarquer qu'avec cette organisation, lire un bit ne dtruit pas celui-ci : on peut parfaitement relire plusieurs fois un bit
sans que celui-ci ne soit effac cause des lectures. C'est une qualit que les DRAM modernes n'ont pas.
Lectures / critures
Les deux autres transistors servent autoriser les lecture et critures. Ainsi, le transistor de gauche va connecter ou dconnecter
le transistor mmorisant notre bit sur la ligne d'criture. L'autre servira connecter le transistor stockant notre bit pour effectuer
une lecture. videmment, il faut bien commander ces deux transistors. Pour cela, il va falloir envoyer un signal qui permettra de
demander un accs mmoire, en lecture ou en criture. Mais cet envoi de signal peut s'effectuer de deux faons.
Soit on utilise un seul signal, qui sert ouvrir les deux transistors (celui de lecture et celui d'criture)
www.openclassrooms.com
Partie 4 : Mmoires
217/467
Bit line
Ensuite, dernire diffrence entre les mmoires DRAM trois transistor : comment sont relies les sorties de notre cellules. Sur
certaines mmoires DRAM, l'criture et la lecture d'un bit se font par le mme fil : le choix entre lecture et criture se fait en
fonction de ce qu'il y a sur ce fil, et grce d'autres portions de la mmoire.
www.openclassrooms.com
Partie 4 : Mmoires
218/467
Sur d'autres mmoires, la lecture et l'criture s'effectuent sur des fils spars. L'entre et la sortie de la cellule sont relies deux
fils spars.
1T-DRAM
Les DRAM actuelles fonctionnent diffremment : elle n'utilisent qu'un seul et unique transistor, et un autre composant
lectronique nomm un condensateur. Pour simplifier, ce condensateur n'est rien d'autre qu'un gros rservoir lectrons : on
peut le remplir dlectrons ou le vider en mettant une tension sur ses entres. C'est ce condensateur qui va stocker notre bit : le
condensateur stocke un 1 s'il est rempli, et stocke un 0 s'il est vide. Rien de plus simple.
A cot, on ajoute un transistor qui relie ce condensateur au reste du circuit. Ce transistor sert d'interrupteur : c'est lui qui va
autoriser l'criture ou la lecture dans notre condensateur. Tant que notre transistor se comporte comme un interrupteur ouvert, le
courant ne passe pas travers, et le condensateur est isol du reste du circuit. : pas d'criture ou de lecture possible. Si on
l'ouvre, on pourra alors lire ou crire dedans.
www.openclassrooms.com
Partie 4 : Mmoires
219/467
On utilise seulement un transistor et un condensateur. Une DRAM peut stocker plus de bits pour la mme surface qu'une SRAM
grce cela : votre avis, entre un transistor coupl un condensateur et 6 transistors, qui prend le moins de place ?
Logiquement, lisolant empche les lectrons de passer d'une armature l'autre : ces lectrons n'ont nulle part o aller et sont
censs rester sur l'armature tant que le transistor servant d'interrupteur ne dcide de relier le condensateur au reste du circuit.
Mais dans la ralit, l'isolant qui spare les deux armatures n'est pas totalement tanche, et des lectrons passent de l'armature
qui le stocke l'autre, relie la masse, et quittent donc le condensateur.
En clair, le bit contenu dans la cellule de mmoire DRAM s'efface, et c'est pour cela qu'on doit le rcrire rgulirement. Vous
www.openclassrooms.com
Partie 4 : Mmoires
220/467
comprenez maintenant pourquoi on doit rafraichir une mmoire DRAM, et aussi pourquoi celle-ci est volatile.
Correction d'erreurs
Une mmoire n'est pas un dispositif parfait : il est possible que certaines oprations de lecture ou d'criture ne se passent pas
correctement et qu'on lise ou crive des donnes corrompues. Un bit d'une mmoire peut parfaitement tre modifi, suite
l'action d'un rayonnement cosmique ou d'une perturbation lectromagntique de passage. Aprs tout, ce n'est pas une chose si
rare : on est sans cesse entour par des rayonnements divers, aussi bien naturels quartificiels, qui peuvent interfrer avec le
fonctionnement des appareils lectroniques qui nous entourent et les mmoires ne font pas exception !
Pour donner un exemple, on peut citer l'incident de Schaerbeek. Le 18 mai 2003, dans la petite ville belge de Schaerbeek, une
dfaillance temporaire d'une mmoire faussa les rsultats d'une lection. Cette ville utilisait une machine voter lctronique, qui
contenait don forcment une mmoire. Et on constata un cart de 4096 voix en faveur d'un candidat entre le dpouillement
traditionnel et le dpouillement lctronique. Mais ce n'tait pas une fraude : le coupable tait un rayon cosmique, qui avait
modifi l'tat d'un bit de la mmoire de la machine voter.
Cet incident n'tait pas trop grave : aprs tout, il a pu corriger l'erreur. Mais imaginez la mme dfaillance dans un systme de
pilotage en haute altitude...
Exemple
Prenons le nombre 00000101. Celui-ci contient 6 bits 0 et 2 bits 1. La somme de tous ces bits vaut donc 2. Le bit de parit
vaudra donc zro.
En plaant le bit de parit au dbut du nombre, on obtient : 000000101.
Autre exemple : le nombre 11100101. Celui-ci contient 3 bits 0 et 5 bits 1. On trouve 5 bits 1 dans ce nombre, ce qui donne
un nombre impair. Le bit de parit vaudra donc un.
Le total sera donc : 11110101.
Dtection d'erreur
www.openclassrooms.com
Partie 4 : Mmoires
221/467
Dtecter une erreur est simple : on compte le nombre de bits 1 dans le nombre stocker, bit de parit inclut, et on regarde s'il est
pair. S'il est impair, on sait qu'au moins un bit t modifi. En modifiant un bit, la parit du nombre total de bits 1 changera : le
nombre de bits 1 sera amput (si un 1 devient un 0) ou augment de 1 (cas inverse) et deviendra un nombre impair. Et ce qui est
valable pour un bit l'est aussi pour 3, 5, 7, et pour tout nombre impair de bits modifis. Par contre, si un nombre pair de bit est
modifi, la parit du total ne changera pas et restera compatible avec la valeur du bit de parit : on ne pourra pas dtecter l'erreur.
Mmoires ECC
Mais savoir qu'un bit a t modifi sans pouvoir corriger l'erreur est quelque peu frustrant. Sans compter les erreurs qui
modifient un nombre pair de bits, qui ne sont pas dtectes. Pour rsoudre ces dfauts, inhrents aux mmoires utilisant un bit
de parit, on a invent d'autres types de mmoires : les mmoires ECC. Ces mmoires utilisent des mthodes de dtection
d'erreur plus sophistiques, qui utilisent au moins deux bits supplmentaires par case mmoire. On les retrouve le plus souvent
dans des serveurs ou dans des ordinateurs qui doivent fonctionner dans des environnements hostiles sans tomber un panne : la
mmoire d'un calculateur implant dans un satellite ou une navette spatiale.
Le plus souvent, la technique de correction d'erreur utilis est un code de hamming, coupl avec un bit de parit. Cela permet de
dtecter les erreurs qui modifient 2 bit ou un nombre impair de bits, et de corriger les erreurs qui ont modifies 1 bit.
www.openclassrooms.com
Partie 4 : Mmoires
222/467
Dans ce chapitre, on va voir comment l'ensemble est organis, et voir dans les grandes lignes comment fonctionne un contrleur
mmoire. Mais avant tout, je tiens donner une petite prcision : je ne parlerais pas du fonctionnement des mmoires multiports
dans ce chapitre, et me contenterais d'voquer les mmoires connectes un seul bus.
www.openclassrooms.com
Partie 4 : Mmoires
223/467
Chaque cellule mmoire d'une case mmoire est connecte sur un fil qui lui permettra de communiquer avec le bus de donne.
Chacun de ces fils s'appelle la Bit Line. Avec cette organisation, la cellule mmoire stockant le i-me bit du contenu d'une case
mmoire (le bit de poids i) est relie au i-me fil du bus.
Vu qu'une case mmoire est stocke sur une ligne, il suffit de slectionner la bonne ligne dans le plan mmoire . Pour pouvoir
www.openclassrooms.com
Partie 4 : Mmoires
224/467
slectionner une ligne, une solution simple est utilise : on dconnecte du bus les cases mmoires/lignes dans lesquelles on ne
veut pas crire ou lire, et on connecte sur le bus uniquement la case mmoire manipuler. Cette connexion/dconnexion est
ralise par un vulgaire interrupteur qu'on peut commander lectroniquement (pour lui dire de s'ouvrir ou de se fermer) : notre
transistor fait son retour !
Exemple en utilisant un transistor en guise d'interrupteur.
Pour autoriser une lecture ou une criture dans une cellule mmoire, il suffira de fermer ce transistor en envoyant un 1 sur la grille
de celui-ci. Par contre, notre cellule mmoire sera dconnecte du bus si la grille du transistor est zro : le transistor se
comportera comme un interrupteur ouvert.
Vous vous souvenez que dans les cellules mmoires de DRAM (et certaines SRAM), il y a au moins un petit circuit
(souvent un transistor) qui permet d'autoriser les lectures ou criture ? Et bien il suffit d'intercaler ce transistor entre le
bus et la mmoire. Dans ce genre de cas, le transistor est intgr la cellule mmoire. Mais a n'est pas toujours le cas.
Vu que tous les bits d'une case mmoire sont rassembls sur une ligne, tous les transistors relis aux cellules mmoires de cette
ligne devront "s'ouvrir" ou se "fermer" en mme temps : on relie donc leur grille au mme fil, sur lequel on enverra un 1 ou un
zro selon qu'on veuille ouvrir ou fermer ces transistors.
Comme vous le voyez, ce fil s'appelle Row Line sur le schma. Pour slectionner notre case mmoire parmi toutes les autres, il
suffira de positionner son entre Row Line 1, et placer les entres Row Line de toutes les autres cases mmoires zro. Le rle
du contrleur mmoire est donc de dduire quelle entre Row Line mettre un partir de l'adresse envoye sur le bus
d'adresse.
Dcodeurs
Pour slectionner la bonne ligne, notre contrleur mmoire doit rpondre plusieurs exigences :
Il doit partir d'une adresse code sur bits, et en dduire quelle case mmoire slectionner : ce contrleur a donc
entres ;
notre adresse de bits peut adresser
bytes : notre contrleur mmoire doit donc possder
sorties ;
chacune de ces sorties sera relie une entre row line et permettra de connecter ou dconnecter une case mmoire du
www.openclassrooms.com
Partie 4 : Mmoires
225/467
bus ;
on ne doit slectionner qu'une seule case mmoire la fois : une seule sortie devra tre place 1, et toutes les autres
zro ;
et enfin, deux adresses diffrentes devront slectionner des cases mmoires diffrentes : la sortie de notre contrleur qui
sera mise 1 sera diffrente pour deux adresses diffrentes places sur son entre.
Il existe un composant lectronique qui rpond ce cahier des charges : le dcodeur. C'est le composant parfait pour positionner
notre bit Row Line.
Exemple d'un dcodeur 3 entre et 8 sorties.
On peut remarquer que toutes les sorties d'un dcodeur sont numrotes : sur un dcodeur possdant
entres, nos sorties
sont numrotes de
. Le fonctionnement de notre dcodeur est trs simple : il prend sur son entre un nombre entier
x cod en binaire, positionne 1 la sortie numrot x et positionne zro toutes les autres sorties.
- 0
- 0
- 0
- 1
Comme vous le voyez, on se retrouve avec nos sorties 1 sur une diagonale. Et cela a une consquence : cela signifie qu'une
fois nos quations logiques crites, il sera impossible de les simplifier ! On se doute bien qu' cause de cela, notre dcodeur va
utiliser beaucoup de portes logiques.
Quoiqu'il en soit, on obtient alors les quations logiques suivantes :
;
;
;
;
Une fois traduite en circuit, on obtient alors le circuit suivant :
www.openclassrooms.com
Partie 4 : Mmoires
226/467
Dcodeurs complets
Utiliser une table de vrit pour crer un dcodeur est impossible si celui-ci utilise trop dentres. Nanmoins, il est possible de
se passer de celle-ci en rusant un peu.
En rflchissant bien, on sait qu'on peut dduire la sortie assez facilement en fonction de l'entre. Si lentre vaut 0, la sortie mise
1 sera la sortie 0. Si l'adresse vaut 1, ce sera la sortie 1. Et on peut continuer ainsi de suite. En clair : si l'adresse vaut N, la sortie
mise 1 sera la sortie N. Bref, dduire quand mettre 1 la sortie N est facile : il suffit de comparer l'adresse avec N. Si l'adresse
vaut N, on envoie un 1 sur la sortie, et on envoie un zro sinon. Pour cela, j'ai donc besoin d'un comparateur spcial pour chaque
sortie, et le tour est jou.
Exemple d'un dcodeur 8 sorties.
www.openclassrooms.com
Partie 4 : Mmoires
227/467
En faisant cela, on se retrouve avec un circuit trs similaire ce qu'on aurait obtenu en utilisant une table de vrit. A quelques
dtails prts, bien sr.
Pr-dcodage
Si on cre un dcodeur partir des techniques vues au-dessus, ce dcodeur utilisera une grande quantit de portes logiques.
Plus prcisment, la quantit de portes logiques utilise augmentera exponentiellement avec le nombre dentres : cela devient
rapidement inutilisable. Pour viter cela, il existe d'autres types de dcodeurs, qui utilisent moins de portes logiques. Ces derniers
sont toutefois plus lents que leurs congnres cres partir d'une table de vrit. Ces dcodeurs moins gourmands en circuits
ont un cblage assez complexe, aussi on vous l'pargnera dans ce qui va suivre.
Circuit complet
Pour adresser une mmoire adressage linaire, il suffit de relier chaque fil Row Line sur une sortie de ce dcodeur. Plus
prcisment, le bit Row Line de la case mmoire d'adresse N doit tre connecte la sortie numro N du dcodeur : ainsi, si on
envoie l'adresse N sur l'entre de ce dcodeur, la sortie N sera slectionne, ce qui slectionnera la case mmoire approprie.
L'adresse a juste tre place directement sur l'entre de notre dcodeur, qui se chargera de slectionner le bon fil Row Line qui
correspond notre adresse.
Exemple d'une mmoire de 4 cases mmoires avec une adresse de deux bits.
www.openclassrooms.com
Partie 4 : Mmoires
228/467
Notre contrleur mmoire se rsumera donc un simple dcodeur, avec quelques circuits pour grer le sens de transfert (lecture
ou criture), et la dtection/correction d'erreur. Ce genre d'organisation s'appelle l'adressage linaire.
Principe
Vous l'avez compris, diminuer le nombre de lignes dans notre mmoire n'est que de la lgitime dfense. Et il n'y a qu'une seule
solution cela : regrouper plusieurs cases mmoires sur une seule ligne.
www.openclassrooms.com
Partie 4 : Mmoires
229/467
Ainsi, il suffira de slectionner la ligne voulue, et slectionner la case mmoire l'intrieur de la ligne. Slectionner une ligne est
facile : on utilise un dcodeur. Mais la slection de la colonne est quelque chose de nettement plus intressant : la mthode
utilise pour slectionner la colonne dpend de la mmoire utilise. Commenons par aborder la premire mthode : celle utilise
pour les mmoires adressage par concidence.
Il faut prciser qu'on trouve une case mmoire l'intersection entre une colonne et une ligne. Bien videmment, chaque case
mmoire est relie au bus via un transistor servant d'interrupteur, comme pour les mmoires adressage linaire. Et comme pour
les mmoires adressage linaire, la slection d'une case mmoire sur le bus se fait grce un signal qui ouvrira ou fermera ces
fameux transistors. Mais ce signal ne se contentera pas d'une ligne Row Line.
Slectionner une colonne se fera en utilisant un second dcodeur. Avec cette solution, toutes les cases mmoires d'une ligne
sont relies un fil, qu'on nommera le Row Line, et toutes les cases mmoires d'une colonne sont relies un autre fil : le
Column Line. Une case mmoire est slectionne quand ces deux fils sont mit 1 : pour cela, il suffit de relier la Row Line et la
Column Line adquates aux entres d'une porte ET dont on relie la sortie sur la grille de notre transistor charg de relier notre
case mmoire au bus.
Sur ce schma, les carrs noirs sont les portes ET dont je parle au-dessus. Faites attention : les Row Line et les Column Line
ne se touchent pas et ne sont pas connectes entre elles : il n'y a pas d'intersection, un des fils passant en-dessous de l'autre.
www.openclassrooms.com
Partie 4 : Mmoires
230/467
On utilise donc deux dcodeurs : un pour slectionner la Row Line relie la ligne contenant la case mmoire lire ou crire ; et
un autre pour slectionner la colonne.
Partie 4 : Mmoires
231/467
Cela permet de dcouper notre adresse mmoire en deux morceaux : une adresse haute qui va slectionner la ligne et une adresse
basse qui va slectionner la colonne.
Double envoi
Cela peut permettre d'envoyer nos adresses en deux fois au lieu d'une : on envoie d'abord l'adresse de ligne, puis l'adresse de
colonne. Ainsi, on peut conomiser des broches et diminuer le nombre de fils pour le bus d'adresse. Vu que ces broches ont un
cout assez important, c'est un bnfice pas ngligeable. Mais cela ncessite de modifier l'intrieur de notre mmoire.
Si notre adresse est envoye en deux fois, notre mmoire doit mmoriser les deux morceaux de l'adresse. Si notre mmoire ne se
souvient pas de l'adresse de la ligne, envoye en premier, elle ne pourra pas slectionner le byte voulu. On doit donc rajouter de
quoi mmoriser l'adresse de la ligne, et l'adresse de la colonne. Pour cela, on place deux mmoires tampons, deux registres, entre
les dcodeurs et le bus d'adresse.
Ceci dit, ajouter ces mmoires tampons ne suffit pas. Si on envoie l'adresse d'une ligne sur le bus d'adresse, celle-ci doit tre
www.openclassrooms.com
Partie 4 : Mmoires
232/467
recopie dans la mmoire tampon situe avant le dcodeur d'adresse. Et rciproquement avec les colonnes. Il faut donc ajouter
de quoi aiguiller le contenu du bus d'adresse vers le bon registre, la bonne mmoire tampon. Cela se fait en utilisant un
composant lctronique nomm un dmultiplexeur.
Principe
Ces mmoires ont toujours pour but de diminuer le nombre de lignes prsentes dans la mmoire. Et les raisons sont les mmes :
viter de se retrouver avec un dcodeur norme et lent, diminuer la longueur des Bit Lines, simplifier la conception de la puce,
etc. Pour diminuer ce nombre de lignes, les mmoires Row Buffer vont regrouper plusieurs Bytes sur une mme ligne, et
slectionner le bon Byte suivant les besoins. C'est le mme principe que pour les mmoires adressage par concidence, du
moins premire vue.
Une mmoire Row Buffer va muler une mmoire de N Bytes partir d'une mmoire contenant moins de Bytes. Seule diffrence,
ces Bytes internes la mmoire seront plus gros, et rassembleront plusieurs Bytes externes. Ainsi, ma mmoire Row Buffer sera
constitue d'une mmoire interne, contenant B fois moins de Bytes, mais dont chacun des Bytes seront B fois plus gros.
Lorsqu'on veut lire ou crire dans une mmoire Row Buffer, on va lire un " Super-Byte " de la mmoire interne, et on va
slectionner le bon Byte dans celui-ci.
www.openclassrooms.com
Partie 4 : Mmoires
233/467
Plan mmoire
Sur le schma du dessus, on voit bien que notre mmoire est compose de deux grands morceaux : une mmoire interne, et un
circuit de slection d'un Byte parmi B. La mmoire interne n'a rien de spcial : il s'agit d'une mmoire adressage linaire tout ce
qu'il y a de plus classique. Elles n'utilisent qu'un seul dcodeur, qui ne sert qu' slectionner la ligne.
www.openclassrooms.com
Partie 4 : Mmoires
234/467
Par contre, le circuit de slection est un nouveau venu, tout comme l'interface entre la mmoire interne et ce circuit.
Row Buffer
Je me permets de signaler que sur la grosse majorit de ces mmoires, la mmoire interne n'est pas relie directement sur ce circuit
de slection des colonnes. Chaque ligne slectionne dans notre mmoire interne est recopie intgralement dans une sorte de
gros registre temporaire, dans lequel on viendra slectionner la case mmoire correspondant notre colonne. Ce gros registre
temporaire s'appelle le Row Buffer.
www.openclassrooms.com
Partie 4 : Mmoires
235/467
Slection de colonnes
Dans sa version la plus simple, le circuit de slection de colonnes est implment avec un dcodeur. Il est donc compos d'un
dcodeur, et de sries de transistors, qui vont (ou non) relier un Byte au bus.
Il y a d'autres faons dimplmenter ce circuit de slection de colonnes, mais on n'en parlera pas ici. Il faut dire que ces autres
mthodes sont plus lentes : pour une fois, la mthode simple est la plus efficace.
www.openclassrooms.com
Partie 4 : Mmoires
236/467
Avantages et inconvnients
Les plans mmoire Row Buffer rcuprent les avantages des plans mmoires par concidence : possibilit de dcoder une ligne
en mme temps qu'une colonne, possibilit d'envoyer l'adresse en deux fois, consommation moindre de portes logiques, etc.
Autre avantage : en concevant correctement la mmoire, il est possible d'amliorer les performances lors de l'accs des donnes
proches en mmoire : si on doit lire ou crire deux Bytes localiss dans la mme ligne de notre mmoire interne, il suffit de charger
celle-ci une fois dans le Row Buffer, et de faire deux slections de colonnes diffrentes. C'est plus rapide que de devoir faire deux
slection de lignes et deux de colonnes. On en reparlera lorsqu'on verra les mmoires SDRAM et EDO, vous verrez.
De plus, cela permet d'effectuer l'opration de rafraichissement trs simplement. Il suffit de recopier le contenu d'une ligne dans le
Row Buffer, avant de faire l'inverse en recopiant le contenu du Row Buffer dans la ligne mmoire slectionne. Il suffira
d'intercaler un circuit charg du rafraichissement quelque part dans notre contrleur mmoire pour que le tout fonctionne.
Pas contre, cette organisation a un dfaut : elle consomme beaucoup d'nergie. Il faut dire que pour chaque lecture d'un Byte
dans notre mmoire, on doit charger une ligne de la mmoire interne dans le Row Buffer, qui contient plusieurs Bytes. Et cela
pompe du courant de recopier tous ces Bytes dans le Row Buffer. Ce n'est pas le cas avec une mmoire adressage linaire ou
par concidence : on ne slectionne que le Byte que l'on veut lire ou crire.
Circuits 3-tats
Premire solution : comme chaque fois qu'on a un problme, on rajoute un circuit.
Il suffit simplement d'intercaler des
composants chargs d'imposer le sens des transferts entre le bus de donnes et les fils relis aux diffrentes cases mmoires.
Les circuits chargs d'imposer le sens des transferts de donnes sont indiqus en jaune sur le schma suivant.
www.openclassrooms.com
Partie 4 : Mmoires
237/467
Ces circuits sont ce qu'on appelle des circuits 3-tats. Rien de bien mchant, il s'agit juste de circuits lectroniques fabriqus
avec des transistors qui vont apporter une solution notre problme.
Voici quoi ressemble un circuit 3-tats :
Notre circuit 3-tats permet de prciser le sens de transfert : soit de E1 vers E2, soit l'inverse. Il peut aussi se comporter comme
un interrupteur ouvert, et ainsi dconnecter les deux fils. Le choix du mode de fonctionnement se fera par ce qu'on mettra sur son
entre de commande :
soit le circuit 3-tats agit comme un interrupteur ouvert ;
soit le circuit 3-tats recopie la tension prsente sur l'entre E1 sur lentre E2 : le bit envoy sur E1 va alors passer vers le
fil reli E2 ;
soit circuit 3-tats recopie la tension prsente sur l'entre E2 sur lentre E1 : le bit envoy sur E1 va alors passer vers le
fil reli E1.
On a besoin de prciser trois cas, donc on utilise deux entres pour cela.
www.openclassrooms.com
Partie 4 : Mmoires
238/467
On a donc rsolu notre problme : il suffit d'intercaler un circuit 3-tats entre le plan mmoire et le bus, et de commander celui-ci
correctement. C'est le contrleur mmoire qui place l'entre de commande du circuit 3-tats pour slectionner le sens de transfert
de donne suivant l'tat du bit R/W.
Petit dtail : ce circuit 3-tats ne ragit pas immdiatement un changement de son entre. En clair : il met un certain temps avant
de passer d'une lecture une criture (et vice-versa). En clair, effectuer des lectures les unes aprs les autres sera plus rapide
qu'alterner lectures et critures. Ce temps d'attente n'est pas toujours ngligeable, et il faut parfois le prendre en compte.
Souvenez-vous : on en reparlera au prochain chapitre.
Comme vous le voyez, crire une donne ne passe pas par les mmes fils que la lecture. Ainsi, la solution est vidente : il suffit
de relier tout ces fils sur le bus, et connecter les bons fils pour choisir le sens de transfert.
www.openclassrooms.com
Partie 4 : Mmoires
239/467
Comme vous le voyez sur ce schma, les fils ddis la lecture ou l'criture sont tous relis sur le bus, avec un transistor
intercal au bon endroit. Il suffit d'ouvrir ou de fermer les bons transistors pour dclencher soit une lecture (on ferme les
transistors IN) ou une criture (on ferme les transistors OUT). C'est le contrleur mmoire qui se charge de dduire les tensions
IN et OUT envoyer sur les grilles des transistors intercals entre le bus et la case mmoire.
Assemblages de mmoires
Ce qu'on a vu plus haut est l'organisation interne d'une mmoire RAM/ROM simple. Dans la ralit, il faut savoir que nos
mmoires ne sont pas faites d'un seul bloc, mais sont constitues de plusieurs mmoires plus simples rassembles dans un seul
boitier.
Si vous ne me croyez pas, prenez une barrette de mmoire RAM, et regardez de plus prt.
Vous voyez : chaque puce noire sur notre barrette de mmoire RAM est une petite mmoire elle toute seule. Sur une barrette de
mmoire RAM, on trouve pleins de petites mmoires rassembles sur un seul circuit imprim (notre barrette de mmoire) et
organises d'une certaine faon. Mais avant de passer la pratique, une petite prcision s'impose : rassembler plusieurs
mmoires dans un seul boitier peut tre fait de diverses faons diffrentes : on peut dcider de doubler le nombre d'adresses,
doubler la taille d'un byte, ou faire les deux. Suivant ce que l'on veut faire, l'organisation de nos sous-mmoires ne sera pas la
mme.
www.openclassrooms.com
Partie 4 : Mmoires
240/467
Arrangement horizontal
Commenons par notre premier cas : on va utiliser plusieurs boitiers pour doubler la taille d'un byte sans changer le nombre de
cases mmoires adressables. C'est ce qu'on appelle l'arrangement horizontal. Prenons un exemple : on va cherche obtenir une
mmoire ayant un byte de 16 bits en partant de deux mmoires ayant un byte de 8 bits. Pour cela, il suffit de relier nos mmoires
de faon ce que la premire contienne les bits de poids fort du byte de 16 bits, et que l'autre contienne les bits de poids faible.
On voit que l'on adresse plusieurs mmoires en mme temps : chaque mmoire contient un morceau de la donne qu'on souhaite
lire ou crire. Il suffit de les relier sur le bus correctement, de faon ce que chaque morceau de la donne aille au bon endroit.
videmment, chaque morceau de donne possde la mme adresse que les autres morceaux : l'adresse (et les entres de
commande : difficile de lire un morceau de case mmoire perdant qu'on en crit un autre) est envoye sur toutes les sousmmoires.
www.openclassrooms.com
Partie 4 : Mmoires
241/467
Lintrt de faire comme ceci ? Maitriser la rpartition de chaleur l'intrieur de notre mmoire. Accder une cellule mmoire, a
chauffe ! Si on utilisait une seule puce mmoire ayant un byte de 8 bits, les 8 bits auxquels on accderait seraient placs les uns
cot des autres et chaufferaient tous au mme endroit. A la place, les fabricants de mmoire RAM prfrent disperser les bits
d'un mme octet dans des puces diffrentes pour rpartir la chaleur sur une plus grande surface et la disperser plus facilement.
Sans cela, nos mmoires ne fonctionneraient tout simplement pas sans systmes de refroidissements adapts.
Dual channel
Vous avez surement dj entendu parler de dual-channel. Et bien sachez que cette technologie est base sur le mme principe.
Sauf qu'au lieu de rassembler plusieurs puces mmoires (les trucs noirs sur nos barrettes) sur une mme barrette, on fait la mme
chose avec plusieurs barrettes de mmoires. Ainsi, on peut mettre deux barrettes ayant un bus de donne capable de contenir 64
bits et on les relie un bus de 128 bits. C'est ce qu'on appelle le dual-channel.
Arrangement vertical
Une autre possibilit consiste rassembler plusieurs boitiers de mmoires pour augmenter la capacit totale. On utilisera un
boitier pour une partie de la mmoire, un autre boitier pour une autre, et ainsi de suite. Par exemple, on peut dcider d'utiliser deux
sous-mmoires : chacune de ces sous-mmoire contenant la moiti de la mmoire totale. C'est ce qu'on appelle l'arrangement
vertical.
a peut vous paraitre bizarre, mais rflchissez un petit peu, vous pouvez trouver un exemple parfait d'arrangement vertical dans
votre PC : vous pouvez parfaitement placer plusieurs barrettes de mmoires sur votre carte mre pour doubler la capacit. Si vus
n'utilisez pas de dual-channel, vous aurez un arrangement vertical.
Entre de slection
Avec cette solution, quand on accde une case mmoire de notre grosse mmoire rassemblant tous les boitiers, on accde un
boitier parmi tout les autres. Il nous faudra slectionner le bon boitier, celui qui contient notre case mmoire. Pour cela, il va falloir
que je vous dise quelque chose. Vous vous souvenez que dans le chapitre prcdent, j'ai dit qu'une mmoire ressemblait a :
www.openclassrooms.com
Partie 4 : Mmoires
242/467
Mais j'ai volontairement pass un dtail sous silence : nos mmoires possdent une broche supplmentaire nomme CS, qui sert
activer ou dsactiver la mmoire. Suivant la valeur de ce bit, notre mmoire sera soit place en veille sans possibilit de ragir
aux vnements extrieurs (elle conservera toutefois son contenu), soit fonctionnera normalement. Et c'est grce cette broche
qu'on va pouvoir rassembler plusieurs boitiers dans notre mmoire.
l'ide est simple : pour accder une case mmoire, on envoie le morceau de l'adresse slectionnant la case mmoire dans le
boitier et le bit R/W toutes les mmoires, et on teint les mmoires qui ne stockent pas la case mmoire voulue. Seul le boitier
contenant la donne restera allume et pourra rpondre la commande (adresse + ordre de lecture/criture) envoy par le
contrleur mmoire.
Il suffira donc de positionner les bits CS de chaque mmoire la bonne valeur. Un seul boitier sera allum et aura donc son bit CS
1, tandis que tous les autres seront teints et verront leur bit CS passer 0. Le fait que seul un boitier parmi tous les autres soit
activ devrait vous rappeler quelque chose : oui, on utilise bien un dcodeur pour slectionner le boitier.
Mmoires interleaved
Mais certaines mmoires, on utilise les bits de poids faible pour slectionner le bon boitier : ce sont ce qu'on appelle des
mmoires interleaved.
www.openclassrooms.com
Partie 4 : Mmoires
243/467
En faisant ainsi, on peut mettre des bytes conscutifs dans des mmoires diffrentes. Cela permet, en adaptant le contrleur
mmoire, d'obtenir des opportunits doptimisation assez impressionnantes. Et l, je suis sr que vous ne voyez pas vraiment
pourquoi. Aussi, une explication s'impose. Il faut savoir dans la grosse majorit des cas, les accs mmoires se font sur des bytes
conscutifs : les lectures ou critures dans la mmoire se font souvent par gros blocs de plusieurs bytes. Il y a diverses raisons
cela : lutilisation de tableaux par les programmeurs, le fait que nos instructions soient places les unes la suite des autres dans
la mmoire, etc. Quoiqu'il en soit, l'accs des zones de mmoire conscutives est quelque cchose que l'on doit optimiser le plus
possible.
Mais l''accs un boitier prend toujours un peu de temps : c'est le fameux temps d'accs dont on a parl il y a quelques chapitres.
Si on place deux bytes ayant des adresses conscutives dans le mme boitier, et qu'on souhaite lire/crire ces deux bytes, on
devra attendre que l'accs au premier byte soit fini avant de pouvoir accder au suivant (sauf si la mmoire est multiports, mais
bref). En clair : on ne peut effectuer qu'un seul accs la fois sur des bytes conscutifs.
Mais ce n'est valable qu'avec les mmoires qui ne sont pas des mmoires interleaved ! Avec les mmoires interleaved , la donne
est diffrentes : des bytes conscutifs sont localiss dans des boitiers diffrentes qui peuvent tre accds en parallle. On peut
ainsi accder des bits conscutifs bien plus rapidement qu'avec des mmoires "normales".
Et voil, maintenant que vous avez lu ce chapitre, vous tes capables de crer une petite mmoire RAM assez simples. a vous
plait ?
www.openclassrooms.com
Partie 4 : Mmoires
244/467
Utilit
Tension d'alimentation
10
11
12
www.openclassrooms.com
Partie 4 : Mmoires
245/467
13
14
15
16
17
18
19
20
21
Bit R/W
22
23
24
25
26
27
28
Signal CASP
29
30
Si vous vous amusez compter les nombre de bits pour le bus de donne et pour le bus d'adresse, vous remarquerez que le bus
d'adresse contient 12 bits et que le bus de donnes en fait 8. Les mmoires 72 broches contiennent plus de bits pour le bus de
donnes : 32 pour tre prcis. Par contre le bus d'adresse ne change pas : il reste de 12 bits. D'autres bits pour ou moins
importants ont ts rajouts : les bits RAS et CAS sont en plusieurs exemplaires et on trouve 4 fois plus de bits de parit (un par
octet transfrable sur le bus de donnes).
Et voil ce que donnait la version 72 broches.
Pour information, la tension d'alimentation des mmoires FPM tait de 5 volts. Pour les mmoires EDO, cela variait entre 5 et 3.3
volts.
RAS et CAS
Je ne sais pas si vous avez remarqus, mais le bus d'adresse de 12 bits de ces mmoires ne permettait d'adresser que 4 kibioctets
de mmoires, ce qui est trs peu compar la taille totale des mmoires FPM (qui faisaient plusieurs mbioctets). En fait, il y a
une grosse astuce derrire tout a : l'adresse tait envoye en deux fois. Cette adresse tait alors dcoupe en deux parties : une
adresse haute, et une adresse basse. Ces mmoires asynchrones taient toutes sont des mmoires adressage par concidence
ou Row Buffer. Elles taient donc organises en lignes et en colonnes. L'adresse haute permettait de slectionner la ligne du
www.openclassrooms.com
Partie 4 : Mmoires
246/467
Petite prcision : les signaux RAS et CAS font quelque chose quand on les met zro et non 1. Le mmoire va les prendre en
compte quand on les fait passer de 1 zro : c'est ce moment l que la ligne ou colonne dont l'adresse est sur le bus sera
slectionne. Tant que des signaux sont zro, la ligne ou colonne reste slectionne : on peut changer l'adresse sur le bus, cela
ne dslectionnera pas la ligne ou la colonne et la valeur prsente lors du front descendant est conserve.
Dans la mmoire
Pour implmenter cette technique, nos mmoires FPM incorporaient deux mmoires tampons, deux registres, qui taient chargs
de stocker les numros de colonnes et de ligne. Ceux-ci avaient leur sortie directement relie aux dcodeurs. A chaque signal
RAS, le registre correspondant une ligne tait mis jour avec le contenu du bus d'adresse. Idem pour le registre de colonne
avec le CAS. On pouvait alors envoyer notre adresse en deux fois sans trop de dommages.
www.openclassrooms.com
Partie 4 : Mmoires
247/467
www.openclassrooms.com
Partie 4 : Mmoires
248/467
Bien sr, ce contrleur mmoire l n'a rien voir avec le contrleur mmoire charg de dcoder les adresses vu dans les chapitre
prcdent qui est intgr dans la barrette de mmoire. C'est ainsi, on a deux contrleurs mmoires : un plac sur la carte mre qui
dduit quoi envoyer sur les bus en fonction de ce que demande le processeur, et un contrleur intgr nos barrette de mmoire
qui dcode les adresses et gre le sens de transfert.
Rafraichissement mmoire
Ce contrleur mmoire ne se charge pas que de la gestion des signaux CAS et RAS, ou du dcoupage des adresses. Il prend en
charge pas mal d'autres fonctionnalits, et sert beaucoup de choses. Autrefois, il s'occupait notamment du rafraichissement
mmoire.
Il ne faut pas oublier quelque chose : ces mmoires FPM et EDO sont avant tout des mmoires DRAM, et doivent donc tre
rafraichies suffisamment souvent. Sur ces mmoires FPM et EDO, le rafraichissement se faisait ligne par ligne : on rcrivait
chaque ligne une par une, intervalle rguliers.
Pour donner l'ordre la mmoire de rafraichir une ligne, il suffit de :
placer l'adresse haute permettant de slectionner la ligne rafraichir sur le bus d'adresse ;
positionner le signal RAS 0 ;
et laisser CAS 1.
Rapidement, les constructeurs de mmoire se sont dit qu'il valait mieux grer ce rafraichissement de faon automatique, sans faire
intervenir le contrleur mmoire intgr la carte mre. Ce rafraichissement a alors t dlgu au contrleur mmoire intgre
la barrette de mmoire, et est maintenant gr par des circuits spcialiss. Ce circuit de rafraichissement automatique n'est rien
d'autre qu'un compteur, qui contient un numro de ligne (celle rafraichir).
www.openclassrooms.com
Partie 4 : Mmoires
249/467
www.openclassrooms.com
Partie 4 : Mmoires
250/467
Avec la FPM ou l'EDO, on n'avait plus besoin de prciser deux fois la ligne si celle-ci ne changeait pas : on pouvait garder la
ligne slectionne durant plusieurs accs.
EDO-RAM
L'EDO-RAM a t invente quelques annes aprs la mmoire FPM. Il n'y a pas de grandes diffrences entre les mmoires EDORAM et les mmoires FPM. Cette mmoire EDO a t dcline en deux versions : la EDO simple, et la Burst EDO. L'EDO simple
n'apportait que de faibles amliorations vraiment mineures, aussi je me permet de la passer sous silence. Mais pour la Burst EDO,
c'est autre chose. Celle-ci permettait daccder quatre octets conscutifs placs sur la mme ligne bien plus rapidement que ses
www.openclassrooms.com
Partie 4 : Mmoires
251/467
prdcesseurs. En effet, sur les mmoires EDO et FPM, on devait lire ces 4 octets conscutifs colonnes par colonnes. Il fallait
envoyer les adresses basses unes par unes (en rglant CAS comme il faut). Notre processeur devait donc envoyer l'adresse du
premier octet, attendre que ligne et colonnes soient slectionner, lire le premier octet, passer la colonne suivante, lire le second
octet, rechanger la colonne, etc. Chacune de ces tapes prenait un cycle d'horloge (on parle de l'horloge du processeur).
Avec les Burst EDO-RAM, on pouvait faire cela bien plus rapidement : pas besoin d'envoyer les adresses basses de chaque
colonne unes par unes. On pouvait programmer notre mmoire pour que celle-ci effectue les 4 accs ces 4 octets conscutifs
toute seule, sans qu'on aie besoin de placer les adresses basses de chaque colonnes sur le bus et positionner le signal CAS :
cela fait pas mal de temps de gagn.
Pour cela, il suffit de configurer le contrleur mmoire pour lui ordonner d'effectuer un tel accs, et adresser le premier octet de la
suite d'octets qu'on souhaite lire. Les 4 octets voulus taient alors disponibles les uns aprs les autres : il suffisait d'attendre un
cycle d'horloge par octet. Les cycles d'horloges ncessaires pour changer de colonne, ncessaires sur les mmoires FPM, taient
inutiles lorsqu'on accdait des donnes successives. Ce genre d'accs mmoire s'appelle un accs en Burst ou en rafale.
Implmenter cette technique ncessite d'ajouter des circuits dans notre mmoire. Il faut notamment rajouter un compteur, capable
de faire passer d'une colonne une autre quand on lui demande. Le tout tat accompagn de quelques circuits pour grer le tout.
www.openclassrooms.com
Partie 4 : Mmoires
252/467
www.openclassrooms.com
Partie 4 : Mmoires
253/467
Avec les SDRAM, la situation est diffrente. Avec l'utilisation d'une horloge, ce n'est plus vraiment le cas : vu que la slection
d'une ligne ou d'une colonne peut prendre plusieurs cycles d'horloge, on peut envoyer une adresse complte avant mme que la
lign ou la colonne soit slectionne. Cela permet d'envoyer notre mmoire une demande de lecture ou d'criture (en envoyant
une adresse complte et autres bits de commande) sans attendre que les prcdentes soient finies.
Pour faire simple, cela signifie qu'on est pas oblig de laisser les signaux RAS et CAS zro pendant qu'on slectionne une ligne
ou une colonne : il suffit de placer ceux-ci zro durant un cycle d'horloge pour la mmoire comprenne ce qu'on lui demande et
laisse la place une autre demande. Cela s'appelle faire du pipelining.
Comme vous le voyez sur le schma du dessus, une lecture/criture, une slection d'une colonne, ainsi qu'une slection de ligne
se font en mme temps, mais dans des circuits diffrents. Cela est rendu possible en utilisant notre Row Buffer et en ajoutant
quelques petits registres au bon endroit.
Nanmoins, il y a parfois des situations assez particulires pour lesquelles il n'est pas forcment possible d'effectuer des accs
en mmoire ainsi. Pour tre plus prcis, sachez que la slection d'une colonne ou d'une ligne peuvent prendre plusieurs cycles
d'horloge et ne durent pas le mme temps, ce qui complexifie la chose, sans compter qu'on peut parfois se retrouver avec des
tapes supplmentaires.
Timings mmoires
Comme je l'ai brivement mentionn plus haut, il faut un certain temps pour slectionner une ligne ou une colonne. Mais dans
notre mmoire, il existe d'autres temps de d'attente plus ou moins bien connus, qu'il est parfois important de connaitre. Dans
cette partie, je vais vous lister quels sont ces temps de latence. Certains d'entre vous qui sont familiers avec l'overcloking
connaissent ces temps d'attente sans le savoir : ces fameux temps d'attente, ou timings mmoires sont en effet trs important
pour eux. Aussi nous allons les voir en dtail.
La faon de mesurer ces timings varie : sur les mmoires FPM et EDO, on les mesure en units de temps (secondes,
millisecondes, micro-secondes, etc), tandis qu'on les mesure en cycles d'horloge sur les mmoires SDRAM. Ainsi, si je vous dit
qu'une mmoire DDR de marque xxxx et de numro de srie a un tRAS de 5, cela signifie qu'il faut attendre 5 cycles d'horloge
avant que la ligne soit slectionne.
Timing
tRAS
tCAS
Description
Le premier de ces timings s'appelle le tRAS : c'est le temps mit pour slectionner une ligne.
Le second timing s'appelle le tCAS et correspond au temps mit pour slectionner une colonne. Comme le tRAS (et
comme tous les autres timings), on le mesure en cycles d'horloge sur les SDRAM et les DDR. Il faut prciser une
www.openclassrooms.com
Partie 4 : Mmoires
tCAS
254/467
petite chose assez amusante : le CAS est un timings qui est programmable sur les toutes les mmoires SDRAM et
DDR.
tRP
Nos mmoires RAM sont des mmoires Row Buffer. Pour rappel, cela signifie que pour slectionner une case
mmoire lire ou crire, il faut slectionner la ligne lire et la recopier dans une mmoire tampon nomme le Row
Buffer, et slectionner la colonne. En fait, j'ai pass un dtail sous silence : dans certains cas, il faut aussi penser
vider le Row Buffer. Lorsque l'on souhaite accder deux cases mmoires qui ne sont pas sur la mme ligne, on doit
vider le Row Buffer, qui contient encore la ligne prcdente, avant de pouvoir slectionner la ligne et la colonne. Le
temps mit pour vider la ligne et la faire revenir son tat initial est appel le tRP.
tRCD
Vient ensuite le temps mit entre la fin de la slection d'une ligne, et le moment o l'on peut commencer
slectionner la colonne, qu'on appelle le tRCD.
tWTR
Une fois qu'on a crit une donne en mmoire, il faut un certain temps avant de pouvoir lancer une lecture qu'on
appelle le tWTR.
tCAStoCAS
Rapidit
Ces timings influencent grandement la vitesse laquelle on accde une donne dans la mmoire. Et oui, car suivant la
disposition des donnes dans la mmoire, l'accs peut tre plus ou moins rapide. Il existe ainsi quelques possibilits plus ou
moins diffrentes, qu'on va vous citer.
Premier cas : la donne que l'on cherche lire est prsente sur la mme ligne que la donne qui a t accde avant elle. Cela se
produit souvent lorsque l'on doit accder des donnes proches les unes des autres en mmoire. Dans ce cas, la ligne entire a
t recopie dans le Row Buffer et on n'a pas la slectionner : on doit juste changer de colonne. Ce genre de situation s'appelle
un Row Buffer Hit . Le temps ncessaire pour accder notre donne est donc gal au temps ncessaire pour slectionner une
colonne (le tCAS auquel il faut ajouter le temps ncessaire entre deux slections de deux colonnes diffrentes (le t-CAS-ToCAS).
Second cas : on accde une donne situe dans une ligne diffrente : c'est un Row Buffer Miss. Et l, c'est une catastrophe !
Dans ce genre de cas, il faut en effet vider le Row Buffer, qui contient la ligne prcdente, en plus de slectionner la ligne et la
colonne. On doit donc ajouter le tRP au tRAS et au tCAS pour avoir le temps d'accs total notre donne.
Le SPD
videmment, ces timings ne sont pas les mmes suivant la barrette de mmoire que vous achetez. Certaines mmoires sont ainsi
conues pour avoir des timings assez bas et sont donc plus rapides, et surtout : beaucoup plus chres que les autres. Le gain en
performances dpend beaucoup du processeur utilis et est assez minime compar au prix de ces barrettes. Les circuits de notre
ordinateur chargs de communiquer avec la mmoire (ceux placs soit sur la carte mre, soit dans le processeur), doivent
connaitre ces timings et ne pas se tromper : sans a, lordinateur ne fonctionne pas.
Pour cela, notre barrette de mmoire contient une petite mmoire ROM qui stocke les diffrents timings d'une faon bien
dtermine : cette mmoire s'appelle le Serial Presence Detect , aussi communment appel le SPD. Ce SPD contient non
seulement les timings de la mmoire RAM, mais aussi diverses informations, comme le numro de srie de la barrette, sa marque,
et diverses informations.
Le contenu de ce fameux SPD est standardis par un organisme nomm le JEDEC, qui s'est charg de standardiser le contenu de
cette mmoire, ainsi que les frquences, timings, tensions et autres paramtres des mmoires SDRAM et DDR. Cette mmoire
ROM est lue au dmarrage de l'ordinateur par certains circuits de notre ordinateur (le fameux BIOS, allez voir ici, pour les curieux :
le BIOS, qu'est-ce que c'est ?), afin de pourvoir configurer ce qu'il faut.
Mode Burst
Les mmoires SDRAM possdent aussi un mode Burst, qui a toutefois t amlior compar au Burst des mmoires EDO : il est
devenu programmable ! Pour cela, notre mmoire RAM contient un petit registre, le register mode, qui permet de configurer
notre mmoire RAM et plus prcisment le fonctionnement de son mode Burst. Il existe ainsi un bit qui permettra de prciser si
on veut effectuer des accs normaux (le bit est alors mit 1), ou des accs en Burst (le bit est mit zro).
Avec les SDRAM, on peut spcifier le nombre d'octets conscutifs auxquels on veut accder. Sur les mmoires EDO, on devait
www.openclassrooms.com
Partie 4 : Mmoires
255/467
absolument lire 4 octets uns par uns, sans pouvoir faire plus ou moins, mais les mmoires SDRAM corrigent ce problme.
D'autres bits vont ainsi permettre de configurer le nombre de cases mmoires conscutives auquel on doit accder lors d'un
accs en Burst. On peut ainsi accder 1, 2, 4, ou 8 octets en une seule fois.
Qui plus est, il existe deux types d'accs en Burst sur les SDRAM : l'accs interleaved , let l'accs squentiel. le mode squentiel
est le mode Burst normal : on accde des octets conscutifs les uns aprs les autres. Un bit du register mode permet de
slectionner le type de burst voulu. Le mode interleaved le fait dans un ordre lgrement diffrent qu'on ne va pas voir ici (celuici n'apporte rien de vraiment utile).
Burst ordering
Il faut noter que ces accs en Burst doivent rpondre certaines contraintes : cela ne marche correctement que dans des blocs
dont la taille est celle du bus de donne et qui sont placs des adresses bien prcises.
Dans le cas contraire, il y a quelques petites subtilits qui font leur apparition. En fait, tout se passe comme si notre ligne tait
dcoupe en blocs ayant la mme taille que le bus de donnes, ce qui donne des blocs de 8 cases mmoires. Dans ce qui va
suivre, on va noter les cases mmoires appartenant un de ces blocs 1, 2, 3, 4, 5, 6, 7, 8 et 9. Un accs en mode Burst n'est pas
oblig de commencer par lire ou crire le bloc 1 : on peut trs bien commencer par lire ou crire au bloc 3, par exemple.
Mais que ce passe-il lorsque l'on veut effectuer un accs en Burst sur 8 cases mmoires ?
Et bien regardons ce qui se passe. On commence par accder la case mmoire numrote 3, puis la 4, la 5 , la 6 et la 7. Il reste
encore 3 cases mmoires lire, mais on arrive au bout de notre bloc de 8 cases mmoires. On pourrait imaginer divers scnarios :
passer au bloc suivant semble tre le plus logique. Mais ce n'est pas ce qui se passe : l'accs reprend au bloc 1, et on accde aux
blocs 1, 2 et 3. En clair : une fois arriv au bout de notre bloc de 8 cases mmoires, on reprend au dbut. Avouez que vous tes
surpris.
Principe
Dans nos mmoires SDRAM, les oprations internes la mmoire sont synchronises entre elles par une horloge. Sur les
mmoires SDRAM simples, cette horloge est la mme que celle du bus mmoire : mmoire et bus sont synchronises de faon
identique. A chaque cycle d'horloge, une SDRAM peut envoyer une seule donne sur le bus. De plus, la taille du bus mmoire
est identique au nombre de donne pouvant tre lues ou crites dans la mmoire. En clair : le bus mmoire fait 64 bits, et la
mmoire est capable de lire ou d'crire dans 64 bits d'un coup. On dit merci au mode Burst.
www.openclassrooms.com
Partie 4 : Mmoires
256/467
Mais avec les mmoires DDR, tout change. Comme je l'ai dit, il s'agit d'une solution hybride. Le plan mmoire fonctionne toujours
la mme frquence : vu qu'on ne peut pas le rendre plus rapide, il fonctionne toujours la mme vitesse. Par contre, ce plan
mmoire est modifi de faon tre plus large : on peut y lire ou y crire 2, 4, 8 fois plus de donnes d'un seul coup. Par contre, le
bus ne change pas ! Comme je l'ai dit, rajouter des fils et des broches n'est pas gratuit et pose beaucoup de problmes. Donc, le
bus transfre toujours autant de donnes en une seule fois.
Logiquement, vous devriez tre tonnes : on charge plus de donnes depuis la mmoire que le bus ne semble supporter. Mais il
y a un truc : la frquence du bus est double. En gros, notre mmoire va lire 128 bits de donnes depuis le plan mmoire, et va les
envoyer sur le bus par blocs de 64 bits.
www.openclassrooms.com
Partie 4 : Mmoires
257/467
C'est ce qui diffrencie les SDRAM des mmoires DDR : leur contrleur mmoire et le bus mmoire fonctionne une frquence
qui est un multiple du plan mmoire. En contrepartie, le dbit du plan mmoire est plus grand pour compenser. Ceci dit, cette
organisation ne se fait pas sans modifications : dans l'exemple au dessus, il faut bien trouver un moyen pour dcouper notre bloc
de 128 bits en deux blocs de 64, envoyer sur le bus dans le bon ordre. Cela se fait dans l'interface avec le bus, grce une sorte
de mmoire tampon un peu spciale, dans laquelle on accumule les 128 bits lus ou crire.
D'autres diffrences mineures existent entre les SDRAM et les mmoires DDR. Par exemple, la tension d'alimentation des
mmoires DDR est plus faible que pour les SDRAM. Ces mmoires DDR ont ts dclines en plusieurs versions : DDR1, DDR2,
DDR3, etc. Les diffrences tiennent dans la tension d'alimentation, leur frquence, etc. Ces mmoires sont standardises, et seuls
certaines frquences sont autorises et agres. L'organisme charg de spcifier et de standardiser les mmoires s'appelle le
JEDEC : c'est un consortium dont le rle est des standardiser certains composants lectroniques mis sur le march.
DDR1
Dans le principe, les mmoires DDR1 transfrent des donnes sur le bus une frquence deux fois suprieure la frquence du
plan mmoire. En consquence, leur dbit parait doubl compar une mmoire SDRAM de mme frquence : elles peuvent
transmettre deux fois plus de donnes dans des conditions favorables.
Mais dans les faits, seul un signal d'horloge est utilis, que ce soit pour le bus, le plan mmoire, ou le contrleur. Seulement, le
bus et les contrleur mmoire ragissent la fois sur les fronts montants et sur les fronts descendants de l'horloge. Le plan
mmoire, lui, ne ragit qu'aux fronts montants.
La quantit maximale de donne qui peut tre transmise par seconde par notre mmoire s'appelle son dbit thorique maximal.
Sur les mmoires SDRAM, ce dbit thorique maximal se calculait en multipliant la largeur du bus de donnes (le nombre de bits
qu'il peut transmettre en une fois) par sa frquence. Par exemple, une mmoire SDRAM fonctionnant 133 Mhz, et utilise en
simple channel utilisera un bus de 8 octets, ce qui fera un dbit de
octets par seconde, ce qui fait
environ du 1 giga-octets par secondes.
Pour les mmoires DDR1, il faut multiplier la largeur du bus mmoire par la frquence, et multiplier le tout par deux pour obtenir le
dbit maximal thorique. En reprenant notre exemple d'une mmoire DDR fonctionnant 200 Mhz, et utilise en simple channel
utilisera un bus de 8 octets, ce qui donnera un dbit de
octets par seconde, ce qui fait environ du
2.1 giga-octets par secondes.
a peut sembler beaucoup, et c'est normal : c'est beaucoup ! Mais ce qui compte dans les performances d'un ordinateur, c'est
surtout le temps d'accs. Certains programmes sont en effet trs sensibles au temps mit pour accder notre mmoire : les jeux
vidos, par exemple, on besoin daccder rapidement la mmoire. Une mmoire ayant un temps d'accs faible permettra d'viter
au processeur d'attendre les donnes qu'il doit manipuler. Il existe bien certains programmes qui ont besoin daccder de
grosses donnes, et pour lesquels avoir un dbit lev est important, mais ceux-ci ne sont pas vraiment une majorit.
Il existe quatre types de mmoires DDR officialiss par le JEDEC.
Dbit
www.openclassrooms.com
Tension d'alimentation
Partie 4 : Mmoires
258/467
DDR 200
PC-1600
100 Mhz
2,5 Volts
DDR 266
PC-2100
133 Mhz
2,5 Volts
DDR 333
PC-2700
166 Mhz
2,5 Volts
DDR 400
PC-3200
200 Mhz
2,6 Volts
DDR2
Dans le principe, es mmoires DDR2 transfrent des donnes sur le bus une frquence quatre fois suprieure la frquence du
plan mmoire. En consquence, leur dbit parait quadrupl compar une SDRAM de mme frquence. Pour obtenir leur dbit
thorique maximal, il faut multiplier la largeur du bus mmoire par la frquence, et multiplier le tout par quatre pour obtenir le dbit
maximal thorique.
Mais dans les faits, le bus a une frquence 2 fois suprieure la frquence de la mmoire et les transferts se font sur les fronts
montants et les fronts descendants.
Avec les mmoires DDR2, 5 types de mmoires sont officialises par le JEDEC.
Dbit
DDR2 400
PC2-3200
100 Mhz
DDR2 533
PC2-4200
133 Mhz
DDR2 667
PC2-5300
166 Mhz
DDR2 800
PC2-6400
200 Mhz
DDR2 1066
PC2-8500
266 Mhz
Diverses amliorations ont ts apportes sur les mmoires DDR2 : la tension d'alimentation est notamment passe de 2,5/2,6
Volts 1,8 Volts.
DDR3
Dans le principe, es mmoires DDR3 transfrent des donnes sur le bus une frquence huit fois suprieure la frquence du
plan mmoire. En consquence, leur dbit parait 8 fois suprieur compar une SDRAM de mme frquence. Pour obtenir leur
dbit thorique maximal, il faut multiplier la largeur du bus mmoire par la frquence, et multiplier le tout par 8 pour obtenir le
dbit maximal thorique.
www.openclassrooms.com
Partie 4 : Mmoires
259/467
Mais dans les faits, le bus a une frquence 4 fois suprieure la frquence de la mmoire et les transferts se font sur les fronts
montants et les fronts descendants.
Avec les mmoires DDR3, 6 types de mmoires sont officialises par le JEDEC.
Dbit
DDR3 800
PC2-6400
100 Mhz
DDR3 1066
PC2-8500
133 Mhz
DDR3 1333
PC2-10600
166 Mhz
DDR3 1600
PC2-12800
200 Mhz
DDR3 1866
PC2-14900
233 Mhz
DDR3 2133
PC2-17000
266 Mhz
Diverses amliorations ont ts apportes sur les mmoires DDR3 : la tension d'alimentation est notamment passe 1,5 Volts.
GDDR
Il existe enfin d'autres types de mmoires DDR : les mmoires GDDR, utilises presque exclusivement sur les cartes graphiques.
Contrairement aux autres, celles-ci ne sont pas vraiment standardises par le JEDEC. Il en existe plusieurs types pendant que
j'cris ce tutoriel : GDDR, GDDR2, GDDR3, GDDR4, et GDDR5. Mais attention : une mmoire GDDR2 n'a pas grand chose voir
avec une mmoire DDR2, par exemple. Il y a des diffrences (sauf pour la GDDR3 qui est identique de la DDR3, mais c'est une
exception) et il ne faut pas laisser piger par les noms de ces mmoires, qui ressemblent leur congnres cres sous la forme de
barrettes.
Gnralement, les mmoires GDDR ont une frquence plus leve que leur congnres utilises en tant que mmoire principale.
Par contre, certains de leurs temps d'accs sont beaucoup plus levs et peuvent aller jusqu 10 cycles d'horloge : slectionner
une ligne prend du temps. L'exception vient du temps de slection d'une colonne, qui est assez faible : 1 cycle dhorloge, gure
plus.
Cela permet ainsi nos cartes graphiques daccder rapidement des donnes conscutives en mmoire, tandis que les autres
types d'accs sont vraiment lents. Qui plus, les mmoires GDDR sont souvent des mmoires multiports, ce qui permet daccder
plusieurs cases mmoires (pas forcment conscutives) en lecture ou en criture en une seule fois.
www.openclassrooms.com
Partie 4 : Mmoires
260/467
suivant la barrette, ainsi que le nombre de broches utilises. Gnralement, les barrettes utilises sur les PC de bureau sont des
barrettes au format DIMM : les deux cots de la barrette sont utiliss pour placer les broches diffrentes, ce qui permet d'en
mettre deux fois plus.
Le nombre de broches d'une barrette au format DIMM peut varier suivant la barrette utilise, ainsi que le type de mmoire. On
peut ainsi avoir entre 168 et 244 broches sur une seule barrette. Je suppose que vous comprendrez le fait que je ne souhaite pas
vraiment en faire la liste, comme je l'ai pour les mmoires FPM 30 broches.
Mais je vais quand mme vous donner le nombre
de broches par barrette en fonction du type de mmoire.
Mmoire
Nombre de broches
SDRAM DDR1
168
184
DDR2
DDR3
Les barrettes de mmoire des ordinateurs portables utilisent souvent un autre format de barrette : le SO-DIMM, et parfois un de
ses concurrent : le Micro-DIMM.
www.openclassrooms.com
Partie 4 : Mmoires
261/467
Mmoire
Nombre de broches
200
www.openclassrooms.com
204
Partie 4 : Mmoires
262/467
Mmoires non-volatiles
Dans les chapitres prcdents, nous avons vu comment fonctionnaient les mmoires RAM et nous les avons vues en dtail.
C'est maintenant au tour des mmoires de masse et des mmoires de stockage d'avoir leur quart d'heure de gloire. Dans ce
chapitre, nous allons aborder les mmoires FLASH et le disque dur.
Le disque dur
Et maintenant, j'ai le plaisir de vous annoncer que nous allons tudier la plus clbre des mmoires de masse : j'ai nomm, le
disque dur ! Tout le monde connait cette mmoire de masse, utilises par tous comme mmoire de stockage. Non-volatile,
pouvant contenir beaucoup de donnes, cette mmoire s'est impose partout o l'on avait besoin d'elle. Ce soir, nous allons
entrer dans l'intimit de cette star, voir ce qu'il peut y avoir dedans, et on va se rendre compte qu'un disque dur, c'est quand
mme franchement plus simple qu'une mmoire RAM (du moins, en apparence).
Plateaux
Ce disque dur est compos de plusieurs plateaux, fabriqus dans un matriau magntique et sur lesquels on inscrit des donnes.
Ces plateau sont composs d'une espce de plaque, fabrique dans un matriau peu magntisable, recouvert de deux couches de
matriau magntique : une couche sur chaque face. Chacune de ces couches de matriau magntique est dcoupe en petits
blocs de donnes, chacun capable de contenir un bit. Sur les anciens disques durs, le stockage d'un bit dans une de ces cellules
est trs simple : il suffit d'aimanter la cellule dans une direction pour stocker un 1 et dans l'autre sens pour stocker un 0.
Les nouveaux disques durs fonctionnent sur un principe lgrement diffrent. Les disques durs rcents utilisent deux cellules
pour stocker un bit. Si ces deux cellules sont aimantes dans le mme sens, c'est un zro, et c'est un 1 sinon. Les disques durs
bass sur ce principe permettent de stocker plus de donnes surface gale. Cela vous paraitra surement bizarre, mais il faudra
me croire sur parole. Expliquer pourquoi serait assez compliqu, et je ne suis pas sur que parler de Giant Magneto Resistance
vous aiderais.
Quoiqu'il en soit, la faon dont on aimante ces blocs diffre suivant le disque dur. Certains aimantent ces blocs la verticale, et
d'autres l'horizontale. Pour simplifier, on va simplement dire que pour des raisons techniques, les disques durs rcents utilisent
l'aimantation verticale. Cela permet de prendre moins de place pour stocker un bit, et donc d'avoir des disques durs contenant
plus de donnes pour la mme taille.
www.openclassrooms.com
Partie 4 : Mmoires
263/467
Petite remarque pour ceux qui nauraient pas remarqus : les deux faces d'un plateau sont utilises pour stocker des donnes.
Ces plateaux entourent un axe central autour duquel les plateaux vont tourner. Plus ces plateaux tournent vite, plus le disque dur
sera rapide.
Les disquettes fonctionnent sur un principe semblable celui du disque dur, une diffrence prs : il n'y a qu'un seul plateau.
Ttes de lecture/criture
Notre disque dur contient aussi de petits dispositifs mobiles capables de lire ou crire une donne sur le disque dur : les ttes de
lecture criture.
Chacune de ces ttes de lecture-criture est un dispositif assez simple. Il s'agit d'un espce de bras mcanique dans lequel passe
un fil lectrique. Ce fil lectrique affleure lgrement au bout de ce bras en formant une espce d'hlice, formant un petit
lectroaimant qui va servir lire ou crire sur le plateau. Lorsque l'on veut crire, il suffira d'envoyer un courant lectrique dans le
fil de notre tte de lecture : cela crera un champ magntique autour de llectroaimant qui est au bout du bras, ce qui permettra
d'aimanter le plateau. Pour lire, il suffira d'approcher la tte de la cellule lire : le champ magntique de la cellule aimant va alors
crer une tension dans notre lectroaimant, qui se propagera dans le fil et qu'on pourra interprter comme un zro (tension
normale) ou un 1 (tension plus leve que prvu).
Ces ttes de lecture se dplacent au-dessus des plateaux, et sont entraines par un moteur capable de les faire tourner autour
des plateaux : cela permet de dplacer les ttes de faon les placer au dessus des donnes lire ou crire. A larrt, les ttes de
lecture sont ranges bien sagement dans un emplacement bien particulier : pas question de les arrter sur place ! Si une tte de
lecture-criture touche la couche magntique, alors l'endroit sur lequel la tte de lecture-criture a atterri est dfinitivement
endommag.
On trouve entre une et deux ttes de lecture-criture pour chaque plateau : gnralement, on trouve une tte de lecture sur
chaque face, pour pouvoir lire et crire sur les deux faces d'un plateau. Pour s'y retrouver et choisir quelle tte de lecture-criture
utiliser, celles-ci sont numrotes par un numro unique qui permet de les identifier.
lectronique de commande
Positionner nos ttes de lecture juste au-dessus de la cellule mmoire lire ou crire ne se fait pas comme par magie. Pour cela, il
faut commander les moteurs qui entrainent les plateaux et les ttes de lecture de faon ce que les ttes se positionnent
correctement. Pour cela, on trouve divers circuits lectroniques qui sont chargs de calculer quelles sont les tensions envoyer
aux moteurs de faon faire acclrer ou dclrer nos ttes correctement. Notre disque dur contient aussi des circuits chargs
de grer ou de lire la tension prsente dans le fil, pour effectuer des lectures ou des critures. Et enfin, on trouve des circuits
chargs de communiquer avec le bus ils reoivent les ordres et les donnes en provenance du bus, et peuvent envoyer une
www.openclassrooms.com
Partie 4 : Mmoires
264/467
Pistes
Ces bits sont tous regroups sur une face de notre plateau en cercles concentriques qu'on nomme des pistes.
Toutes ces pistes contiennent le mme nombre de bits ! Cela peut paraitre bizarre, mais il y a une explication cela. Au bord du
disque, la taille d'une piste est cense tre plus grande qu'au centre : on devrait pouvoir y stocker plus de bits. Sauf que notre
plateau tourne, et que la vitesse des bords est plus grande la priphrie qu'au centre. Vu que lire ou crire prend toujours le
mme temps, on est oblig de stocker nos bits sur une surface plus grande pour viter de changer de bits en plein milieu d'une
lecture/criture parce que le plateau tourne trop vite.
Ces pistes sont toutes numrots dans une face d'un plateau : chaque face contenant pistes, chaque piste aura un numro
compris entre et . Mais attention : deux pistes peuvent avoir le mme nombre si celles-ci sont sur des faces ou des plateaux
diffrents. Ces pistes ayant le mme numro seront alors la verticale les unes des autres : elles formeront ce qu'on appelle un
cylindre.
Secteurs
Ces pistes sont dcoupes en blocs de taille fixe qu'on appelle des secteurs. Quand on veut lire ou crire sur notre disque dur,
on est oblig de lire ou d'crire l'intgralit de notre secteur. Pour simplifier le travail de l'lectronique du disque dur, on prfre
utiliser des paquets ayant une taille de la forme . Sur les disques durs actuels, un secteur a une taille de 512 octets, soit 4 096
bits.
Ces secteurs contiennent des donnes, mais pas seulement. Le dbut de chaque secteur est identifi par un prambule, qui
permet de dlimiter le secteur sur une piste. Ce prambule est suivi des donnes du secteur proprement dit, puis de bits de
correction d'erreur, qui servent dtecter et corriger d'ventuelles corruptions de donnes du secteur.
Toutes les pistes contiennent le mme nombre de secteurs, et chaque secteur d'une piste est numrot : cela permet de retrouver
un secteur en particulier dans une piste. Ainsi, si une piste possde secteurs, chacun de ces secteur est numrot de .
Mais attention : deux secteurs peuvent avoir le mme numro si ceux-ci sont sur des plateaux ou sur des pistes distinctes.
www.openclassrooms.com
Partie 4 : Mmoires
265/467
Sur ce schma, le machin rouge reprsente tous les secteurs ayant le mme numro sur le mme plateau, et sur des pistes
diffrentes.
Adressage CHS
Pour localiser un secteur sur un disque dur, il suffit de prciser le plateau, la face de celui-ci, le numro de la piste (en fait, c'est le
numro du cylindre, mais passons) et le numro du secteur. Ainsi, chaque secteur possde une adresse compose des numros
de la tte de lecture (qui sert identifier la plateau et la bonne face), de piste et de secteur vus plus haut : c'est ce qu'on appelle
l'adresse CHS.
Historiquement, nos ordinateurs utilisaient 10 bits pour coder le numro de piste, 8 bits pour la tte de lecture (parfois 4) et 6 bits
pour le numro de secteur : nos adresse CHS taient limites 24 bits. Cela limitait la taille maximale possible du disque dur
environ 500 mbi-octets. Pour contrer cette limite, on a invent diverses astuces.
Une de ces astuces consiste transformer les coordonnes CHS codes sur 24 bits (10 bits pour la piste + 8 pour le plateau + 6
pour le numro de secteur) en coordonnes de 28 bits.
Adressage LBA
Avec la progression de la taille des disques durs, on a invent l'adressage LBA. Celui-ci numrote simplement chaque secteur du
disque dur par un nombre, sans se proccuper de son numro de tte, de cylindre ou de secteur. Il est donc identifi par un
simple nombre : l'adresse LBA, qui peut tre traduite en une adresse CHS code sur suffisamment de bits pour pouvoir adresser
toutes les cellules de notre disque dur.
www.openclassrooms.com
Partie 4 : Mmoires
266/467
Les disques durs S-ATA rcents dots de la bonne carte mre permettent de faire quelques optimisations sur le contenu de cette
Request Queue. Ils peuvent changer l'ordre de traitement des requtes afin de diminuer la distance que la tte de lecture doit
parcourir pour trouver la donne. Llectronique de commande peut ainsi changer l'ordre de traitement des requtes pour accder
le plus possible des donnes proches. Au lieu de faire sans cesse des aller et retours, notre disque dur peut tenter daccder de
prfrence des donnes proches dans un ordre diffrent. Cela s'appelle du Native Command And Queing.
Enfin, dernire optimisation, nos disques durs incorporent une sorte de mmoire cache qui permet de diminuer le temps d'accs
des donnes accdes rcemment. Ainsi, toute donne lue (ou crite) est place dans cette mmoire tampon. Si le disque dur
veut relire cette donne dans un avenir proche, le disque dur n'a pas aller relire cette donne sur le disque dur : pas besoin de
dplacer des tte de lecture et d'attendre qu'elles se mettent en place, la donne est immdiatement disponible dans cette
mmoire cache ultra-rapide.
Mmoires FLASH
Les mmoires FLASH sont utilises comme mmoires de masse un peu partout de nos jours : SSD, cls USB, BIOS, et dans des
tas d'autres composants dont vous ne souponnez mme pas l'existence. Ce sont des mmoires EEPROM, contrairement ce
que certains croient. En effet, pas mal de personnes croient tort que certaines mmoires FLASH sont des mmoires RAM, ou
du moins utilisent leur technologie. C'est faux, mme si certaines caractristiques de certaines de ces mmoires FLASH peuvent
faire croire le contraire.
Elles sont fabriques avec des transistors. Plus prcisment, on utilise un seul transistor pour fabriquer une cellule mmoire de
FLASH. Mais ce transistor est un peu particulier. Il ne s'agit pas d'un bon vieux transistor MOSFET comme on en a vu au
chapitre 2 : il s'agit d'un floating gate transistor qui possde deux armatures et deux couches d'isolant !
Comme vous le voyez sur ce schma, on retrouve bien deux armatures en mtal. C'est dans la seconde armature qu'on stockera
notre bit : il suffira de la remplir dlectrons pour stocker un 1, et la vider pour stocker un 0. Ce remplissage est assez compliqu
et parler d'effet tunnel ou des divers phnomnes physiques qui permettent d'crire dans ces mmoires FLASH serait surement
un peu compliqu, aussi je me permet de passer tout cela sous silence. Sachez juste que ce remplissage ou vidage se fait en
faisant passer des lectrons entre la grille et le drain, et en plaant une tension sur la grille : les lectrons passeront alors dans la
grille en passant travers l'isolant.
www.openclassrooms.com
Partie 4 : Mmoires
267/467
Dans nos mmoires FLASH SLC, c'est la mme chose, cette tension sera simplement celle mesurable sur notre seconde armature :
elle dpendra du remplissage ou de la vacuit de l'armature.
www.openclassrooms.com
Partie 4 : Mmoires
268/467
Ainsi, on peut utiliser une seule cellule mmoire MLC pour stocker plusieurs bits au lieu de plusieurs cellules mmoires SLC : a
prend beaucoup moins de place !
www.openclassrooms.com
Partie 4 : Mmoires
269/467
FLASH NOR
Ces mmoires tirent leur nom de la faon dont sont cbles leurs cellules mmoires, qui ressemble fortement au cblage d'une
porte NOR constitue de transistors CMOS. Elles sont assez rapides, mais ont une mauvaise densit : leurs cellules mmoires
prennent de la place et on ne peut pas en mettre beaucoup sur surface fixe.
Dans les mmoires FLASH de type NOR, chacun des octets prsents dans un bloc possde une adresse. La reprogrammation ou
la lecture ne posent pas vraiment de problmes : elles peuvent se faire octets par octets. Par contre, l'effacement se fait par blocs,
sans qu'on ne puisse y faire quoique ce soit.
Comme je l'ai dit, chaque bloc est adressable, ce qui fait que les FLASH NOR ressemble beaucoup aux mmoires EEPROM ou
RAM courantes.
FLASH NAND
Ces mmoires tirent leur nom de la faon dont sont cbles leurs cellules mmoires, qui ressemble fortement au cblage d'une
porte NAND constitue de transistors CMOS. Contrairement aux FLASH NOR, ces FLASH NAND peuvent avoir une grande
capacit sans problme.
Mais par contre, l'accs est plus lent et ne se fait pas octets par octets pour le lecture ou la programmation. Pour les FLASH
NAND, lecture, programmation, et effacement se font sur des morceaux de blocs ou des blocs entiers. Il faut savoir que dans ces
mmoires FLASH NAND, les blocs sont eux-mmes dcoups en pages, d'environ 4 kibioctets, qu'on peut lire ou programmer
individuellement. Mais l'effacement se fait toujours bloc par blocs.
L'accs ces pages ou blocs n'est pas direct comme pour une FLASH NOR : tout se fait par l'intermdiaire d'une mmoire RAM
interne (c'est la RAM interne vue plus haut, qui sert entre autres pour l'effacement). Toute donne lire ou crire est ainsi copie
dans cette RAM avant d'tre copie sur le bus (lecture) ou dans un bloc/page (criture).
Les SSD
Les disques durs magntiques sont encore des composants trs utiliss dans nos ordinateurs. Mais cela risque de changer
l'avenir. De nouveaux types de disques durs ont fait leur apparition il y a de cela quelques annes, et ceux-ci pourraient bien
remplacer nos bons vieux disques durs magntiques. Ces SSD ne sont pas fabriqus avec des dispositifs magntiques comme
nos bons vieux disques durs, mais sont justement cres avec de la mmoire FLASH. Ce sont les Solid State Drive, plus connus
sous le nom de SSD.
Pourquoi avoir invent ces SSD, alors que nos disques durs ne semblent pas avoir de problmes ?
En fait, ces SSD ont plusieurs avantages qui pourraient leur permettre de prendre le pas sur leurs concurrents magntiques.
Ceux-ci sont des dispositifs purement lectroniques : il n'y a pas de pice mcanique en mouvement, susceptible de se
casser en rendant notre disque dur inutilisable. Faites tomber votre disque dur par terre, et vous pouvez tre certain que
la tte de lecture-criture sera morte. Ce qui fait que ces SSD sont plus fiables que les disques durs.
Autre avantage : leur temps d'accs. Celui-ci est bien plus faible que le temps d'accs d'un disque dur. Avec un SSD, on
n'a pas besoin de dplacer des pices mcaniques, positionner la tte de lecture, etc : on accde notre donne
directement, ce qui est plus rapide.
Et enfin, dernier avantage : ils consomment beaucoup moins d'nergie.
www.openclassrooms.com
270/467
Dfinition
Sa largeur
C'est le nombre de bits qui peuvent tre transmis simultanment sur notre bus.
Son dbit
C'est le nombre de bits que notre bus peut transmettre par seconde. Plus celui-ci est lev, plus le bus est
www.openclassrooms.com
271/467
binaire
rapide.
Sa latence
C'est le temps d'attente que met une donne tre transfre sur le bus. Ce temps de latence dpend de la
frquence du bus et d'autres paramtrs. Plus il est bas, plus le bus est rapide.
Son
caractre
Half
Duplex,
Full duplex
ou Simplex
Son
caractre
synchrone
ou
asynchrone
Certains bus possdent un fil sur lequel circule un signal d'horloge permettant de synchroniser les
diffrents composants : ce sont les bus synchrones. D'autres se passent de signal d'horloge, et
synchronisent leurs composant par dautres mthodes.
Le protocole d'un bus dfinit comment celui est gr. Ce protocole dfinit quand et comment les donnes
doivent tre envoyes sur le bus.
Son
protocole
Mais a ne se limite pas a : en effet, certains bus ont besoin de mcanismes assez sophistiqus pour
fonctionner correctement. Pour donner un exemple, on peut citer le cas dans lequel plusieurs composants
lectroniques doivent transmettre leurs donnes sur un seul et unique bus. Le protocole doit alors intgrer
des mcanismes permettant aux composants de ne pas se marcher sur les pieds en monopolisant le bus ou
en crivant des donnes en mme temps.
Ceux-ci varient normment suivant le bus :
Son bus de
commande
Et encore, on vous a pargn avec cette liste assez courte ! Suivant l'utilisation d'un bus, on choisit chacune de ces
caractristiques en fonction des besoins. Par exemple, pour relier un clavier notre ordinateur, on l'utilisera pas le mme bus que
pour relier une carte graphique sur la carte mre. La carte graphique aura besoin de transfrer beaucoup de donnes par seconde
et aura besoin d'un bus rapide, contrairement au clavier qui aura d'autres besoins.
Il y a peu dire sur la frquence, le dbit binaire et la latence d'un bus, sinon que la latence doit tre la plus faible possible et la
frquence et le dbit binaire levs si on veut gagner en rapidit. Par contre, il faut prciser certaines choses importantes sur la
largueur du bus.
www.openclassrooms.com
272/467
Vu qu'ils peuvent transfrer plusieurs bits en une fois, les bus parallles sont bien plus rapides que les bus sries, non
?
a dpend de la dure durant laquelle un bus ne peut pas changer d'tat. En effet, un bus doit toujours attendre un certain
moment avant d'envoyer la donne suivante. La donne prsente sur le bus va y rester durant un moment, et sera mise jour
aprs un certain temps.
Pour un bus srie, il s'agit du temps d'envoi d'un bit, par exemple.
Pour les bus parallle, c'est le temps que la donne envoye restera sur ses fils avant d'tre mise jour par une nouvelle donne.
Pour information, si le contenu d'un bus parallle d'une largeur de bits est mis jour
fois par secondes, alors son dbit
binaire (le nombre de bits transmis par seconde) est de
.
On pourrait alors croire que les bus parallles sont plus rapides, mais ce n'est pas forcment vrai. En effet, il est difficile pour un
bus parallle de mettre jour son contenu et d'envoyer la donne suivante rapidement. Un bus srie n'a pas ce mal : la dure de
transmission d'un bit est trs faible.
Pourquoi ?
Voici l'explication : Lorsque la tension l'intrieur du fil varie (quand le fil passe de 0 1 ou inversement), le fil va mettre des
ondes lectromagntiques qui vont aller perturber la tension dans les fils d' cot. Il faut donc attendre que la perturbation
lectromagntique se soit attnue pour pouvoir lire le bit sans se tromper. Et ces temps d'attente limitent le nombre de
changement d'tat du bus effectus par seconde ! D'o un nombre de donnes envoy par seconde plus faible.
Autre problme : les fils d'un bus parallle ne sont pas tous identiques lectriquement : il n'est pas rare que la rsistance des fils
ou d'autres proprits lectriques changent trs lgrement d'un fil l'autre. Consquence : un bit va se propager d'un bout
l'autre d'un fil des vitesse qui varient suivant le fil. Et on est oblig de se caler sur la vitesse la plus basse pour viter des
problmes techniques la rception.
Un bus srie n'a pas ce genre de problmes et peut donc envoyer un grand nombre de bits trs rapidement. Cela peut compenser
le fait quun bus srie ne peut envoyer qu'un bit la fois assez facilement.
Dans nos PC
Je suis certains que vous connaissez l'USB, au moins de nom. Mais savez-vous ce que c'est ? Il s'agit d'une norme, qui dfinit un
bus, le bus USB. Ce bus est un bus srie, un peu particulier.
Notre bus USB dfinit 4 fils, nots 1, 2, 3 et 4 dans le schma suivant.
Numro du fil
Fonction
Contenu
Couleur
D+
Donne
Vert
D-
Donne
Blanc
Masse
0 volts
Noir
De ce qu'on voit de ce bus, c'est qu'il possde une masse et un fil d'alimentation, ce qui permet d'alimenter le priphrique qui est
connect sur le port USB. Ben oui, votre souris USB, elle nest pas relie au 220 volts, et doit bien tre alimente en lectricit
quelque part !
On pourrait croire qu'un bus ne pouvant transmettre qu'un seul bit la fois ne contient qu'un seul fil pour transmettre les
donne, mais ce bus en est un parfait contre-exemple : celui-ci possde 2 fils pour transmettre le bit en question.
www.openclassrooms.com
273/467
Le truc, c'est que notre donne n'est pas code en utilisant un codage NRZ. On ne va pas rentrer dans les raisons qui ont
pousses les crateurs de l'USB a faire ce choix. Tout ce qu'il faut savoir, c'est que notre bus USB transmet un 1 en mettant une
tension de -5 volts sur la broche D- (la broche D+ contient alors un joli petit zro volt), et transmet un 0 en mettant une tension
de +5 volts sur la broche D- (la broche D- contient alors un joli petit zro volt).
Autre exemple de bus srie que vous connaissez surement : le bus S-ATA. Celui-ci sert communiquer avec nos disques durs. Il
a t invent pour remplacer le bus P-ATA, un bus plus ancien, servant lui aussi communiquer avec nos disques durs, mais qui
avait un dfaut : c'tait un bus parallle.
Simplex
Sur un bus simplex, les informations ne vont que dans un sens. On a donc deux cas :
Soit les informations sont transmises d'un priphrique vers un autre composant (par exemple le processeur). L'autre sens
est interdit !
Soit les informations sont transmises d'un composant vers le priphrique. L'autre sens est interdit !
Il n'y a qu'un seul des composants qui puisse tre metteur et l'autre reste tout jamais rcepteur.
Half-duplex
Sur un bus half-duplex, Il est possible d'tre metteur ou rcepteur, suivant la situation. Par contre, impossible d'tre la fois
metteur et rcepteur.
Full-duplex
Un bus full duplex permet d'tre la fois rcepteur et metteur. L'astuce des bus full duplex est simple : il suffit de regrouper deux
bus simplex ensemble ! Il y a un bus pour l'mission et un pour la rception.
Ces bus sont donc plus rapides, vu qu'on peut mettre et recevoir des donnes en mme temps, mais ncessitent plus de fils
cbler, ce qui peut tre un dsavantage.
www.openclassrooms.com
274/467
L'avantage de ces bus est que le temps que va mettre un rcepteur ou un metteur pour faire ce qu'on lui demande est fix une
bonne fois pour toute. Par contre, ces bus posent des problmes quand on augmente la frquence ou la longueur des fils du bus
: notre signal d'horloge va mettre un certain temps pour se propager travers son fil, ce qui induit un lger dcalage entre les
composants. Si ce dcalage devient trop grand, nos composants vont rapidement se dsynchroniser : il faut que ce dcalage soit
trs petit compar la priode de l'horloge.
Plus on augmente la longueur des fils, plus l'horloge mettra de temps se propager d'un bout l'autre du fil qui lui est ddi, et
plus ces dcalages deviendront ennuyeux. Et la frquence pose un problme similaire : plus on augmente la frquence, plus cette
priode diminue compar au temps de propagation de l'horloge dans le fil, et plus ces dcalages risquent de poser problme.
Mine de rien, ce genre de phnomnes fait qu'il est trs difficile d'atteindre des frquences de plusieurs centaines gigahertz sur
les processeurs actuels : le fil d'horloge est trop long pour que ces dcalages soient ngligeables.
Bus asynchrones
Et maintenant, j'ai une rvlation vous faire : certains bus se passent compltement de signal d'horloge.
Ces bus ont un protocole conu spcialement pour faire communiquer deux priphriques/composants sans les synchroniser sur
une horloge. Pour cela, ces bus permettent deux composants de se synchroniser grce des fils spcialiss du bus de
commande, qui transmettent des bits particuliers. Gnralement, ce protocole utilise deux fils supplmentaires : REQ et ACK.
www.openclassrooms.com
275/467
Lorsqu'un composant veut envoyer une information sur le bus un autre composant, celui-ci place le fil REQ 1, afin de dire au
rcepteur : "attention, j'ai besoin que tu me fasse quelque chose". Les autres composants vont alors ragir et lire le contenu du
bus. Le composant qui la donne ou l'ordre est destin va alors ragir et va faire ce qu'on lui a demand (les autres composants
se rendorment et se dconnectent du bus). Une fois qu'il a termin, celui-ci va alors positionner le fil ACK 1 histoire de dire : j'ai
termin, je libre le bus !
Exemple avec une lecture
Ces bus sont trs adapts pour transmettre des informations sur de longues distances (plusieurs centimtres ou plus), ou pour
communiquer simplement avec des composants au besoin, sans avoir les synchroniser en permanence. Sans compter qu'ils
sont parfois plus rapides : on n'a pas attendre un dlai fix avant de recevoir le rsultat d'une lecture/criture. Ds que la
demande est effectue, on libre le bus. Sur un bus synchrone, on aurait eu besoin d'attendre la fin du dlai fix par le protocole
du bus, mme si le rcepteur/metteur a fait ce qu'il lui tait demand.
Va falloir partager !
Comme je l'ai dit plus haut, un bus est un ensemble de fils qui relie plusieurs composants. Mais le nombre de composants
connects au bus est variable suivant le bus.
Certains bus se contentent de connecter deux composants entre eux, pour leurs permettre de communiquer. Le bus n'a pas
besoin d'tre partag entre plusieurs composants, et est rserv ces deux composants. Ce sont les bus ddis.
www.openclassrooms.com
276/467
Sur d'autres bus, on peut connecter un nombre plus important de composants, qui peut tre assez lev dans certaines
situations : le bus doit donc tre partag entre ces composants. Ce sont les bus multiplexs.
Conflit d'accs
Si on cble plusieurs composants sur le mme bus, rien n'empche ces deux composants de vouloir envoyer ou recevoir une
donne sur le bus en mme temps. C'est ce qu'on appelle un conflit d'accs au bus. Cela pose problme si un composant cherche
envoyer un 1 et l'autre un 0 : quand on envoie plusieurs bits en mme temps, tout ce que lon reoit l'autre bout du fil est un
espce de mlange incohrent des deux donnes envoyes sur le bus par les deux composants. En clair, a ne ressemble plus
rien l'autre bout du fil !
Pour rsoudre ce petit problme, il faut obligatoirement rpartir l'accs au bus de faon ce qu'un seul composant utilise le bus
la fois. Ainsi, chaque composant va pouvoir envoyer des donnes sur le bus et dmarrer une communication tour de rle. Les
composants ne pourront donc pas toujours mettre quand ils le souhaitent : si un composant est dj en train d'crire sur le bus,
et qu'un autre veut l'utiliser, on devra choisir lequel des deux pourra mettre ses donnes sur le bus. Ce choix sera effectu
diffremment suivant le protocole du bus et son organisation, mais ce choix nest pas gratuit : certains composants devront
attendre leur tour pour avoir accs au bus. Ces temps d'attente ralentissent quelque peu les transferts. Un bus ddi n'a pas ce
problme, et est donc plus rapide, plus simple.
Pour limiter les problmes dus ces temps d'attente, les concepteurs de bus ont invents diverses mthodes pour grer ces
conflits daccs, et choisir le plus quitablement et le plus efficacement possible quel composant peut envoyer ses donnes sur
le bus. C'est ce qu'on appelle l'arbitrage du bus. Divers types d'arbitrage existent.
Dans l'arbitrage centralis, un circuit spcialis s'occupe de l'arbitrage du bus, et aucun composant n'a quoique ce soit dire : ils
doivent se contenter dobir aux ordres du circuit charg de grer l'arbitrage. Dans l'arbitrage distribu, chaque composant se
dbrouille de concert avec tous les autres pour viter les conflits daccs au bus : les composants sont relis par des fils entre
eux, et chacun dcid d'mettre ou pas suivant l'tat du bus. Dans ce qui va suivre, on va vous montrer deux exemples de
mthodes d'arbitrages du bus particulirement simples.
Implmentation
C'est bien beau d'avoir cre un protocole d'arbitrage du bus un peu mieux, mais encore faut-il que nos composants puissent
savoir que le bus est occup pour que ce protocole puisse fonctionner. Pas de panique : le bus de commande est l pour ! Il
suffit de lui rajouter un fil qui sert indiquer que le bus est occup et qu'un composant l'utilise : le fil Busy.
Cet arbitrage peut tre implant aussi bien en une version centralise qu'en une version distribue.
www.openclassrooms.com
277/467
Premire gnration
Pour les bus de premire gnration, un seul et unique bus reliait tous les composants de notre ordinateur. Ce bus s'appelait le
bus systme ou backplane bus.
Ce bus tait partag entre tous les composants : chacun d'entre eux monopolisait le bus durant un moment, et le librait quand il
avait fini de transmettre des donnes dessus.
Ces bus de premire gnration avaient le fcheux dsavantage de relier des composants allant des vitesses trs diffrentes : il
arrivait frquemment qu'un composant rapide doive attendre qu'un composant lent libre le bus. Le processeur tait le
composant le plus touch par ces temps d'attente.
Seconde gnration
Pour rgler ce genre de problmes, on a dcid de diviser le bus systme en deux bus bien spars : un bus pour les
priphriques lents, et un autre pour les priphriques rapides. Deux composants lents peuvent ainsi communiquer entre eux
sans avoir utiliser le bus reliant les priphriques rapides (et vice-versa), qui est alors utilisable volont par les priphriques
rapides. Les composants rapides et lents communiquent chacun de leur cot sans se marcher dessus.
Ces deux bus taient relis par un composant nomm le chipset , charg de faire la liaison et de transmettre les donnes d'un bus
l'autre.
Comme vous le voyez sur cette image, les composants considrs comme rapides sont le processeur et la mmoire. Ceux-ci sont
souvent associs la carte graphique. Le reste des composants est considr comme lent.
www.openclassrooms.com
278/467
Northbridge et southbridge
Sur certains ordinateurs, le chipset est divis en 2 :
Le northbridge :
une partie qui s'occupe de tous les bus relis aux composants rapides : processeurs, RAM, carte graphique (et oui !) ;
Le southbridge :
et une partie qui s'occupe de grer les bus des priphriques lents, comme les disque durs, les ports USB, le clavier, etc.
De nos jours
De nos jours, nos ordinateurs contiennent bien plus que deux bus, et presque chaque composant ou contrleur de priphrique
est connect sur le chipset par un bus.
Le preuve par l'exemple :
www.openclassrooms.com
279/467
Sur les ordinateurs ayant des processeurs rcents (2009-2010), le northbridge a disparu : celui-ci est intgr directement dans le
processeur.
www.openclassrooms.com
280/467
En clair, on a un bus qui relie le processeur la mmoire, et un autre qui relie le processeur au southbridge, avec parfois un autre
bus pour la carte graphique, mais passons. Ces nouveaux bus reliant le processeur au southbridge vous sont peut-tre connus
si vous allez souvent sur des sites parlant de l'actualit du hardware : il ne s'agit ni plus ni moins que des bus Intel QuickPath
www.openclassrooms.com
www.openclassrooms.com
281/467
282/467
Interfacage Entres-sorties
Dans la faon la plus simple de procder, le processeur se connecte au bus et va directement envoyer sur le bus : l'adresse, les
donnes, et autres commandes envoyer l'entre-sortie ou au priphrique. Ensuite, le processeur va devoir attendre et reste
connect au bus tant que le priphrique n'a pas trait sa demande correctement, que ce soit une lecture, ou une criture.
Cette mthode a beau tre simple, elle a un gros problme : nos priphriques sont trs lents pour un processeur. Le processeur
passe normment de temps attendre que le priphrique aie reu ou envoy sa donne. Et il a donc fallu trouver des solutions
plus ou moins lgantes.
Interfaage
Pour faciliter la communication entre processeur et entres-sorties/priphriques, une solution toute simple t trouve :
intercaler des registres entre le processeur et les entres-sorties. Ces registres servent faciliter la communication avec le
processeur : il suffit au processeur de lire ou crire dans ces registres pour communiquer avec le priphrique .
Le processeur peut crire des donnes sur une sortie sans monopoliser le bus en attendant que la sortie ou le priphrique aie
reu la donne. Il crit sa donne dans les registres dinterfaage et n'attend pas que le priphrique aie reu la donne. Cette
sortie aura juste lire le contenu du registre de faon rgulire (ou quand elle aura dtect une criture dans ce registre) pour
voir si le processeur ou un autre composant lui a envoy quelque chose.
Pour les entres, la situation ne s'amliore pas vraiment pour le processeur : il doit continuer lire le contenu des registres
dinterfaage rgulirement pour voir si un priphrique lui a envoy quelque chose. C'est plus rapide que devoir scruter en
quasi-permanence le bus : les processeur peut faire ce qu'il veut comme calcul, entre deux lecture du contenu du registre. Mais le
problme demeure. Bien sr, on va bientt voir que diverses techniques peuvent permettre des amliorations parfois notables.
Registres d'interfaage
Ces registres sont appels des registres d'interfaage et permettent au priphrique de communiquer avec "l'extrieur". C'est
dans ces registres que le processeur va lire les informations que le priphrique veut lui transmettre, ou qu'il va crire les
donnes et ordres qu'il veut envoyer au priphrique.
www.openclassrooms.com
283/467
Le contenu de ces registres dpend fortement du priphrique et on peut difficilement tablir des rgles gnrales quand leur
contenu.
Pour simplifier, on peut dire que ces registres peuvent contenir
des donnes tout ce qu'il y a de plus normales ;
ou des "ordres".
Ces ordres sont transmis au priphrique par des bits ou des groupes de bits individuels localiss dans des registres
dinterfaage. Le priphrique est conu pour effectuer un ensemble d'actions prprogrammes. Suivant la valeur de ces bits ou
groupes de bits, une de ces actions parmi toutes les autres sera slectionne, et ces bits ou groupes de bits peuvent donc servir
transmettre un "ordre". On peut comparer ces ordres avec les instructions d'un processeur, sauf qu'ici, ces ordres seront
destins un priphrique.
Contrleur de priphrique
Bon maintenant que notre processeur a crit dans les registres dinterfaage, qu'est-ce que se passe ?
A ce moment, un petit circuit nomm contrleur de priphrique va alors prendre le relai. Celui-ci est un petit circuit lectronique
qui va lire les donnes et informations envoyes par le processeur, les interprte, et va piloter le priphrique de faon ce que
celui-ci fasse ce qui lui est demand. Ce circuit peut tre plus ou moins compliqu et dpend du bus utilis, ainsi que du
priphrique.
Vu que les ordres et les informations envoyes par le processeur sont stocks dans les diffrents registres relis au bus, le
contrleur a juste lire le contenu de ces registre et le traiter pour faire ce qui lui est demand.
www.openclassrooms.com
284/467
Comme vous le voyez, le boulot du contrleur de priphrique est de gnrer des signaux de commande qui dclencheront une
action effectue par le priphrique. Ces signaux sont gnrs partir du contenu des registres. L'analogie avec le squenceur
d'un processeur est possible, bien que limite. Il faut bien remarquer qu'un contrleur de priphrique travaille la demande : on
lui donne un ordre, il obit et gnre les signaux de commande.
Les contrleurs de priphriques peuvent tre trs diffrents les uns des autres. Cela peut aller du simple circuit compos de
quelques centaines de transistors un petit micro-contrleur, avec sa RAM, son CPU et son programme intgr. De plus, le
contrleur de priphrique peut trs bien tre spar du priphrique qu'il va commander. Certains priphriques intgrent en
leur sein ce contrleur : les disques durs IDE, par exemple). Mais dautres sont commands par un contrleur spar du
priphrique. Dans certains cas, ce contrleur est plac sur la carte mre et peut mme commander plusieurs priphriques en
mme temps : c'est le cas du contrleur de bus USB.
Une prcision assez importante s'impose : certains contrleurs de priphriques peuvent permettre au processeur de
communiquer avec plusieurs priphriques en mme temps. C'est notamment le cas pour tout ce qui est contrleurs PCI, USB et
autres : ces contrleurs sont relis un bus sur lequel plusieurs priphriques sont connects. Le contrleur se contente de
prendre en charge l'change dinformations via le bus en question et peut ainsi communiquer avec plusieurs priphriques.
www.openclassrooms.com
285/467
Dans ce genre de cas, on peut parfaitement considrer que le contrleur sert plus d'interface entre un bus spcialis et le
processeur.
Registre d'tat
Certains de ces contrleurs intgrent un registre qui contient des informations sur l'tat du contrleur, du priphrique ou du bus
qui relie ces registres au priphrique. Ils peuvent tre utiles pour signaler des erreurs de configuration ou des pannes touchant
un priphrique.
Pilotes de priphriques
Lorsqu'un ordinateur utilise un systme d'exploitation, celui-ci ne connait pas toujours le fonctionnement d'un priphrique et/ou
de son contrleur ( par exemple, si le priphrique a t invent aprs la cration de l'OS). Il faut donc installer un petit
programme qui va s'excuter quand on souhaite communiquer avec le priphrique et qui s'occupera de tout ce qui est
ncessaire pour le transfert des donnes, l'adressage du priphrique, etc. Ce petit programme est appel driver ou pilote de
priphrique.
La "programmation" d'un contrleur de priphrique est trs simple : il suffit de savoir quoi mettre dans les registres pour
paramtrer le contrleur. Et un pilote de priphrique ne fait que cela. Pour simplifier au maximum, un pilote de priphrique est
un ensemble de petits sous-programmes qui ont chacun une utilit particulire. Chacun de ces sous-programmes sexcute la
demande, quand un programme en a besoin. Ces sous-programme vont alors configurer les registres dinterfaage de faon ce
que ceux-ci contiennent les ordres et donnes ncessaires pour que le contrleur de priphrique fasse ce qu'on lui demande.
Problmes
Avec les registres dinterfaage, l'criture est nettement plus rapide : le processeur crit dans le registre adquat et peut
continuer son travail dans son coin en attendant que le priphrique aie fini. La seule contrainte, c'est que le processeur ne peut
pas forcment (sauf cas particuliers) envoyer une autre commande au contrleur de priphrique tant que la premire commande
n'est pas traite. Tant que le contrleur de priphrique n'est pas "libre", le processeur devra attendre.
Aprs avoir envoy un ordre au contrleur, le processeur ne sait pas quand le contrleur redeviendra libre, et doit donc vrifier
priodiquement si le contrleur est prt pour un nouvel envoi de commandes/donnes. Gnralement, il suffit au processeur de
lire le registre d'tat du contrleur : un bit spcial de celui-ci permet d'indiquer si le contrleur est libre ou occup. Pour la lecture,
la situation est similaire : le processeur doit lire rgulirement son contenu pour voir si le priphrique ne lui a pas envoy
www.openclassrooms.com
286/467
quelque chose.
Cette mthode consistant vrifier priodiquement si le priphrique a reu ou envoy quelques chose s'appelle le Pooling.
Cette technique permet de ne pas rester connect en permanence durant le temps que met le priphrique pour effectuer une
lecture ou une criture, mais ce n'est pas parfait : ces vrifications priodiques sont autant de temps perdu pour le processeur.
Pour solutionner ce problme, on a dcid dutiliser des interruptions !
Interruptions
Encore un terme barbare ! Qu'est-ce que c'est qu'une interruption ?
Ces interruptions sont des fonctionnalits du processeur qui vont interrompre temporairement lexcution d'un programme afin
de ragir un vnement extrieur (matriel, erreur fatale dexcution d'un programme...) et de le traiter en temps voulu, avant de
rendre la main au programme interrompu. Notre interruption va donc devoir effectuer un petit traitement (ici, communiquer avec
un priphrique). Ce petit traitement est fait par un petit programme au auquel on a donn un nom technique : routine
d'interruption.
On les utilise pour quelques cas bien prcis, qui ncessitent un traitement ne pouvant attendre trop longtemps. Communiquer
avec des priphriques est un de ces cas. Ainsi, pour communiquer avec une carte graphique, un disque dur ou encore avec le
clavier, vous allez devoir utiliser des interruptions. Ces interruptions sont aussi utilises pour permettre plusieurs programmes
de s'excuter sur un processeur : on switche constamment d'un programme un autre, l'aide d'interruptions ; et pour bien
d'autres choses encore. Il existe des processeurs qui ne grent pas les interruptions, mais ceux-ci sont vraiment trs rare, vu leurs
nombreuses utilisations diverses et varies.
Trs simplement : avec elles, le processeur n'a pas vrifier priodiquement si le contrleur de priphrique est libre ou a bien
envoy sa donne. Les interruptions vont tre utilises pour prvenir que le contrleur de priphrique a envoy une donne au
processeur ou qu'il est libre. Ainsi, le processeur se contente d'crire dans les registres dinterfaage et ne fait rien de plus : on
n'utilise le processeur que quand on en a besoin..
Prenons le cas d'une lecture ou un cas dans lequel le priphrique envoie une donne au processeur (du genre : une touche a t
tape au clavier). Dans ce cas, le priphrique enverra une interruption au processeur pour le prvenir qu'une donne lui est
destine. Le processeur traitera l'interruption en copiant le contenu des registres dinterfaage contenant la donne signale par
www.openclassrooms.com
287/467
Registres, again
Ce sous-programme va fatalement utiliser certains registres du processeur lors de son excution. Comme pour les fonctions, il
faut alors sauvegarder certains registres du processeur pour viter que notre routine dinterruption vienne craser des donnes
qui ne doivent pas l'tre. Ainsi, les registres utiliss par notre routine d'interruption seront sauvegards au sommet de la pile de
notre ordinateur.
Cette sauvegarde n'est pas toujours faite automatiquement par notre processeur. Parfois, c'est le programmeur qui doit coder luimme la sauvegarde de ces registres dans la routine d'interruption elle-mme. Il peut ainsi dcider de ne pas sauvegarder certains
registres qui ne sont pas destins tre utiliss par la routine, afin de gagner un peu de temps.
Choix de la routine
Comme on l'a dit, une interruption a t conue pour ragir un vnement, mais ce sont avant tout des programmes comme les
autres, qui peuvent tre excuts comme n'importe quelle autre programme. Dans notre cas, ces interruptions seront simplement
considres comme des programmes simplistes permettant d'agir sur un priphrique. Bien sr, devant la multiplicit des
priphriques, on se doute bien qu'il n'existe pas d'interruption tout faire : il va de soi qu'un programme envoyant un ordre au
disque dur sera diffrent d'un programme agissant sur une carte graphique. Dans chaque cas, on aura besoin d'effectuer un
traitement diffrent. On a donc besoin de plusieurs routines d'interruption.
Mais il faut bien dcider quelle est l'interruption excuter suivant la situation. Par exemple, excuter l'interruption de gestion du
clavier alors qu'on souhaite communiquer avec notre disque dur donnerait un rsultat plutt comique.
On va donc devoir
stocker plusieurs de ces routines dans sa mmoire. Mais comment les retrouver ? Comme les autres donnes ! Chaque routine
est donc place dans la mmoire un certain endroit, localisable par son adresse : elle indique sa position dans la mmoire.
Pour retrouver la position de notre routine en mmoire et savoir laquelle excuter, certains ordinateurs utilisent une partie de leur
mmoire pour stocker toutes les adresses de dbut de chaque routine d'interruption. En gros, cette partie de la mmoire contient
toutes les adresses permettant de localiser chaque routine. Cette portion de la mmoire s'appelle le vecteur d'interruption. Pour
chaque interruption, une partie fixe de la mmoire contiendra l'adresse de dbut de l'interruption effectuer. Lorsqu'une
interruption a lieu, le processeur va automatiquement aller chercher son adresse dans ce vecteur d'interruption.
Une autre solution est simplement de dlguer cette gestion du choix de linterruption au systme d'exploitation : l'OS devra alors
traiter l'interruption tout seul. Dans ce cas, le processeur contient un registre qui stockera des bits qui permettront l'OS de
dterminer la cause de l'interruption : est-ce le disque dur qui fait des siennes, une erreur de calcul dans l'ALU, une touche
appuye sur le clavier, etc.
Et bien, dans ce cas l, on ne peut excuter qu'une seule interruption. On doit donc choisir d'excuter une interruption et pas
l'autre. Le truc, c'est que certaines interruptions seront prioritaires sur les autres. Chaque interruption possde une priorit.
Cette priorit est code par un nombre : plus le nombre est lev, plus l'interruption a une priorit faible ! Quand deux
interruptions souhaitent s'excuter en mme temps, on choisit d'excuter celle qui est la plus prioritaire (celle dont le nombre est
le plus faible).
L'autre interruption n'est pas excute, et doit attendre. On dit que cette interruption est masque. Le masquage d'interruption
empche l'excution d'une interruption et la force attendre un vnement prcis pour pouvoir enfin s'excuter. On peut
nanmoins masquer des interruptions sans que cela soit du l'excution de deux interruptions simultanes, mais passons cela
sous le tapis pour le moment.
Bien videment, il faut dcider quelles sont les interruptions les plus prioritaires sur les autres . Cela se fait par leur utilit :
certaines interruptions sont plus urgentes que les autres. Une interruption qui gre l'horloge systme est plus prioritaire qu'une
interruption en provenance de priphriques lents comme le disque dur ou une cl USB.
288/467
IRQ
Les IRQ sont des interruptions qui sont dclenches par un priphrique. Dans une implmentation simple des IRQ, notre
priphrique est reli notre processeur sur une de ses entres. Si on envoie un 1 sur cette entre, le processeur excute une
interruption parmi toute les autres. Ainsi, notre processeur contient autant d'entre supplmentaires qu'il peut excuter
d'interruption.
Cela utilise un petit peu trop d'entres qui pourraient tre utilises autre chose. Pour viter cela, on a invent le contrleur
d'interruptions. Ce contrleur d'interruptions est un petit circuit sur lequel on va connecter tous les fils d'IRQ. Ce contrleur va
recevoir sur ses entres les IRQ envoyes par les priphriques.
Ce contrleur possde :
une sortie sur laquelle on envoie un signal sur une entre du processeur qui va signaler qu'il faut excuter une
interruption ;
un registre qui contient l'adresse de la routine sur laquelle il faut brancher ;
et une "mmoire" ou un circuit qui contient (mmoire) ou dduit (circuit) pour chaque interruption, l'adresse de
branchement de la routine excuter.
www.openclassrooms.com
289/467
Interruptions logicielles
Ces interruptions ont une cause diffrente : elle sont dclenches par un programme en cours d'excution sur notre ordinateur.
Ces interruptions sont des instructions qui sont excutables par un programme. Ainsi, le jeu d'instruction du CPU contient une
instruction d'interruption. Un programmeur peut donc dcider d'utiliser des interruptions un certain moment de ce programme,
pour des raisons particulires.
Par contraste, les IRQ ne sont pas des instructions appartenant au jeu d'instruction, et ne sont excutes que quand une entresortie en fait la demande. D'ailleurs, certains processeurs grent les IRQ, mais pas les interruptions logicielles.
Ces interruptions logicielles sont beaucoup utilises par les pilotes de priphriques : ces interruptions logicielles peuvent tre
excutes au besoin. Ainsi, les programmes d'un systme d'exploitation utilisent des interruptions pour dlguer la
communication avec les priphriques au pilotes de priphriques. Ces interruptions logicielles vont faire excuter des routines
charges de lire ou crire dans les registres dinterfaage. Il va de soit que ces routines sont celles du pilote de priphrique.
Ceux qui veulent en savoir plus peuvent aller lire mon tutoriel sur les systmes d'exploitation.
Exceptions
Et maintenant, une petite digression, pour vous prouver que les interruptions peuvent servir beaucoup de choses et pas
seulement communiquer avec des priphriques. On va parler des exceptions matrielle.
Ne pas confondre les exceptions matrielles et celles utilises dans les langages de programmation, qui n'ont rien voir
!
Une exception matrielle est aussi une interruption, mais qui a pour raison un vnement interne au processeur, par exemple une
erreur d'adressage, une division par zro...Pour pouvoir excuter des exceptions matrielles, notre processeur doit pouvoir
dclencher une interruption lorsqu'une erreur particulire survient dans le traitement d'un instruction. Il faut donc que ce CPU
intgre des circuits ddis cette tache.
Lorsqu'une exception matrielle survient, il faut trouver un moyen de corriger l'erreur qui a t la cause de l'exception matrielle :
la routine excute va donc servir corriger celle-ci. Bien sur, une exception matrielle peut avoir plusieurs causes. On a donc
plusieurs routines.
Arbitrage du bus
Le bus mastering n'est pas sans poser quelques petits problmes : le processeur et/ou plusieurs priphrique peuvent bouloir
accder au bus en mme temps. Manque de chance : on ne peut laisser deux composants tenter d'crire des donnes en mme
temps sur le mme bus : si on laissait faire ce genre de choses, on se retrouverait vite avec n'importe quoi sur notre bus !
Voici pourquoi : si on cble plusieurs composants sur le mme bus, rien n'empche ces deux composants de vouloir envoyer ou
recevoir une donne sur le bus en mme temps. C'est ce qu'on appelle un conflit d'accs au bus. Cela pose problme si un
composant cherche envoyer un 1 et l'autre un 0 : le niveau logique du bit envoyer est alors inconnu. Et quand on envoie
plusieurs bits la suite, tout ce que lon reoit l'autre bout du fil est un espce de mlange incohrent des deux donnes
envoyes sur le bus par les deux composants. En clair : a ne ressemble plus rien l'autre bout du fil !
Il faut donc trouver diverses mthodes pour grer ces conflits daccs, et choisir le plus quitablement et le plus efficacement
possible quel composant peut envoyer ses donnes sur le bus. C'est ce qu'on appelle l'arbitrage du bus.
La technique du bus mastering est une technique assez gnrale, aussi je vais vous prsenter, assez rapidement, une version de
cette technique nomme le direct memory acces.
www.openclassrooms.com
290/467
priphrique plus rapide. Elle peut mme servir transfrer des donnes de la mmoire vers la mmoire, pour effectuer des copies
de trs grosses donnes, mme si cela ne marche qu'avec du matriel particulier. Nanmoins, avec le Direct Memory Acces, le
processeur doit tout de mme intervenir au dbut et la fin d'un transfert de donnes entre la mmoire et un priphrique.
Mais comment a marche ?
Sans Direct Memory Acces, les priphriques et leurs contrleurs ne peuvent pas modifier le contenu du bus d'adresse ou le bit
R/W afin de demander une lecture ou une criture : ils n'ont accs qu'aux registres dinterfaage et peuvent dclencher des
interruptions, mais le bus leur est interdit. Ainsi, les contrleurs de priphriques ne peuvent adresser la mmoire et demander
des oprations de lecture et/ou criture directement : il doivent passer par un intermdiaire, savoir notre bon vieux processeur.
Contrleur DMA
Avec la technologie DMA, un circuit spcial souvent intgr notre priphrique (ou son contrleur), le contrleur DMA est
reli au bus mmoire et peut modifier le contenu des bus d'adresse, de commande et de donnes. L'change de donne entre le
priphrique et la mmoire est intgralement gr par celui-ci. Ce contrleur DMA est similaire un contrleur de priphrique : il
possde des registres dans lesquels le processeurs peut crire et chacun de ces registres contient des donnes utiles au
contrleur pour faire ce qu'on lui demande.
Ce contrleur DMA est capable de transfrer un gros bloc de mmoire entre un priphrique et la mmoire. Le transfert peut aller
dans les deux sens : du priphrique vers la RAM, ou de la RAM vers le priphrique. Le sens du transfert, ainsi que les
informations sur le bloc de mmoire transfrer, sont prciss dans un des registres du contrleur DMA.
Ce contrleur incorpore donc des registres chargs de contenir :
une adresse qui va dfinir le dbut du segment de la mmoire ;
la longueur de ce segment de mmoire ;
et parfois un ou plusieurs registres de contrle.
Ces registres de contrle peuvent contenir beaucoup de chose : avec quel priphrique doit-on changer des donnes, les
donnes sont-elles copies du priphrique vers la RAM ou l'inverse, et bien dautres choses encore.
Le travail du contrleur est assez simple. Celui-ci doit se contenter de placer les bonnes valeurs sur les bus, pour effectuer le
transfert. Il va donc initialiser le bus d'adresse l'adresse du dbut du bloc de mmoire et initialiser le bus de commande selon la
valeur du bit/registre spcifiant le sens de la transaction. Puis, chaque fois qu'une donne est lue ou crite sur le priphrique,
il va augmenter l'adresse de ce qu'il faut pour slectionner le bloc de mmoire suivant.
Modes DMA
Il existe trois facon de transfrer des donnes entre le priphrique et la mmoire. On peut ainsi citer le mode block, le mode cycle
stealing , et le mode transparent. Ces trois modes diffrent par la faon dont le processeur est laiss libre de ses mouvements.
Dans le mode block, le contrleur mmoire se rserve le bus mmoire, et effectue le transfert en une seule fois, sans
interruptions. Cela a un dsavantage : le processeur ne peut pas accder la mmoire durant toute la dure du transfert entre le
priphrique et la mmoire. Alors certes, a va plus vite que si on devait utiliser le processeur comme intermdiaire, mais bloquer
ainsi le processeur durant le transfert peut diminuer les performances. Dans ce mode, la dure du transfert est la plus faible
possible. Il est trs utilis pour charger un programme du disque dur dans la mmoire, par exemple. Et oui, quand vous dmarrez
un programme, c'est souvent un contrleur DMA qui s'en charge !
Dans le mode cycle stealing , on est un peu moins strict : cette fois-ci, le contrleur ne bloque pas le processeur durant toute la
dure du transfert. En cycle stealing , le contrleur va simplement transfrer un byte (un octet) la fois, avant de rendre la main
au processeur. Puis, le contrleur rcuprera l'accs au bus aprs un certain temps. En gros, le contrleur transfre un byte;, fait
une pause d'une dure fixe, puis recommence, et ainsi de suite jusqu' la fin du transfert.
Et enfin, on trouve le mode transparent, dans lequel le contrleur DMA accde au bus mmoire uniquement quand le processeur
ne l'utilise pas.
Un peu dlectricit
Premier bmol : le processeur et le contrleur DMA sont tous deux relis au bus. Et Cela pose problme ! Il faut arbitrer le bus et
trouver viter que le processeur et un priphrique envoient des donnes sur le bus en mme temps.
www.openclassrooms.com
291/467
Les concepteurs de la technologie DMA sont des malins : ils ont trouvs une solution, base sur les interruptions.
La solution retenue par le DMA est la suivante :
le processeur et chaque priphrique est reli au bus par un transistor, un composant lectronique qu'on utilisera en tant
qu'interrupteur ;
de plus, un fil relie directement le priphrique au bus, et donc la mmoire (indirectement).
Tant que le priphrique n'accde pas la mmoire, tout les interrupteurs reliant le priphrique au bus sont dconnects : le
priphrique n'est pas reli au bus. Par contre, le processeur est connect au bus mmoire et peut faire ce qu'il veut dessus, du
moment que c'est dans son programme.
Lorsqu'un priphrique souhaite accder la mmoire ou qu'un programme veut envoyer des donnes un priphrique, il
dclenche l'excution d'une interruption. Pour qu'un priphrique puisse dclencher cette interruption, il suffit d'envoyer un bit
sur le fil qui le relie au processeur. Dans le cas prsent, la routine d'interruption va alors demander au processeur d'ouvrir ses
interrupteurs ce qui le dconnecte du bus, tandis que le priphrique ferme ses interrupteurs. Le priphrique peut alors accder
la mmoire.
Le contrleur DMA s'occupera alors de l'change de donnes, laissant le processeur libre d'excuter ses calculs dans son coin,
sans accder au bus. A la fin de la transaction, le contrleur DMA dconnecte le priphrique du bus. Pour prvenir le
processeur de la fin d'un change de donne entre priphrique et mmoire, le contrleur DMA enverra une interruption vers le
www.openclassrooms.com
www.openclassrooms.com
292/467
293/467
Ben oui, pour communiquer avec les registres du contrleur, il doit bien exister un moyen pour pouvoir les localiser et les
slectionner ! Ce chapitre va vous montrer les diffrentes mthodes utilises pour pouvoir "adresser" notre contrleur de
priphrique. Elles sont au nombre de trois et se nomment :
la connexion directe ;
les entres-sorties mappes en mmoire ;
et l'espace d'adressage spar.
Connexion directe
Dans le cas le plus simple, le contrleur est reli directement sur des entres et des sorties du processeur : certaines entressorties du processeur sont spcialement ddies la communication avec un priphrique ou un contrleur de priphrique
particulier. On se retrouve donc avec un bus supplmentaire, qui s'occupe de relier processeur et contrleur de priphrique : le
bus d'entres-sorties.
Bus multiples
En faisant ainsi, on peut accder un contrleur de priphrique et la mmoire en mme temps : on accde la mmoire par le
bus mmoire, et on accde notre priphrique via le bus d'entres-sorties. Dans ce genre de cas, le contrleur n'a pas d'adresse
qui permettrait de lidentifier. Le bus d'entres-sorties se rduit donc un bus de donne coupl un bus de commande.
Les problmes commencent lorsqu'on se retrouve avec plusieurs contrleurs de priphriques cbler sur le processeur : on doit
cbler autant de bus qu'on a des priphriques ! La quantit de fils utiliss, ainsi que le nombre de connexions ajouter sur le
processeur augmente beaucoup trop pour que ce soit possible. On doit donc trouver un moyen qui permette de grer un grand
nombre de priphriques et de contrleurs qui soit viable techniquement parlant.
www.openclassrooms.com
294/467
Avec cette solution, on doit trouver un moyen pour slectionner le contrleur de priphrique avec lequel on souhaite changer
des donnes. Pour cela, on est oblig dutiliser l'adressage : chaque contrleur de priphrique se voit attribuer une adresse, qui
est utilise pour l'identifier et communiquer avec lui. Notre bus d'entres-sorties se voit donc ajouter un bus d'adresse en plus du
bus de donne et de commande.
En faisant ainsi, on peut accder un contrleur de priphrique et la mmoire en mme temps : on accde la mmoire par le
bus mmoire, et on accde notre priphrique via le bus d'entres-sorties. Par contre, impossible d'accder plusieurs
contrleurs de priphriques en mme temps : avec des bus spars pour chaque contrleur, on aurait ventuellement pu le faire,
au prix d'un nombre de fils et de connexions impressionnant et trs couteux.
Il va de soit qu'avec cette solution, on conomise beaucoup de fils : on n'a plus qu'un bus d'entres-sorties cbler sur le
processeur, au lieu de devoir utiliser autant de bus d'entres-sorties que de contrleurs de priphriques. L'conomie est norme
! Sans compter que le processeur n'a pas devoir grer plusieurs bus d'entre-sortie : il est moins complexe, ce qui fait gagner
pas mal de transistors.
Et bien c'est une trs bonne ide : on peut dcider de partager les bus d'adresse du bus mmoire et du bus d'entres-sorties sans
problmes. Ainsi, le mme bus d'adresse sera utilis pour les accs aux priphriques et pour les accs mmoires.
www.openclassrooms.com
295/467
Par contre, les bus de donnes et de commande sont toujours spars : on ne les mutualise pas !
Partage d'adresse
Et quand une case mmoire et un contrleur de priphrique ont la mme adresse, il se passe quoi ?
Aie ! Effectivement, cela arrive : on n'est pas l'abri de ce genre de chose. Mais il y a une solution trs simple : rajouter un fil sur
le bus d'adresse qui servira dire qu'on veut communiquer avec un contrleur de priphrique, ou avec la mmoire. Ainsi, on
rajoute un bit supplmentaire notre adresse qui servira distinguer la nature du composant avec lequel on veut communiquer :
mmoire ou entres-sorties. Ce bit sera appel le bit IO dans la suite de ce tutoriel.
www.openclassrooms.com
296/467
IO Instructions
Notre processeur est tout de mme un peu perdu : comment faire pour que celui-ci positionne la valeur du bit IO la
bonne valeur et utilise le bon bus de donne suivant qu'il veuille communiquer avec un priphrique ou avec la
mmoire ?
Et bien on n'a pas vraiment le choix : on doit utiliser des instructions diffrentes suivant le composant avec lequel on
communique. Ainsi, l'instruction qui crira dans une adresse ddie un contrleur de priphrique ne sera pas la mme que
celle charge d'crire dans une adresse en mmoire. Suivant l'instruction utilise, le bit IO sera automatiquement positionn la
bonne valeur, et le bon bus de donne sera slectionn vitant toute confusion.
Cela a une consquence : il est difficile de crer des instructions capables de transfrer des donnes entre un priphrique et la
mmoire directement. Gnralement, les processeurs ne disposent pas d'instructions aussi spcialises : cela demanderait
beaucoup de circuits pour pas grand chose. Pour transfrer des donnes d'un priphrique vers la mmoire, on est donc oblig
de se servir d'un intermdiaire : les registres du processeur. Par exemple, prenons un transfert de donne d'un priphrique vers
la mmoire : on est oblig de copier la donne du priphrique vers un registre du processeur, avant d'crire le contenu de ce
registre dans la case mmoire de destination. videment, cela est tout aussi vrai pour les transferts qui vont dans l'autre sens.
Pour viter de devoir passer par un registre, on peut aussi utiliser la technique du Direct memory acces, qui rsout totalement le
problme. Mais il faut que notre priphrique ou notre carte mre incorpore un tel dispositif, ce qui n'est pas toujours le cas : a
peut couter cher ce genre de machin.
www.openclassrooms.com
297/467
Ainsi, certains "blocs" d'adresses mmoires seront invalides en dur par des circuits lectroniques chargs de grer le bus, et
renverront vers le priphrique slectionn.
Perte de mmoire
On peut remarquer un petit dfaut inhrent cette technique : on ne peut plus adresser autant de mmoire qu'avant. Avant,
toutes les adresses permettaient de slectionner une case de la mmoire principale. Plus maintenant : certaines adresses mmoire
sont rserves aux priphriques et ne peuvent plus tre utilises pour adresser la mmoire. Les cases mmoires en question
deviennent inaccessibles.
Bon, a peut paraitre thorique, et il faut bien avouer que l'on peut aisment penser que a ne risque pas de nous concerner de
sitt. Et pourtant, ce problme touche nos ordinateurs modernes.
Vous avez dj entendus parler du problme des 4 gigaoctets ?
C'est un problme souvent rencontr sur les forums : certaines personnes installent 4 gigaoctets de mmoire sur leur ordinateur
et se retrouvent avec "seulement" 3.5-3.8 gigaoctets de mmoire. Ce "bug" apparait sur les processeurs x86 quand on utilise un
systme d'exploitation 32 bits. Avec ce genre de configuration, notre processeur utilise des adresses mmoires de 32 bits, ce qui
fait 4gigaoctets de mmoire adressable.
Et bien parmi certaines de ces adresses, une partie est utilise pour adresser nos priphriques et ne sert pas adresser de la
mmoire RAM : on perd un peu de mmoire. Et mine de rien, quand on a une carte graphique avec 512 mgaoctets de mmoire
intgre (cette mmoire est adresse directement et ca fait 512 Mo en moins d'un coup), une carte son, une carte rseau PCI, des
www.openclassrooms.com
298/467
ports USB, un port parallle, un port srie, des bus PCI-Express ou AGP, et un BIOS stocker dans une EEPROM FLASH, a part
assez vite.
Vous pouvez aussi tenter de regarder ce que a donne pour d'autres machines qui ne sont pas des PC, vous trouverez
exactement le mme problme. Essayez de regardez sur le net ce que a donne pour des ordinateurs tels que la Gamecube, les
vielles consoles Atari, une Gameboy color, ou d'autres machines plus ou moins bizarres : cela vous montrera d'autres exemples
assez intressants.
Processeurs priphriques
Avec certains priphriques, cette technique qui consiste mapper nos entres-sorties en mmoire est pousse lextrme. C'est
souvent le cas pour certains priphriques possdant une mmoire RAM intgre dans leurs circuits : cartes graphiques, cartes
sons, etc. Cette mmoire est directement accessible directement par le processeur en dtournant suffisamment d'adresses
mmoires. La mmoire de notre priphrique est accessible via des adresses mmoires normales : elle est ainsi en partie (voire
totalement) partage entre le processeur principal de l'ordinateur et le priphrique (et plus globalement avec tout priphrique
pouvant adresser la mmoire).
Certains de ces priphriques intgrant une mmoire RAM vont mme plus loin et possdent carrment un processeur pour des
raisons de rapidit. Une grande partie de la gestion des entres-sorties est ainsi dlgue au processeur intgr dans le
priphrique et n'a pas tre gre par le processeur principal de l'ordinateur.
Ce processeur intgr pourra ainsi excuter des programmes chargs de commander ou configurer le priphrique. Ces
programmes sont souvent fournis par les pilotes du priphrique ou le systme d'exploitation. Ces programmes sont souvent
recopis par le processeur principal ou via un contrleur DMA dans la mmoire du priphrique (partage). Ainsi, adresser de
tels priphriques pourra se faire assez directement en recopiant des programmes dans leur mmoire et en configurant quelques
registres. Cela peut paraitre bizarre, mais sachez que c'est exactement ce qui se passe pour votre carte graphique si celle-ci a
moins de vingts ans.
On peut considrer que ces priphriques sont des mini-ordinateurs, relis notre processeur.
Bus unique
Cette technique a un gros avantage : on peut utiliser un bus unique, sans rien dupliquer : fini le bus de donne prsent en
double ! Avec cette mthode, on peut se contenter d'un seul bus qui relie le processeur aussi bien avec la mmoire qu'avec les
priphriques.
www.openclassrooms.com
299/467
Avec cette technique, on conomise beaucoup de fils. Par contre, impossible d'accder la fois la mmoire et un contrleur
d'entres-sorties : si le bus est utilis par un priphrique, la mmoire ne pourra pas lutiliser et devra attendre que le priphrique
aie fini sa transaction (et vice-versa).
Et pour le CPU ?
Autre avantage : on n'a pas besoin d'instructions diffrentes pour accder aux priphrique et la mmoire. Tout peut tre fait
par une seule instruction : on n'a pas besoin de positionner un quelconque bit IO qui n'existe plus. Notre processeur possde
donc un nombre plus limit d'instructions machines, et est donc plus simple fabriquer.
www.openclassrooms.com
300/467
La mmoire virtuelle
De nombreuses instructions ou fonctionnalits d'un programme ncessitent pour fonctionner de connaitre ou de manipuler des
adresses mmoires qui sont censes tre fixes (accs une variable, pointeurs, branchements camoufls dans des structures de
contrles, et d'autres). De nombreux modes d'adressages permettent de manipuler ou de calculer des adresses mmoires, plus ou
moins efficacement.
Sur les ordinateurs qui nexcutent qu'un seul programme la fois, cela ne pose aucun problme : on sait exactement o va tre
charg notre programme dans la mmoire. Mais sur des ordinateurs un peu plus compliqus, c'est rarement le cas : l'adresse
laquelle on va charger un programme dans notre mmoire RAM n'est presque jamais la mme d'une excution sur l'autre. Ainsi,
les adresses de destination de nos branchements et les adresses de nos donnes ne sont jamais les mmes. Il nous faut donc
trouver un moyen pour faire en sorte que nos programmes puissent fonctionner avec des adresses qui changent d'une excution
l'autre.
De plus, un autre problme se pose : un programme peut tre excut sur des ordinateurs ayant des capacits mmoires diverses
et varies et dans des conditions trs diffrentes. Et il faut faire en sorte qu'un programme fonctionne sur des ordinateur ayant
peu de mmoire sans poser problme. Aprs tout, quand on conoit un programme, on ne sait pas toujours quelle sera la
quantit mmoire que notre ordinateur contiendra, et encore moins comment celle-ci sera partage entre nos diffrentes
programmes en cours dexcution : s'affranchir de limitations sur la quantit de mmoire disponible est un plus vraiment
apprciable.
Et d'autres problmes existent encore : nos processeurs ne grent pas la mmoire de la mme faon. Si on devait prendre en
compte cette gestion de la mmoire par le processeur lors de la conception de nos programmes, ceux-ci se seraient adapts qu'
certains processeurs et pas d'autres.
Solutions matrielles
Vous l'avez compris, tous les dtails concernant l'organisation et la gestion de la mmoire sont assez compliqu grer et faire en
sorte que nos programmes n'aient pas s'en soucier est un plus vraiment apprciable. Ce genre de problme a eu des solutions
purement logicielles : on peut citer par exemple l'overlaying . C'est compliqu, long et donne des programmes utilisables sur un
ordinateur en particulier et presque aucun autre : la compatibilit de ces programmes sur d'autres ordinateurs que celui pour
lequel ils ont ts conus est difficile voire impossible.
Mmoire virtuelle
Mais d'autres techniques rglent ces problmes. Leur avantage : elles sont en partie voire totalement prises en charge par notre
matriel, et c'est celles-ci qu'on va sintresser. Ces solutions sont ce qu'on appelle la mmoire virtuelle. Le principe de la
mmoire virtuelle est simple : donner aux programmes une reprsentation simplifie de la mmoire qui contient plus de mmoire
qu'installe sur notre ordinateur, et qu'un programme peut manipuler sans avoir connaitre l'organisation exacte de la mmoire.
La fameuse reprsentation simplifie de la mmoire dont on parle consiste simplement en une mmoire fictive, compose d'autant
(voire plus) d'adresses que ce que le processeur peut adresser. Ainsi, on se moque des adresses inaccessibles, rserves aux
priphriques, de la quantit de mmoire rellement installe sur l'ordinateur, ou de la mmoire prise par d'autres programmes en
cours dexcution.
Tout se passe comme si notre programme tait seul au monde et pouvait lire et crire toutes les adresses disponibles partir de
l'adresse zro. Bien sr ces adresses sont des fausses adresses, des adresses fictives, mais c'est celles-ci qu'on retrouvera dans
notre programme : toutes les adresses de destination de nos branchements, de nos donnes (modes d'adressages), et autres ;
seront ces adresses fictives.
www.openclassrooms.com
301/467
Vous remarquerez que notre programme a accs plus d'adresses fictives que d'adresses relles. Pour viter que ce surplus de
fausse mmoire pose problme, on utilise une partie des mmoires de masse (disque durs) d'un ordinateur en remplacement de la
mmoire physique manquante.
Alors bien sr, cette reprsentation fictive de la mmoire, cette mmoire virtuelle, n'est pas utilisable en l'tat : on voit bien que
notre programme va pouvoir utiliser des adresses auxquelles il n'a pas accs. Mais notre programme a malgr tout accs une
certaine quantit de mmoire dans la mmoire relle.
Pour que cette fausse mmoire devienne utilisable, on va transformer les fausses adresses de cette fausse mmoire en adresses
rellement utilisables. Ces fausses adresses sont ce qu'on appelle des adresses logiques : ce seront les adresses manipules par
notre programme, grce aux divers modes d'adressages vus plus haut, et qu'on retrouvera dans nos registres. Par contre, les
adresses relles seront ce qu'on appelle des adresses physiques.
La MMU
Maintenant, il ne nous reste plus qu' implmenter cette technique.
Mais comment faire ?
Segmentation
La premire technique de mmoire virtuelle qu'on va aborder s'appelle la segmentation. Cette technique consiste dcouper
notre mmoire virtuelle en gros blocs de mmoire qu'on appelle segments.
www.openclassrooms.com
302/467
Gnralement, on ne dcoupe pas ces blocs n'importe comment : on prfre que ce dcoupage soit logique et reflte un peu
l'organisation du programme qu'on est en train de dcouper en segments. Par exemple, il est assez courant de dcouper nos
programmes en plusieurs zones bien distinctes :
Segment
Text
Utilit
Il sert stocker la suite d'instructions qui consiste notre programme : il s'agit d'un segment qui rassemble tout le
contenu de la mmoire programme (souvenez-vous des premiers chapitres de la partie 2).
Ce segment a presque toujours une taille fixe.
Le segment data contient des donnes qui occupent de la mmoire de faon permanente.
Data
Ce segment Data est un segment dans laquelle on stocke des donnes dfinitivement. Impossible de librer la
mmoire de ce segment pour faire de la place. En consquence, ce segment a toujours une taille fixe.
Stack
Il s'agit de notre pile : celle-ci possde un segment rien que pour elle.
Heap
Le Heap, ou tas, est un segment qui sert stocker des donnes, un peu comme le segment Data. Mais l'inverse
de ce dernier, on peut effacer les donnes qu'il contient lorsqu'elles deviennent inutiles. Ce tas a donc une taille
variable.
Grosso modo, on retrouve cette organisation dans beaucoup de programmes conus pour utiliser la segmentation, quelques
dtails prt. Par exemple, on peut trouver d'autres segments supplmentaires plus ou moins utiles comme des segments d'tat de
tche, mais cela nous entrainerait trop loin. Comme vous le voyez, ce dcoupage est assez cohrent avec l'organisation d'un
programme en mmoire.
Principe
Pour donner un aperu de la technique de segmentation, je vais prendre un petit exemple assez simple : la technique de
segmentation telle qu'elle est utilise sur les processeurs x86.
Segment
Sur ces processeurs x86, la mmoire virtuelle est bien plus grande que l'espace d'adressage du processeur. Sur un processeur 32
bits, capable d'adresser
bytes de mmoire, cette mmoire virtuelle utilise des adresses de 48 bits. Cette mmoire virtuelle peut
tre dcoupe en
segments de taille variable, pouvant faire jusqu' maximum 4 gibi-octets.
Chaque segment commence donc une adresse bien particulire : cette adresse est un multiple de 4 gibi. En clair, les 32 bits de
poids faible de l'adresse de dbut d'un segment valent tous 0. En clair, tout se passe comme si un segment avait droit un espace
mmoire de
bits rien que pour lui, qu'il peut utiliser loisir : on en revient notre description de dpart de la mmoire
virtuelle.
www.openclassrooms.com
303/467
Adresse virtuelle
Toute donne localise dans le segment peut donc tre localise partir de l'adresse de base du segment : si on connait le
segment, et la position de la donne dans le segment, on peut en dduire l'adresse finale de notre donne. Pour identifier un
segment, seuls les 16 bits de poids forts de l'adresse 48 bits sont utiles. Ceux-ci permettent de prciser le segment dont on parle :
on les appelle le slecteur de segment. A ce descripteur de segment, on rajoute donc un offset, qui permet de dterminer la
position de notre donne dans le segment.
Voici donc quoi ressemble une adresse logique 48 bits :
Slecteur Offset
16 bits
32 bits
Relocation
Chacun de ces segments peut tre plac n'importe o en mmoire physique. C'est le premier avantage de la segmentation : un
segment n'a pas d'adresse bien fixe en mmoire physique et peut tre dplac comme bon nous semble. Mais par contre,
l'organisation des donnes dans un segment n'est pas modifie.
www.openclassrooms.com
304/467
Gnralement, lorsqu'on veut charger un segment en mmoire partir du disque dur, celui-ci sera plac quelque part en mmoire
RAM, une certaine adresse. C'est le systme d'exploitation qui gre le placement des segments dans la mmoire physique.
www.openclassrooms.com
305/467
Il faut prciser que cette table de correspondance est unique pour chaque programme : chaque programme manipule les mmes
adresses virtuelles. Ce qui fait que deux programmes peuvent manipuler des adresses logiques identiques dans leur mmoire
fictive qui leur est attribue. Pourtant, les donnes correspondant ces adresses logiques seront diffrentes et seront stockes
dans des adresses mmoires physiques diffrentes. Pour viter les problmes, on n'a pas le choix : il faut soit utiliser des tables
de correspondances diffrentes pour chaque programme.
MMU
La MMU d'un processeur implmentant la segmentation est donc assez simple. Il s'agit d'un circuit qui prend en entre une
adresse virtuelle et renvoie en sortie une adresse physique. On a vu que pour faire cette traduction adresse virtuelle -> adresse
physique, notre MMU a besoin de savoir faire une addition, ainsi que d'une table de correspondance. Notre MMU contient
donc un additionneur pour faire l'addition entre l'adresse de base et l'Offset. Reste grer le cas de la table de correspondance.
Dans le cas le plus simple, cette table de correspondance est stocke en mmoire RAM. Et donc, pour chaque accs une
adresse virtuelle, notre processeur va non seulement accder l'adresse physique, mais il va aussi devoir effectuer une lecture
en RAM pour rcuprer l'adresse de base du segment.
Ceci dit, devoir accder la RAM chaque accs mmoire est une perte de temps. Pour viter d'avoir accder une table de
correspondance stocke en mmoire, on peut stocker celle-ci dans un Register File. Le slecteur de segment peut donc tre
considr comme un nom de registre qui va prciser dans quel registre est plac l'adresse de base du segment manipuler.
Comme je l'ai dit plus haut, notre processeur utilise des tables de correspondances diffrentes pour chaque programme. Lorsque
notre processeur veut changer de programme, il doit pouvoir charger le contenu de cette table de correspondance dans les
registres. Ce chargement est souvent effectu par le systme d'exploitation.
Mais il y a moyen de faire plus simple. Si on remarque bien, on n'est pas oblig de garder les adresses de base de tous les
segments dans nos registres. Dans la grosse majorit des cas, il est rare que notre processeur doive accder deux segments
simultanment. Et les changements de segments sont rares. Quand on accde un segment, on peut tre sur que notre
processeur va effectuer un grand nombre d'accs dans ce segment avant d'en changer.
Dans ces conditions, indiquer le slecteur dans chaque adresse mmoire serait une catastrophe : imaginez un peu l'impact sur la
quantit de mmoire prise par notre programme ! A la place, il est possible de prciser le slecteur une fois pour toute, via une
instruction spciale. Ce slecteur est alors mmoris dans un registre, le registre de base. Tous les accs mmoire suivants
utiliseront ce slecteur, et n'auront pas le prciser : on vite d'avoir prciser le slecteur chaque fois.
www.openclassrooms.com
306/467
Pour implmenter cette technique, nous avons juste besoin de rajouter un registre pour stocker ce slecteur, et quelques
instructions qui permettent de modifier ce registres : ces instructions serviront changer de slecteur.
On peut encore amliorer la situation en faisant en sorte que notre registre de base ne stocke pas le slecteur du segment, mais
directement son adresse de base. Notre MMU est alors un peu plus rapide.
Dans ce cas, la gestion du contenu de ce registre de base est dlgue au systme d'exploitation ou certains circuits du
processeur.
Protection mmoire
La segmentation nous permet donc de relocaliser nos programmes o l'on veut en mmoire RAM. Mais la segmentation ne
permet pas que cela : elle permet aussi d'interdire certaines manipulations dangereuses sur la mmoire.
Gnralement, plusieurs programmes sont prsents en mme temps dans notre ordinateur. Bien sur, on ne peut, sur une machine
un seul processeur, excuter plusieurs programmes en mme temps. Mais les autres programmes dmarrs par l'utilisateur ou
par le systme d'exploitation, doivent absolument se partager la mmoire RAM, mme s'il ne sexcutent pas. La cohabitation de
plusieurs programmes pose en effet quelques problmes.
Si un programme pouvait modifier les donnes d'un autre programme, on se retrouverait rapidement avec une situation nonprvue par le programmeur. Cela a des consquences qui vont de comiques catastrophiques, et cela fini trs souvent par un joli
plantage.
Comment viter qu'un programme accde une donne d'un autre programme ?
www.openclassrooms.com
307/467
Trs simple : on dfinit pour chaque programme des portions de la mmoire dans laquelle il pourra crire ou lire. Le reste de la
mmoire sera inaccessible en lecture et en criture, part quelques petites parties de la mmoire, partages entre diffrents
programmes. Aucun autre programme ne pourra alors lire ou crire dans cette partie rserve de la mmoire.
Cette gestion des droits sera prise en charge par la MMU, qui empchera aux programmes d'aller crire ou lire des donnes qu'ils
n'ont pas le droit de toucher. Ces droits sont diffrents pour chaque programme et peuvent tre diffrents pour la lecture et
l'criture : on peut ainsi autoriser un programme de lire une partie de la mmoire, mais pas d'y crire, ou autoriser lecture et
criture, ou interdire les deux.
Toute tentative d'accs une partie de la mmoire non-autorise dclenchera ce qu'on appelle une exception matrielle (rappelezvous le chapitre sur les interruptions) qui devra tre traite par une routine du systme d'exploitation. Gnralement, le
programme fautif est sauvagement arrt et supprim de la mmoire, et un message d'erreur est affich l'cran.
La segmentation va ainsi permettre d'implanter des mcanismes permettant de supprimer ces manipulations dangereuses. Bien
sr, on pourrait les implmenter sans avoir utiliser la segmentation, mais ce serait plus difficile. On va voir comment la
segmentation nous permettra de grer facilement cette protection de la mmoire.
Pour effectuer cette vrification, rien de plus simple : il suffit de comparer l'adresse de fin de notre segment avec l'adresse
laquelle on veut accder. Si cette adresse physique est plus grande que l'adresse de fin du segment, a dborde. On peut aussi
viter d'avoir comparer des adresses, et comparer l'Offset avec la longueur du segment. Si l'Offset est plus grand que la taille du
segment, c'est qu'il y a un problme. Dans tous les cas, notre MMU devra incorporer un comparateur.
Pour cela, il y a une seule solution : notre MMU doit se souvenir non seulement de l'adresse du dbut de chaque segment, mais
aussi des adresses de fin. Pour cela, on doit donc avoir une seconde table de correspondance qui associe le slecteur d'un
segment son adresse de fin. Cette table de correspondance peut tre place en mmoire RAM. Mais encore une fois, il vaut
mieux placer celle-ci dans les registres du processeur.
www.openclassrooms.com
308/467
Plus haut, on a vu qu'implanter toute une table de correspondance complte dans le processeur tait un gchis de circuits. Au
lieu de garder toute une table de correspondance dans des registres, on avait vu qu'on pouvait aussi se contenter d'un simple
registre de base. Et bien il est aussi possible d'appliquer la mme technique pour les adresses de fin. Au lieu d'avoir toute une
table de correspondance complte, il vaut mieux rduire celle-ci un simple registre limite. Celui-ci contient soit l'adresse de fin
de notre segment, soit sa longueur.
Droits d'accs
Vient ensuite la gestion des droits d'accs en lecture et en criture. Chaque segment se voit attribuer sa cration un certain
nombre d'autorisations d'accs. Ces droits indiquent si l'on peut : lire ou crire dans un segment, mais aussi considrer que celuici contient des donnes ou des instructions : on peut ainsi excuter le contenu d'un segment ou au contraire interdire cette
excution.
Par exemple, le segment Text peut tre excutable : on peut considrer son contenu comme un programme, qui ne doit pas tre
modifi ou lu comme le serait une donne : on peut le rendre executable only, et interdire de copier son contenu dans les
registres gnraux, ou d'crire dedans. De mme, on peut dcider d'interdire de charger le contenu d'un segment dans le registre
d'instruction ou le registre d'adresse d'instruction pour viter dexcuter des donnes (ce qui rend plus difficile certaines failles
de scurit ou lexcution de certains virus).
De plus chaque segment est attribu un programme en particulier : un programme n'a pas besoin daccder aux donnes
localises dans un segment appartenant un autre programme, alors autant limiter les erreurs potentielles en spcifiant quel
programme appartient un segment.
Lorsqu'on veut excuter une opration interdite sur un segment, il suffira la MMU de dclencher une exception matrielle pour
traiter l'erreur. Pour cela, pas de miracle : il faut retenir les autorisations pour chaque segment. Toutes ces informations sont
rassembles dans ce qu'on appelle un descripteurs de segment.
www.openclassrooms.com
309/467
Allocation dynamique
Attention toutefois : nos segments peuvent avoir des tailles variables ! Certains segments peuvent ainsi grossir ou diminuer au
fil du temps. Cela permet de rserver juste ce qu'il faut de mmoire au lancement d'un programme, et augmenter ou diminuer la
quantit de mmoire rserve celui-ci suivant les besoins.
Si notre programme a besoin de plus de mmoire quand il est en train de sexcuter, le programme peut alors demander de grossir
le segment qu'il est en train d'occuper, grce une interruption logicielle spcialement conue pour. Bien sr, quand un
programme n'a plus besoin d'une portion de mmoire, il peut "d-rserver" celle-ci et la rendre utilisable par notre systme
d'exploitation en diminuant la taille du segment qu'il occupe : on dit que notre programme libre la mmoire.
Quelques problmes
Bien sr, a ne marche pas toujours. Imaginons le cas suivant : deux programmes sont lancs et sont stocks dans deux
segments diffrents. Ces programmes vont alors rgulirement avoir besoin de mmoire et vont prendre de la mmoire quand ils
en ont besoin. Imaginez qu'un programme aie tellement grossit qu'on en arrive la situation suivante :
Imaginez maintenant que le programme N1 aie besoin de plus de mmoire, que se passe-il ?
Je suppose que vous voyez bien qu'il y a un problme : il n'y a pas de mmoire libre la suite du programme N1, et son segment
www.openclassrooms.com
310/467
ne peut pas grossir. Pour le rsoudre, notre systme dexploitation va devoir dplacer au moins un programme dans la mmoire et
rorganiser la faon dont ceux-ci sont rpartis en mmoire afin de faire de la place la suite du premier segment. Ce qui signifie
que au moins un des deux segments sera dplac : a demande de faire beaucoup d'accs mmoire et prend donc pas mal de
temps.
Fragmentation externe
La segmentation pose toutefois un petit problme : de la mmoire est gche un peu btement et est difficilement rcuprable.
Cela vient du fait que nos segments ne sont pas "colls les uns au autres", et qu'il existe des vides de mmoires, qu'on ne peut
pas forcment remplir facilement. Pour expliquer la situation, on va prendre un exemple : on lance un programme, avec 4
segments, qui voient leur taille bouger au fil du temps et sont allous par le systme d'exploitation. Leur taille augmente, et on
aboutit la situation dcrite dans le schma ci-dessus.
Comme on le voit, il reste des vides de mmoires entre les segments. Ce n'est pas un mal : si des segments veulent augmenter
leur taille, il leur reste un peu de marge.
Et maintenant, dans la situation dcrite par le schma du dessus, imaginez qu'on lance un programme qui a besoin de 700 mgaoctets de mmoire pour charger ses segments text et data a la suite. On aura suffisamment de mmoire libre pour les caser : on a
bel et bien 1.1 gibi-octet de libre, mais aucun bloc de mmoire libre ne sera suffisamment gros pour rpondre la demande.
C'est ce qu'on appelle le phnomne de fragmentation externe : on dispose de suffisamment de mmoire libre, mais celle-ci est
disperse dans beaucoup de petits segments vides, qui peuvent difficilement stocker un segment eux tout seuls.
Si aucun bloc de mmoire vide n'est suffisamment gros pour combler une demande d'un programme, notre systme d'exploitation
va devoir regrouper les morceaux de mmoire utiliss par les diffrents programmes et les dplacer pour crer des vides plus
gros. En clair, il va devoir dplacer des segments entiers dans la mmoire, ce qui prend beaucoup de temps inutilement.
Partage de segments
Pour terminer cet aperu de la segmentation, on peut signaler que des morceaux de segments peuvent tre partags. Rien ne
lempche : il suffit de donner deux segments des adresses de base et des longueurs convenablement tudies pour.
www.openclassrooms.com
311/467
Pagination
De nos jours, la segmentation est considre comme obsolte et n'est plus vraiment utilise, malgr ses atouts de taille
concernant la protection mmoire. On utilise la place une autre technique de mmoire virtuelle nomme la pagination.
Que ce soit avec la segmentation ou avec la pagination, notre mmoire virtuelle et notre mmoire physique sont toujours
dcoupes en gros blocs de donnes. La diffrence entre ces deux techniques tient dans la taille des blocs et ce qu'on met
dedans. Avec la segmentation, nos segments avaient des tailles variables et taient souvent utiliss pour stocker quelque chose
de prcis : un programme, des donnes, la pile, etc. Avec la pagination, tout ces blocs ont une taille fixe et ne sont pas organiss
de faon vraiment logique. Ces blocs de mmoire de taille fixe sont appels des pages mmoires.
Autre dtail : la mmoire physique et la mmoire virtuelle sont dcoupes en pages. Ces pages sont toutes de la mme taille, que
ce soit en mmoire physique ou dans la mmoire fictive. Cette taille varie suivant le processeur, le systme d'exploitation, et peut
parfois tre rgle manuellement. Cette taille tourne souvent autour de 4 kibi-octets : c'est la taille la plus couramment employe
par les systme d'exploitation comme Windows ou Linux, voire Mac OS.
Toute page mmoire de la mmoire fictive peut tre place n'importe quelle page mmoire de la mmoire physique. Ainsi, une
page dans la fausse mmoire sera place dans une page de la mmoire physique, qui peut tre n'importe laquelle. Une page en
mmoire physique correspond donc une page dans notre fausse mmoire.
www.openclassrooms.com
312/467
Swapping
Vous aurez remarqus que notre mmoire physique contient moins de pages que la mmoire fictive. Pourtant, rien nempche
d'utiliser plus de pages que notre mmoire contient : si on doit partager cette mmoire physique avec plusieurs programmes, ce
genre de situation peut arriver, aprs tout. Il nous faut donc trouver un moyen de faire en sorte que cela ne pose pas de
problme. La solution consiste utiliser des mmoires de stockage comme mmoire d'appoint : si on besoin de plus de page
mmoires que la mmoire physique n'en contient, alors certaines pages mmoires vont tre dplaces sur le disque dur (ou toute
autre mmoire de stockage) pour faire de la place.
Cela implique que certaines pages mmoires sont localises sur le disque dur. Et l'on ne peut y accder directement : on doit
d'abord les charger dans la mmoire RAM, avant de pouvoir les modifier. Il faut donc les rapatrier en mmoire RAM, ce qui peut
prendre du temps. Lorsque l'on veut traduire l'adresse logique d'une page mmoire qui a t dplace sur le disque dur, notre
MMU ne va pas pouvoir associer l'adresse logique une adresse en mmoire RAM. Elle va alors lever une exception matrielle,
une sorte d'interruption que le processeur excute automatiquement lorsque certains vnement arrivent. Cette exception
matrielle dclenchera lexcution d'une routine (souvent fournie par le systme d'exploitation) qui rapatriera notre page en
mmoire RAM.
Algorithmes
www.openclassrooms.com
313/467
Pinning
Petite remarque : sur la majorit des systmes d'exploitation, il est possible d'interdire le rapatriement de certaines pages
mmoires sur le disque dur. Ces pages restent alors en mmoire RAM durant un temps plus ou moins long. Certaines restent
mme en RAM de faon permanente. Cette possibilit est trs utile pour les programmeurs qui conoivent des systmes
d'exploitation. Par exemple, cela permet de grer les vecteurs d'interruptions assez simplement. Pour donner un exemple, essayez
d'excuter une interruption de gestion de Page Miss alors que la page contenant le code de l'interruption est place sur le disque
dur.
Translation d'adresse
Par contre, le contenu d'une page en mmoire fictive est rigoureusement le mme que le contenu de la page correspondante en
mmoire physique. Deux donnes qui se suivent l'intrieur d'une page de la mmoire fictive se suivront dans une page de la
mmoire relle. Ainsi, on peut parfaitement localiser une donne dans une page par un numro, qui sera le mme que cette page
soit la page en mmoire physique ou la page de la fausse mmoire. Pour numroter une case mmoire l'intrieur d'une page, on
utilise quelques bits de poids fort de l'adresse (physique ou logique).
Une adresse (qu'elle soit logique ou physique) se dcompose donc en deux parties : une partie qui identifie la page dans la
mmoire (fictive ou physique suivant la nature de l'adresse), et un numro permettant d'identifier la donne dans la page.
Traduire notre adresse logique en adresse physique consiste simplement remplacer le numro de la page logique en un numro
de page physique.
www.openclassrooms.com
314/467
Il faut prciser que cette table des pages est unique pour chaque programme : chaque programme manipule les mmes adresses
virtuelles. Ce qui fait que deux programmes peuvent manipuler des adresses logiques identiques dans leur mmoire fictive qui
leur est attribue. Pourtant, les donnes correspondant ces adresses logiques seront diffrentes et seront stockes dans des
adresses mmoires physiques diffrentes. Pour viter les problmes, on n'a pas le choix : il faut soit utiliser des tables des pages
diffrentes pour chaque programme.
Cette table des pages est souvent stocke dans la mmoire RAM, un endroit bien prcis, connu du processeur. Accder la
mmoire ncessite donc daccder d'abord la table des pages en mmoire, puis de calculer l'adresse de notre donne, et enfin
daccder la donne voulue.
TLB
Pour viter d'avoir lire la table des pages en mmoire RAM chaque accs mmoire, les concepteurs de processeurs ont
dcids d'implanter une petite mmoire cache dans le processeur, qui stocke une partie de la table des pages : gnralement, on
conserve dans ce cache le morceau de la table des pages qui sert traduire les dernires adresses ayant t accdes. Cette
mmoire cache s'appelle le Translation Lookaside Buffer, aussi appel TLB.
Ainsi, notre processeur va vrifier si le morceau de la table des pages stock dans ce TLB permet de calculer l'adresse physique
laquelle accder. Si c'est le cas, le processeur n'a pas accder la mmoire RAM et va lire directement la donne depuis ce
TLB. Mais dans le cas contraire, l'accs la RAM est invitable.
Cet accs est gr de deux faon :
soit le processeur gre tout seul la situation ;
soit il dlgue le traitement de la situation un programme particulier ou au systme dexploitation.
Dans le premier cas, le processeur est conu pour lire lui mme le contenu de la page des tables en mmoire et y trouver la bonne
correspondance dans celle-ci. Une fois trouve, le processeur va alors copier celle-ci dans le TLB et recalculer l'adresse
physique. Dans le second cas, si l'adresse cherche n'est pas dans le TLB, le processeur va lever une exception matrielle qui
excutera une routine d'interruption charge de grer la situation.
www.openclassrooms.com
315/467
Allocation dynamique
Comme avec la segmentation, nos programmes peuvent demander au systme d'exploitation l'accs un peu plus de mmoire de
temps autre. Si jamais un programme a besoin de plus de mmoire, notre systme d'exploitation va lui rserver une page
mmoire supplmentaire, qu'il pourra manipuler loisir. Bien sr, si notre programme n'a plus besoin de la page qui lui a t
confie, il peut la librer : elle sera alors disponible pour n'importe quel autre programme qui en aurait besoin.
Il faut remarquer que le problme mentionn avec des segments conscutifs, "qui se touchent", n'apparait pas avec la
pagination. On peut fragmenter notre programme dans des pages disperses dans la mmoire sans aucun problme, ce qui fait
qu'on n'est pas oblig de dplacer des pages mmoires pour compacter la mmoire libre. Cela fait qu'avec la pagination, il n'y a
pas vraiment de fragmentation externe, vu qu'on peut fragmenter notre programme dans des pages diffrentes pour utiliser au
mieux la mmoire libre disponible au lieu de tout devoir caser dans un seul gros segment.
Mais cela nempche pas certaines pertes de mmoire utilisable. En effet, quand un programme demande un surplus de mmoire,
le programme qui gre la gestion de la mmoire (c'est souvent le systme d'exploitation), va rserver une page mmoire complte :
il ne peut pas faire autrement, mme si notre programme n'a besoin que de quelques octets. Si un programme a besoin d'une
quantit plus petite que ce que la page lui offre, une partie de notre page sera rellement utilise pour stocker des donnes. Par
exemple, un programme voulant rserver 2 kibi-octets se verra attribuer le double (en supposant une page de 4 kibi-octets) : de
l'espace mmoire est perdu.
Et la mme chose arrive lorsque notre programme a besoin d'une quantit de mmoire qui n'est pas multiple de la taille d'une
page. Si un programme a besoin de 5 kibi-octets, il se verra attribuer deux pages de 4 kibi-octets : 3 kibi-octets ne serviront rien.
Ce genre de pertes du au fait que la mmoire est alloue par pages s'appelle la fragmentation interne.
Protection mmoire
La pagination permet elle aussi de protger la mmoire et son contenu de manipulations potentiellement dangereuses sur nos
pages ou sur leur contenu. Avec la pagination, on peut parfaitement autoriser ou interdire la lecture ou l'criture, voir lexcution
du contenu d'une page. Pour cela, il suffit de rajouter des bits dans la table des pages : chaque numro de page
virtuelle/physique se verra attribuer des droits, reprsents par des bits d'une certaine valeur. Suivant la valeur de ces bits, la
page sera accessible ou non, en lecture, en criture, excutable, etc.
De plus chaque page est attribue un programme en particulier : un programme n'a pas besoin daccder aux donnes
localises dans une page rserve par un autre programme. Autant limiter les erreurs potentielles en spcifiant quel programme
appartient une page. Pour cela, des bits permettant didentifier le programme possesseur de la page sont ajout en plus des
adresses et des bits de gestion des droits d'accs en lecture/criture dans la table des pages.
www.openclassrooms.com
316/467
Accs au cache
Notre mmoire cache est, comme toutes les autres mmoires, divises en cases mmoires, qu'on peut modifier individuellement.
Dans un cache, ces cases mmoires sont regroupes en blocs de taille fixe qu'on appelle des lignes de cache. Gnralement, ces
blocs ont une taille assez grosse compar aux cases mmoires : cela peut varier de 64 256 octets.
Sur la majorit des caches actuels, on est oblig de transfrer des donne entre le cache et la mmoire, ligne de cache par ligne de
cache. Il est impossible de charger seulement un morceau d'une ligne de cache depuis la mmoire. Les transferts se font lignes de
caches par lignes de cache. Par contre, chaque case mmoire d'une ligne de cache peut tre accde individuellement par le
processeur, que ce soit en lecture ou en criture. En clair, on peut modifier une case mmoire l'intrieur d'une ligne sans
problme. Le regroupement en lignes de cache ne compte que pour les transferts entre mmoire RAM et cache, pas pour les
transferts entre cache et registres.
Accs au cache
Comme je l'ai dit et rpt plus haut, une case mmoire du cache ne possde pas d'adresse. Aussi bizarre que cela puisse paraitre,
nos mmoires caches ne sont pas les seules mmoires ne pas pouvoir tre adressables, mais passons. Cela a une consquence
: notre processeur ne va pas accder directement la mmoire cache. Il peut juste demander une lecture ou criture dans la RAM,
qui aboutira ou non une lecture/criture partir du cache.
Notre processeur va donc accder la mmoire RAM et cet accs mmoire sera intercept par le cache, qui vrifiera si la donne
demande est prsente ou non dans le cache. Tout se passe comme si le cache n'existait pas pour le processeur. Et vu que notre
processeur ne peut pas grer lui-mme le cache, on se doute bien que notre cache se "gre tout seul" : il possde un ou
plusieurs circuits lectroniques conus pour grer le cache automatiquement.
Les donnes prsentes dans le cache sont t (pr)charges depuis la mmoire : toute donne prsente dans le cache est la
copie d'une donne en mmoire RAM.
www.openclassrooms.com
317/467
On a donc une correspondance entre une ligne de cache et une adresse mmoire, mmorise par les circuits lectroniques qui
s'occupent de la gestion de la mmoire cache.
...
...
Lorsqu'un processeur cherche accder la mmoire (que ce soit pour une lecture ou une criture), celui-ci va envoyer l'adresse
mmoire laquelle il veut accder vers un circuit qui permet d'crire ou de lire en mmoire RAM. Cette adresse va d'abord tre
intercepte par les circuits de gestion du cache, qui vont vrifier si cette adresse mmoire correspond une ligne de cache.
Si c'est le cas, la donne voulue est prsente dans le cache : on a un cache hit et on accde la donne depuis le cache.
Sinon, le donne n'est pas dans le cache : on a un cache miss et on est oblig daccder la RAM ou de recopier notre donne
de la RAM dans le cache.
Le nombre de cache miss par nombre d'accs mmoire est appel le hit ratio . Plus celui-ci est lev, plus on accde au cache la
place de la RAM et plus le cache est efficace. Ce hit ratio varie beaucoup suivant le processeur, l'organisation des caches, ou le
programme en cours dexcution : de nombreux paramtres peuvent influencer celui-ci.
www.openclassrooms.com
318/467
cache, et on reoit la donne voulue assez rapidement. Mais les choses changent pour l'criture. L'criture dans un cache fait
face diverses situations, qu'il faut grer au mieux. Pour grer certaines situations embarrassantes, deux stratgies d'critures
sont couramment implmentes dans les circuits de gestion du cache.
Ces deux stratgies sont
le Write Back ;
et le Write Throught.
Write back
Si la donne qu'on veut mettre jour est prsente dans le cache, on crit dans celui-ci sans crire dans la mmoire RAM : on
attend que la donne soit efface du cache pour l'enregistrer en mmoire. Cela vite de nombreuses critures mmoires inutiles.
Mais peut poser des problmes dans les architectures multiprocesseurs ! Si deux processeurs doivent manipuler la mme
donne, des cas litigieux peuvent survenir. Imaginons que deux processeurs manipulent une donne : ceux-ci ont une copie de la
donne dans leur cache qu'ils manipulent et modifient loisir. Si un processeur modifie cette copie de la donne et que celle-ci
est enregistre dans son cache ou en mmoire, elle sera alors diffrente de celle prsente dans le cache de l'autre processeur. Ce
qui fait qu'un processeur peut continuer manipuler une donne prime qui vient d'tre mise jour par l'autre processeur. Hors,
un processeur doit toujours viter de se retrouver avec une donne prime et doit toujours avoir la valeur correcte dans ses
caches : cela s'appelle la cohrence des caches.
La seule solution pour arriver un rsultat correct est d'utiliser des mcanismes permettant de faire en sorte que ce genre de cas
n'arrivent pas. Ces mcanismes se chargent de dterminer quelles sont les donnes primes, et ensuite les remplacer par des
donnes valides. Ces mcanismes se chargent de faire mettre jour les donnes dans les diffrents caches, en copiant les
donnes mises jour du cache d'un processeur vers un autre, en passant ventuellement en se servant de la mmoire comme
intermdiaire. Les caches Write Back rendent plus difficile l'implantation de ces mcanismes de gestion de la cohrence des
caches. C'est pourquoi il existe un autre type de cache : le cache Write Trought ; mieux adapt ce genre de situations.
Write Through
Toute donne crite dans le cache est crite en mme temps dans la mmoire RAM. Ces caches sont appels No Write Allocate :
si on souhaite crire en mmoire une donne qui n'a pas t prcharge dans le cache, on crit en mmoire RAM, mais pas dans
le cache. Leur utilit ? Les ordinateurs avec plusieurs processeurs, comme dit plus haut. Mais cela a fatalement un cout en terme
de performance.
Ces caches ont tendance commettre beaucoup d'critures dans la mmoire RAM, ce qui peut saturer le bus reliant le processeur
la mmoire. De plus, on ne peut crire dans ces caches lorsqu'une criture en RAM a lieu en mme temps : cela forcerait
effectuer deux critures simultanes, en comptant celle impose par l'criture dans le cache. Dans ces conditions, on doit
attendre que la mmoire RAM soit libre pour pouvoir crire dans notre cache.
Pour viter ces temps d'attentes, certains processeurs intgrent un Write Buffer : une espce de mmoire tampon dans laquelle
on place temporairement les donnes transfrer du cache vers la RAM en attendant que la RAM soit libre. Ces donnes
crire sont places dans l'ordre d'arriv dans ce Write Buffer et sont automatiquement crites en mmoire RAM quand celle-ci est
libre. On n'a pas se soucier du fait que la mmoire soit occupe vu qu'on crit les donnes crire non pas en RAM, mais dans
ce Write Buffer : on peut continuer crire dedans tant que celui-ci n'est pas plein, vitant les temps d'attente dus la RAM.
www.openclassrooms.com
319/467
Par souci d'efficacit, les caches Write Trough implmentent parfois des techniques de Write Combining dans le Write Buffer. Le
Write Combining est une technique assez simple comprendre : si jamais deux critures sont en attente dans le Write Buffer,
seule la plus rcente est prise en compte, et l'ancienne est abandonne.
Comme a, au lieu d'crire une donne avant de la remplacer immdiatement aprs par une autre, autant crire directement la
donne la plus jour et ne pas crire l'ancienne inutilement. Cela fait un peu de place dans le Write Buffer, et lui permet
d'accumuler plus d'criture avant de devoir bloquer le cache. Et oui, une fois le Write Buffer plein, le cache n'est plus accessible
en criture : il n'y a plus de place pour une criture supplmentaire. On doit donc bloquer le cache, histoire d'attendre qu'il y aie
un peu de place dans le Write Buffer pour accueillir une nouvelle criture.
La question peut paraitre compltement stupide, mais pour expliquer cela correctement, il faut prendre conscience de quelques
proprits que beaucoup de programmes ont tendance respecter.
Localit temporelle
Un programme a tendance rutiliser les instructions et donnes qui ont ts accdes dans le pass : c'est la localit
temporelle. Bien videment, cela dpend du programme, de la faon dont celui-ci est programm et accde ses donnes et du
traitement qu'il fait, mais c'est souvent vrai en gnral.
Lorsqu'on excute une instruction ou qu'on accde donne pour le premire fois, celle-ci (linstruction ou la donne) n'a pas
www.openclassrooms.com
320/467
encore t charge dans le cache. Le cache miss est invitable : ce genre de cache miss s'appelle un Cold Miss. Mais on peut
tre presque sr que cette donne sera rutilise plus tard, et on pourra alors utiliser la version de la donne charge dans le
cache au lieu d'accder en mmoire. Il suffit alors de garder cette donne dans le cache : d'aprs le principe de localit temporelle,
elle sera surement rutilise plus tard et sera alors disponibles dans le cache.
videment, cette technique des limites. Si on doit accder beaucoup de donnes, le cache fini par tre trop petit pour
conserver les anciennes donnes : de nouvelles donnes sont ajouts dans ce cache au fil du temps, et le cache doit bien finir
par faire de la place en supprimant les anciennes donnes (qui ont peu de chances d'tre rutilises). Ces anciennes donnes
prsentes en cache, qui peuvent tre accdes plus tard, devront cder la place d'autres. Elles vont quitter le cache et tout
prochain accs cette donne mnera un cache miss. C'est ce qu'on appelle un Capacity Cache Miss.
Les seules solutions pour viter cela consistent augmenter la taille du cache, faire en sorte que notre programme prenne moins
de mmoire cache et amliorer la localit du programme excut. Sachez qu'un programmeur peut parfaitement tenir compte de la
localit spatiale lorsqu'il programme pour gagner normment en performance. Pour donner un exemple, les boucles sont des
structures de contrle qui respectent le principe de localit temporelle : les instructions d'une boucle seront r-excutes
plusieurs fois.
Localit spatiale
Autre proprit : un programme qui s'excute sur un processeur tendance utiliser des instructions et des donnes qui ont des
adresses mmoires trs proches, c'est la localit spatiale.
Pour donner un exemple, les instructions d'un programme sont places en mmoire dans lordre dans lequel on les excuts : la
prochaine instruction excuter est souvent place juste aprs l'instruction en cours (sauf avec les branchements). La localit
spatiale est donc respecte tant qu'on a pas de branchements qui renvoient assez loin dans la mmoire (appels de sousprogrammes). De plus, on ne charge pas des donnes individuelles dans notre cache, mais des lignes de cache compltes. On
charge donc la donne voulue, mais aussi des donnes/instructions situe dans des adresses mmoires proches : cela permet de
gros gains lorsque le principe de localit spatiale est respect.
L'influence du programmeur
De nos jours, le temps que passe le processeur attendre la mmoire devient de plus en plus un problme au fil du temps, et
grer correctement le cache est une ncessit, particulirement sur les processeurs multi-cores. Il faut dire que la diffrence de
vitesse entre processeur et mmoire est tellement importante que les Cache Miss sont trs lents compares aux instructions
machines usuellement employes : alors qu'une simple addition ou multiplication va prendre entre 1 et 5 cycles d'horloge, un
cache miss fera plus dans les 400-1000 cycles d'horloge. Tout ce temps sera du temps de perdu que notre processeur tentera de
remplir avec des instructions ayant leurs donnes disponibles (dans un registre voire dans le cache si celui-ci est non-bloquant),
mais cela a une efficacit limite. Autant dire que supprimer des Caches Miss sera beaucoup plus efficace que virer des
instructions de calcul normales.
Bien videment, optimiser au maximum la conception des caches et de ses circuits ddis amliorera lgrement la situation, mais
n'en attendez pas des miracles. Il faut dire qu'il n'y a pas vraiment de solutions anti-Cache Miss qui soit facile implmenter. Par
exemple, changer la taille du cache pour contenir plus de donnes aura un effet dsastreux sur son temps d'accs qui peut se
traduire par une baisse de performance. Par exemple, les processeurs Nehalem d'Intel ont vus leurs performances dans les jeux
vidos baisser de 2 3 % malgr de nombreuses amliorations architecturales trs volues : la latence du cache L1 avait
augmente de 2 cycles d'horloge, rduisant nant de nombreux efforts d'optimisations architecturales.
Non, une bonne utilisation du cache (ainsi que de la mmoire virtuelle) repose en ralit sur le programmeur qui doit prendre en
compte les principes de localits vus plus haut ds la conception de ses programmes. La faon dont est conue un programme
joue normment sur sa localit spatiale et temporelle. Un programmeur peut parfaitement tenir compte du cache lorsqu'il
programme, et ce aussi bien au niveau :
de son algorithme : on peut citer l'existence des algorithmes cache oblivious ;
du choix de ses structures de donnes : un tableau est une structure de donne respectant le principe de localit spatiale,
tandis qu'une liste chaine ou un arbre n'en sont pas (bien qu'on puisse les implmenter de faon limiter la casse);
ou de son code source : par exemple, le sens de parcourt d'un tableau multidimensionnel peut faire une grosse diffrence.
Cela permet des gains trs intressants pouvant se mesurer avec des nombres deux ou trois chiffres. Je vous recommande, si
vous tes programmeur, de vous renseigner le plus possible sur les optimisations de code ou algorithmiques qui concernent le
cache : il vous suffira de chercher sur Google. Quoiqu'il en soit, il est quasiment impossible de prtendre concevoir des
programmes optimiss sans tenir compte de la hirarchie mmoire. Et cette contrainte va se faire de plus en plus forte quand on
devra passer aux architectures multicurs. Il y a une citation qui rsume bien cela, prononce par un certain Terje Mathisen. Si
vous ne le connaissez pas, cet homme est un vieux programmeur (du temps durant lequel on codait encore en assembleur), grand
gourou de loptimisation, qui a notamment travaill sur le moteur de Quake 3 Arena.
www.openclassrooms.com
321/467
Citation : Terje Mathisen
Quand notre cache reoit une demande de lecture ou criture, il va comparer le Tag de chaque ligne avec les bits de poids fort de
l'adresse lire ou crire. Si une ligne contient ce Tag , alors c'est que cette ligne correspond l'adresse demande et un cache hit
lieu. Mais si aucune ligne de cache n'a ce Tag , alors c'est un cache miss.
Mine de rien, cela demande de comparer le tag avec un nombre de ligne de cache qui peut tre consquent, et qui varie suivant
l'organisation du cache : certains caches n'ont pas besoin d'effectuer cette vrification du Tag pour toutes les lignes de caches,
comme on le verra tout l'heure.
Sector Caches
Sur certains caches assez anciens, on pouvait transfrer nos lignes de caches morceaux par morceaux. Ces caches avaient des
lignes de cache divises en sous-secteurs, ces sous-secteurs tant des morceaux de ligne de cache qu'on pouvait charger
indpendamment les uns des autres. On pouvait ainsi charger seulement un morceau d'une ligne de cache depuis la mmoire et
ne pas charger les autres secteurs.
Sur ces caches, chaque secteur avait ses propres bits de contrle. Mais le Tag tait commun tous les secteurs, ce qui fait que
les morceaux de mmoire copis dans les secteurs appartenant une mme ligne de cache appartenaient au bloc de mmoire
RAM correspondant au Tag . Ils se suivaient en mmoire, quoi.
Virtually Tagged
www.openclassrooms.com
322/467
Sur certains caches, la correspondance se fait entre une adresse virtuelle et une ligne de cache. Notre cache peut donc tre plac
avant la MMU dans notre processeur.
Ce genre de cache n'a donc pas besoin d'attendre que la MMU aie finie de traduire l'adresse logique en adresse physique pour
vrifier si la donne laquelle accder est prsente ou non dans le cache : ces caches sont plus rapides.
Mais les problmes arrivent facilement quand on utilise plusieurs programmes avec ce genre de cache. En effet, plusieurs
programmes peuvent utiliser la mme adresse logique : pour eux, toute la mmoire est strictement libre, sans aucun programme
qui viendrait prendre des adresses. Ils sont donc autoriss utiliser toutes les adresses logiques depuis l'adresse 0, et rien ne dit
qu'un autre programme n'aura pas choisit la mme adresse logique pour autre chose. Cela ne pose pas problme en temps normal,
vu que la mme adresse logique peut correspondre plusieurs adresses physiques suivant le programme (on dit merci la
MMU).
Mais avec notre cache, comment savoir quel programme appartient la ligne de cache qui correspond une adresse
virtuelle ?
On n'a pas vraiment le choix : soit on rajoute dans notre ligne de cache des bits de contrle qui permettront d'identifier le
programme qui possde la ligne de cache ; soit on vide totalement le cache en changeant de programme.
Physically Tagged
Sur d'autres caches, c'est l'adresse physique qui est utilise pour faire la correspondance entre une ligne de cache et une adresse
mmoire. Notre cache doit donc tre plac aprs la MMU dans notre processeur.
www.openclassrooms.com
323/467
Ce genre de caches est plus lent en terme de temps d'accs : il faut attendre que la MMU traduise l'adresse logique en adresse
physique pour qu'on puisse enfin demander au cache si la donne laquelle accder est dans le cache ou pas. Par contre, on n'a
strictement rien faire pour partager le cache entre plusieurs programmes.
www.openclassrooms.com
324/467
L'accs au cache est trs rapide vu qu'il suffit de vrifier une seule ligne de cache : celle qui est prdfinie pour l'adresse
laquelle on souhaite accder. Si le Tag est le bon, c'est un cache hit, sinon, c'est un cache miss.
Les circuits chargs de grer un cache direct mapped sont particulirement simples : pas besoin de faire une recherche dans tout
le cache lors de laccs un lment (un seul circuit comparateur peut suffire), pas besoin de beaucoup "rflchir" pour savoir
o charger une donne dans le cache, etc. En consquence, ces caches ont un temps d'accs trs faible, et chauffent trs peu.
Conflit miss
Juste une remarque : le cache est plus petit que la mmoire, ce qui fait que certaines adresses mmoires devront se partager la
mme ligne de cache.
Si on a besoin de manipuler frquemment des donnes qui se partagent la mme ligne de cache, chaque accs une donne
supprimera l'autre du cache. Et tout accs l'ancienne donne, qui a quitt le cache, se soldera par un cache miss. Ce genre de
cache miss du au fait que deux adresses mmoires ne peuvent utiliser que la mme ligne de cache s'appelle un conflit miss.
Cela fait que le hit ratio de ce genre de cache est quelque peu...comique ! Par contre, les circuits de gestion de ce genre de cache
ncessitent trs peu de transistors et l'accs aux donnes prsentes dans le cache est trs rapide.
Adresse
Gnralement, les concepteurs de mmoire cache s'arrangent pour que des adresses conscutives en mmoire RAM occupent
des lignes de cache conscutives. Cela permet de simplifier fortement les circuits de gestion du cache, sans compter que c'est
plus logique.
Sur les caches direct mapped , chacune de ces lignes de cache possde un index, un nombre entier positif ou nul qui permet de
l'identifier et la slectionner parmi toutes les autres lignes. Il ne s'agit pas d'une adresse ! Une ligne de cache n'a pas d'adresse et
n'est pas adressable via le bus d'adresse : l'index qui va identifier cette ligne reste confine dans les circuits qui s'occupent de
grer notre mmoire cache sans jamais quitter notre processeur. Notre cache n'est pas non plus mapp dans la mmoire RAM,
pas plus qu'il n'existe un espace d'adressage spar pour le cache : aucune adresse ne permet de slectionner une ligne de cache,
c'est le processeur qui gre celui-ci en interne et utilise une sorte d' "adresse interne" pour slectionner nos lignes de cache:
l'index.
Avec cette implmentation, notre adresse mmoire peut donc permettre de spcifier l'index de notre donne. Le Tag correspond
www.openclassrooms.com
325/467
aux bits de poids forts de l'adresse mmoire correspondant notre ligne de cache. Le reste des bits de l'adresse reprsente l'index
de notre ligne, et la position de la donne dans la ligne.
Implmentation
Maintenant, passons aux circuits de notre cache Direct Mapped . Celui-ci est conu d'une faon assez simple : il suffit d'utiliser
une RAM, un comparateur, et un paquet de multiplexeurs. La mmoire RAM servira stocker la fois les lignes de caches, mais
aussi les Tags qui leur correspondent. Un byte de cette mmoire contiendra ainsi une ligne de cache, avec son Tag . Chaque ligne
tant slectionne par son Index, on devine aisment que l'Index de notre ligne de cache sera envoye sur le bus d'adresse de
notre mmoire RAM pour slectionner celle-ci.
Ensuite, il suffira de comparer le Tag de la ligne de cache slectionne par l'Index, et le comparer avec le Tag de l'adresse de la
donne lire ou crire. On saura alors si on doit faire face un Cache Miss ou si on a un joli petit Cache Hit. Ensuite, on devra
slectionner la bonne donne dans notre ligne de cache avec un ensemble de multiplexeurs. Et voil, nous obtenons un beau
cache Direct Mapped .
www.openclassrooms.com
326/467
On pourrait ventuellement placer les Tags et les lignes de caches dans deux mmoires RAM part, mais c'est un dtail.
Adresse
En clair, l'adresse mmoire ne peut pas servir identifier une ligne en particulier : le format de l'adresse ne contient pas de quoi
spcifier l'Index. Elle est donc dcoupe en un Tag , et de quoi identifier la position de la donne dans la ligne de cache
correspondante.
Ces caches ont un hit ratio trs lev, vu qu'il y a pas de possibilit d'avoir le moindre conflit miss : deux donnes diffrentes ne
peuvent pas avoir l'obligation de se partager la mme ligne, vu qu'on peut placer nos donnes n'importe o.
Implmentation
Concevoir des caches totalement associatif est beaucoup plus complexe que concevoir des caches Direct Mapped . Vool quoi
ressemble d'organisation gnrale d'un cache Fully Associative :
www.openclassrooms.com
327/467
D'abord, on doit dterminer si on a un Cache Miss ou un Cache Hit. Vu que notre donne peut tre place dans n'importe quelle
ligne de cache, il faut vrifier les Tags de toutes les lignes de cache. Chaque Tag est donc reli un comparateur, qui vrifiera
l'galit entre le Tag de la ligne de cache, et le Tag extrait de l'adresse accde en lecture ou en criture. Si un seul de ces
comparateur renvoie "Vrai" (en clair, 1), alors on a un Cache Hit. Sinon, c'est un Cache Miss. Le signal qui indique l'apparition
d'un Cache Hit est donc un gros ET logique entre toutes les sorties des comparateurs.
Toutes nos lignes de caches sont relies un bus interne qui permettra de relier nos lignes de cache lextrieur. Si les deux Tags
sont identiques, cela signifie que la ligne de cache associe est la bonne, et que c'est celle-ci qu'on doit lire ou crire. Il faut donc
la connecter ce bus, et dconnecter les autres. Pour cela, on relie donc la sortie du comparateur des transistors chargs de
connecter ou de connecter les lignes de cache sur notre bus.
Ensuite, il ne reste plus qu' slectionner la portion de la ligne de cache qui nous intresse, grce un paquet de multiplexeurs,
comme pour les caches Direct Mapped .
Comme vous le voyez, ce genre de cache a besoin d'un grand nombre de comparateurs : un par ligne de cache, compar aux
caches Direct Mapped , qui n'ont besoin que d'un seul comparateur.
. a ncessite normment de transistors et a chauffe !
www.openclassrooms.com
328/467
En clair, il s'agit d'un regroupement de plusieurs caches Direct Mapped , avec comme particularit le fait qu'on peut choisir dans
quel cache stocker notre donne.
Adresse
L'adresse d'une case mmoire va devoir tre dcoupe en trois partie : un Tag , un Index, et un Offset. Rien ne change compar
aux caches Direct Mapped .
Implmentation
Comme je l'ai dit, un cache Set Associative peut tre vu comme un regroupement de plusieurs caches Direct Mapped . Et bien
cela se voit dans la faon dont ces caches sont conus : leur organisation est un vrai mlange de Direct Mapped et de Fully
Associative. Jugez par vous-mme !
www.openclassrooms.com
329/467
Comme vous pouvez le voir, l'organisation est identique celle d'un cache Fully Associative, part que chaque ensemble TagLigne de cache est remplac par une mmoire RAM qui en contient plusieurs. Et pour slectionner une donne dans cette RAM,
il suffit d'envoyer son Index dans le bus d'adresse de toutes ces mmoires RAM, et de rcuprer les couples Tag-Ligne de cache.
On vrifie alors les Tags de ces couples, et si jamais il y a correspondance avec le Tag de l'adresse lire ou crire, on connecte la
ligne de cache (celle reue en sortie de notre mmoire RAM) sur le bus reli au MUX. Et ensuite, le MUX slectionne la donne
voulue dans notre ligne.
Way Prediction
Les caches Set Associative sont donc une sorte de compromis entre Direct Mapped et Fully Associative. Ils ont un Hit Ratio et
un temps d'accs intermdiaire. La diffrence de temps d'accs entre un cache Set Associative et un cache Direct Mapped vient
du fait qu'on doit slectionner l'ensemble qui contient la bonne donne. On doit rajouter un multiplexeur pour cela. Ce qui fait
que l'on prend un peu plus de temps compar un cache Direct Mapped.
Pour rduire ce temps d'accs et le rendre le plus similaire possible au temps d'accs qu'on pourrait avoir avec un cache Direct
Mapped, certains chercheurs ont eu une ide lumineuse : la Way Prediction. Cette technique consiste faire des paris sur
l'ensemble dans lequel on va aller lire une donne. Au lieu d'attendre que les comparaisons des Tags soient effectues, le
processeur va slectionner automatiquement un ensemble et va configurer l'avance les multiplexeurs. Le processeur va donc
parier sur un ensemble en esprant que ce soit le bon, et en esprant que l'opration finisse par un Cache Hit. Si le processeur ne
se trompe pas, le processeur va accder la donne de faon prcoce, et commencer l'utiliser un deux cycles plus tt que
prvu. S'il se trompe, le processeur devra annuler la lecture effectue en avance, et recommencer en allant chercher la donne
dans le bon ensemble.
Cette technique peut aussi avoir un autre avantage : elle peut tre adapte de faon diminuer la consommation nergtique du
processeur. Pour cela, il suffit de mettre en veille tous les caches Direct Mapped sur lesquels le processeur n'a pas pari. C'est
plus efficace que d'aller lire plusieurs donnes dans des mmoires diffrentes, et n'en garder qu'une.
Reste implmenter cette technique. Pour cela, rien de plus simple. Dj, prdire quelle sera l'ensemble est d'une simplicit
dconcertante. En vertu du principe de localit, on peut dcemment penser que si on accd un ensemble, alors les accs
futurs auront lieu dans le mme ensemble. Il nous suffit donc de retenir l'ensemble le plus rcemment accd, et le tour est jou.
Pour cela, il suffit de placer un registre sur l'entre de commande du multiplexeur qui choisit l'ensemble lire. Pour vrifier que la
prdiction est correcte, il suffit de comparer le contenu de ce registre au rsultat renvoy aprs vrification des Tags.
www.openclassrooms.com
330/467
Le choix des donnes charger dans la mmoire est gr automatiquement par le cache et des circuits ddis. Gnralement, une
donne est charge dans le cache quand on doit lire ou crire dedans. Mais sur certaines processeurs, le cache est reli un
circuit qui va se charger de prcharger l'avance certaines donnes dont il prdit qu'elles seront utiles dans le futur. Ce circuit
s'appelle le prefetcher, et il possde des algorithmes parfois assez sophistiqus capable de dduire quelles donnes seront
accdes dans un futur proche.
Comment choisir ?
videmment, le choix des donnes rapatrier en mmoire RAM ne peut pas tre fait n'importe comment : rapatrier une donne qui
sera surement utilise sous peu est inutile, et il vaudrait mieux supprimer des donnes qui ne serviront plus ou dans alors dans
longtemps. Il existe diffrents algorithmes spcialement ddi rsoudre ce problme efficacement, directement cbls dans les
units de gestion du cache. Certains sont vraiment trs complexes, aussi je vais vous prsenter quelques algorithmes
particulirement simples.
Implmentation
Mais avant de voir ces algorithme, il faut absolument que je vous parle d'une chose trs importante. Quelque soit l'algorithme en
question, il va obligatoirement faire une chose : choisir une ligne de cache parmi toute les autres. Et une fois cette ligne de cache
choisie, il va devoir recopier son contenu dans la RAM. Notre algorithme va donc devoir identifier et slectionner cette ligne de
cache parmi toute les autres. Difficile de faire ceci efficacement en utilisant nos Tags. Pour rsoudre ce problme, notre circuit de
slection des lignes de cache remplacer va pouvoir adresser chaque ligne de cache ! Et oui, vous avez bien vu : chaque ligne
de cache sera numrote par une adresse, interne au cache. Ainsi, notre algorithme de suppression des lignes de cache a juste
former l'adresse de la ligne de cache remplacer.
Alatoire
Premier algorithme : la donne efface du cache est choisie au hasard ! Si l'on dispose d'un cache avec N lignes, cet algorithme
s'implmente avec un circuit qui fournit un nombre alatoire, compris entre 0 et N. Bien sr, cette gnration de nombre alatoire
n'a pas besoin d'tre des plus parfaite : le nombre tir n'a pas besoin d'tre obtenu de faon totalement alatoire, et une simple
approximation du hasard suffit largement.
A premire vue, cet algorithme ne paye pas de mine. Mais dans les faits, cet algorithme se dbrouille relativement bien, et donne
des rsultats assez honorables. D'ailleurs, certains processeurs ARM, utiliss dans lembarqu, utilisent cet algorithme, qui n'est
clairement pas parmi les pires. Cet algorithme a aussi un avantage : son implmentation utilise trs peu de portes logiques. Juste
un vulgaire compteur ou un registre coupl un circuit combinatoire trs simple. Le tout prend moins d'une centaine de
transistors. C'est trs peu compar aux autres algorithmes, qui prennent beaucoup plus de circuits. Autant dire qu'ils ont intrt
tre efficaces.
Clock Counter
Reste l'implmenter cet algorithme. Pour cela, on peut utiliser une premire solution : un simple compteur qui s'incrmente
chaque cycle d'horloge. Gnralement, les Caches Miss n'ont pas lieu chaque cycle d'horloge, et sont souvent spars par un
nombre assez important et irrgulier de cycles d'horloge. Dans ces conditions, cette technique donne un bon rsultat.
www.openclassrooms.com
331/467
Comme vous le savez, si le contenu de ce registre est dcal d'un cran vers la gauche, le bit de poids fort de ce registre est alors
mit soit 1, soit zro. Sur les registres dcalages normaux, ce bit de poids fort est rempli par une valeur par dfaut aprs
chaque dcalage: que ce soit un 0 ou un 1, c'est toujours le mme bit qui rentre par la gauche.
Mais dans un Linear Shift Register, le bit faire rentrer gauche change chaque fois. Ce bit est calcul par un petit circuit
combinatoire, qui est coupl au registre dcalage. Ce circuit combinatoire va prendre en entre le contenu du registre
dcalage, et va en dduire le bit faire rentrer dedans. Ce circuit va donc utiliser tout ou partie des bits du registre dcalage,
faire quelques oprations simples dessus, et en dduire quel bit faire rentrer gauche (ou droite).
Le contenu du registre dcalage est donc notre nombre alatoire, qu'on utilise comme adresse de ligne de cache. Suivant la
complexit du circuit combinatoire, on peut obtenir des rsultats plus ou moins proches de l'alatoire. Le circuit le plus simple
consiste utiliser quelques portes XOR sur certains bits du registre dcalage.
Mais on peut aussi faire plus compliqu pour obtenir un bon rsultat.
www.openclassrooms.com
332/467
avant les autres. Cet algorithme particulirement stupide a une efficacit qui est souvent infrieure l'algorithme alatoire. Dans
la majorit des cas, il y a peu de diffrences, mais l'avantage est tout de mme du cot de l'algorithme alatoire. En tout cas,
l'algorithme FIFO est un des plus simple implmenter en circuit : un vulgaire compteur, incrment lors d'un Cache Miss suffit.
Implmentation
Pour implmenter cet algorithme, la solution la plus simple permet de se contenter d'un simple compteur. Prenons un cache Fully
Associative : dans celui-ci, une nouvelle donne peut aller n'importe o dans le cache. On peut profiter de cette proprit pour
insrer les donnes dans le cache les unes la suite des autres. Exemple : si j'ai insr une donne dans la ligne de cache numro
X, alors la prochaine donne ira dans la ligne numro X+1. Si jamais on dborde, on revient automatiquement zro. En faisant
ainsi, nos lignes de caches seront tries de la plus ancienne la plus rcente automatiquement.
La ligne de cache la plus ancienne sera localise un certain endroit, et la plus rcente sera localise juste avant. Il nous suffit
juste de se souvenir de la localisation de la donne la plus ancienne, et le tour est jou. Cela peut se faire avec un compteur
unique pour tout le cache si celui-ci est Fully Asscoaitive. Pour un cache Set Associative, on doit avoir un compteur par
ensemble.
Anomalie de Belady
Cet algorithme possde une petite particularit qui concerne directement les caches Set Associative. Vous pensez surement qu'en
augmentant le nombre d'ensembles, les performances augmentent : on diminue le nombre de Conflicts Miss. Et bien avec un
algorithme de remplacement des lignes de cache FIFO, les performances peuvent se dgrader. C'est ce qu'on appelle l'anomalie
de Belady.
www.openclassrooms.com
333/467
Cet algorithme s'implmente simplement avec un registre, dans lequel on place le numro de la dernire ligne de cache utilise.
Premier circuit
Le circuit qui dtermine quel compteur est le bon est assez simple : il a N entres, numrotes de 0 N-1. De plus, il dispose de N
sorties, numrotes de 0 N-1. Si jamais le compteur plac sur l'entre numro X contient la plus petite valeur, alors la sortie X
est mise 1, et toute les autres sont mises 0.
www.openclassrooms.com
334/467
On peut facilement crer ce circuit avec un gros paquet de comparateurs et quelques portes logiques ET. Rflchissez un petit
peu, la solution est vidente.
Second circuit
Le dernier circuit est un peu plus complexe. Celui-ci va avoir N entres, numrotes de 0 N-1, et une sorties. Sur cette sortie, le
circuit fournira le numro de la ligne de cache la moins frquemment utilise. Ce numro est dduit en fonction de l'entre qui a
pour valeur 1.
Ce circuit est ce qu'on appelle un Encodeur, et il peut tre vu comme un cousin du dcodeur. Si vous regardez bien, ce circuit fait
exactement l'inverse de ce que fit un dcodeur : au lieu de prendre une adresse et d'en dduire la sortie mettre 1, il fait l'inverse
: en fonction de l'entre 1, il en dduit une adresse. Mais attention : ne croyez pas que ces deux circuits sont conus de la mme
faon. Ces deux circuits ont des cblages totalement diffrents.
Approximations du LRU
Comme on l'a vu, implmenter le LRU coute cher en transistors. Bien plus qu'implmenter un algorithme FIFO ou alatoire. Le
choix de la ligne de cache la moins rcemment utilise demande des circuits contenant beaucoup de transistors. Plus
prcisment, le nombre de transistors est proportionnel au carr du nombre de lignes de cache. Autant dire que le LRU devient
impraticable sur de gros caches. Le LRU a un dfaut : trouver la ligne de cache la moins rcemment utilise prend pas mal de
temps, et ncessite des circuits qui bouffent du transistor par pellets de 12. C'est dommage, car le LRU est un algorithme
particulirement efficace.
Pour rsoudre ce problme, nos processeurs implmentent des variantes du LRU, moins couteuses en transistors, mais qui ne
sont pas exactement du LRU : ils donnent un rsultat assez semblable au LRU, mais un peu plus approximatif. En clair, ils ne
slectionnent pas toujours la ligne de cache la moins rcemment utilise, mais une ligne de cache parmi les moins rcemment
utilise.
Il faut dire que les lignes les moins rcemment utilises ont toutes assez peu de chance d'tre utilises dans le futur. Entre choisir
de remplacer une ligne qui a 0,5% de chance d'tre utilise dans le futur et une autre qui a une chance de seulement 1%, la
diffrence est ngligeable : cela aura une influence assez faible en terme de Hit Ratio. Mais les gains en terme de circuit ou de
temps d'accs au cache de ces algorithmes peuvent donner des rsultats impressionnants.
Splitted LRU
L'algorithme le plus simple consiste couper le cache (ou chaque ensemble du cache s'il est Set Associative) en deux.
L'algorithme consiste choisir le morceau de cache le moins rcemment utilis, et de choisir alatoirement une ligne de cache
dans ce morceau. Pour implmenter cet algorithme, il nous suffit d'une simple bascule qui mmorise le morceau la moins
rcemment utilis, et d'un circuit qui choisit alatoirement une ligne de cache dans ce morceau.
PLRUm
Autre algorithme, un peu plus efficace : le Pseudo LRU de type m. Cet algorithme est assez simple : chaque ligne de cache, on
attribue un bit. Ce bit sert indiquer de faon approximative si la ligne de cache associe est une candidate pour un
remplacement ou non. Si ce bit est 1, cela veut dire : attention, cette ligne n'est pas une candidate pour un remplacement.
Inversement, si ce bit est zro, la ligne peut potentiellement tre choisie pour laisser la place aux jeunes.
Lorsque l'on lit ou crit dans une ligne de cache, ce bit est mit 1. Histoire de dire : pas touche ! videmment, au fil du temps,
toutes les lignes de cache finiront par avoir leur bit 1. Aussi, l'algorithme permet de remettre les pendules l'heure. Si tous les
bits sont 1, on les remet tous zro, sauf pour la dernire ligne de cache accde.
www.openclassrooms.com
335/467
L'ide derrire cet algorithme est d'encercler la ligne de cache la moins rcemment utilise au fur et mesure des accs. Tout
commence lorsque l'on remet tous les bits associs aux lignes de cache 0 (sauf pour la ligne accde en dernier). Puis, au fur et
mesure que nos lignes de cache voient leurs bits passer un, l'tau se ressert autour de notre ligne de cache la moins utilise.
Et on finit par l'encercler de plus en plus : au final, aprs quelques accs, l'algorithme donne une estimation particulirement
fiable. Et comme les remplacement de lignes de caches sont rares compars aux accs aux lignes, cet algorithme finit par donner
une bonne estimation avant qu'on aie besoin d'effectuer un remplacement.
LRU amlior
L'algorithme LRU, ainsi que ses variantes approximatives, sont trs efficaces dans la majorit des programmes. Du moment que
notre programme respecte relativement bien la localit temporelle, cet algorithme donnera de trs bons rsultats : le Hit Ratio du
cache sera trs lev. Par contre, cet algorithme se comporte assez mal dans certaines circonstances, et notamment quand on
traverse des tableaux. Dans ces conditions, on n'a pas la moindre localit temporelle, mais une bonne localit spatiale. Pour
rsoudre ce petit inconvnient, des variantes du LRU existent : celles-ci combinent plusieurs algorithmes la fois et vont choisir
lequel de ces algorithmes est le plus adapt la situation. Notre cache pourra ainsi dtecter si il vaut mieux utiliser du MRU, du
LRU, ou du LFU suivant la situation.
Caches L1, L2 et L3
Depuis environ une vingtaine d'annes, nos caches sont segments en plusieurs sous-caches : les caches L1, L2 et parfois un
cache L3. Certains de ces caches sont petits, mais trs rapides : c'est ceux auxquels on va accder en priorit. Viennent ensuite
d'autres caches, de taille variables, mais plus lents.
Le L1 est le cache le plus petit et le plus rapide. C'est celui dans lequel le processeur va d'abord chercher les
donnes/instructions voulues. On trouve ensuite un cache L2, de vitesse et de taille moyenne, et parfois un cache L3, assez lent
mais assez gros.
Laccs au cache est simple : on commence par vrifier si notre adresse correspond une donne du cache le plus rapide (qui est
souvent le plus petit) : j'ai nomm le cache L1. Si elle ne l'est pas , on effectue la mme vrification pour le cache de niveau
infrieur (le L2). Si une donne est prsente dans un des caches, on la charge directement dans le squenceur (instruction) ou en
entre des units de calcul (donne). Dans le cas contraire, on vrifie le cache du niveau infrieur. Et on rpte cette opration,
jusqu avoir vrifi tous les caches. : on doit alors aller chercher la donne en mmoire.
Caches inclusifs
Ces caches sont organiss diffremment, et leur contenu varie suivant le cache. Dans le cas des caches inclusifs, le contenu d'un
cache est recopi dans les caches de niveau infrieur. Par exemple, le cache L1 est recopi dans le cache L2 et ventuellement
dans le cache L3.
www.openclassrooms.com
336/467
Ce genre de cache a un avantage : le temps d'accs une donne prsente dans le cache est plus faible. Cela est du en partie la
prsence des copies des caches de niveau suprieurs dans les caches de niveau infrieurs (mais pas que). Pour expliquer
pourquoi, prenons un exemple : si la donne voulue n'est pas dans le cache L1, on n'est pas oblig de vrifier la partie du cache
L2 qui contient la copie du L1. Ainsi, les circuits qui doivent vrifier si une adresse correspond bien une donne place dans le
cache peuvent tre simplifis et ne pas vrifier certaines portions du cache. Ce qui donne un rsultat plus rapide.
En contrepartie, une partie des caches de niveau infrieur contient les donnes contenues dans le cache de niveau suprieur, qui
sont donc en double. Exemple, le cache L2 contient des donnes prsentes dans le L1. De mme, le cache L3 contient une copie
du L2. Une partie du cache est donc un peu inutilise, ce qui fait que c'est comme si le cache tait plus petit. Celui-ci pouvant
contenir moins de donnes utiles (on ne compte pas les donnes prsentes en double dans les diffrents niveaux de cache), on a
parfois un plus grand risque de cache miss, quand le cache est trs utilis.
De plus, la mise jour du contenu d'un niveau de cache doit tre rpercute dans les niveaux de cache infrieurs et/ou
suprieurs. On doit donc transfrer des informations de mise jour entre les diffrents niveaux de caches.
Caches exclusifs
Dans les caches exclusifs, le contenu d'un cache n'est pas recopi dans le cache de niveau infrieur. Chaque cache contient des
donnes diffrentes. Ainsi, le cache ne contient pas de donne en double et on utilise 100% de la capacit du cache. Le cache
contenant plus de donne, on a plus de chance d'avoir un cache hit.
Par contre, le temps d'accs une donne prsente dans le cache est plus long : il faut vrifier l'intgralit du contenu des caches
www.openclassrooms.com
337/467
de niveau infrieur. Par exemple, si une donne n'est pas dans le cache L1, on doit vrifier l'intgralit du cache L2, puis du cache
L3. De plus, assurer qu'une donne n'est prsente que dans un seul cache ncessite aux diffrents niveaux de caches de
communiquer entre eux pour garantir que l'on a pas de copies en trop d'une ligne de cache. Et ces communications peuvent
prendre du temps.
Caches d'instruction
Au fait, sur certains processeurs, le cache L1 est segment en deux sous-caches : un qui contient des instructions, et un autre
qui ne contient que des donnes.
Ces deux caches tant dans des mmoires spares et tant relis au reste du processeur par des bus spars, on peut charger
une instruction et manipuler une donne en mme temps, ce qui est un gros avantage en terme de performances.
www.openclassrooms.com
338/467
On peut par exemple rajouter des informations qui permettent de dlimiter nos instructions ou dterminer leur taille : c'est trs
utile pour les processeurs qui utilisent des instructions de taille variable. On peut aussi dtecter la prsence de branchements,
pour informer les divers prefetchers, histoire qu'ils fassent leur travail correctement. On peut aussi faire beaucoup de
transformations de ce genre sur nos instructions, comme harmoniser le opcodes, etc. Bref, notre cache d'instructions peut se
charger d'une partie du dcodage des instructions, grce un petit circuit spcialis, spar de l'unit de dcodage d'instruction.
Caches spcialiss
Il existe parfois des caches spcialiss internes au processeur, et qui ne servent pas forcment acclrer les accs mmoire.
Loop Buffer
Pour donner un exemple, nos processeurs rcents utilisent un cache spcialis qu'on Loop Buffer. Il sert acclrer lexcution
des boucles (pour rappel, les boucles sont des structures de contrle qui permettent de rpter une suite d'instruction). Il est
charg de stocker les ops correspondant des instructions machines qui ont dj ts dcodes et excutes, dans le cas o
elles devraient tre r-excutes plus tard.
Sans Loop Buffer, si une instruction est excute plusieurs fois, elle doit tre charge depuis la mmoire et dcode, chaque
fois qu'on veut lexcuter. Le Loop Buffer permet d'viter de devoir Fetcher et dcoder cette instruction plusieurs fois de suite.
Avec ce Loop Buffer, notre instruction est charge et dcode en micro-oprations une seule fois, et le rsultat est stock dans
ce fameux Loop Buffer. Si notre instruction doit tre r-excute, il suffit d'aller chercher le rsultat du dcodage de l'instruction
directement dans le Loop Buffer au lieu de recharger l'instruction et la redcoder.
Si notre instruction est excute dans une boucle contenant trs peu d'instructions machines, le trace cache va fonctionner. De
mme, si une instruction micro-code est mule par une suite de ops contenant une boucle (l'instruction REP SCACB du jeu
d'instruction x86, par exemple), ce Loop Buffer va aider. Nanmoins, ce cache ne peut stocker qu'un nombre limit d'instruction. Si
une boucle dpasse ce nombre d'instruction maximal, l'utilisation du trace cache ne donne strictement aucun gain, dans l'tat
actuel de nos technologies. Les programmeurs pourront en dduire une des innombrables raisons qui font que drouler des
boucles (Loop unrolling ) est le mal incarn.
Le victim cache
Ce cache est un petit cache qui vient en supplment du cache principal (ou des caches L1, L2 et L3) et n'est prsent que sur les
caches de type Write Back. Il a t invent pour limiter les dfauts des caches direct mapped . Pour rappel, sur les caches direct
mapped , chaque adresse mmoire est assigne une seule et unique de cache : le contenu d'une adresse mmoire ne peut aller
que dans cette ligne, et pas dans une autre.
Cela pose quelques problmes : il arrive souvent que certaines adresses mmoires qui se partagent la mme ligne de cache soient
manipule simultanment. Dans ce cas, tout accs une de ces adresses va virer le contenu de l'autre adresse du cache. Nos
deux adresses seront expulses puis recharges dans le cache continuellement : c'est ce qu'on appelle des conflits miss.
Pour limiter ces conflits miss, des scientifiques ont alors eu l'ide d'insrer un cache permettant de stocker les toutes dernires
donnes vires du cache. En faisant ainsi, si une donne est vire du cache, on peut alors la retrouver dans ce cache spcialis.
Ce cache s'appelle le Victim Cache. Il va de soit que cette technique peut aussi tre adapte aux caches N-Ways Associatives.
Voyons comment est gr ce cache. Si jamais on veut accder une donne qui n'est ni dans le cache, ni dans le Victim Cache :
on charge notre donne dans le cache, aprs avoir sauvegarde le contenu de celle-ci dans le Victim Cache. Ce Victim Cache est
gr par un algorithme de suppression des lignes de cache de type FIFO : les donnes les plus anciennes du cache sont celles
qui sont supprime en cas de besoin. Si jamais on veut lire une donne, et que celle-ci n'est pas dans le cache, mais qu'elle est
dans le Victim Cache : on change le contenu du Victim Cache avec la ligne de cache correspondante.
Petit dtail : ce cache utilise un Tag lgrement plus long que celui du cache Direct Mapped au-dessus de lui. L'index de la ligne
de cache doit en effet tre contenu dans le Tag du Victim Cache, pour bien distinguer deux adresses diffrentes, qui iraient dans
la mme ligne du cache juste au-dessus.
Le TLB
Vous vous souvenez du Translation Lookaside Buffer, ou TLB, vu au chapitre prcdent ? Et bien celui-ci est aussi un cache
spcialis, au mme titre que le Trace cache ou le Victim cache. Ce cache est parfois dcoup en plusieurs sous-caches, L1, L2,
L3, etc. Sur les architectures Harvard, on trouve parfois deux TLB spares : une pour les accs aux instructions, et une pour les
accs aux donnes.
www.openclassrooms.com
339/467
Le Prefetching
Dans le chapitre prcdent, j'ai parl du principe de localit spatiale, qui dit que nos programmes ont tendance accder des
donnes proches en mmoire. Pour profiter au maximum de ce principe de localit spatiale, il est plutt avantageux de dcider de
prcharger l'avance les instructions ou donnes proches de celles charges il y a peu : on permet au processeur de trouver plus
souvent les donnes qu'il cherche dans le cache. Ce prchargement s'appelle le Prefetching, et peut tre effectu par le
programmeur ou directement par le processeur. Le tout est de dterminer quelle donne prcharger, et quand !
Vous vous souvenez que les transferts entre la mmoire et le cache se font lignes de cache par lignes de cache. En consquence,
notre prefetcher va prcharger des blocs qui ont la mme taille que nos lignes de cache. Reste savoir comment celui-ci se
dbrouille.
Certains processeurs mettent disposition du programmeur une instruction spciale capable de prcharger des donnes partir
d'une certaine adresse. Cela permet aux programmeurs de grer quelque peu le contenu du cache. Le problme, c'est qu'il faut
programmer en assembleur pour pouvoir en profiter. Et soyons franc, les programmeurs actuels refusent de programmer en
assembleur ou d'utiliser ces instructions dans leurs programmes, pour des raisons de portabilit.
Mais il existe une autre solution : laisser le processeur prcharger lui-mme les donnes. Pour ce faire, celui-ci contient souvent
un circuit nomm Prefetcher, qui s'occupe de prcharger des donnes/instructions. Presque tous les processeurs grand public
actuels possdent un Prefetcher. Il faut dire que les gains de performances apport par ce circuit sont assez impressionnants : se
priver d'un tel avantage serait du suicide. Qui plus est, on peut utiliser la fois des instructions de Prefetch et un Prefetcher
matriel intgr au processeur : les deux solutions en sont pas incompatibles.
Mais comment ce Prefetcher peut-il fonctionner ?
Tout d'abord, il faut prciser qu'il existe plusieurs types de Prefetchers. Certains sont assez rudimentaires, tandis qu d'autres sont
plus volus, plus efficaces. Ce chapitre va vous montrer ces diverses formes de Prefetchers et vous en expliquer les grands
principes de fonctionnement.
Array Prefetching
Certains de ces Prefetchers sont particulirement adapts l'utilisation de structures de donnes particulires : les tableaux. On
a vu ce qu'tait un tableau dans le chapitre sur l'assembleur, il y a quelques chapitres. Il s'agit de blocs de mmoires qu'on rserve
pour y stocker des donnes de mme taille et de mme type. Certains de nos Prefetchers profitent du fait que ces tableaux sont
souvent accds cases par cases, avec certaines rgularits. Je ne sais pas si vous avez dj programms, mais si c'est le cas,
vous avez surement parcouru des tableaux cases par cases, en partant du dbut d'un tableau pour arriver la fin. Et bien ce
genre de parcourt est prcisment acclr par ces Prefetchers. Ds que l'on doit itrer dans un tableau, ces Prefetchers pourront
servir. Voyons comment ceux-ci fonctionnent.
Prefetchers squentiels
Commenons par les prefetchers squentiels. Ces prefetchers se contentent de prcharger les donnes immdiatement
conscutives de la donne venant tout juste d'tre lue ou crite.
Les Prefetchers de ce type sont vraiment stupides et ne fonctionnent que lorsqu'on accde des donnes conscutives en
mmoires, les unes aprs les autres. Mine de rien, ce genre d'accs la mmoire est assez courant : cela arrive souvent quand on
parcourir des tableaux dans leur totalit, en partant du dbut la fin (ou de la fin vers le dbut).
www.openclassrooms.com
340/467
Le plus simple de ces Prefetchers sont ceux qui utilise le Prefetching de type One Block Lookahead. Le terme est barbare, je me
doute. Mais le principe est trs simple. Il consiste simplement prcharger le bloc de mmoire qui suit. Ainsi, si vous accdez
un bloc de mmoire, le Prefetcher commencera charger le bloc immdiatement suivant le plus tt possible.
Pour fonctionner, ces Prefetchers ont juste besoin de se souvenir de la dernire adresse lue ou crite, et de quoi dduire la
prochaine adresse. Cette prdiction de la prochaine adresse se fait simplement en additionnant la longueur d'une ligne de cache
l'adresse du dernier bloc de mmoire lu ou crit dans le cache. Le tout peut ventuellement tre modifi de faon ne pas
prefetcher inutilement des blocs de mmoires dj prsents dans le cache.
Nanmoins, cette technique peut simplmenter de trois faons diffrentes. Tout dpend de quand on Prefetche. La premire
solution consiste Prefetcher le bloc suivant de manire systmatique. Pour cela, rien de plus simple : il suffit simplement
d'utiliser un compteur dans notre processeur. En plaant notre adresse mmoire lire ou crire dans ce compteur, l'adresse
suivante prefetcher est calcule automatiquement.
Deuxime solution : ne prefetcher que lors d'un cache miss. Ainsi, si j'ai un cache miss qui me force charger le bloc B dans le
cache, le Prefetcher chargera le bloc immdiatement suivant avec.
Dernire solution : chaque accs un bloc de mmoire dans le cache, on charge le bloc de mmoire immdiatement suivant.
Pour cela, on doit mmoriser quelle est la dernire ligne de cache qui a t accde. Cela se fait en marquant chaque ligne de
cache avec un bit spcial, qui indique si cette ligne a t accde lors du dernier cycle d'horloge. Ce bit vaut 1 si c'est le cas, et
vaut 0 sinon. Ce bit est automatiquement mit zro au bout d'un certain temps (typiquement au cycle d'horloge suivant). Le
Prefetcher se contentera alors de charger le bloc qui suit la ligne de cache dont le bit vaut 1.
www.openclassrooms.com
341/467
Adaptative Prefetching
Vous aurez aussi remarqu que ces Prefetcher ne fonctionnent que pour des accs des zones conscutives de la mmoire. Le
seul problme, c'est que beaucoup d'accs mmoire ne se font pas des zones de mmoire conscutives. L'utilisation d'un
Prefetcher squentiel est alors contre-productive. Pour limiter la casse, les Prefetcher sont capables de reconnaitre les accs
squentiels et les accs problmatiques.
Cette dtection peut se faire de deux faons. Avec la premire, le Prefetcher va calculer une moyenne du nombre de blocs
prchargs qui ont ts utiles. Ce calcul de cette moyenne se fera sur un chantillon contenant les N derniers blocs prchargs,
histoire d'avoir une estimation locale. En clair : il va calculer le rapport entre le nombre de blocs qu'il a prcharg dans le cache, et
le nombre de ces blocs qui ont ts accds. Si jamais ce rapport diminue trop, cela signifie que l'on a pas affaire des accs
squentiels : le Prefetcher arrtera temporairement de prcharger des trucs. Par contre, si jamais ce rapport dpasse une certaine
limite, on est presque certain d'avoir affaire des accs squentiels : le Prefetcher prchargera des donnes.
Autre solution : garder un historique des derniers accs mmoires et de voir s'ils accdent des zones conscutives de la
mmoire. Si c'est le cas, le Prefetcher prefetche, et dans le cas contraire, il ne prefetche pas. Le processeur peut mme dcider de
dsactiver temporairement le Prefetching si jamais le nombre de blocs prchargs utilement tombe trop prt de zro.
Streams Buffers
Le seul problme avec ces techniques de Prefetching, c'est le cas o le Prefetcher se trompe et o il prefetche des donnes qui
n'auraient pas du l'tre. Charger ces donnes va prendre du temps, ncessite daccder la mmoire, etc. Mais surtout, des
www.openclassrooms.com
342/467
donnes sont charges inutilement dans le cache, et elles prennent la place d'une donne qui aurait pu tre plus utile. On va
donc se retrouver avec quelques lignes de caches qui contiendront des donnes qui ne servent rien, et qui auront ject des
donnes potentiellement utiles du cache. De plus, cette donne charge inutilement ne va pas quitter le cache tout de suite. Si
celui-ci utilise un algorithme de slection des lignes de cache de type LRU, cette donne charge inutilement ne va pas tre
slectionne pour remplacement lors du prochain cache miss : ce seront d'autres lignes de caches qui le seront. Et il va de soit
que ce lignes de caches auraient encore pu tre utiles, contrairement la donne charge l'avance, qui squattera dans le cache.
Bref, on se retrouve avec une donne inutile dans le cache, qui y reste durant longtemps, et qui se permet en plus de foutre
dehors des donnes qui auraient pu se rendre utiles, elles ! C'est ce qu'on appelle un phnomne de Cache Pollution. Il va de
soit que limiter au maximum cette Cache Pollution est une ncessit si on veut tirer parti au maximum de notre mmoire cache.
Reste savoir comment.
Une premire solution consiste dire que les donnes prefetches sont bonnes pour la casse si celles-ci ne servent pas
rapidement. Vous savez que nos lignes de caches comportent des informations qui permettent de dterminer lesquelles ont t
frquemment utilises (algorithme LFU), ou rcemment utilises (LRU). Et bien sur les processeurs modernes, une donne
preftche qui n'a pas servi peu de temps aprs son chargement anticip depuis la mmoire est marque comme tant trs peu
utilise ou comme tant celle la moins rcemment utilise. Dans ce cas, cette donne quittera le cache assez rapidement. Cela ne
lempche pas d'craser une donne plus utile lors de son chargement anticip, mais au moins, cela dure peu.
Autre solution : prefetcher nos donnes non pas dans le cache, mais dans une mmoire spare, spcialise dans le prefetching.
Cette mmoire temporaire s'appelle un Stream Buffer. En gros, tout ce qui est prefetch n'atterrit pas dans le cache, mais dans ce
Stream Buffer. Si jamais un cache miss a lieu dans le cache, on regarde si la ligne de cache lire ou crire est dans le Stream
Buffer. Si elle y est, on va la rapatrier dans le cache. Si ce n'est pas le cas, c'est que le Stream Buffer contient des donnes
prftches tord : le Stream Buffer est totalement vid, et on va chercher la donne en mmoire.
Accs en Stride
Nos Prefetchers squentiels. Les Prefetchers fonctionnent bien quand on parcourt des tableaux de donnes de base lments
par lments. Mais il arrive que les programmeurs n'accdent qu' certains lments du tableaux, tous spars par une mme
distance. On obtient alors ce qu'on appelle des accs en Stride, qui ressemblent ceci :
On le voit, ces accs se font sur des donnes spares par une distance constante. On appelle de tels accs des accs en KStride, avec k la distance entre deux donnes accdes. Ces accs en Stride ont deux origines : les parcours de tableaux
multidimensionnels, et le parcours de tableaux de structures/objets. Si on parcourt un tableau multidimensionnel de la mauvaise
faon, (colonnes par colonnes en C, lignes par lignes en FORTRAN), on obtient de tels accs en Stride. D'un point de vue
performances, ces accs sont souvent trs lents. Il vaut mieux accder des donnes purement squentielles. Moralit :
programmeur, faites gaffe au sens de parcours de vos tableaux ! En plus, avec ce genre d'accs, un Prfecther squentiel a
tendance charger des donnes inutiles (en blanc), situes entre les donnes utiles (celles en jaune). Cela fait pas mal de cache
gaspill, ce qui est synonyme de baisses de performances.
Pour viter cela, on peut dcider de transformer nos tableaux de structures en structures de tableaux ou modifier l'ordre de
parcours de nos tableaux deux dimensions. Mais pour limiter l'impact de tels accs, qu'ils soient dus des programmeurs mal
avertis ou non, certains Prefetchers grent de tels accs en Stride et peuvent prdire la perfection quelle sera le prochain bloc
de mmoire charger. Cela ne rend pas ces accs aussi rapides que des accs des blocs de mmoire conscutifs : on gche
souvent une ligne de cache pour n'en utiliser qu'une petite portion, ce qui n'arrive pas avec ces accs purement squentiels.
Mais cela aide tout de mme beaucoup.
www.openclassrooms.com
343/467
Nanmoins, il faut savoir que ces prefetchers ne peuvent fonctionner que si les accs la mmoire sont assez rapprochs: si les
donnes sont trop loignes en mmoire, le prefecther ne peut rien faire et ne prchargera pas correctement les donnes. En
dessous de cette limite, gnralement, toutes les distances sont supportes. Le prefetcher peut ainsi choisir s'il faut prcharger
les donnes situes 250 adresses plus loin ou 1024 adresses plus loin, de faon sadapter le plus possible la situation. Toutes
les distances intermdiaire entre 0 et la limite maximale supportes par le prefetcher sont possibles.
Un peu mieux
Le gain apport par les prefetchers capable de prdire des accs en stride est apprciable. Mais on pourrait certainement faire
mieux. Par exemple, on peut vouloir faire en sorte que nos prefetchers fonctionnent la perfection sur des accs cycliques ou
rptitifs.
Des accs de ce type sont plus rares. Ils apparaissent surtout quand on parcourt plusieurs tableaux la fois. Pour grer aux
mieux ces accs, on a invent des prefetchers plus volus, capables de ce genre de prouesses. Il en existe de plusieurs types,
avec des performances diffrentes, mais on en parlera pas ici : le principe de fonctionnement de ces prefetchers est assez
compliqu, et je ne suis pas sur que vous parler de chaines de Markov puisse vous intresser. Mais malheureusement, ces
prefetchers possdent les dfauts des prefetchers prcdents : si on effectue des accs pas vraiment rguliers, notre prefetcher
ne peut rien faire : il n'est pas devin.
Le Futur
Les techniques vues au-dessus sont celles qui sont couramment utilises dans les processeurs actuels. Mais il en existe
d'autres, qui n'ont pas encore ts utilises couramment dans nos processeurs. Il existe ainsi des prefetchers plus volus,
capables de dcider quelle donne ou instruction charger en utilisant des mthodes plus compliques. Ces prefetchers essayent
de trouver des tendances, pas forcment rptitives, dans les accs mmoires prcdents, et essayent de dduire quelle seront
les adresses manipules prochainement en effectuant des calculs statistiques plus ou moins volus sur ceux-ci.
www.openclassrooms.com
344/467
mmoire.
Pour faire le lien entre les donnes, chacune d'entre elle sera stocke avec des informations permettant de retrouver la donne
suivante ou prcdente en mmoire. Chaque donne est donc stocke en mmoire, avec l'adresse de la ou des donnes
suivantes ou prcdentes.
Autres
Et on peut aller plus loin, en permettant chaque donne d'avoir plusieurs donnes suivantes et/ou prcdentes. On obtient
alors des arbres.
Et d'autres structures de donnes encore plus complexes existent : on pourrait citer les graphes, parler des diffrentes manires
d'implmenter des arbres ou des listes, etc. Mais cela relverait d'un cours d'algorithmique de haute vole.
Et le Prefetching ?
Il va de soit que le Prefetching squentiel ou le Prefetching base de Strides ne fonctionnent pas avec ces structures de
donnes : nos donnes sont stockes n'importe comment en mmoire, et ne sont pas places intervalle rgulier en mmoire.
Cela dit, a ne veut pas dire qu'il n'existe pas de techniques de Prefetching adapte pour ce genre de structures de donnes. En
fait, il existe deux grandes techniques pour ce genre de structures de donnes, et quelques autres techniques un peu plus
confidentielles.
www.openclassrooms.com
345/467
Comme vous le voyez, on se retrouve avec deux chargements de donne depuis la mmoire : un premier qui produit l'adresse, et
un autre qui l'utilise. Ces deux chargements de donnes sont effectues par des instructions de lecture en mmoire. Dans ce qui
va suivre, je vais identifier ces deux instructions en parlant d'instruction productrice (celle qui charge l'adresse), et
consommatrice (celle qui utilise l'adresse charge).
Table de corrlation
Avec le Dependance Based Prefetching , le processeur va tenter de prdire quels sont les chargements qui produisent ou
consomment une adresse tel que vu au-dessus. Il va aussi dtecter si une instruction va produire une adresse ou en consommer
une. Pour cela, rien de plus simple : le processeur va regarder si deux instructions ont une dpendance producteurconsommateur : si c'est le cas, il s'en souviendra pour la prochaine fois. Pour s'en souvenir, il va utiliser une petite mmoire cache
qui stockera les adresses du producteur et du consommateur. Cette petite mmoire cache sappelle la table de corrlation.
www.openclassrooms.com
346/467
Reste que les corrlations stockes dans cette table ne sortent pas de cuisse de Jupiter. Il faut bien que notre processeur puisse
dtecter les instructions productrices et consommatrices. Pour cela, notre processeur va les identifier lors de lexcution d'une
instruction consommatrice. Lorsque cette instruction consommatrice sexcute, le processeur vrifie si l'adresse qu'elle cherche
lire a t charge depuis la mmoire par une autre instruction. Si c'est le cas, alors le processeur dtecte l'instruction
consommatrice.
Fonctionnement
Le remplissage de la table de corrlation est alors trs simple : lorsqu'une instruction de lecture se termine, on stocke la donne
qu'elle a lu depuis la mmoire, ainsi que l'adresse de linstruction dans la Potential Producer Windows. Lors de lexcution d'une
prochaine instruction, on compare l'adresse lire avec les donnes prsentes dans la Potential Producer Windows : si il y a
www.openclassrooms.com
347/467
correspondance avec un Tag, alors on dtecte une correspondance producteur-consommateur. L'adresse de nos deux
instructions productrice-consommatrice sont alors stockes dans la table de corrlation.
En quoi cela nous donne des indications pour pouvoir prfetcher quoi que ce soit ? Trs simple : chaque lecture, le processeur
vrifie si cette lecture est effectue par une instruction productrice en regardant le contenu de la table de corrlation. Ds qu'une
instruction dtecte comme productrice a charg son adresse, le processeur se charge de prefetcher les donnes situes cette
adresse sans attendre que l'instruction qui consomme cette adresse sexcute. Lorsqu'elle sexcutera (quelques cycles plus
tard), la donne aura dj commenc tre lue depuis la mmoire.
Instruction Prefetching
Au fait : sur certains processeurs, on utilise deux prefetchers spars : un pour les instructions, et un autre pour les donnes.
Cela permet d'adapter plus facilement les stratgie de prchargement. En effet, les instructions ont parfois besoin de techniques
de prchargement spcialises qu'on va voir dans ce qui suit. Les prefetchers spcialiss pour les instructions peuvent donc se
contenter de techniques de prfetching adaptes, assez simples, tandis que ceux spcialiss pour les donnes peuvent utiliser
des techniques plus compliques. Cela vite au prefetcher de confondre accs aux instructions et accs aux donnes : si jamais
le prefetcher confond un accs une instruction et utilise une technique pas adapte, cela pourrait lui faire rater un
prchargement.
www.openclassrooms.com
348/467
Les branchements qui posent ce genre de problmes sont : tous les branchements inconditionnels, et notamment les appels et
retour de sous-programmes, ainsi que les branchements conditionnels pris (qui envoient le processeur ailleurs, et non la suite
du programme). Autant le dire tout de suite : ils sont assez nombreux.
Pour implmenter cette technique, nos Prefetchers incorporent une sorte de petite mmoire cache, capable de stocker ces
adresses de destination pour ces branchements. Plus prcisment, cette mmoire cache va contenir des correspondance entre :
une ligne de cache, et la ligne de cache charger la suite de celle-ci.
Pour donner un exemple, regardons ce qui se passe avec le morceau de programme suivant.
www.openclassrooms.com
349/467
Cette technique de Prefetching fonctionne sur un principe trs simple : quand on lit ou crit dans une ligne de cache, le
processeur interroge la table de correspondance. Il rcupre la ligne de cache suivante, et prfetche celle-ci.
Pour plus d'efficacit, certains processeurs utilisent cette table d'une manire un peu plus efficace. Dans ceux-ci, la table ne
stocke pas les correspondance entre lignes de cache si celles-ci sont conscutives. Si jamais deux lignes de caches sont
conscutives, on fera alors face un Cache Miss dans cette mmoire qui stocke nos correspondances. Le Prefetcher utilisera
alors automatiquement un Prefetching squentiel. Ainsi, la table de correspondance est remplie uniquement avec des
correspondances utiles.
Il va de soit que l'adresse de destination du branchement n'est connue que lors de l'tage de Decodage de l'instruction : il faut
thoriquement que le branchement aie fourni son adresse avant que l'on puisse l'utiliser. Ce qui fait qu'au final, l'adresse du bloc
prefetcher dans le cache est connue trs tard. Si le branchement est pris, il n'y a pas besoin de prefetcher : notre processeur
fetchera normalement les instructions de destination indiques par le branchement. Mais si le branchement n'est pas pris
www.openclassrooms.com
350/467
(condition fausse), on prefetchera quand mme les instructions correspondant un branchement non-pris (celles situes juste
aprs les branchement).
A premire vue, ce chargement est inutile : on prefetche des instructions qui ont ts zappes par le branchement. L'astuce vient
du fait que notre branchement peut parfaitement sexcuter plusieurs fois : un programme est souvent rempli de boucles,
fabriques avec des branchements, sans compter que ces boucles peuvent aussi contenir des branchements. Et l'adresse de
destination du branchement peut changer lors de son excution. Avec la Wrong Path Prefetching , on va charger les instructions
correspondant aux deux cas : branchement pris (condition vraie), ou non-pris (condition fausse). Ainsi, lors de la seconde
excution du branchement, les instructions de destination seront forcment dans le cache.
D'aprs certaines simulations, cette technique fonctionne un peu mieux que le Target Line Prefetching dans certaines situations.
Il suffit d'avoir beaucoup de branchements conditionnels rpts dans notre programme, et une mmoire RAM avec un bon
dbit pour obtenir de bons rsultats.
Autres
Il existe encore d'autres techniques de Prefetching pour nos instructions. On peut notamment citer les techniques bases sur
des chaines de Markov, qui utilisent des statistiques pour dduire si un futur branchement sera pris ou pas pour dcider quelle
bloc de mmoire charger dans le cache. Mais on n'en parlera pas ici. Du moins, pas encore !
www.openclassrooms.com
351/467
, dpend :
du nombre moyen
d'instructions excutes par notre programme (ce nombre peut varier suivant les donnes
manipules par le programme, leur taille, leur quantit, etc) : celui-ci porte un petit nom : il s'appelle l'Instruction path
length) ;
du nombre moyen de cycles d'horloge ncessaires pour excuter une instruction, qu'on notera
(ce qui est
l'abrviation de Cycle Per Instruction) ;
et de la dure d'un cycle d'horloge.
Ce temps T est gal :
Quand on sait que la frquence n'est rien d'autre que l'inverse de la priode d'un cycle d'horloge, on peut rcrire cette quation
comme ceci :
Comme on le voit, il existait trois solutions pour rendre un programme plus rapide :
Que faire ?
Comment ?
Pour cela, il existe plusieurs solutions :
Diminuer son
nombre
d'instructions
N
compter sur le programmeur pour optimiser son programme : un bon choix d'algorithme et une
implmentation efficiente de celui-ci peut donner des gains assez intressants ;
amliorer le jeu d'instruction.
Cela peut se faire en crant des instructions plus complexes, capables de remplacer des suites
d'instructions simples : il n'est pas rare qu'une grosse instruction complexe fasse exactement la mme
chose qu'une suite d'instructions plus lmentaires. C'est la raison mme de l'existence des
www.openclassrooms.com
352/467
processeurs CISC.
Il existe diffrentes solutions pour diminuer CPI.
Tout d'abord, on peut concevoir notre processeur de faon diminuer le temps mis par notre processeur
pour excuter une instruction. C'est particulirement difficile et ncessite de refaire les circuits de notre
processeur, trouver de nouveaux algorithmes matriels pour effectuer une instruction, amliorer le
fonctionnement de notre processeur et sa conception, etc.
De ce point de vue, les processeurs RISC sont avantags : leurs instructions sont toutes simples, et peuvent
souvent s'effectuer en quelques cycles d'horloges. On est vraiment loin des anciens processeurs CISC : si
certaines instructions de base taient simples et rapides, d'autres instructions trs complexes pouvaient
Diminuer CPI
mettre une bonne dizaine voire centaine de cycles d'horloge pour sexcuter.
Un autre solution consiste mieux choisir les instructions utilises. Comme je l'ai dit plus haut, le nombre
CPI est un nombre moyen : certaines instructions sont plus rapides que d'autres. En utilisant de prfrence
des instructions rapides au lieu d'instructions plus lentes pour faire la mme chose, on peut facilement
diminuer le CPI. De nos jours, les programmeurs n'ont que trs peu d'influence sur le choix des instructions
utiliser : les langages de haut niveau comme le C++ ou le Java se sont dmocratiss et ont dlgus cette
tache aux compilateurs (qui se dbrouillent particulirement bien, en passant).
Pour cela, il faut utiliser des composants lectroniques plus rapides. Gnralement, cela ncessite de
miniaturiser les transistors de notre processeur : plus un transistor est petit, plus il est rapide (rappelez vous
Augmenter la
le chapitre sur les transistors). Durant un temps, cela fonctionnait merveille, grce la loi de Moore. Mais de
frquence
nos jours, le Heat wall et le Memory wall ont finis par diminuer les effets de la monte en frquence, rendant
celle-ci de plus en plus inutile en terme de performances.
Mais avec le temps, il est devenu de plus en plus difficile de monter en frquence. Le coup de grce fut celui port par le Heat
wall et le Memory wall : la monte en frquence devenant de plus en plus difficile, malgr les amliorations des processus de
fabrication des composants lectroniques, et les performances ont commences stagner.
La solution consistant rajouter des instructions et modes d'adressage complexes ne fonctionnait pas non plus : ces
instructions taient souvent assez complexes et les occasions de les utiliser taient assez rares. Pourtant les performances
pouvaient tre au rendez-vous, mais utiliser ces instructions est souvent difficile pour un compilateur. Mais le principal problme
de cette solution n'est pas l : modifier un jeu d'instruction est quelque chose qui doit se faire sur le long terme, avec le poids de
la compatibilit, ce qui n'est pas sans poser quelques problmes.
Par exemple, un programme qui utiliserait des instructions toutes nouvelles ne peut pas fonctionner sur les anciens processeurs
ne possdant pas ces instructions. Ainsi, on a beau rajouter des tas d'instructions dans nos processeurs, il faut attendre assez
longtemps pour que celle-ci soient utilises : le temps que presque tout le monde aie un processeur capable dexcuter ces
nouvelles instructions. Pour donner un exemple trs simple : votre avis, sur les nouvelles instructions rajoutes dans chaque
nouveau processeur Intel, AMD, ou ARM, combien sont rellement utilises dans les programmes que vous utilisez ? Combien
utilisent les instructions SSE, AVX ou autres extensions rcentes ? Surement peu.
Il ne restait plus qu'une solution : diminuer le CPI. Cela n'tait pas facile, et diverses solutions ont ts mises en place : amliorer
les circuits de calcul et le squenceur de notre processeur, fabriquer des circuits plus rapides, etc. Quoiqu'il en soit, les
concepteurs de processeurs ont cherch optimiser au mieux les instructions les plus utilises et se sont plus ou moins heurts
un mur : leurs oprations taient dj diablement rapides au point qu'il tait assez difficile de leur faire prendre moins de temps.
En clair, les solutions orthodoxes visant toucher au jeu d'instruction, la frquence ou aux circuits de lunit de calcul ont
atteint une sorte de mur difficile dpasser. Les concepteurs de processeurs ont donc dt ruser et ont du trouver dautres
mthodes. Il est devenu vident au fil du temps qu'il fallait rflchir hors du cadre et trouver des solutions innovantes, ne
ressemblant rien de connu. Ils ont fini par trouver une solution assez incroyable : excuter plusieurs instructions en mme
temps ! Comme a, pas besoin de gaspiller son nergie rendre nos instructions encore plus rapides en amliorant des circuits
proches de l'optimum : avec cette mthode, le CPI devenait infrieur 1 pour les instructions rapides, ce qui donnait de gros
gains en performances.
Pour excuter plusieurs instructions en mme temps, il a bien fallu trouver quelques solutions diverses et varies. Le pipeline est
une de ces solutions. Pour expliquer en quoi il consiste, il va falloir faire un petit rappel sur les diffrentes tape d'une
instruction.
www.openclassrooms.com
353/467
Sans pipeline
Quoiqu'il en soit, ces tapes sont plus ou moins indpendantes, mais sont excutes l'une aprs l'autre, dans l'ordre, sur un
processeur sans pipeline.
Sans pipeline, on est oblig d'excuter les instructions les unes aprs le autres. Ce n'est qu'une fois une instruction termine
qu'on peut passer la suivante. Dit autrement, on ne peut commencer excuter une instruction que lorsque la dernire tape de
l'instruction prcdente est termine.
www.openclassrooms.com
354/467
Dans l'exemple du dessus, on a un pipeline 5 tages. Comme vous le voyez, durant le cycle not 4, 4 instructions diffrentes
sexcutent : la premire est l'tape MEM, la seconde l'tape EX, la troisime l'tape ID, la quatrime l'tape IF, et un tage
ne sert rien (il aura pu servir et on aurait alors eu 5 instructions excutes en mme temps).
Le nombre total d'tapes ncessaires pour effectuer une instruction (et donc le nombre d'tages du pipeline) est appel la
profondeur du pipeline. Plus ce nombre est grand, plus notre pipeline peut excuter d'instructions en mme temps. Du moins en
thorie, parce qu'on va voir qu'il y a quelques petites subtilits qui viennent mettre leur grain de sel.
Par exemple, dans
l'exemple du dessus, un tage tait inutilis : et bien sachez que pour diverses raisons qu'on abordera plus tard, ce genre de cas
est possible, et est mme frquent.
Pour les curieux, voici les longueurs de pipeline de certains processeurs plus ou moins connus.
Processeur
Longueur du pipeline
Motorola PowerPC G4
MIPS R4400
Intel Itanium
10
Intel Pentium II
14
Intel Pentium 3
10
20
AMD Athlon
12
AMD Athlon 64
16
16
Sun UltraSPARC IV
14
www.openclassrooms.com
355/467
chacun de lexcution d'une tape, doivent utiliser des circuits indpendants : impossible de rutiliser un circuit dans plusieurs
tapes.
Dans un processeur sans pipeline, plusieurs tapes diffrentes d'une mme instruction peuvent utiliser le mme circuit. Par
exemple, le circuit charg d'effectuer l'addition (l'additionneur) peut tre utilis :
pour augmenter la valeur du registre d'adresse d'instruction durant l'tape de fetch, afin de le faire pointer sur l'adresse de
l'instruction suivante ;
pour calculer l'adresse d'une oprande si besoin est (gnralement, les calculs d'adresses sont des bases sur des
additions, des multiplications et ventuellement des dcalages) ;
puis pour effectuer l'addition lors de l'tape d'exec;
pour calculer l'adresse laquelle sauvegarder le rsultat de l'instruction d'addition si besoin.
Cela ne pose pas le moindre problme : aprs tout, ces tapes ne sont jamais simultanes sur de tels processeurs et partager le
mme circuit pour des tapes diffrentes permet d'viter de dupliquer des circuits. Dans notre exemple avec l'additionneur, cela
permet d'utiliser un seul additionneur au lieu de 3 ou 4.
Mais sur un processeur dot de pipeline, on ne peut se permettre ce genre de chose. Il est prfrable que chaque tape aie son
propre unit de traitement ddie pour viter diffrentes tapes de se partager le circuit. Imaginez que deux instructions dans
des tapes diffrentes aient besoin du mme circuit : il est impossible de partager le circuit en deux et d'en donner la moiti
chaque instruction. Un processeur utilisant un pipeline utilisera donc beaucoup plus de transistors et de portes logiques pour
fonctionner, ce qui a un certain cout.
Mine de rien, cette sparation ne fait pas tout : certaines ressources, comme les registres ou le bus mmoire peuvent tre
partages entre instructions : sur un processeur dot de pipeline, deux instructions peuvent vouloir manipuler le mme registre
ou le bus mmoire, et il faudra grer ce genre de cas avec des techniques plus ou moins labores.
On comprend qu'il est important de sparer les units en charge de chaque tape. Il existe pour cela diverses approches qu'on va
www.openclassrooms.com
356/467
Comment on fait ?
Certains pipelines intercalent des registres entre chaque tage du pipeline pour les rendre indpendants. Ces registres jouent le
rle de tampon et isolent chaque tage des autres.
Exemple avec un pipeline 4 tages.
Ces registres sont des registres compltements invisible pour le programmeur : on ne peut pas manipuler ceux-ci avec des
instructions du type load, store, ou d'autres instructions cense pouvoir manipuler le contenu d'un registre. Il n'ont donc pas
de nom, et sont accessibles que par les units en charge de chaque tape.
Quand une unit fini son travail, elle crit son rsultat dans le registre. Quelques instants plus tard, l'unit en charge de l'tape
suivante lira le contenu de ce registre et pourra alors effectuer l'tape qui lui est attribue. Le tout est de savoir quand lunit
suivante lira le contenu de ce registre.
Buffered Synchrones
Sur certains processeurs, le pipeline est synchronis sur l'horloge de notre processeur. Chaque tage du pipeline met donc un
cycle d'horloge pour effectuer son travail. Il va lire le contenu du registre qui le relie l'tape qui le prcde au dbut du cycle et
va dduire le rsultat qu'il crira dans le registre qui le relie lunit suivante juste avant le prochain cycle d'horloge.
Pour viter les ennuis, on fait en sorte que la frquence de l'horloge soit suffisamment petite pour viter que le contenu d'un
registre n'aie pas fini d'tre lu (par l'tage le suivant) avant d'tre modifi par l'tage qui le prcde.
Ce sont ce genre de pipeline que l'on trouve dans les processeurs Intel et AMD les plus rcents.
Buffered Asynchrones
Sur d'autres pipelines, il n'y a pas d'horloge pour synchroniser le passage des rsultats d'un tage un autre. Sur ces
www.openclassrooms.com
357/467
processeurs, chaque tage est reli par deux fils l'tage suivant : on nommera ces fils REQUEST et ACK.
Quand un tage a fini son travail, il envoie un 1 l'tage suivant sur le fil REQ, pour lui dire : " j'ai fini mon travail, et j'ai quelques
donnes pour toi " . Il va alors attendre que l'tage suivant soit libre et que celui-ci lui rponde : " je suis libre, je m'occupe de tes
donnes " en mettant le fil ACK 1. Suite cela, ces deux fils sont remis zro et nos tages peuvent se remettre au travail
chacun de leur cot.
Unbuferred pipeline
D'autres pipelines se dbrouillent sans registres intercals entre chaque tage, mais ceux-ci sont beaucoup plus rares.
En fait, il y a anguille sous roche : qui vous a dit que la frquence tait la mme ?
Car c'est un fait : possder un pipeline permet d'augmenter la frquence du processeur ! Et l, je suis sr que vous ne voyez pas
vraiment le rapport entre le pipeline et la frquence, et que quelques explications seraient les bienvenues. C'est une histoire de
temps de propagation.
www.openclassrooms.com
358/467
de notre circuit : sans cela, celui-ci ne sera pas synchronis avec les autres composants et notre processeur ne fonctionnera pas
!
Hors, un tage de pipeline est un mini-circuit capable d'effectuer un morceau d'instruction : il contient nettement moins de portes
logiques qu'un circuit capable dexcuter une instruction complte. Donc, un tage de pipeline possde un temps de propagation
nettement plus faible qu'un gros circuit capable d'effectuer une instruction rien qu' lui tout seul ! Vu que le temps de
propagation d'un tage est nettement plus petit que le temps de propagation de notre circuit sans pipeline, on peut alors
augmenter la frquence sans risques.
Gnralement, plus un processeur possde d'tages, plus il est facile d'augmenter sa frquence. Certains fabricants de
processeurs n'ont d'ailleurs pas hsit crer des processeurs ayant un nombre d'tages assez lev dans le but de faire
fonctionner leurs processeurs des frquences assez leves. C'est ce qu'a fait Intel avec le Pentium 4. A l'poque, la frquence
d'un processeur tait un excellent argument marketing : beaucoup de gens croyaient que plus un processeur avait une frquence
leve, plus il tait puissant. Les fabricants de processeurs cherchaient donc des moyens d'augmenter au maximum la frquence
de leurs processeur de manire sure, pour s'assurer de vendre beaucoup de processeurs. Le pipeline d'un Pentium 4 faisait ainsi
entre 20 tages (pour les Pentium 4 bass sur l'architecture Willamette et Northwood), 31 tages (pour ceux bass sur
l'architecture Prescott et Cedar Mill). Pour un exemple plus rcent, les processeurs AMD bass sur l'architecture Bulldozer
suivent un peu la mme approche.
Mais...
On pourrait croire que dcouper un processeur en x tages permet de multiplier la frquence par x. Pour vrifier ce qu'il en est, on
va vrifier cela avec un raisonnement simple. On va comparer le temps mit par notre instruction pour sexcuter sur deux
processeur identiques un dtail prt : le premier sera pipelin, et l'autre non.
Sur notre processeur sans pipeline, une instruction met un temps
pour sexcuter.
La dure
Vu que notre instruction met cycles pour sexcuter, on en dduit que le temps dexcution de notre instruction est donc gal
au nombre de cycles ncessaires pour excuter une instruction dure d'un cycle. Ce qui donne :
www.openclassrooms.com
359/467
Ce qui est suprieur . On voit donc que le pipeline augmente lgrement le temps mit pour excuter une instruction toute
seule. Mais en contrepartie on excute plusieurs instructions en une fois, ce qui donne un gros avantage au processeur pipelin.
On peut aussi dduire une autre chose de cette formule : plus un pipeline possde d'tages, plus il faut rajouter de registres entre
les tages et plus le temps
augmente. Ainsi, la dure d'une instruction augmente avec le nombre
d'tages. Ce qui peut tre fortement dsavantageux et nuire la performance de notre processeur.
De plus, il y a aussi un problme avec notre hypothse de base ; le dcoupage de notre processeur en tages n'est pas si simple,
et certains tages possdent beaucoup de portes logiques que les autres. Gnralement, c'est le dcoupage du squenceur qui
pose le plus de problme.
La dure d'un cycle d'horloge devra tre suprieure au temps de propagation de l'tage le plus fourni en portes logiques. En clair,
on se cale sur l'tage le plus lent, ce qui fait augmenter encore plus la dure d'une instruction.
Implmentation hardware
Dcouper un processeur en tages de pipeline n'est pas une chose facile. Suivant le processeur, le nombre d'tage varie
beaucoup, et leur contenu fait de mme. Tous nos pipelines ne se ressemblent pas : certains ont un grand nombre d'tapes,
d'autres se dbrouillent avec peu d'tapes. Aussi, dcouper un processeur en pipeline peut se faire de diffrentes manires.
Dans le chapitre sur la micro-architecture d'un processeur, on avait vu que nos instructions machines taient dcomposes en
plusieurs micro-oprations qu'on excutaient les unes pars les autres. Et ce nombre de micro-oprations varie suivant
l'instruction. Suivant le pipeline, on peut pipeliner lexcution des instructions machines, ou celle des micro-oprations. Nous
allons commencer par voir un pipeline simple dans lequel toutes nos instructions sexcuteront en une seule micro-opration. En
consquence, toutes les instructions ont le mme nombre d'tages. En consquence, certains tages sont inutiles pour certaines
instructions : vous allez voir de quoi je parle dans ce qui suit. On verra plus tard que les processeurs actuels fonctionnent
www.openclassrooms.com
360/467
autrement : ils ne pipelinent pas lexcution des instructions machines, et vont pipeliner lexcution des micro-oprations la
place. Mais passons.
Pipeline 7 tages
Nous allons prendre comme exemple un pipeline simple, compos de 7 tages :
PC : mise jour du Program Counter
Fetch : chargement de l'instruction depuis la mmoire ;
Decode : dcodage de l'instruction ;
Register Read : lecture des oprandes dans les registres ;
Exec : calcul impliquant l'ALU ;
MEM : accs mmoire en lecture ou criture ;
et Writeback : criture du rsultat d'une lecture ou d'un calcul dans les registres.
Avec cette description, on sait grosso-modo quoi mettre dans chaque tage. L'tage de PC va ainsi contenir le Program
Counter. L'tage de Fetch va devoir utiliser l'interface de communication avec la mmoire. L'tage de Decode contiendra l'unit
de dcodage d'instruction. L'tage de Register Read contiendra le Register File. L'tage d'Exec contiendra l'ALU, l'tage de MEM
aura besoin de l'interface avec la mmoire, et l'tage de Writeback aura besoin des ports d'criture du Register File.
Navement, on peut tre tent de relier l'ensemble de cette faon :
Datapath
Mais cela ne marchera pas ! Toutes les instructions n'ont pas besoin daccder la mmoire, tout comme certaines instructions
n'ont pas utiliser l'ALU ou lire des registres. Certains tages sont "facultatifs" : l'instruction doit quand mme passer par ces
tages, mais ceux-ci ne doivent rien faire. Par exemple, l'tage MEM ne doit rien faire pour toutes les instructions ne devant pas
accder la mmoire.
Court-circuit
Il faut donc trouver un moyen pour que nos tages ne fassent rien. Dans le cas o un tage doit tre rendu inactif, on peut le
court-circuiter en utilisant des multiplexeurs. C'est ainsi : une utilisation intelligente de multiplexeurs peut servir court-circuiter
certains tages du pipeline. Comme vous allez le voir, cela permet de grer certains modes d'adressage.
www.openclassrooms.com
361/467
Petite remarque : les tages de PC, Fetch et Decode ont toujours quelque chose faire. Toute instruction doit tre
charge et dcode, et le Program Counter mit jour, que l'on le veuille ou non. Il ne peuvent donc pas tre courtcircuits.
Tout d'abord, on peut remarquer que certaines instructions n'ont pas besoin daccder la RAM : on doit donc court-circuiter
l'tage de MEM. On peut ainsi grer les instructions comme les additions ou multiplication qui travaillent uniquement dans les
registres.
NOP
L'ALU aussi doit tre court-circuite dans certaines situations. On n'a pas besoin de l'ALU quand on veut changer le contenu
de deux registres ou qu'on veut envoyer le contenu d'un registre sur le bus d'adresse ou de donnes. Ceci dit, on n'a pas
forcment besoin d'utiliser des multiplexeurs : il suffit juste de faire en sorte que notre ALU puisse effectuer une instruction NOP,
savoir une instruction qui recopie une des entres de l'ALU sur sa sortie. Mme chose pour le Register File : il suffit
simplement de dconnecter ses entres et ses sorties : pas besoin de le court-circuiter.
Modes d'adressages
La lecture dans les registres peut tre court-circuit lors de l'utilisation de certains modes d'adressage. C'est notamment le cas
lors de l'usage du mode d'adressage absolu. Pour le grer, on doit envoyer l'adresse, fournie par l'unit de dcodage, sur lentre
d'adresse de l'interface de communication avec la mmoire.
www.openclassrooms.com
362/467
Le principe est le mme avec le mode d'adressage immdiat, sauf que l'on envoie une constante sur une entre de l'ALU.
Signaux de commandes
Les MUXs prsents dans notre pipeline doivent tre commands correctement. De mme, on doit aussi commander l'ALU, et la
mmoire, en leur envoyant des signaux de commande. Seulement, ces signaux de commande sont gnrs par l'unit de
dcodage, dans la second tage de notre pipeline. Comment faire pour que ces signaux de commande traversent le pipeline et
arrivent au bon moment aux MUXs et aux circuits configurer ? Relier directement les sorties de l'unit de dcodage aux circuits
incrimins ne marcherait pas : les signaux de commande arriveraient immdiatement aux circuits, sans temps d'attente : on
sauterait des tages !
La rponse consiste simplement faire passer nos signaux de commande d'un tage l'autre en utilisant des registres, comme
pour les entres-sorties des MUX et autres units.
www.openclassrooms.com
363/467
Branchements
Il ne nous reste plus qu'une dernire catgorie d'instruction implanter : les branchements.
Splitted branchs
Dans ce qui va suivre, nous allons prendre des instructions de branchements simples, qui ne font que brancher : les
comparaisons et branchements sont intgres dans des instructions part, et il n'y a pas d'instruction qui fusionne branchement
et comparaison. Dans ce cas, rien de bien compliqu : tout dpend du mode d'adressage des branchements. Pour un
branchement absolu, il suffit que l'unit de dcodage d'instruction envoie l'adresse laquelle brancher directement dans le
Program Counter.
www.openclassrooms.com
364/467
La gestion des branchements relatifs se fait d'une manire assez similaire, en ajoutant des multiplexeurs et un additionneur.
www.openclassrooms.com
365/467
Pour les branchements indirects, on doit relier la sortie du Register File au Program Counter, en utilisant quelques
multiplexeurs, et le tour est jou.
Fused branch
Pour les processeurs qui fusionnent les tests et branchements en une seule instruction, tout change. Cette fois-ci, le choix de
l'adresse laquelle brancher doit s'effectuer une fois le test effectu. Ce test est effectu par l'ALU, et son rsultat va servir
commander des MUXs qui dtermineront la mise jour du Program Counter.
www.openclassrooms.com
366/467
Pipelines complexes
Avec le pipeline 7 tages vu plus haut, on fait face un dfaut assez gnant. Avec ce genre de pipeline, toutes les instructions
ont exactement le mme nombre d'tages. Cela a de gros avantages, avec notamment une gestion simplifie du pipeline, et une
conception plus simple. Mais cela a aussi quelques dsavantages : la gestion des instructions multicycles est assez complique.
Voyons pourquoi.
Micro-oprations
Si vous regardez bien, vous verrez que certains tages sont inutiles pour certaines instructions. Par exemple, si je prends une
instruction qui effectue une addition entre deux registres, un des tages ne servira rien : l'tage MEM. Normal, notre instruction
n'accdera pas la mmoire. Et on peut trouver beaucoup d'exemples de ce type. Par exemple, si je prends une instruction qui
copie le contenu d'un registre dans un autre, aie-je besoin de l'tage d'Exec ou de MEM ? Non ! En clair : c'est un peu du gchis.
Si on regarde bien, on saperoit que ce problme de nombre de micro-oprations variable vient du fait qu'il existe diverses
classes d'instructions, qui ont chacune des besoins diffrents.
Sur un processeur non pipelin, on aurait pu viter de passer par ces tages inutiles. Si vous vous rappelez bien, un processeur
normal va dcouper notre instruction machine en micro-oprations, qu'il excutera dans un ordre bien prcis. Et le nombre de
micro-oprations utilis par une instruction peut varier sans aucun problme : une instruction prendra alors juste ce qu'il faut de
micro-oprations pour sexcuter. Mais avec notre pipeline de longueur fixe, ce n'est pas possible : toutes les instructions
utilisent un nombre identique de micro-oprations, chaque micro-opration tant un des tages du pipeline situ aprs l'tage de
Decode.
Principe
Pour rsoudre ce problme, il suffit d'avoir une petite ide : faire varier la longueur du pipeline suivant l'instruction. Si on
remarque bien, certains tages sont communs toutes les instructions : la mise jour du Program Counter, le Fetch, l'tage de
Dcodage, etc. Mais pour les autres tages, il arrivent que ceux-ci soient facultatifs dans certaines instructions. Dans ce cas,
pourquoi ne pas placer ces tages facultatifs en parallle les uns des autres, et partager les tages communs ?
Avec cette technique, le pipeline de notre processeur est dcompos en plusieurs parties. La premire partie est celle qui est
commune toute les instructions : elle s'occupe de calculer l'adresse de la prochaine instruction, de la charger depuis la mmoire,
de la dcoder, et parfois plus. Cette partie fonctionne de manire identique pour toutes les instructions. On l'appelle le Front
www.openclassrooms.com
367/467
End. Ce Front End est ensuite suivi par une partie du pipeline que l'on nomme le Back End .
Ce Back End est lui-mme dcompos en plusieurs units, chacune adapte un certain type d'instruction. Ainsi, une partie du
Back End sera spcialis pour les instructions arithmtiques et logiques, qui se passent de l'tape MEM. Une autre partie sera
spcialise dans les oprations d'accs mmoires, qui passent par toutes les tapes du pipeline. Une autre sera rserve aux
instructions d'change de donnes entre registres, qui se passent des tages Exec et MEM. Et ainsi de suite. On peut considrer
que chaque type d'instruction dispose de son propre Back End , spcialis, et dont la longueur peut varier suivant le type
d'instructions.
RISC
Le cas le plus simple est celui des processeurs RISC : leur faible nombre de modes d'adressages, et leur simplicit va grandement
aider. Grosso-modo, le fait que nos processeurs RISC sont des processeurs de type Load-Store va grandement nous aider : nos
processeurs RISC ont des instructions simples, qui ne mlangent pas les accs mmoires avec des oprations arithmtiques
et/ou logiques. Les instructions arithmtiques et logiques sont plus simples : elles naccdent pas la mmoire et vont
simplement aller trifouiller les registres. Quand aux instructions d'accs mmoires, elles vont simplement calculer une adresse
avant d'aller lire ou crire dans celle-ci.
Dans ce cas, on peut dcouper notre Back End en deux : une partie du pipeline est rserve aux instructions arithmtiques et
logiques, tandis qu'une autre est rserve aux instructions mmoires. Notre processeur a juste fournir deux grosse units : une
pour les accs mmoire, et une autre pour les calculs. Il suffit alors de les placer en parallle et de rediriger linstruction dans
l'unit qui la prend en charge.
www.openclassrooms.com
368/467
On se retrouve ainsi avec un pipeline contenant un tage de moins. Le pipeline contient donc les tages suivant :
PC Update ;
Fetch ;
Decode ;
Registre Read ;
Exec ;
Write Back.
La ruse vient du fait que l'tage d'Exec est diffrente suivant chaque instruction. Les instructions arithmtiques sexcuteront
dans leur unit ddie, et les instructions d'accs mmoire auront leur propre unit spcialise dans les lectures et critures. On a
www.openclassrooms.com
369/467
Placer des units en parallle a un avantage : il est possible d'envoyer des instructions diffrentes dans des units spares en
parallle. C'est possible si l'on dispose d'instructions multicycles, ou que le processeur est prvu pour. On en reparlera dans la
suite du tutoriel, mais pour le moment, oubliez ce que je viens de dire. Reste que ce Back End peut s'organiser de diverses
faons.
CISC
Mais sur les processeurs qui possdent un grand nombre d'instructions complexes, ou d'instructions avec des modes
d'adressages complexes, la situation est assez difficile rsoudre. Il est alors trs difficile de faire en sorte que nos instructions
prennent juste ce qu'il faut de micro-oprations pour leur excution. C'est notamment trs difficile de pipeliner des processeurs
dont certaines instructions peuvent effectuer plusieurs accs mmoires.
Imaginez par exemple, un processeur qui possde une instruction permettant d'additionner deux nombres, et qui va chercher ses
oprandes en mmoire, avant d'aller enregistrer son rsultat en mmoire. Cette instruction peut tre trs utile pour additionner le
contenu de deux tableaux dans un troisime : il suffit de placer cette instruction dans une boucle, avec quelques autres
instructions charges de grer l'indice et le tour est jou. Notre instruction se dcomposerait alors en beaucoup d'tapes :
Le calcul de l'adresse de l'instruction (PC update) ;
le chargement de l'instruction depuis la mmoire d'instruction ;
le dcodage de celle-ci ;
une tape de calcul d'adresse de la premire oprande ;
le chargement de loprande (depuis la mmoire) ;
une tape de calcul d'adresse de la seconde oprande ;
www.openclassrooms.com
370/467
le chargement de loprande ;
lexcution de l'addition ;
le calcul de l'adresse du rsultat ;
lenregistrement du rsultat en mmoire.
On se retrouverait alors avec un pipeline compos de 10 tages minimum. Dans la ralit cela pourrait aller plus loin. Mais une
grande partie de ces tages ne servirait que pour les quelques rares instructions devant effectuer plusieurs accs mmoires. De
plus, certains tages seraient identiques : avoir trois tages chargs de calculer des adresses, c'est de la duplication de circuits
un peu inutile.
La seule solution, c'est de dcouper nos instructions machines en sous-instructions qui seront alors charges dans notre
pipeline. Pour faire simple, notre instruction machine est charge depuis la mmoire dcode, et transforme par le dcodeur
dinstructions en une suite de micro-instructions, qui sont excutes chacune dans un ordre bien prcis. Ces micro-instructions
sont directement excutables par notre pipeline. Il va de soit que cette organisation complique pas mal le fonctionnement du
squenceur et du pipeline. Par exemple, l'instruction mentionne au-dessus serait dcoupe en deux lecture, une instruction
d'addition, et une criture. Cela permet d'utiliser le pipeline RISC vue au-dessus.
Instructions multicyles
Nous avons donc rgl le cas des instructions multicycles dont le nombre de micro-oprations tait variable. Il suffit simplement
d'envoyer ces instructions dans des units spares suivant leurs besoins. Mais il nous reste un cas assez particulier
d'instructions multicycles rgler.
Avec un pipeline comme le pipeline 7 tages qu'on a vu au-dessus, chaque tage dispose de seulement un cycle d'horloge pour
faire son travail, et pas plus. Par exemple, toutes les oprations arithmtiques et logiques doivent se faire en un seul cycle. Le
temps de propagation des circuits de l'ALU va devoir se caler sur lopration la plus complexe que celle-ci peut effectuer. Autant
vous dire qu'en faisant cela sur un processeur qui implmente des oprations complique comme la division, on est mort : la
frquence du processeur ne dpassera pas les 20 Mhz, et il vaudrait mieux abandonner notre pipeline rapidement et revenir un
processeur tout ce qu'il y a de plus normal. En faisant cela, dans notre pipeline 7 tages, toutes les instructions devront donc
sexcuter en 7 cycles d'horloge, sans possibilit d'avoir de rab. Toutes les instructions doivent se caler sur la plus lente d'entre
elle.
Pour viter cela, on peut permettre nos instructions de prendre un nombre de cycles d'horloge variable pour sexcuter.
Certaines instructions pourront alors prendre 7 cycles, d'autres 9, d'autres 25, etc. Avec cette solution, on se retrouve face
quelques complications techniques, qu'il faudra grer.
Stalls
La solution la plus simple consiste simplement faire en sorte que notre instruction multicycle occupe d'unit de calcul durant
plusieurs cycles. Si jamais une instruction a besoin d'utiliser l'ALU durant 4, 5 cycles, elle reste dans l'tage d'Exec durant autant
de cycles qu'elle en a besoin.
Si jexcute une instruction multi-cycle qui monopolise l'ALU, il est vident que l'unit de calcul est inutilisable tant que cette
instruction multicycle n'est pas termine. Elle ne peut pas commencer excuter une nouvelle instruction. Si une instruction veut
www.openclassrooms.com
371/467
utiliser la mme unit de calcul au mme moment, on est face un problme. On fait alors face ce qu'on appelle une dpendance
structurelle : plusieurs instructions veulent occuper un mme circuit en mme temps. Ici, le circuit en question est l'ALU.
Pour viter tout problme, notre unit de dcodage est mise au courant du fait que notre ALU est occupe et ne peut pas
dmarrer de nouvelle instruction. Si jamais une instruction qui utilise l'ALU arrive la fin du Front End, le processeur va vrifier
que l'ALU est libre. Si elle ne l'est pas, la nouvelle instruction va devoir attendre que l'ALU se libre. Pour faire attendre cette
instruction, on est oblig de bloquer le fonctionnement de certains tages du pipeline. Tout les tages qui prcdent l'ALU ne
peuvent alors plus rien faire : l'instruction reste bloque l'tage de Decode, et toutes les instructions dans les tages
prcdents sont aussi bloques. Ce blocage et cette dtection des dpendance structurelle est effectue par quelques circuits
implants dans le processeur. Le blocage proprement dit est assez simple raliser : il suffit de ne pas faire parvenir l'horloge aux
registres intercals entre les tages tant que la dpendance n'est pas rsolue.
Par exemple, on peut avoir une ALU principale, spcialise dans les oprations qui durent un cycle d'horloge (additions,
soustractions, dcalages, etc). Puis, cot, on peut avoir une ALU pour les multiplications , et une autre pour les divisions.
Prenons un exemple : on veut effectuer une instruction de multiplication, qui dure 5 cycles. Sans units de calcul parallle, tout le
pipeline est bloqu : la seule ALU est occupe par la multiplication. Avec plusieurs ALUs, les autres ALU sont disponibles par
effectuer des oprations plus simples : des additions, des soustractions, etc.
En thorie, on peut supprimer toute dpendances structurelles totalement en ajoutant autant d'ALU que notre instruction met de
cycles pour sexcuter. Si on voulait garder des ALU multifonction, il faudrait dupliquer cette grosse ALU en normment
d'exemplaire pour seulement une instruction. Autant dire qu'avec des divisions de 80 cycles, c'est pas la peine d'essayer : c'est
trop couteux en circuits. Prenons un exemple : toutes mes instructions arithmtiques prennent un cycle, part la multiplication
qui prend 5 cycles et la division qui prend 40 cycles. Je peux supprimer toute dpendance structurelle en utilisant une ALU pour
les oprations en 1 cycle, 5 ALU capable de faire une multiplication, et 40 ALU capables ddies aux division.
videmment, aucun processeur ne fait cela : vous imaginez placer 80 diviseurs dans un processeur, alors que cette opration est
une des plus rare qui soit ? Cette technique consistant dupliquer les ALUs est souvent couple avec la technique du Stall.
Pipelined ALU
Mais dupliquer des ALU n'est pas la seule solution : on peut aussi pipeliner nos units de calculs. Si jamais vous avez une
opration qui prend 5 cycles, pourquoi ne pas lui fournir un seul circuit, et le pipeliner en 5 tages ? Pour certains circuits, c'est
possible. Par exemple, on peut totalement pipeliner une unit de multiplication.
www.openclassrooms.com
372/467
En faisant ainsi, on n'a pas besoin de bloquer notre pipeline : on n'a plus aucune dpendance structurelle. Il est possible de
dmarrer une nouvelle multiplication chaque cycle d'horloge dans la mme ALU.
Ceci dit, certaines instructions se pipelinent mal, et leur dcoupage en tages se fait assez mal. Il n'est ainsi pas rare d'avoir
grer des units de calcul dont chaque tage peut prendre deux trois cycles pour sexcuter. Par exemple, voici ce que cela
pourrait donner avec une ALU spcialise dans les divisions, dont chaque tage fait 10 cycles.
Avec une telle ALU, il faut attendre un certain temps (10 cycles) avant de pouvoir envoyer une nouvelle division dans notre
pipeline. Ceci dit, cela ne pose pas souvent de problmes. Les divisions sont trs rares, et il est rare qu'on en lance deux moins
d'une centaine de cycles dintervalle. Et c'est aussi valable pour d'autres instructions assez rares. Autant dupliquer des ALU
pour des instructions courantes est utile, autant dupliquer des units de division ou des units spcialises dans des
instructions rares ne sert pas grand chose : vitons de gaspiller des circuits.
www.openclassrooms.com
373/467
Interruptions et Pipeline
Maintenant, nous devons parler un peu des interruptions et des exceptions. Pour rappel, ces interruptions sont des
fonctionnalits de notre processeur qui permettent d'interrompre temporairement lexcution d'un programme pour xecuter un
morceau de code. Il existe divers types d'interruptions : logicielles, matrielles, et les exceptions. Les interruptions logicielles
peuvent tre vus comme des appels de sous-programmes spciaux, tandis que les interruptions matrielles servent grer nos
priphriques. Quand aux exceptions, elles servent traiter des erreurs exceptionnelles qui ne devraient pas arriver dans un code
bien conu : un opcode non reconnu, une division par zro, une erreur de protection mmoire, etc.
Sur un processeur purement squentiel, ces interruptions et exceptions ne posent aucun problme. Mais si on rajoute un
pipeline, les choses changent : nos interruptions et exceptions vont alors jouer les troubles ftes. Voyons cela par l'exemple.
Imaginons que je charge une instruction dans mon pipeline. Celle-ci va alors gnrer une exception quelques cycles plus tard.
Cette exception est indique en rouge sur le schma.
Seul problme, avant que l'exception aie eu lieu, notre processeur aura continu charger des instructions dans notre pipeline. Il
s'agit des instructions en jaune. Et ces instructions sont donc en cours dexcution dans notre pipeline...alors qu'elles ne
devraient pas. En effet, ces instructions sont places aprs l'instruction qui est l'origine de notre exception dans l'ordre du
programme. Logiquement, elles n'auraient pas dues tre excutes, vu que l'exception est cense avoir fait brancher notre
processeur autre part.
Que faire de ces instructions excutes trop prcocement ? Dans ce cas, il y a deux solutions : soit on s'en moque, et on laisse
ces instructions finir leur excution, soit on trouve un moyen pour que ces instructions ne fassent rien. Dans la premire
solution, on se moque de ce problme, et on ne prend aucune mesure. Tout se passe comme si l'exception avait eu lieu avec du
retard : on dit que l'exception est imprcise. Certains processeurs se contentent d'utiliser des interruptions et exceptions
imprcises : certains processeurs MIPS ou ARM sont dans ce cas. Mais cela pose quelques problmes pour les programmeurs,
qui doivent faire avec ces interruptions dcales. Autant dans la majorit des cas cela ne pose pas de problmes, autant cela
peut devenir un vritable enfer dans certaines situations.
Pour faciliter la vie des programmeurs, certains processeurs ont dcids de supporter des interruptions prcises. Par
interruptions prcises, on veut dire que ces interruptions ne se font pas aprs un temps de retard. Lorsque ces interruptions
sexcutent, le processeur fait en sorte que tout se passe bien, en remettant le pipeline en ordre. Pour ce faire, il existe diverses
solutions. Certaines de ces solutions ne permettent que de grer des interruptions logicielles et des exceptions prcises, mais se
foutent des interruptions matrielles. D'autres de ces techniques sont plus polyvalentes et grent tous les types d'interruptions
de faon prcise.
NOP Insertion
Pour viter tout problme, on doit faire en sorte que les instructions charges en trop ne fassent pas de dgts dans notre
processeur. La solution la plus simple consiste placer des instructions inutiles aprs le branchement. Avec ces instructions, le
processeur chargera des instructions qui ne feront rien dans notre pipeline, jusqu ce que l'adresse laquelle brancher soit
connue.
Dans l'exemple du dessus, l'exception est prise en compte avec 2 cycles dhorloge de retard. Il suffit donc de placer deux
instructions inutiles juste aprs l'instruction pouvant causer une exception. Celle-ci est indique en jaune dans le schma qui
www.openclassrooms.com
374/467
suit.
Le seul problme, c'est qu'insrer ces instructions n'est pas trivial. Si on n'en met pas suffisamment, on risque de se retrouver
avec des catastrophes. Et si on en met trop, c'est une catastrophe en terme de performances. Et dduire le nombre exact
d'instruction inutiles ajouter ncessite de connaitre le fonctionnement du pipeline en dtail. Autant dire que niveau portabilit,
c'est pas la joie !
Au lieu d'insrer ces instructions directement dans le programme, les concepteurs de processeur ont dcid de faire en sorte que
le processeur se charge lui-mme de grer nos exceptions et interruptions correctement. Et pour cela, ils ont invents diverses
techniques.
In-Order Completion
Pour limiter la casse, d'autres techniques de gestion des exceptions ont ts inventes. Et celles-ci sont spculatives. Par
spculatives, on veut dire que le processeur va faire des paris, et excuter des instructions en spculant quelque chose. Ici, le
processeur va spculer que les instructions qu'il vient de charger ne lvent aucune exception, et qu'il peut les excuter sans
aucun problme. Si la spculation tombe juste, le processeur continuera excuter ses instructions, et aura vit des Pipeline
Bubbles inutiles. Mais si jamais cette prdiction se rvle fausse, il va devoir annuler les dommages effectus par cette erreur de
spculation.
Au final, ce pari est souvent gagnant : les exceptions sont quelque chose de rare, tandis que les instructions capables d'en lever
son monnaies courantes dans un programme. Beaucoup d'instructions peuvent lever des exceptions, mais elles en lvent
rarement. On peut gagner en performance avec cette technique. Il faut toutefois signaler que cette technique ne marche que pour
les exceptions, pas pour les interruptions logicielles. Ces dernires vont toujours crer des vides dans le pipeline. Mais elles sont
rares, et cela ne pose pas de problmes.
Exemple
Prenons cet exemple : je charge deux instructions l'une la suite de l'autre dans mon pipeline. La premire est une lecture en
www.openclassrooms.com
375/467
mmoire et prend 8 cycles pour sexcuter, tandis que la seconde est une multiplication qui prend 4 cycles.
Ces deux instructions sont indpendantes, et pourtant, on est face un problme. On a beau avoir dmarr les instructions dans
l'ordre, les rsultats de ces instructions ne sont pas enregistres dans les registres ou la mmoire dans l'ordre impos par le
programme. En clair : si la premire instruction lve une exception, les rsultats de la seconde auront dj t enregistrs dans les
registres. Le mal est fait : tout se passe comme si l'exception avait t retard d'une instruction. Cela peut donner n'importe quoi.
On est donc face un problme : comment maintenir l'ordre d'arrive des rsultats dans les registres/la mmoire ?
Maintien de l'ordre
Dans sa version la plus simple, il s'agit de ce qu'on appelle un registre dcalage. Ce n'est rien de moins qu'un registre un peu
spcial, qui dcale son contenu vers la droite chaque cycle d'horloge. J'ose esprer que vous vous souvenez des dcalages, vu
dans le chapitre sur l'ALU.
Ce registre dcalage contient autant de bits qu'il y a d'tages dans notre pipeline. Chacun de ces bits signifiera que cet tage
est utilis par une instruction dmarre prcdemment. A chaque cycle d'horloge , ce registre est dcal d'un cran vers la droite.
Cela permet de prendre en compte le fait que chaque instruction progresse d'un tage chaque cycle d'horloge. Il va de soit que
ce dcalage est un dcalage logique, qui remplit les vides par des zros.
Lorsque l'unit de dcodage veut dmarrer lexcution d'une instruction, celle-ci va alors vrifier le nombre de cycles que va
prendre l'instruction pour sexcuter. Il va alors vrifier le bit numro i (en partant de la droite) de ce registre. Si il est 1, cela
signifie qu'une autre instruction est dj en cours pour cet tage. L'instruction va devoir attendre que cet tage soit libre dans
lunit de dcodage. En clair : on ajoute des Pipeline Bubbles. Si ce bit est 0, lunit va alors le placer 1, ainsi que tous les bits
prcdents. Cela permet d'viter qu'une instruction plus courtes aille sexcuter avant que notre instruction soit finie. Et
l'instruction sexcutera.
Version amliore
Dans ses versions plus labores, ce Result Shift Register contient, pour chaque instruction envoye dans le pipeline, non
seulement un bit qui prcise si l'tage est occup, mais aussi des informations sur l'instruction. L'unit de calcul qu'elle utilise, le
registre dans lequel elle veut stocker son rsultat, et l'adresse de l'instruction. Ces informations permettent de piloter l'criture
www.openclassrooms.com
376/467
des rsultats de nos instructions en mmoire, et sont utile pour d'unit de dcodage : cette dernire a besoin dinformations pour
savoir s'il faut gnrer ou non des Pipeline Bubbles.
Par exemple, on stocke l'adresse de l'instruction pour remettre le Program Counter sa bonne valeur, si une exception arrive. Et
oui, ce Program Counter est modifi automatiquement par l'unit de Fetch chaque cycle. Et si une exception arrive, il faut
trouver un moyen de remettre le Program Counter la bonne valeur : celle de l'instruction qui a leve l'exception, afin de pouvoir
savoir o brancher au retour de l'exception.
On stocke le registre de destination pour savoir dans quel registre cette instruction doit crire, et aussi pour savoir quels sont les
registres utiliss par les instructions en cours dans le pipeline. J'avais dit plus haut que pour l'unit de dcodage devait vrifier si
l'instruction qu'elle sapprte lancer va lire une donne crite pas une instruction encore dans le pipeline. Si c'est le cas, l'unit
de dcodage doit alors insrer des Pipeline Bubbles. Et bien la liste des registres crit pas les instructions prsentes dans notre
pipeline se trouve dans ce Result Shift Register.
En tout cas, notre Result Shift Register est un peu plus complexe. Celui-ci est compos d'entres, des espces de blocs de
mmoire qui stockent toutes les informations pour une instruction. Unit de calcul utilise, registre de destination, Program
Counter, et bit indiquant que l'tage est occup. Auparavant, avec la version simplifie du Result Shift Register, seul les bits
indiquant l'occupation d'un tage taient dcals vers la droite. Mais avec la version volue du Result Shift Register, ce sont
toutes les entres qui sont dcales d'un cran chaque cycle d'horloge.
Speculation Recovery
Maintenant, il nous reste savoir quand traiter et dtecter ces exceptions. Et pour cela, il n'y a pas de miracle : ces exceptions
sont dtectes dans le pipeline, quand elles sont leves par un circuit. Mais elles ne sont prises en compte qu'au moment
d'enregistrer les donnes en mmoire, dans l'tage de Writeback.
Mais pourquoi ?
Imaginez que dans l'exemple du dessus, les deux instructions lvent une exception des tages diffrents. Quelle exception
traiter en premier ?
Il va de soit qu'on doit traiter ces exceptions dans l'ordre du programme, donc c'est celle de la premire instruction qui doit tre
traite. Mais les deux exceptions ont lieu en mme temps.
En traitant les exceptions la fin du pipeline, on permet de traiter les exceptions dans leur ordre doccurrence dans le programme.
C'est trs utile quand plusieurs exceptions sont leves dans le pipeline.
www.openclassrooms.com
377/467
Une fois arriv la fin, un petit circuit combinatoire va alors vrifier ces bits (pour voir si une exception a t leve), et va agir en
consquence.
Register Checkpointing
La premire technique, le Register Checkpointing, est assez simple. Elle consiste faire des sauvegardes rgulires de nos
registres de temps autre, et rcuprer cette sauvegarde lors d'une exception. Il suffirait alors de poursuivre lexcution partir
de notre sauvegarde jusqu' retomber sur l'instruction qui lve l'exception, et agir en consquence.
Seul problme, cette solution est lente : sauvegarder tous les registres du processeur n'est pas gratuit. En consquence, cette
solution n'est donc jamais utilise.
Re-Order Buffer
La premire solution consiste excuter nos instructions sans se proccuper de l'ordre des critures, avant de remettre celles-ci
dans le bon ordre. Le tout sera d'envoyer dans le bon ordre les rsultats des instructions dans les registres. Pour remettre en
ordre ces critures, les rsultats des instructions seront mis en attente dans une sorte de mmoire tampon, avant d'tre autoriss
tre enregistrs dans les registres une fois que cela ne pose pas de problmes.
www.openclassrooms.com
378/467
Cette mmoire tampon s'appelle le Reorder Buffer, et elle fera l'objet d'un chapitre dans la suite du tutoriel. On la laisse de cot
pour le moment.
History Buffer
Autre solution pour retrouver les bonnes valeurs de nos registres : on laisse nos instructions crire dans les registres dans
l'ordre qu'elles veulent, mais on garde des informations pour retrouver les bonnes valeurs de nos registres. Ces informations
sont stockes dans ce qu'on appelle l'History buffer.
Une file
Cette sauvegarde doit tre faite pour chaque instruction. Ainsi, notre History buffer est organis en plusieurs entres, des
espces de blocs de mmoire qui de quoi revenir la normale pour chaque instruction. A chaque fois qu'on veut dmarrer une
instruction, on rserve une entre pour notre instruction, et on la rempli avec les informations qu'il faut. Une fois qu'on sait que
notre instruction s'est termine sans exception, on libre l'entre occupe par notre instruction. Pour grer nos instructions dans
l'ordre du programme, ces entres sont tries de la plus ancienne a la plus rcente. Voyons comment cela est fait.
Notre History buffer contient un nombre d'entre qui est fix, cbl une fois pour toute. Chacune de ces entres est identifie par
un nombre, qui lui est attribu dfinitivement.
Ces entres sont gres par leur identifiant. Le numro de l'entre la plus ancienne est ainsi mmoris dans une petite mmoire.
Cela permet de pointer sur cet entre, qui contient la prochaine donne enregistrer dans les registres ou la mmoire.
Quand cette entre quitte le History buffer, le numro, le pointeurs sur la dernire entre est augment de 1, pour pointer sur la
prochaine entre.
De mme, le numro de l'entre la plus rcente est aussi mmoris dans une petite mmoire. Il faut bien savoir o ajouter de
www.openclassrooms.com
379/467
nouvelles entres. Ainsi, le History buffer sait quelles sont les entres valides : ce sont celles qui sont situes entre ces deux
entres.
Quand on ajoute une instruction dans le History buffer, il ne faut pas oublier d'augmenter ce numro de 1.
Petit dtail : quand on ajoute des instructions dans le History buffer, il se peut que l'on arrive au bout, l'entre qui a le plus
grand nombre. Pourtant, le History buffer n'est pas plein. De la place se libre dans les entres basses, au fur et mesure que le
History buffer. Dans ce cas, on n'hsite pas reprendre depuis le dbut.
Exemple : je prends l'exemple prcdent, avec l'entre 4 occupe. Si je rajoute une instruction, je remplirais l'entre 5.
La prochaine entre tre remplie sera l'entre numrot 0. Et on poursuivra ainsi de suite.
www.openclassrooms.com
380/467
Mais cette valeur, dans quel registre la remettre en place ? Et bien on n'a pas trop le choix : on doit aussi se souvenir quel registre
t modifi par notre instruction.
Ensuite, il faut savoir si lexcution de l'instruction est termine. On va donc rajouter un bit Valid, qui indique si l'instruction est
termine.
De mme, il faut savoir si celle-ci s'est termine sans exception. Et on rajoute un bit Exception qui indique si l'instruction a leve
une exception. Avec cette technique, les exceptions sont encore une fois gres la fin de l'instruction : la dtection des
exceptions se fait au dernier tage de notre pipeline, exactement comme dans les techniques prcdentes.
Et enfin, si notre instruction lve une exception, on doit savoir o reprendre. Donc, on sauvegarde l'adresse de notre instruction.
Celle-ci est disponible dans le Program Counter.
Principe
Lorsqu'une instruction situe dans l'entre la plus ancienne a lev une exception, celle-ci est dtecte grce au bit Exception
dans l'entre qu'elle occupe. Il suffit alors d'annuler toutes les modifications faites par cette instruction et les suivantes. Pour
annuler les modifications d'une instruction, il suffit de remettre le registre modifi par l'instruction a son ancienne valeur. Pour
cela, on utilise les informations stockes dans l'History buffer.
Pour remettre les registres dans leur tat valide, on vide l'History buffer dans l'ordre inverse d'ajout des instruction. En clair : on
commence par annuler les effets de linstruction la plus rcente, et on continue de la plus rcente la plus ancienne jusqu' vider
totalement l'History buffer. Une fois le tout termin, on retrouve bien nos registres tels qu'ils taient avant l'xecution de
l'exception.
Future File
L'History Buffer possde un grand dfaut : en cas d'exception ou d'interruption, on est oblig de remettre les registres leur
bonne valeur. Et cela se fait en copiant la bonne valeur de l'History Buffer dans les registres. Et cela peut prendre du temps. Cela
peut trs bien ne pas poser de problmes : aprs tout, les exceptions sont rares. Seul problme : on verra dans les prochains
chapitres que les branchements posent des problmes similaires aux exceptions et que les solutions utilises pour nos
exceptions sont rutilisables. Mais les branchements sont beaucoup plus nombreux que les exceptions : environ une instruction
sur 10 est un branchement. Et dans ces conditions, l'History Buffer et ses remises en l'tat des registres sont trop lentes. On doit
donc trouver une autre alternative.
www.openclassrooms.com
381/467
enregistr dans le Future File. Les oprandes de nos instructions seront aussi lues depuis le Future File, sauf en cas
d'exception. En cas d'exception, les oprandes sont alors lues depuis l'autre Register File, celui qui contient les donnes valides
en cas d'exception.
Pour que ce dernier contiennent les bonnes donnes, on doit lui envoyer les rsultats des instructions dans le bon ordre. Pour
remettre en ordre ces critures, les rsultats des instructions seront mis en attente dans une sorte de mmoire tampon, avant
d'tre autoriss tre enregistrs dans les registres une fois que cela ne pose pas de problmes. Cette mmoire tampon est un
History Buffer modifi qu'on appelle le Re-Order Buffer. Celui-ci contient exactement la mme chose qu'un History Buffer normal,
un dtail prt : au lieu de stocker l'ancienne valeur d'un registre (celle avant modification), il stockera le rsultat de l'instruction.
www.openclassrooms.com
382/467
Tout se passe comme si notre branchement t retard, dcal de quelques cycles d'horloge. Durant ce temps de retard, les
instructions continueront d'tre charges dans notre pipeline. Il s'agit des instructions en jaune. Et ces instructions sont donc en
cours dexcution dans notre pipeline...alors qu'elles ne devraient pas. En effet, ces instructions sont places aprs le
branchement dans l'ordre du programme. Logiquement, elles n'auraient pas dues tre excutes, vu que notre branchement est
cense avoir fait brancher notre processeur autre part.
Pour viter tout problme, on doit faire en sorte que ces instructions ne fassent rien de mal, et qu'elles ne modifient pas les
registres du processeurs ou qu'elles ne lancent pas d'critures en mmoire.
Solutions non-spculatives
Comme on vient de le voir, nos branchements posent quelques problmes, et il a bien fallu trouver une solution. Pour cela,
quelques solutions simplistes ont t trouves, et c'est celles-ci dont on va parler en premier lieu.
Dlai de branchements
La solution la plus simple consiste inclure des instructions qui ne font rien la suite du branchement : c'est ce qu'on appelle un
dlai de branchement. Avec ces instructions, le processeur chargera des instructions qui ne feront rien dans notre pipeline,
jusqu ce que l'adresse laquelle brancher soit connue.
Prenons l'exemple d'un pipeline 4 tages, dans lequel l'adresse laquelle brancher est connue dans le deuxime tage. Il suffit
donc de placer une instruction inutile juste aprs le branchement. Celle-ci est indique en jaune dans le schma qui suit.
www.openclassrooms.com
383/467
En rajoutant juste ce qu'il faut d'instructions qui ne font rien, on vite les problmes. On peut limiter la casse en remplissant le
vide d'instructions qui suit le branchement par des instructions indpendantes du branchement, mais cela a ses limites : a n'est
pas toujours possible.
Mais pour rajouter juste ce qu'il faut d'instructions, il faut que notre compilateur sache quel tage du pipeline l'adresse du
branchement est connue. Et cela varie suivant les processeurs, mme pour des processeurs ayant un jeu d'instruction identique :
par exemple, cet tage n'est pas le mme entre un Core 2 Duo et un Pentium 4 ! Certains connaissent cette adresse tt, d'autres
plus tard. Autant vous dire qu'avec cette solution, il faudrait recompiler ou reprogrammer tous nos programmes pour chaque
processeur.
Pour limiter la casse, on peut faire en sorte que l'adresse laquelle brancher soit connue le plus tt possible. En concevant
correctement le pipeline, cela peut se faire plus ou moins difficilement. Mais d'autres solutions ont ts inventes, et on verra
celles-ci dans deux chapitres.
Instructions prdicats
Ceci dit, fournir des instructions pour supprimer des branchements est une bonne ide qui va plus loin que ce qu'on a vu plus
haut. Certains concepteurs de processeurs ont ainsi voulu crer des instructions plus gnrale, capables de supprimer un plus
grand nombre de branchements. Ainsi sont nes les instructions prdicat ! Ces instructions prdicat sont des instructions
"normales", comme des additions, copie d'un registre dans un autre, multiplication, accs mmoire, etc ; avec une diffrence :
elles ne font quelque chose que si une condition est respecte, valide. Dans le cas contraire, celles-ci se comportent comme un
nop, c'est dire une instruction qui ne fait rien !
www.openclassrooms.com
384/467
Utilit
Leur but ? Rendre les branchements inutiles pour la construction de petites structures de contrle de type Si...Alors ou
Si...Alors...Sinon. Avec ces instructions, il suffit dutiliser une instruction de test et de placer les instructions excuter ou ne
pas excuter (en fonction du rsultat de l'instruction de test) immdiatement la suite. Si la condition teste par l'instruction de
test est ralise, nos instructions feront ce qui leur est demand tandis qu'elles ne feront rien dans le cas contraire : c'est bien ce
qu'on attend d'un Si...Alors ou d'un Si...Alors...Sinon
Dfauts
videmment, ces instructions ont quelques dfauts : elles ne sont utiles que pour des Si...Alors ou des Si...Alors...Sinon
contenant peu d'instructions. Si ceux-ci contiennent beaucoup d'instructions, nos instructions prdicat ne feront rien durant
un moment alors qu'un branchement aurait permis de zapper directement les instructions ne pas excuter. De mme, ces
instructions entrainent l'apparition de dpendances de donnes : les instructions qui les suivent seront dpendantes de leur
rsultat. Ce ne serait pas le cas avec d'autres techniques comme la prdiction de branchement. Autant dire que ces instructions
ne rsolvent pas grand chose et que d'autres techniques doivent imprativement tre trouves.
Conclusion
Ces techniques seraient suffisantes si les branchements n'taient pas nombreux. Mais ce n'est pas le cas : diverses analyses
faites dans les annes 1985 ont montres que dans un programme, environ une instruction sur 15 tait un branchement dont plus
de la moiti taient des appels ou retours de sous-programme. Et depuis, la situation est devenue encore pire avec la
prminence de la programmation objet : celle-ci est souvent l'origine d'un plus grand nombre d'appels de fonctions (dans ce
genre de langages, les sous-programmes sont plus courts mais plus nombreux, avec moins d'instructions) et plus de
branchements indirects.
Autant dire que les branchements posent un srieux problme et empchent d'obtenir de bonnes performances avec notre
pipeline. Pour rsoudre ce problme, il a fallu trouver des techniques encore plus efficaces pour limiter la catastrophe. Voyons
lesquelles !
Prdiction de branchement
Pour viter ces temps d'attente, les concepteurs de processeurs ont invent ce qu'on appelle lexcution spculative de
branchement. Cela consiste essayer de deviner l'adresse vers laquelle le branchement va nous envoyer suivant sa nature, et
lexcuter avant que celui soit dcod et que l'adresse de destination soit connue. On va donc devoir essayer de prdire quel
sera le rsultat du branchement et vers quelle adresse celui-ci va nous envoyer.
www.openclassrooms.com
385/467
Erreurs de prdiction
Bien videmment, une erreur est toujours possible : le processeur peut se tromper en faisant ses prdictions : il peut se tromper
d'adresse de destination par exemple. Et le processeur doit viter tout problme.
On a alors deux cas :
soit les instructions charges en avance sont les bonnes : le processeur a donc gagn du temps et continue simplement
son excution ;
soit les instructions prcharges ne sont pas les bonnes : c'est une erreur de prdiction.
Que faire lors d'une erreur de prdiction ?
Vider le pipeline
Dans ce cas, notre pipeline aura commenc excuter des instructions qui n'auraient pas du tre excutes. Il faut donc faire en
sorte que ces instructions n'enregistrent pas leurs rsultats et soient stoppes si possible. La gestion des mauvaises prdiction
dpend fortement du processeur, et certains sont plus rapides que d'autres quand il s'agit de grer ce genre de cas : certains
peuvent reprendre lexcution du programme immdiatement aprs avoir dtect la mauvaise prdiction (ils sont capables de
supprimer les instructions qui n'auraient pas du tre excutes), tandis que d'autres ne peuvent le faire immdiatement et doivent
attendre quelques cycles.
Dans le pire des cas, ces instructions qui n'auraient pas du tre charges ne peuvent pas tre interrompues et on doit attendre
qu'elles aient fini leur excution : elles vont poursuivre leur chemin dans le pipeline, et progresser tage par tage jusqu' leur
dernire tape. On est donc oblig d'attendre que celle-ci arrivent leur toute dernire tape avant de pouvoir faire quoique ce
soit : il faut que ces instructions quittent le pipeline et que celui-ci soit vid de ces instructions poubelle. Tant que ces
instructions ne sont pas sorties du pipeline, on est oblig d'attendre sans pouvoir charger d'instructions dans notre pipeline. Ce
temps d'attente est du temps de perdu.
Exemple : un pipeline 5 tages :
Fe : Fetching ;
De : Dcodage ;
Of : Operand Fetching ;
Ex : Excution ;
Wb : Write back.
On suppose que l'adresse de destination est connue l'tape Ex.
On suppose que l'on excute un branchement JMP dans notre pipeline et que celui-ci est mal prdit : le processeur se trompe
d'adresse de destination. Ce qui fait que tant que notre adresse destination relle n'est pas connue, notre processeur continue
charger les instructions partir de la fausse adresse de destination qu'il a prdit.
Dans le tableau qui va suivre, X reprsente des instructions qui doivent tre excutes normalement et Ix reprsente des
instructions qui n'auraient pas du tre executes. Les tirets reprsentent des tages qui ne font rien.
www.openclassrooms.com
386/467
tat du pipeline
Fe
De
Of
Ex
Wb
Normal
Jmp
X1
X2
X3
X4
Normal
I1
Jmp
X1
X2
X3
Vidage du pipeline
I2
I1
Jmp
X1
X2
Vidage du pipeline
I2
I1
Jmp
X1
Vidage du pipeline
I2
I1
Jmp
Vidage du pipeline
I2
I1
Vidage du pipeline
I2
Restauration du pipeline
Jmp
X1
X2
X3
X4
X265 Jmp
X1
X2
X3
Normal
A la ligne 3, le processeur repre une erreur de prdiction : au cycle d'horloge suivant, il ne chargera pas d'instruction et
commencera vider le pipeline. Une fois la pipeline vid, il faudra restaurer celui-ci son tat originel (avant lexcution du
branchement) pour viter les problmes, et recommencer excuter les bonnes instructions..
On remarque une chose importante dans notre exemple : cela prend 5 cycles pour vider le pipeline, et notre pipeline possde 5
tages. Ce temps d'attente ncessaire pour vider le pipeline est gal au nombres d'tages de notre pipeline. Sachez que c'est vrai
tout le temps, et pas seulement pour des pipelines de 5 tages. En effet, la dernire instruction tre charge dans le pipeline le
sera durant l'tape laquelle on dtecte l'erreur de prdiction : il faudra attendre que cette instruction quitte le pipeline, et qu'elle
passe par tous les tages de celui-ci.
Restaurer le pipeline
De plus, il faut remettre le pipeline dans l'tat qu'il avait avant le chargement du branchement dans le pipeline. Tout se passe lors
de la dernire tape. Et pour cela, on rutilise les techniques vues dans le chapitres prcdent. Les techniques qui nous servaient
pour les exceptions sont rutilises pour les mauvaises prdictions de branchements. Dans tous les cas, notre processeur doit
dtecter automatiquement les erreurs de prdiction : a utilise pas mal de circuits assez complexes.
Premire solution : faire en sorte que les modifications et calculs effectues par les instructions fautives ne soient pas
enregistres en mmoire ou dans les registres. Il faut donc faire en sorte que la dernire tape de ces instructions ne fasse rien et
n'enregistre pas les rsultats de ces instructions. Le rsultat de l'instruction, est recopi dans le registre final lors de leur dernire
tape si aucune erreur de prdiction n'a eu lieu. Dans le cas contraire, les modifications et manipulations effectues par notre
instruction ne sont pas crites dans le registre ou la case mmoire voulue et le tout est simplement oubli et perdu. Pour cela, on
peut forcer l'ordre de lenregistrement des rsultats en mmoire, afin que ceux-ci se fassent dans l'ordre, et autoriser les critures
la fin du pipeline. On peut aussi laisser nos instructions enregistrer leurs rsultats dans le dsordre : il suffit de stocker les
rsultats de nos instructions une sorte de mmoire tampon qu'on appelle le Reorder Buffer.
Deuxime solution : on laisse nos instructions crire leurs rsultats et manipuler leurs rsultats et on restaure les donnes
valides, qui auront pralablement ts sauvegardes quelque part dans le processeur. Cela peut se faire soit en utilisant un
History Buffer, ou un Future File.
www.openclassrooms.com
387/467
On remarque pourtant que certaines instruction sont potentiellement correctes : celles qui suivent le point d'arrive du
branchement. Elles ne le sont pas forcment : il se peut qu'elles aient des dpendances avec les instructions supprimes. Mais si
elles n'en ont pas, alors ces instructions auraient du tre excutes. Il serait donc plus efficace de les laisser enregistrer leurs
rsultats au lieu de les r-excuter lidentique un peu plus tard.
www.openclassrooms.com
388/467
Ce genre de choses est possible sur les processeurs qui implmentent une technique du nom de Minimal Control Dependancy.
En gros, cette technique fait en sorte que seules les instructions qui dpendent du rsultat du branchement soient supprimes
du pipeline en cas de mauvaise prdiction.
Sans la rponse cette question, impossible de charger les bonnes instructions, et on doit alors attendre que l'adresse de
destination soie connue : en clair, effectuer un dlai de branchement.
La prdiction de direction de branchement sert compenser ce manque en prdisant quelle sera l'adresse de destination. Bien
sur, une unit de prdiction de direction de branchement n'est pas un circuit extralucide, mais utilise quelques algorithmes
simples pour dduire l'adresse de destination.
Cette prdiction est plus ou moins facile suivant le type de branchements. La prdiction de branchement se moque qu'un
branchement soit conditionnel ou inconditionnel, ce qui l'intresse c'est de savoir si le branchement est :
www.openclassrooms.com
389/467
Ce Branch Target Buffer est souvent implment comme un cache fully associative : il est dcoup en lignes de cache qui
contiennent l'adresse de destination du branchement et dont le tag contient l'adresse du branchement. Pour prdire l'adresse de
destination d'un branchement, il suffit de vrifier les tags de chaque ligne et de comparer avec l'adresse du branchement
excuter : si un tag correspond, on a alors un Branch Target Buffer Hit et le Branch Target Buffer contient l'adresse de
destination du branchement. Dans le cas contraire, on ne peut pas prdire l'adresse de destination du branchement : c'est un
Branch Target Buffer Miss.
Le fonctionnement de lalgorithme de prdiction de branchement bas sur un Branch Target Buffer est simple. A la premire
excution du branchement, on attend donc que le branchement s'excute et on mmorise l'adresse du branchement ainsi que
l'adresse de destination. A chaque nouvelle excution de ce branchement, il suffit de lire l'adresse de destination contenue dans
le Branch Target Buffer et continuer l'excution du programme cette adresse. Il va de soit que cette technique ne peut rien lors
de la premire excution d'un branchement.
De plus, cela ne marche pas dans certains cas impliquant des branchements indirects, pour lesquels l'adresse de destination peut
varier. Lorsque cette adresse de destination change, le Branch Target Buffer ne sert rien et une erreur de prdiction a lieu.
Pour information, sachez que notre Branch Target Buffer ne peut stocker qu'un nombre limit d'adresses. Sur les processeurs x86
actuels, le nombre d'adresses est d'environ 64, et varie suivant le processeur. Quand le Branch Target Buffer est rempli et qu'un
nouveau branchement sexcute, on supprime les informations d'un branchement du Branch Target Buffer pour faire de la place.
Cela peut poser un problme : un branchement qui aurait pu tre excut dans un futur proche peut se retrouver supprim du
Branch Target Buffer. On ne peut prdire l'adresse vers laquelle il branchera alors qu'avec un Branch Target Buffer plus grand,
on aurait pu. Cela s'appelle un BTB Miss.
Pour limiter la casse, certains Branch Target Buffer ne mmorisent pas les branchements non-pris (du moins, ceux qui n'ont
jamais t pris auparavant). Cela permet de faire un peu de place et vite de remplacer des donnes utiles par une adresse qui ne
servira jamais. D'autres optimisations existent pour viter de remplir le Branch Target Buffer avec des adresses mmoires de
branchement inutiles, et permettre de garder un maximum de contenu utile dans le Branch Target Buffer. Pour cela, quand un
branchement doit tre stock dans notre Branch Target Buffer et que celui-ci est plein, il faut choisir quel branchements enlever
du Branch Target Buffer avec le plus grand soin. Si vous vous souvenez, notre Branch Target Buffer est une mmoire cache : et
bien sachez que les algorithmes vus dans le chapitre sur la mmoire cache fonctionnent merveille !
www.openclassrooms.com
390/467
destination valide lors de la dernire excution du branchement est stocke dans le Branch Target Buffer. A chaque fois que ce
branchement change d'adresse de destination, on se retrouve avec une mauvaise prdiction. Tous les processeurs moins rcents
que le Pentium M prdisent les branchements indirects de cette faon.
Certains processeurs haute performance sont capables de prdire l'adresse de destination d'un branchement indirect. A une
condition cependant : que l'adresse destination change de faon rptitive, en suivant une rgularit assez simple.
Ces techniques de prdiction de branchement indirect utilisent un Branch Target Buffer amlior. Ce Branch Target Buffer
amlior est capable de stocker plusieurs adresses de destination pour un seul branchement. De plus, ce Branch Target Buffer
amlior stocke pour chaque branchement et pour chaque adresse de destination des informations qui lui permettent de dduire
plus ou moins efficacement quelle adresse de destination est la bonne.
Mais mme malgr ces techniques avances de prdiction, les branchements indirects et appels de sous-programmes indirects
sont souvent trs mal prdits, mme avec un branch predictor optimis pour ce genre de cas. Pour information, ce type de
branchement est devenu plus frquent avec l'apparition des langages orients objets, les langages procduraux utilisant peu de
branchement indirects (c'est d'ailleurs une des raisons qui font que les langages orients objets sont plus lents que les langages
procduraux).
Prdiction de branchement
Maintenant, voyons comment notre processeur fait pour prdire si un branchement est pris ou non.
Prdiction statique
L'ide derrire la prdiction statique est simple. Suivant le branchement, on considre que celui-ci est soit toujours pris, soit
jamais pris. L'ide est de faire une distinction entre les diffrents types de branchements qui ont beaucoup de chance d'tre pris
et ceux qui ne seront jamais ou presque jamais pris.
Il faut savoir que :
un branchement inconditionnel est toujours pris, de mme qu'un branchement conditionnel dont la condition de saut est
vrifie ;
et qu'un branchement conditionnel dont la condition de saut n'est pas respecte est non-pris.
Ainsi, si on prdit qu'un branchement est non-pris, on pourra continuer lexcution des instructions qui suivent le branchement
dans la mmoire sans problme. A l'inverse si le branchement est prdit comme tant pris, le processeur devra recourir l'unit de
prdiction de direction de branchement.
L'algorithme de prdiction statique le plus simple est de faire une distinction entre branchements conditionnels et branchements
inconditionnels. Par dfinition un branchement inconditionnel est toujours pris, tandis qu'un branchement conditionnel peut tre
pris ou ne pas tre pris.
Ainsi, on peut donner un premier algorithme de prdiction dynamique :
les branchement inconditionnels sont toujours pris ;
les branchements conditionnels ne sont jamais pris.
www.openclassrooms.com
391/467
Lors de lexcution d'un branchement conditionnel, le processeur continue dexcuter les instructions qui suivent le
branchement dans la mmoire programme jusqu' ce que le rsultat du branchement conditionnel soit disponible. Si la prdiction
tait fausse, on recommenait partir de l'adresse vers laquelle pointait le branchement et continuait sinon.
Cette mthode est particulirement inefficace pour les branchements de boucles, o la condition est toujours vraie, sauf en sortie
de boucle ! Il a donc fallu raffiner lgrement l'algorithme de prdiction statique.
Une autre manire dimplmenter la prdiction statique de branchement est de faire une diffrence entre les branchements
conditionnels ascendants et les branchements conditionnels ascendants.
Un branchement conditionnel ascendant, aussi appel forward branch , est un branchement qui demande notre programme de
reprendre une instruction dont l'adresse est suprieure l'adresse du branchement. En clair, le branchement demande au
processeur de reprendre plus loin dans la mmoire.
Par exemple, prenons une structure de contrle Si...Alors : le branchement conditionnel est un forward branch . Ce branchement
renvoie des instruction ayant une adresse plus leve : l'instruction vers laquelle on branche est place aprs le branchement.
Un branchement conditionnel descendent, aussi appel backward branch , est un branchement qui demande notre programme
de reprendre une instruction dont l'adresse est infrieure l'adresse du branchement. En clair, le branchement demande au
processeur de reprendre plus loin dans la mmoire.
Par exemple, regardons la conception en assembleur d'une boucle Do...While : celle-ci est fabrique avec un backward branch .
Ce branchement renvoie des instruction ayant une adresse plus faible, plus haute : l'instruction vers laquelle on branche est
place avant le branchement.
www.openclassrooms.com
392/467
Hors, si vous regardez la traduction en assembleur des structures de contrle utilises dans les langages de programmation
structurs actuels, vous remarquerez que sous quelques hypothses (condition d'un if toujours pris et que les boucles excutent
au moins une itration), les forward branch sont rarement pris et les backward branch sont presque toujours pris. On peut ainsi
modifier lalgorithme de prdiction statique comme suit :
les branchements inconditionnels sont toujours pris ;
les backward branch sont toujours pris ;
les forward branch ne sont jamais pris .
Bien sr, cette prdiction statique est base sur quelques hypothses, comme mentionn plus haut : un Si...Alors a sa condition
vrifie et le branchement conditionnel n'est pas pris, par exemple (gnralisable au Si...Alors...Sinon, avec quelques subtilits).
Un programmeur peut ainsi, s'il connait la traduction de ses structures de contrle en assembleur, tenter de respecter au maximum
ces hypothses afin d'optimiser ses structures de contrle et leur contenu pour viter que les branchements de ses structures de
contrle soient mal prdits.
Sur certains processeurs, certains bits de l'opcode d'un branchement peuvent permettre de prciser si notre branchement est
majoritairement pris ou non-pris : ces bits spciaux permettent d'influencer les rgles de prdiction statique et de passer outre les
rglages par dfaut. Ainsi, un programmeur ou un compilateur peut donner lunit de prdiction de branchement des
informations sur un branchement en lui disant que celui-ci est trs souvent pris ou non-pris. Ces informations peuvent faire
passer outre les mcanismes de prdiction statique utiliss normalement. On appelle ces bits des Branch Hints.
Compteurs saturation
Avec la prdiction dynamique, il n'y a pas besoin de supposer que le branchement est pris ou pas suivant sa nature : l'unit de
prdiction de branchement peut le deviner dans certains cas. L'implmentation la plus simple de la prdiction dynamique est
base sur la technique des compteurs saturation. Pour cela, on mmorise chaque excution du branchement si celui-ci est
pris ou pas, et on effectue une moyenne statistique sur toutes les excutions prcdentes du branchement.
Par exemple, un branchement qui a dj t excute quatre fois, qui a t pris une seule fois et non-pris les 3 autres fois, a une
chance sur 4 d'tre pris et trois chances sur quatre d'tre pris. L'ide est donc de se souvenir du nombre de fois qu'un
branchement a t pris ou non-pris pour pouvoir dduire statistiquement la probabilit que ce branchement soit pris. Si cette
probabilit est suprieure 50%, le branchement est considr comme pris. Dans le cas contraire, notre branchement est
considr comme non-pris.
www.openclassrooms.com
393/467
L'ide, c'est d'utiliser un compteur ddi pour chaque branchement prsent dans le Branch Target Buffer, qui mmorisera le
nombre de fois qu'un branchement est pris ou non-pris. Ces compteurs sont des circuits lectroniques qui stockent un nombre
entier de N bits, dont la valeur est comprise entre et
. Ce nombre entier peut tre augment ou diminu de 1 selon le
rsultat de lexcution du branchement (pris ou pas).
Lorsqu'un branchement doit tre excut, l'unit de prdiction de branchement regarde si celui-ci a son adresse dans le Branch
Target Buffer. Si ce n'est pas le cas, on rserve une partie de cette mmoire pour ce branchement et le compteur est initialis
une certaine valeur, gnralement gale peu-prt la moiti de . Par la suite, si ce branchement est pris, le compteur sera
augment de 1. Dans le cas contraire, le compteur sera diminu de 1.
Pour dcider si le branchement sera pris ou pas, on regarde le bit de poids fort du nombre stock dans le compteur : si vous
regardez le schma au-dessus, vous remarquerez que le branchement est considr comme pris si ce bit de poids fort est 1.
Dans le cas contraire, notre branchement est donc considr comme non-pris.
Certains processeurs ont une unit de branchement qui se limite un seul compteur saturation auquel on a jout un Branch
Target Buffer et de quoi effectuer de la prdiction statique si jamais le branchement n'a jamais t excut ou si celui-ci n'est pas
un branchement conditionnel. C'est le cas du processeur Intel Pentium 1, par exemple. Pour la culture gnrale, il faut savoir que
le compteur saturation du Pentium 1 tait lgrement bugg.
www.openclassrooms.com
394/467
de branchement est capable de se souvenir des deux excutions prcdentes du branchement. Un branchement qui ferait : pris,
non-pris, non-pris, non-pris, pris, non-pris, non-pris, non-pris, etc ; demandera une unit de prdiction de branchements capable
de se souvenir des 4 dernires excutions d'un branchement.
Pour cela, on va utiliser un registre qui stockera l'historique des derniers branchements excuts. Ce registre est ce qu'on appelle
un registre dcalage. Ce registre dcalage fonctionne exactement comme un registre qu'on aurait coupl un dcaleur (ici, un
dcaleur par 1), qui est charg de dcaler le contenu de notre registre. A chaque fois qu'un branchement sexcute, on dcale le
contenu du registre et on fait rentrer dans celui-ci un 1 si le branchement est pris, et un zro sinon.
Pour chaque valeur possible contenue dans le registre, on trouvera un compteur saturation qui permettra de prdire quelle est
la probabilit que le prochain branchement soit pris. Ce registre est donc coupl plusieurs compteurs saturations : pour un
registre de n bits (qui se souvient donc des n derniers branchements excuts), on aura besoin de
compteurs saturation.
Chacun de ces compteurs permettra mmoriser le nombre de fois qu'un branchement a t pris chaque fois que que celui-ci a
t excut aprs s'tre retrouv dans une situation telle que dcrite par le registre. Par exemple, si le registre contient 010, le
compteur associ cette valeur (qui est donc numrot 010), sert dire : chaque fois que je me suis retrouv dans une situation
telle que le branchement a t non-pris, puis pris, puis non-pris, le branchement a t majoritairement pris ou non-pris.
En utilisant une unit de prdiction de branchement de ce type, on peut prdire tout branchement qui suivrait un schma qui
se rpte tous les branchements ou moins, en utilisant un registre d'historique de bits (et les
compteurs saturation
qui vont avec).
Certains processeurs se payent le luxe d'avoir un registre (et le jeu de compteurs saturation qui vont avec) diffrent pour
chaque branchement qui est plac dans le Branch Target Buffer : on dit qu'ils font de la prdiction locale.
www.openclassrooms.com
395/467
Global Predictor
D'autres, prfrent utiliser un registre unique pour tous les branchements : ceux-ci font de la font de la prdiction globale. Ces
units de prdiction de branchement incorporent un seul registre d'historique, qui est utilis pour tous les branchements. C'est
par exemple le cas du Pentium 4E qui utilise une unit de branchement capable de se souvenir des 16 derniers branchements
prcdents. Les processeurs AMD 64 utilisent quand eux un two level adaptative predictor avec un registre d'historique de 8
bits.
L'avantage de ces units de prdiction, c'est que d'ventuelles corrlations entre branchements sont prises en compte. Mais cela
a un revers : si deux branchements diffrents passent dans l'unit de prdiction de branchement avec le mme historiques, alors
ils modifieront le mme compteur saturation. En clair : ces deux branchements vont se marcher dessus sans vergogne : chacun
des branchements va interfrer sur les prdiction de l'autre!
Bien videmment, il faut absolument trouver une solution. Et c'est la raison d'tre des units de prdiction Gshare et Gselect.
Avec ces units de prdiction, limiter le plus possible les cas dans lesquels deux branchements diffrents avec la mme
historique utilisent le mme compteur saturation. Pour cela, on va effectuer une petite opration entre l'historique et certains
bits de l'adresse de ces branchements (leur Program Counter) pour trouver quel compteur utiliser.
Avec les prdicteurs Gshare, cette opration est un simple XOR entre le registre d'historique et les bits de poids faible de
l'adresse du branchement. Le rsultat de ce XOR donne ne numro du compteur utiliser.
Avec les prdicteurs Gselect, cette opration consiste simplement mettre cote cote ces bits et l'historique pour obtenir le
numro du compteur saturation utiliser.
www.openclassrooms.com
396/467
Agree Predictor
Le Two level adaptative predictor possde toutefois un lger problme : avec celui-ci, on prdit qu'un branchement est pris ou
non-pris en fonction des branchements qui le prcdent et qui ont chacun mit jour les compteurs saturation dans notre Two
level adaptative predictor. Ces compteurs saturation ne sont pas rservs un branchement et sont partags : seul le contenu
du registre d'historique permet de slectionner un de ces compteurs saturation.
Et le problme vient de l : deux branchements diffrents, excuts des moments diffrents peuvent devoir modifier le mme
compteur saturation : il suffit que les branchements qui prcdent ces branchements aient positionns le registre d'historique
la mme valeur. Et dans ce cas l, un branchement sera prdit non pas en fonction de son historique (est-ce que celui-ci a dj t
pris ou non-pris beaucoup de fois), mais aussi en fonction des excutions de branchements qui lui sont indpendants et qui ont
modifis le mme compteur. Et ces interfrences ont tendance entrainer l'apparition de mauvaises prdictions qui auraient pus
tre vites. Il faut donc trouver un moyen de limiter la casse.
Pour cela, 4 chercheurs ont dcids d'inventer une nouvelle unit de prdiction de branchements capable de rsoudre de
problme : l'agree predictor. Cet agree predictor va permettre de se souvenir pour chaque branchement individuel si celui-ci est
plus souvent pris ou non-pris en stockant cette information dans un bit spcial nomm le biasing bit . Ainsi, notre agree
predictor est divis en deux circuits : un Two level adaptative predictor normal, et un circuit qui va calculer le biasing bit . Ce
biasing bit est calcul avec l'aide d'un compteur saturation, reli au branch target buffer. Chaque branchement sera identifi
par son adresse dans le Branch target buffer (ce qui permet dindividualiser la prdiction en fonction du branchement pour
viter les interfrences) et chaque branchement aura un compteur saturation rien que pour lui, qui permettra de savoir si notre
branchement est souvent pris ou pas.
www.openclassrooms.com
397/467
Le dcision prendra compte des deux circuits de prdiction de branchement en vrifiant que ces deux units de branchement
sont d'accord. Lorsque les deux units de branchement ne sont pas daccord, c'est qu'il y a surement eu interfrence. Cette
dcision se fait donc en utilisant une porte XOR suivie d'une porte NON entre les sorties de ces deux units de prdictions de
branchement : faites la table de vrit pour vous en convaincre !
Loop Prdictor
Maintenant, il faut savoir que les units de prdiction de branchement des processeurs haute performance modernes sont
capables de prdire la perfection les branchements de certaines boucles : les boucles FOR, ainsi que quelques autres boucles
devant sexcuter
fois ( pouvant varier lexcution). De telles units de prdiction de branchement sont mmes capables
de prdire correctement le branchement qui fait sortir de la boucle en le considrant comme pris !
Comment ces units de prdiction de branchement sont capables d'une telle prouesse ?
C'est trs simple : leur unit de branchement contient un circuit spcialis dans la prdiction des branchements de ce genre de
boucles.
Pour rappel, pour une boucle devant sexcuter
fois ( dpendant de la boucle), les branchements permettant d'implmenter
cette boucle vont devoir sexcuter
fois : ils vont tre pris
fois, le dernier branchement tant mal prdit. Donc, la
solution est d'utiliser un compteur qui compte de de un en un partir de zro. A chaque fois que le branchement est excut, on
augmente la valeur contenue dans le compteur de 1. Tant que la valeur stocke dans le compteur est diffrente du nombre , on
considre que le branchement est pris. Si le contenu de ce compteur vaut , le branchement n'est pas pris.
Mais comment savoir la valeur de ce nombre
www.openclassrooms.com
398/467
utilisant la prdiction statique ou les compteurs saturation ou toute autre mthode de prdiction de branchement. De plus,
doit rester la mme chaque excution de la boucle.
De plus, le Loop Prdictor, qui ne peut prdire correctement qu'un nombre limit dexcution d'un branchement, gal au nombre
maximal de valeurs diffrentes stockables dans son compteur. Exemple : si un branchement utilis pour concevoir une boucle doit
sexcuter plus que 64 fois (au hasard 5000 fois), et que le Loop Predictor utilise un compteur pouvant compter jusqu 64
(valeur la plus grande connue ce jour, valable pour un core 2 duo), alors on aura une mauvaise prdiction tout les 64 excution
du branchement. Autre dtail : les branchements lintrieur des boucles interfrent avec le fonctionnement du Loop Predictor
et empchent celui-ci de voir qu'il a affaire une boucle : une autre mthode de prdiction des branchements sera utilise.
Eager execution
Comme vous le savez, un branchement peut tre pris ou non-pris. Le principe de la prdiction de branchement est de choisir une
de ces deux possibilits et de commencer lexcuter en esprant que ce soit la bonne. Les units de prdiction de branchement
se sont donc amliores de faon viter de se tromper, et choisissant la possibilit la plus probable. Mais si on rflchit bien, il
y a une autre manire de faire : on peut aussi excuter les deux possibilits sparment, et choisir la bonne une fois qu'on connait
l'adresse de destination du branchement. C'est ce qu'on appelle l'Eager Execution.
Pour information, sachez qu'il s'agit d'une technique assez avant-gardiste, qui n'est pas encore prsente dans les processeurs de
nos ordinateurs. Vous pouvez considrer que ce tutoriel est la pointe de la technologie.
Bien sr, on est pas limit un seul branchement, mais on peut poursuivre un peu plus loin.
On peut remarquer que cette technique ne peut pas se passer totalement de la prdiction de branchement. Pour pouvoir charger
les deux suites d'instructions correspondant un branchement pris et non-pris, il nous faut forcment savoir quelle est la
destination du branchement. On a donc encore besoin de notre unit de prdiction de direction de branchement. Mais on peut
thoriquement se passer de lunit de prdiction de branchement, charge de savoir si le branchement est pris ou non-pris. J'ai
bien dit thoriquement...
www.openclassrooms.com
399/467
suites d'instructions correspondant aux cas pris et non-pris. On ne peut plus en lancer qu'une.
Que faire ?
La solution est trs simple : on peut dcider de nexcuter qu'un seul des cas (pris ou non-pris, histoire d'utiliser notre
processeur au mieux. Et oui : on peut coupler l'eager execution avec des units de prdictions de branchement.
Gnralement, on prfre commencer par xecuter les premiers branchements rencontrs via eager execution, et si trop de
branchements sont rencontrs alors qu'on a beaucoup de branchements encore en attente (on ne sait pas encore vers o ils
branchent), alors on prdit les branchements suivants via la prdiction de branchements. Cela permet d'viter de trop utiliser
dunits de calculs ou de registres en excutant deux suites d'instructions.
www.openclassrooms.com
400/467
www.openclassrooms.com
401/467
A chaque fois qu'un nouveau branchement est rencontr, le processeur refait les calculs de probabilit. Cela signifie que
d'anciens branchements qui n'avaient pas ts excuts car ils avaient une probabilit trop faible peuvent tre excut si des
branchements avec des probabilits encore plus faibles sont rencontrs en cours de route.
Il existe encore d'autres techniques de prdiction de branchements, qu'on a pas encore vu ici : par exemple, on n'a pas abord
l'alloyed predictor. Et l'on a pas abord les diverses optimisations possibles sur les circuits vus prcdemment. Pour vous en
donner une ide, sur certains processeurs, on utilise carrment deux units de prdiction de branchements : une trs rapide mais
pouvant prdire les branchements "simples prdire" , et une autre plus lente qui prend le relais quand la premire unit de
prdiction de branchement n'arrive pas prdire un branchement. La prdiction est ainsi plus rapide pour certains branchements.
Il existe aussi divers projets de recherche, plus ou moins bien avancs, qui cherchent des moyens de prdire encore plus
efficacement nos branchements. Certains pensent ainsi utiliser des units de prdiction de branchement bases sur des rseaux
de neurones : le rsultat serait assez lent, mais trs efficace sur certains branchements. Enfin, certains cherchent adapter les
diffrentes mthodes de prdiction de branchement sur les instructions prdicat, afin de pouvoir rendre celle-ci plus efficaces.
La recherche est encore en cours, et on peut s'attendre quelques gains dans les annes qui suivent, mme si ces gains seront
surement relativiser. Les marges de manuvre sont assez faibles, et les branchements resteront un problmes durant un
moment encore.
Conclusion
Pour tout ceux qui veulent savoir comment nos branchements sont grs par les processeurs actuels, tlchargez donc le
troisime fichier PF prsent sur ce site : http://www.agner.org/optimize/. A l'intrieur ce celui-ci vous aurez de nombreuses
informations sur le fonctionnement des processeurs "rcents", avec notamment une revue des diffrentes techniques de
prdiction de branchements utilises.
www.openclassrooms.com
402/467
Dpendances de donnes
Dans le chapitre prcdent, j'ai parl des dpendances dinstructions et j'ai dit qu'il s'agissait de situations dans lesquelles une
instruction avait besoin du rsultat d'une ou de plusieurs instruction prcdentes pour sexcuter. J'ai aussi parl des
dpendances structurelles, qui ont tendance mettre un peu d'ambiance. Ces dpendances sont un des points faibles des
processeurs possdant un pipeline. Et pour que nos pipelines deviennent vraiment intressants, il a bien fallu trouver des
solutions pour supprimer l'effet de ces dpendances. Dans ce chapitre, on verra que l'imagination des ingnieurs et des
chercheurs a permit de trouver de trs belles solutions ce genre de problmes. Nous verrons les techniques de bypass,
dexcution out-of-order, et le register renamming , ainsi que quelques autres technologies de pointes que les processeurs
modernes implmentent dans leurs circuits. Mais tout d'abord, parlons un peu plus prcisment de ces fameuses dpendances :
il faut bien commencer par les bases !
Dpendances d'instructions
Une...dpendance ? Nos instructions sont drogues ?
Mais non !
Bien que le terme soit un peu bizarre, il a une signification simple : deux instructions ont une dpendance quand elles cherchent
manipuler la mme ressource. Il se peut que deux instructions en cours d'excution dans le pipeline aient besoin d'accder au
mme registre, la mme unit de calcul ou la mme adresse mmoire en mme temps. Une des deux instructions devra alors
attendre que la ressource voulue soit libre, en patientant dans un tage du pipeline.
Il existe divers types de dpendances, qui ont toutes des origines ou des proprits diffrentes. Ces dpendances sont au
nombre de trois : dpendances de contrle, dpendances structurelles, et dpendances de donnes. Les dpendances de
contrle sont simplement celles dues au branchements et aux exceptions/interruptions : ce qui est aprs un branchement dpend
du rsultat du branchement. On a vu tout cela en long en large et en travers dans les deux chapitres prcdents. Il ne nous reste
plus qu' voir les dpendances structurelles et les dpendances de contrle.
Dpendances structurelles
Il se peut qu'un circuit du processeur doive tre manipul par plusieurs instructions la fois : deux instructions peuvent ainsi
vouloir utiliser l'unit de calcul en mme temps, ou accder la mmoire simultanment, etc. Dans ce genre de cas, il est difficile
un circuit de traiter deux instructions la fois s'il n'est pas conu pour. Le processeur fait alors face une dpendance
structurelle.
Mais quelles peuvent tre ces dpendances structurelles ?
Pour vous montrer quoi peut ressembler une dpendance structurelle, rien de mieux que de parcourir le pipeline et de lister
quelles sont les dpendances qui peuvent survenir.
Exemple
Prenons un exemple : on va charger une instruction devant aller chercher une donne dans la mmoire dans notre pipeline de 7
tages vu au-dessus. Voici le rsultat :
T
T+1
T+2
T+3
T+4
T+5
T+6
Exec
MEM
Writeback
Fetch
Decode
Read Operand
Exec
MEM
PC
Fetch
Decode
Read Operand
Exec
PC
Fetch
Decode
Read Operand
PC
Fetch
Decode
PC
Fetch
PC
www.openclassrooms.com
403/467
Regardez ce qui se passe sur les deux colonnes de la fin : on doit effectuer une tape de Fetch, et l'tape de MEM
simultanment. Or, ces deux tapes doivent aller effectuer des lectures en mmoire. On est en plein alas structurel : notre
mmoire ne peut logiquement effectuer qu'un seul accs la fois.
Solution
Pour viter tout problme cause de ces dpendances, on peut placer des instructions inutiles dans notre programme, afin de
dcaler nos instructions dans le pipeline. Par exemple, si deux instructions sont besoin d'utiliser le mme circuit dans un cycle
d'horloge, on peut dcider d'en retarder une d'un cycle d'horloge. Il suffit juste d'insrer des instructions qui ne font rien au bon
endroit dans notre programme. Mais ce n'est pas une solution trs lgante : on perd pas mal en performance en faisant excuter
des instructions "inutiles".
Sinon, on peut laisser la gestion de ces dpendances au processeur. Sur toutes les instructions qui bataillent pour accder au
circuit, le processeur peut donner l'accs au circuit une instruction la fois. A chaque cycle, le processeur choisira une
instruction et les autres attendrons leur tour bien sagement, bloques dans un tage du pipeline.
Mais ce genre d'alas se rgle souvent en dupliquant la ressource partager. Il suffit de dupliquer le circuit partager : au lieu
de partager un circuit, on en rserve d'avance un par instruction, et c'est rgl ! C'est pour cela que le cache L1 est coup en deux
caches (un pour les instructions et un autre pour les donnes). L'unit de Fetch peut ainsi charger une (voire plusieurs)
instruction depuis le cache L1 sans tre gne par l'tage MEM : chacun de ces tages pourra accder un cache spar (L1
instruction pour l'unit de Fetch, et L1 donne pour l'tage de MEM ). Dupliquer une unit de calcul, des registres, ou tout autre
circuit est quelque chose d'assez commun pour viter d'avoir partager une ressource, et viter ainsi les alas structurels.
Mais cela a tout de mme un gros dfaut : cela bouffe beaucoup de transistors. Au final, il n'est pas rare que les concepteurs de
processeurs laissent des dpendances structurelles dans leurs pipeline pour viter de faire grossir leur processeur plus que
raison.
Dpendances de donnes
Cette fameuse ressource partager peut aussi tre un emplacement mmoire. Dans ce cas, on parle de dpendance de donnes.
Deux instructions ont une dpendance de donne quand elles accdent (en lecture ou criture) au mme registre ou la mme
adresse mmoire. Suivant l'ordre dans lequel on effectue des instructions ayant une dpendance de donnes, le rsultat peut
changer. Ainsi, un programme devra absolument suivre l'ordre d'accs la mmoire impos par le programmeur (ou le
compilateur), histoire de donner le bon rsultat.
Effets
Read
after
Read
Nos deux instructions doivent lire la mme donne, mais pas en mme temps ! Dans ce cas, on peut mettre les
deux instructions dans n'importe quel ordre, cela ne pose aucun problme.
Read
after
write
La premire instruction va crire son rsultat dans un registre ou dans la RAM, et un peu plus tard, la seconde
va lire ce rsultat et effectuer une opration dessus. La seconde instruction va donc manipuler le rsultat de la
premire.
Write
after
Read
la premire instruction va lire un registre ou le contenu d'une adresse en RAM, et la seconde va crire son
rsultat au mme endroit un peu plus tard. Dans ce cas, on doit aussi excuter la premire instruction avant la
seconde.
Write
after
Nos deux instructions effectuent des critures au mme endroit : registre ou adresse mmoire. Dans ce cas
aussi, on doit conserver l'ordre des instructions et ne pas rordonnancer, pour les mmes raisons que les deux
www.openclassrooms.com
after
Write
404/467
dpendances prcdentes.
Je dois apporter une petite prcision : quand je parle d'ordre des instruction, il y a une petite subtilit. L'ordre en question est
celui des lectures et critures de nos instruction, pas l'ordre de dmarrage des instructions. Si deux instructions ont une
dpendance de donne, la premire doit avoir termin sa lecture ou criture avant que l'autre n'effectue sa lecture ou criture. Par
exemple, si deux instructions ont une dpendance RAW, la premire doit avoir crit son rsultat avant que l'autre ne doive le lire.
Gnralement, cela veut dire que la premire instruction doit avoir termin son excution avant l'autre. C'est une contrainte assez
forte.
Et cette contrainte n'est pas forcment respecte sur un processeur avec un pipeline. Aprs tout, le principe mme du pipeline est
de dmarrer lexcution d'une nouvelle instruction sans attendre que la prcdente soit termine. Dans ces conditions, l'ordre de
dmarrage des instructions est respecte, mais pas l'ordre des lectures et critures. Cela pose problme avec les dpendances
RAW, WAW, et WAR.
Dpendances RAW
Premier problme : les dpendances RAW. Pour utiliser le pipeline de faon optimale, les oprandes d'une instruction ne doivent
pas dpendre du rsultat d'une instruction prcdente. Il serait en effet bien difficile dexcuter une instruction alors que les
donnes ncessaires son excution manquent.
Prenons un exemple simple : on va prendre un pipeline 4 tages pour se simplifier la vie : Fetch, Decode, Exec, WriteBack. Deux
instructions qui se suivent sont charges l'une aprs l'autre dans notre pipeline. La seconde instruction doit attendre le rsultat
de la premire pour commencer son excution. J'ai colori sur le schma en jaune les tapes des instructions durant lesquelles
l'unit de calcul est utilise. La situation idale serait celle-ci.
Mais la ralit est plus cruelle : le rsultat de notre instruction n'est disponible qu'aprs avoir t enregistr dans un registre, soit
aprs l'tape de Writeback. Si on ne fait rien, la seonde instruction ne lira pas le rsultat de la premire, mais l'ancienne valeur qui
tait prsente dans le registre. En clair : le rsultat ne sera pas bon !
Une solution pour viter tout problme pourrait tre faire en sorte que notre instruction fournisse son rsultat en un seul cycle
d'horloge. On se retrouverait alors avec un Back End d'un seul cycle pour toutes les instructions. Avec un tel pipeline, les
dpendances RAW deviennent impossibles, vu que le rsulta est fourni presque immdiatement. Mais c'est impossible raliser
en pratique, surtout en ce qui concerne les instructions d'accs mmoire ou les instructions complexes.
www.openclassrooms.com
405/467
;
soit avoir une criture qui prend plusieurs tages elle toute seule :
Si aucune de ces conditions n'est runie, ces dpendances WAW n'apparaissent pas.
Pour les dpendances WAR, c'est un peu la mme chose. Elle n'apparaissent que sur certains pipelines, dans lesquels l'criture
des rsultats a lieu assez tt (vers le dbut du pipeline), et les lectures assez tard (vers la fin du pipeline).
Que faire ?
Pour viter tout problme avec ces dpendances, on est oblig d'insrer des instructions qui ne font rien entre les deux
instructions dpendantes. Dans le schma qui suit, linstruction qui ne fait rien est en jaune.
Le seul problme, c'est qu'insrer ces instructions n'est pas trivial. Si on n'en met pas suffisamment, on risque de se retrouver
avec des catastrophes. Et si on en met trop, c'est une catastrophe en terme de performances. Dduire le nombre exact
d'instruction inutiles ajouter ncessite de connaitre le fonctionnement du pipeline en dtail. Autant dire que niveau portabilit,
c'est pas la joie ! La meilleure des solution est encore de dlguer cet ajout d'instructions inutiles au processeur. Et avec
quelques circuits en plus, il en est parfaitement capable ! Voyons en dtail cette histoire.
Principe
Le principe est simple : dans le cas le plus simple, tout se passe dans les units de dcodage. Si une dpendance de donne est
dtecte, l'unit de dcodage d'instruction se bloque tant que la bonne donne n'est pas disponible. Par bloquer, on veut dire
qu'il n'envoie pas l'instruction qu'il vient de dcoder aux ALU. Elle met cette instruction en attente, et attend que la donne
l'origine de la dpendance soit disponible.
Voici ce que cela donne dans notre pipeline. Sur ce schma, chaque couleur reprsente une instruction. On remarque qu'en plus
de bloquer l'unit de dcodage, il faut aussi bloquer tous les tages prcdents.
www.openclassrooms.com
406/467
Durant ce temps d'attente, on se retrouvera avec des vides dans le pipeline : certains tages seront inoccups et n'auront rien
faire. Ce sont les tages marqus en gris sur le schma suivant.
www.openclassrooms.com
407/467
Ces vides, on les appelle des Pipeline Stall, ou encore des Pipeline Bubble. Il apparaissent chaque fois qu'une instruction
doit attendre dans un tage du pipeline.
Et ces Pipeline Bubble, ces vides dans le pipeline, sont autant d'tages gaspills ne rien faire, qui nexcutent pas
d'instructions. En clair : lorsqu'une Pipeline Bubble apparait, notre pipeline est sous-utilis, et on perd en performances
btement.
Processeurs In-order
Alors certes, on verra dans ce chapitre et dans la suite du tutoriel, qu'il y a des techniques pour remplir ces vides. Dans la suite
du tutoriel, on verra que certains processeurs sont capables de changer l'ordre des instructions pour remplir ces vides. Mais
pour le moment, nous allons parler des processeurs qui ne remplissent pas ces vides en changeant l'ordre des instructions. Nous
allons commencer par parler des processeurs qui excutent les instructions dans l'ordre impos par le programme. Ces
processeurs sont appels des processeurs In-Order.
Voyons un peu comment grer les diffrentes dpendances sur ce genre de processeurs.
Dpendances RAW
Les dpendances RAW sont les dpendances les plus videntes. Vi comment est concu notre pipeline, il est possible qu'une
instruction charge dans le pipeline aille lire une ancienne version d'une donne. Il suffit pour cela que la version la plus rcente
n'aie pas encore t crite par une instruction prcdente : cela arrive si celle-ci est encore dans le pipeline. Pour grer les
dpendances sur les processeurs In-Order, il suffit simplement d'viter cela.
Instructions multicycles
Une autre source de dpendances vient de certaines instructions. Il n'est pas rare que certaines instructions monopolisent une
unit de calcul durant plusieurs cycles d'horloge. Par exemple, une division peut prendre jusqu' 80 cycles d'horloge, et rester
dans son ALU durant tout ce temps. Et cette ALU est inutilisable pour une autre instruction. On est donc en face d'une belle
www.openclassrooms.com
408/467
dpendance structurelle, qu'il faut rsoudre. De mme, il est possible que des dpendances WAW apparaissent.
Pour viter tout problme, l'ALU va devoir fournir des informations l'unit de dcodage, qui permettront celle-ci de dcider si
elle doit insrer une Pipeline Bubble ou non. Notre unit de dcodage devra connaitre l'utilisation de chaque unit de calcul
(occupe ou non), afin de dcider.
Accs la mmoire
De plus, cette technique pose un problme lors des instructions d'accs la mmoire. Ces instructions n'ont pas une dure bien
dfinie. La donne charger peut se trouver aussi bien dans la mmoire cache, que dans la mmoire RAM, et les temps d'accs
ne sont pas les mmes. On pourrait ventuellement insrer des Pipeline Bubbles dans notre pipeline tant que la lecture ou
criture n'est pas termine. C'est trs simple implmenter.
Premire implmentation : si l'unit de dcodage envoie une instruction qui accde la mmoire dans le pipeline, elle se
bloque, et attend que l'unit qui accde la mmoire lui envoie un signal lectrique pour lui dire : dbloque toi, j'ai fini.
Seconde implmentation : l'unit charge daccder la mmoire va bloquer elle-mme tous les tages prcdents du
pipeline si elle doit accder la mmoire, et elle les libre une fois la donne lue ou crite.
Mais dans les deux cas, ce serait un vrai dsastre en terme de performances. En tout cas, on verra que ce genre de problme peut
facilement tre vit avec certaines structures de donnes matrielles. Mais le moment de parler des ReOrder Buffers n'est pas
encore arriv.
Implmentation
Ces temps d'attente n'apparaissent pas comme pas magie. Il faut concevoir notre processeur pour qu'il fasse ce qu'il faut.
Stall
Ce blocage se fait simplement en empchant l'horloge d'arriver aux registres prsents entre les tages de Fetch et de Dcodage.
Ainsi, les registres entre les tages ne seront pas mis jour, et garderont leur valeur qu'ils avaient au cycle prcdent. Cette
inhibition de l'horloge se fait en activant un simple interrupteur ou en utilisant un vulgaire petit circuit base de portes logiques.
Aprs avoir bloqu les tages prcdents, l'unit de dcodage va ensuite insrer une instruction nop dans le pipeline, histoire
que la Pipeline Bubble ne fasse rien.
Bypass et Forwarding
Comme on l'a vu plus haut, les dpendances posent de sacrs problmes. Alors certes, on peut profiter du fait que nos
www.openclassrooms.com
409/467
instructions soient indpendantes pour les xecuter en parallle, dans des tages diffrents du pipeline, mais cela ne rsout pas
le problme dus nos dpendances. Diminuer l'effet des dpendances sur notre pipeline est une bonne ide. Et pour ce faire,
diverses techniques ont ts inventes. La premire de ces technique s'occupent de diminuer l'impact des dpendances de type
RAW. Cette dpendances indique qu'une instruction a besoin du rsultat d'une autre instruction pour pouvoir sexcuter.
Mais la ralit est plus cruelle : notre pipeline, tel qu'il est actuellement, possde un lger dfaut qui peut crer ces temps
d'attentes inutiles. Avec le pipeline tel qu'il est actuellement, on doit attendre qu'une instruction soit totalement termine pour
pouvoir rutiliser son rsultat. Ainsi, le rsultat de notre instruction n'est disponible qu'aprs avoir t enregistr dans un
registre, soit aprs l'tape de Writeback, note W sur le schma.
On voit bien que la seconde instruction doit attendre l'autre. Pourtant, son rsultat est calcul bien avant que l'instruction ne
termine, mais il n'est pas rutilisable immdiatement. Et pour cause : il doit tre enregistr dans les registres, et cela ne se fait pas
sans prcautions. Sans prcautions signifie que certaines modifications faites sur les registres ne doivent pas tre enregistres.
Par exemple, on ne doit pas enregistrer les rsultats calculs aprs un branchement mal prdit. Il faut aussi grer les exceptions et
les interruptions. Par exemple, si une exception a eu lieu dans le pipeline, on ne doit pas enregistrer les modifications faites tord
par les instructions excutes aprs l'exception. Pour cela, il y a des tages qui permettent (ou non) d'enregistrer un rsultat en
mmoire ou dans les registres.
Bypass
Une ide vint alors : pourquoi ne pas faire en sorte que le rsultat d'une l'instruction soit le plus rapidement disponible ? Pas
besoin d'attendre que l'instruction termine pour avoir accs au rsultat : ds qu'un rsultat est calcul, il vaut mieux qu'il soit
utilisable par d'autres instructions le plus vite possible.
www.openclassrooms.com
410/467
Et si jamais notre instruction rutilise un rsultat qui n'est pas bon, il suffit de ne pas enregistrer son rsultat.
Quelles instructions ?
Mais cela n'est pas possible pour toutes les instructions. Gnralement, il y a deux types d'instructions qui donnent un rsultat :
les instructions de lecture en mmoire, et les instructions de calcul. Quand on charge une donne depuis la mmoire, le rsultat
n'est autre que la donne lue depuis la mmoire. Et pour les instructions de calcul, il s'agit simplement du rsultat du calcul. Pour
les accs mmoires, on peut limiter la casse en utilisant des mmoires caches, en jouant sur le pipeline, et utilisant diverses
techniques plus ou moins volues. Mais On verra cela plus tard. Toujours est-il que ces accs mmoire ont tendance tre trs
longues, ce qui cre des gros vides dans notre pipeline, difficile supprimer. Mais on peut toujours jouer sur les instructions de
calculs : celle-ci ont des temps d'attente plus faibles, sur lesquels il est facile de jouer.
Principe
D'ordinaire, ce calcul est effectu par notre unit de calcul, et est ensuite crit dans un registre ou en mmoire aprs un certain
temps. Pour rduire le temps d'attente, on peut faire en sorte que le rsultat de notre instruction, disponible ne sortie de l'unit de
calcul, soit directement rutilisable, sans devoir attendre qu'il soit crit dans un registre ou dans la mmoire.
Pour cela, on a juste modifier les circuits du processeur. Ce rsultat peut tre directement accd par la seconde instruction
sans devoir tre enregistr dans un registre. Ainsi, la seconde instruction peut donc s'excuter avant que la premire aie termin
son tape de Writeback. Il s'agit de la technique du bypass, aussi appele forwarding .
Implmentation
Implmenter la technique du bypass dans un processeur n'est pas tellement compliqu sur le principe. Il suffit simplement de
relier la sortie des units de calcul sur leur entre quand une instruction a besoin du rsultat de la prcdente. Il faut pour cela
ajouter quelques circuits charg de dcider si le contenu de la sortie de lunit de calcul peut tre envoy sur son entre.
Multiplexeurs
Cela se fait en utilisant des multiplexeurs : on relie la sortie de notre ALU un multiplexeur dont la sortie sera relie l'entre de
cette mme unit de calcul, l'autre entre tant relie au bus interne au processeur. On pourra ainsi relier (ou pas) la sortie de
l'ALU une de ses entres en configurant ce multiplexeur.
www.openclassrooms.com
411/467
Forwarding Unit
Pour dtecter nos dpendances, il suffira de comparer le registre destination dans le registre plac aprs l'ALU, et le registre
source plac en entre. Si ce registre est identique, on devra faire commuter le multiplexeur pour relier la sortie de l'ALU sur
l'entre. Cette comparaison est effectue par deux comparateurs, chacun commandant un multiplexeur.
www.openclassrooms.com
412/467
Clusters
Sur les processeurs ayant beaucoup d'units de calculs, on trouve souvent un systme de bypass (forwarding ) assez toff.
Aprs tout, rien ne dit que deux instructions dpendantes seront rparties sur la mme unit de calcul. Le Scheduler peut trs
bien envoyer deux instructions ayant une dpendances RAW sur des units de calcul diffrentes. Pour cela, il n'y a qu'une
solution : chaque sortie d'une unit de calcul doit tre relie aux entres de toutes les autres ! Et bien sr, on doit aussi rajouter
les multiplexeurs et comparateurs qui vont avec. Je ne vous raconte pas la difficult cbler un rseaux d'interconnexions pareil.
Pour units de calcul, on se retrouve avec pas moins de
interconnexions. Autant dire que cela fait beaucoup de fils et que
sur certains processeurs, cela peut poser problme.
Sur certains processeurs, on arrive se dbrouiller sans trop de problmes. Mais quand on commence mettre un peu trop
dunits de calculs dans le processeur, c'est termin : on ne peut pas forcment, ou l'on a pas envie, de cbler un rseau de
bypass aussi touffu et complexe. Pour limiter la casse, on utilise alors une autre mthode : on ne relie pas toutes les units de
calcul ensemble. A la place, on prfre regrouper ces units de calcul dans diffrents blocs spars qu'on appelle des clusters. Le
bypass est alors rendu possible entre les units d'un mme cluster, mais pas entre les units appartenant deux clusters
diffrents.
Toutes ces dpendances vont imposer un certain ordre dexcution nos instructions. Par chance, cet ordre ne permet pas
d'ordonner toutes les instructions : autant dans l'ordre dexcution impos par le programme toutes les instructions sont
ordonnes et doivent sexcuter les unes aprs les autres, autant l'ordre des dpendances laisse plus de liberts. Si deux
instructions n'ont pas de dpendances de donnes, c'est qu'elles sont indpendantes. Dans ce cas, le processeur peut les
excuter en parallle ou changer leur ordre dexcution sans problme. Il existe diverses techniques pour ce faire : Excution Out
Of Order, Superscalarit, etc. Mais pour le moment, voyons un peu quel est l'effet de ces dpendances sur notre pipeline, et
comment on peut limiter la casse.
www.openclassrooms.com
413/467
Principe
Introduisons le problme par un exemple. Prenons deux instructions qui se suivent et qui possdent une dpendance de
donnes. La seconde devant attendre le rsultat de la premire pour commencer son excution. J'ai colori sur le schma en jaune
les tapes des instructions durant lesquelles l'unit de calcul est utilise.
On voit bien que la seconde instruction doit attendre l'autre. C'est un fait : si deux instructions ont une dpendance de donne et
que celle qui prcde l'autre est une instruction multicycle, alors on va perdre du temps dans ce fameux temps d'attente. Des
problmes similaires apparaissent lors des accs mmoires. Si une donne attend des donnes en provenance de la mmoire, on
se retrouve aussi avec ce genre de vides, sauf que l'unit de calcul est libre.
Les deux types de dpendances, structurelles ou de donnes, ainsi que les accs mmoires, on exactement le mme effet sur
notre pipeline : ils forcent certains tages du pipeline attendre qu'une donne ou qu'un circuit soit disponible. Dans ce cas, on
est oblig de modifier lgrement le comportement de notre pipeline : on doit stopper l'tage qui attend et l'immobiliser, ainsi que
celui de tous les tages prcdents. En clair, notre tage ne fait rien et attend sagement, sans passer l'instruction suivante. Et
les tages prcdents font pareils. C'est la seule solution pour viter les catastrophes. Et pour cela, on doit rajouter des circuits
qui vont dtecter les dpendances dans notre pipeline et qui vont stopper le fonctionnement de l'tage devant attendre ainsi que
les tages prcdents.
C'est le rsultat des dpendances de donne : certains tages ne font rien, pendant que certaines instructions attendent la
donne voulue. L'instruction va devoir attendre que ses oprandes soient disponibles dans un tage et va bloquer tous les
tages prcdents dans le pipeline : cela retarde le chargement des instructions suivantes. Au final, notre pipeline excute moins
dinstructions en simultan que prvu.
www.openclassrooms.com
414/467
explicitement dans les instructions (comme c'est le cas sur les architectures dataflow), et il doit dduire les dpendances entre
instructions tout seul, en regardent les registres ou adresses mmoires utilises par linstruction. Une fois ces dpendances
connues, il change lui-mme l'ordre des instructions et dcide de leur rpartition sur les diffrentes units de calcul.
Chacune de ces solutions a ses avantages et ses inconvnients. Par exemple, le compilateur peut travailler sur des morceaux de
programmes plus gros et ainsi rordonnancer les instructions un peu mieux que le processeur, qui ne traitera qu'une dizaine ou
une vingtaine dinstruction la fois. Mais par contre, le processeur peut virer certaines dpendances qui apparaissent
lexcution (branchements) : cela est impossible pour le compilateur. Bien sr, rien nempche de faire les deux, pour avoir un
maximum de performances.
La dernire solution qui consiste rorganiser l'ordre dans lequel s'excutent les instructions du programme pour gagner en
efficacit s'appelle l'excution Out-Of-Order. Avec cette solution, si une instruction doit attendre que ses oprandes soient
disponibles, on peut remplir le vide cre dans le pipeline par une autre instruction indpendante de la premire : on excute une
instruction indpendante au lieu de ne rien faire. Cette instruction pourra sexcuter avant l'instruction qui bloque tout le pipeline
et n'aura donc pas attendre son tour : on excute bien des instructions dans le dsordre.
Petit dtail : quand je parle d'instructions, il peut s'agir aussi bien d'instructions machines (celle que notre processeur fourni au
programmeur), que de micro-instructions (celles qu'on a vue dans le chapitre sur la micro-architecture d'un processeur, quand on
a parl de squenceurs micro-cods). Si votre processeur utilise un squenceur micro-cod, la rorganisation des instructions se
fera non pas instructions machines par instructions machines, mais micro-oprations par micro-oprations. Cela permet d'avoir
plus de possibilits de rorganisations.
Problme : l'unit de calcul n'accepte qu'une seule instruction, et la situation du dessus est impossible. On est donc oblig de
retarder lexcution de notre seconde instruction. On va donc appliquer la solution de base en cas de dpendances structurelle :
on dupliquer le circuit fautif, qui est ici l'unit de calcul, et on rpartit nos instructions sur les diffrentes units de calcul. Le seul
problme, c'est que rien nempche une instruction charge dans le pipeline aprs une autre de finir avant celle-ci. Les
instructions ayant des temps dexcutions variables, les rsultats peuvent arriver dans le dsordre. Et dans un cas pareil, il faut
absolument grer correctement les dpendances de donnes entre instructions correctement.
Scoreboarding
Commenons par la premire de ces techniques : le scoreboarding. Avec le scoreboarding , la gestion des dpendances de
donnes est effectue par un seul circuit, nomm le scoreboard : il se chargera ainsi de grer l'ensemble des units de calcul et se
chargera de tout ce qui a rapport lexcution Out Of Order . Son rle est de dtecter les dpendances de donnes entre
instructions et dexcuter au mieux les instructions en consquence. Mais ce scoreboard n'est pas le seul circuit ncessaire pour
pouvoir xecuter nos instructions dans un ordre diffrent de celui impos par le programme.
www.openclassrooms.com
415/467
tape d'issue
Au moins une tape supplmentaire apparait : l'tape d'issue. Cette tape remplace l'tape de dcodage de l'instruction, ou plutt
elle la complte. L'tape d'issue va non-seulement dcoder notre instruction, mais elle va aussi dcider si notre instruction peut
dmarrer son excution ou non. Pour cela, notre tape d'issue va vrifier quels sont les registres utiliss pour stocker le rsultat
de notre instruction et va vrifier que notre instruction n'a aucune dpendance WAW (elle n'a pas besoin d'crire son rsultat au
mme endroit qu'une autre instruction qui la prcde dans l'ordre du programme). Elle va aussi vrifier si une unit de calcul est
disponible pour lexcuter. Si notre instruction possde une dpendance WAW ou qu'aucune unit de calcul disponible ne peut
lexcuter, alors notre instruction va attendre son tour bien sagement. Dans le cas contraire, elle va pouvoir progresser dans le
pipeline : le scoreboard sera alors mis jour.
Attention, toutefois : nos instructions sont dcodes et envoyes aux units de calculs les unes aprs les autres, en srie. On
peut ventuellement en envoyer plusieurs (il suffit d'adapter un peu l'tape d'issue), mais cet envoi vers les ALU se fera dans
l'ordre impos par le programme. Vu comme cela, on se demande bien o est l'Out Of Order . Mais celui-ci vient aprs, plus loin
dans le pipeline.
www.openclassrooms.com
416/467
instruction. Dans ce cas, notre instruction doit attendre que la donne en question doit lue depuis la mmoire ou calcule par
l'instruction avec laquelle elle partage une dpendance. Il faut donc trouver un moyen pour viter de commencer excuter notre
instruction alors que seulement la moiti de ses donnes sont dj disponibles.
Mais qu' cela ne tienne, envoyons-la quand mme lunit de calcul !
Heu... excuter une instruction sans avoir ses oprandes, c'est pas un peu casse-cou ?
Si, effectivement. Mais rassurez-vous, les concepteurs de processeurs Out Of Order ont penss tout (en mme temps, on les
paye pour a !).
Pour viter les problmes, une seule solution : notre instruction va tre mise en attente en attendant que ses oprandes soient
disponibles. Pour ce faire, on ajoute une tape dans notre pipeline, gre par notre scoreboard . Cette tape se chargera de
retarder lexcution de notre instruction tant que ses donnes ne seront pas disponibles. Notre scoreboard va ainsi stocker
notre instruction dans une petite mmoire tampon (avec ventuellement ses oprandes), et la fera attendre tant que les
oprandes ne sont pas prtes.
Excution
Une fois ses oprandes prtes, l'instruction est envoye une unit de calcul et est excute. C'est cet endroit du pipeline que
l'on peut vraiment parler d'Out Of Order : notre processeur contiendra obligatoirement plusieurs units de calcul, dans lesquelles
on pourra xecuter des instructions en parallle. Sur un processeur sans scoreboarding et sans Out Of Order , lorsqu'une
instruction n'a pas fini de sexcuter (si elle prend plusieurs cycles ou attends des donnes), on doit attendre que celle-ci se
termine avant de pouvoir en dmarrer une autre. Avec le scoreboarding , ce n'est pas le cas : si une instruction prend plusieurs
cycles pour sexcuter ou attend des donnes, on peut dmarrer une nouvelle instruction au cycle suivant dans une autre unit
de calcul disponible. Pas besoin d'attendre : une instruction indpendante peut ainsi commencer son excution au cycle suivant
sans attendre la fin de l'instruction prcdente.
videmment, cela marche uniquement si une instruction prend plus d'un cycle pour sexcuter : si elles attend des donnes
depuis la RAM, ou si il s'agit d'une instruction complexe demandant beaucoup de temps. Si toutes les instructions mettent un
cycle d'horloge pour sexcuter (accs mmoires compris), le scoreboarding ne sert rien vu qu'on dcode nos instructions
unes par unes.
Lexcution de l'instruction va prendre un ou plusieurs cycles d'horloge, et on doit absolument prendre en compte cet tat de fait
: toutes les instructions ne prennent pas le mme temps pour sexcuter. Ainsi, leur rsultat sera disponible plus ou moins
tardivement, et les scoreboard doit en tenir compte. Pour cela, quand le rsultat de notre instruction est calcul, le scoreboard
est prvenu par l'unit de calcul et il se mettra jour automatiquement.
Writeback
Enfin, le rsultat de notre instruction est prt. Il ne reste plus qu' le sauvegarder dans un registre ou dans la mmoire...enfin
presque ! Ben oui, il reste les dpendances WAR : il faut attendre que toutes les lectures dans le registre que l'on va crire soient
termines. Pour cela, il n'y a pas vraiment de solution : on doit encore une fois attendre que ces lectures soient finies pour
autoriser l'criture du rsultat. Seule solution : placer nos rsultats dans une file d'attente, et autoriser l'criture du rsultat dans
le register file une fois que toutes les lectures de la donne prsente dans le registre crire soient termines. Bien videmment,
c'est le scoreboard qui autorisera ou non cette criture.
Scoreboard
On a vu prcdemment que le scoreboard a tout de mme pas mal de responsabilits : il doit faire patienter les instructions
possdant une dpendance WAW dans l'tage d'issue, faire patienter notre instruction dans l'tage de Read Operand tant que
ses donnes ne sont pas disponibles, et temporiser l'criture du rsultat d'une instruction tant que les lectures prcdentes dans
le registre crire ne sont pas effectues. Cela ncessite de commander pas mal d'tage du pipeline, ainsi que quelques circuits
annexes.
Mine de rien, notre scoreboard va devoir avoir accs pas mal dinformations pour grer le tout efficacement.
Celui-ci devra retenir :
les dpendances entre instructions ;
quelles sont les instructions en cours dexcution ;
des units de calcul charge de lexcution de celles-ci ;
et les registres dans lesquels nos instructions en cours dexcution vont crire leur rsultat.
www.openclassrooms.com
417/467
Final
Au final, on saperoit que cette forme d'Out Of Order est assez rudimentaire : les instructions sont toujours dcodes dans
l'ordre du programme et sont rparties sur une ou plusieurs units de calcul. Par contre, celles-ci sont ensuite rparties sur des
units de calculs spares dans lesquelles elles peuvent sexcuter dans un ordre diffrent de celui impos par le programme.
Pire : elles peuvent enregistrer leurs rsultats dans un ordre diffrent de celui impos apr le programmeur : elles fournissent leur
rsultat ds que possible. Nanmoins, on observe quelques limitations assez problmatiques : les dpendances RAW, WAW et
WAR vont faire patienter nos instructions. Et il serait bien de limiter un peu la casse propos de ces dpendances !
www.openclassrooms.com
418/467
Cette instruction window est gre diffremment suivant le processeur. On peut par exemple la remplir au fur et mesure que les
instructions sont excutes et quittent donc celle-ci. Ou on peut attendre que celle-ci soit vide pour la remplir intgralement en
une fois. Les deux faons de faire sont possibles.
Vous remarquerez que j'ai plac les units du squenceur sur le schma. Mais le dcodeur d'instruction peut tre plac de l'autre
cot de l'instruction window. En fait, celles-ci peuvent se retrouver des deux cots de l'instruction window. On peut en effet
dcoder les instructions avant leur passage dans l'instruction window : c'est ce qui se fait surement dans vos processeurs x86
actuels et dans la majorit des processeurs utilisant la micro-programmation horizontal (pour ceux qui ont oublis, allez voir ici :
le chapitre sur la micro-architecture d'un processeur de ce tutoriel). Mais on peut aussi se dbrouiller pour faire autrement, en
plaant les units de dcodage aprs l'instruction window.
Pour choisir quelle instruction xecuter, il suffira de rajouter un circuit qui se chargera de lire le contenu de cet Instruction
Window, et qui dcidera quelles sont les instructions excuter. Ce circuit, le Scheduler, regardera quelles sont les instructions
dans cet Instruction Window qui sont indpendantes et dcidera alors de les rpartir sur les units de calcul inutilises au
besoin.
Au fait : ce Scheduler n'est rien d'autre que le circuit en charge de l'tape d'Issue, auquel on permet de traiter plusieurs
instructions. C'est lui qui vrifiera les dpendances entre instructions et qui sera charg de rpartir des instructions sur plusieurs
units de calcul.
www.openclassrooms.com
419/467
Sur un processeur implmentant le Schelving , on ne trouve non pas une, mais plusieurs Instructions Windows. Gnralement, on
trouve une Instruction Window par ALU. L'unit d'Issue va simplement vrifier qu'une unit de calcul est libre pour excuter
notre instruction, et va l'envoyer dans une de ces Instruction Window, attache la bonne ALU.
Une fois place dans cette Instruction Window, notre instruction va attendre que toutes les dpendances soient rsolues avant
de sexcuter. A chaque cycle d'horloge, un circuit va vrifier que notre instruction a ses oprandes de prtes, que l'unit de
calcul est libre, et vrifie aussi les dpendances WAR et WAW. Une fois que notre instruction n'a plus aucune dpendance, elle
est directement envoye l'ALU et elle sexcute. Dans le cas contraire, elle patiente dans l'Instruction Window. Gnralement,
ces Instructions Windows spcialises sont parfois appeles des Reservations Stations.
Utiliser du Shelving a un avantage : les Schedulers attachs aux Reservations Stations sont souvent beaucoup plus simples et
consomment nettement moins de circuits. Plusieurs raisons cela. Pour commencer, chaque Reservation Station est pluis petite
qu'une grosse Instruction Window : la slection de la prochaine instruction envoyer l'ALU est donc plus simple. Aprs tout,
entre slectionner une instruction parmi 100, et une parmi 10, un des deux cas est le plus simple, et vous avez devin lequel.
Ensuite, une Reservation Station ne peut librer qu'une entre par cycle, vu qu'elle envoie une instruction la fois sur l'ALU.
Mais avec une grosse Instruction Window, plusieurs instructions peuvent quitter cele-ci durant un seul cycle : il suffit que
plusieurs ALU dmarrent une nouvelle instruction.
Mais les Reservations Stations ont aussi des inconvnients. Elles sont souvent sous-utilises et partiellement remplies. Il est
rare que la totalit d'une Reservation Station soit utilis, tandis qu'une Instruction Window n'a pas ce problme et est souvent
remplie en totalit. Niveau rentabilit circuits/remplissage, l'Instruction Window est la grande gagnante.
Quelques dtails
Ces Instruction Window sont composes d'entres, des blocs de mmoires qui servent stocker une instruction dcode.
Lorsqu'une instruction est dcode, elle rserve une entre rien que pour elle. Cette entre est libre dans deux cas : soit quand
l'instruction est envoye aux ALU, soit quand elle termine son excution. Cela dpend du processeur et de son pipeline. Le rle
du Scheduler est de vrifier le contenu des entres pour savoir quelle instruction Issue. Si plusieurs instructions sont prtes
tre issue sur la mme ALU, ce dernier doit faire un choix. Et gnralement cela signifie "issue la plus ancienne".
Il existe deux grands types d'Instruction Window. Ces deux types dpendent du contenu de celle-ci. Dans le premier type,
l'Instruction Window ne stocke pas les oprandes de l'instruction : une entre ne contient que notre instruction, et puis c'est
tout. Le Scheduler sait quand les oprandes d'une instructions sont disponibles et quand il n'y a plus de dpendances grce au
Scoreboard . Dans le second type, l'Instruction Window contient aussi les oprandes d'une instruction, celles-ci tant envoye
www.openclassrooms.com
www.openclassrooms.com
420/467
421/467
Le renommage de registres
Dans ce que j'ai dit prcdemment, j'ai voqu trois types de dpendances de donnes. Certains d'entre elles sont des
dpendances de donnes contre lesquelles on ne peut rien faire : ce sont de "vraies dpendances de donnes". Une vraie
dpendance de donne correspond au cas o une instruction a besoin du rsultat d'une instruction prcdente pour fonctionner
: il s'agit des dpendances Read After Write. Ces dpendances sont aussi appeles des dpendance de donne vritables ou une
True Dependency, ce qui montre bien leur caractre invitable. Il est en effet impossible dexcuter une instruction si les
donnes ncessaires son excution ne sont pas encore connues. Quelque soit la situation, on est oblig de tenir compte de ces
dpendances, qui imposent un certain ordre dexcution de nos instructions, limitant ainsi les possibilits pour notre Out Of
Order.
Ces dpendances apparaissent si on lit ou crit des donnes diffrentes au mme endroit : si ce n'est pas le cas, on peut trouver
une solution ! Et cette solution est assez simple : on doit faire en sorte de ne pas rutiliser une portion de mmoire qui contient
une donne. C'est bien plus facile dire qu' faire, et rarement faisable : quand on est limit 4 ou 8 registres sur un processeur,
rutiliser au maximum les registres est au contraire une ncessit si on veut viter de devoir accder la RAM ou au cache pour
tout et n'importe quoi.
Bien videmment, limagination dbride des concepteurs de processeur a dj trouve une solution ce problme dans le cas
de dpendances dues un partage de registres entre deux instructions. Cette solution s'appelle le renommage de registre, et
permet d'liminer ces fausses dpendances de donnes Write after Read ou Write after Write.
Le renommage de registres
Prenons le cas d'une dpendance WAR : on a une lecture suivie par une criture. Si on dcide de changer l'ordre des deux accs
mmoires et que l'on effectue l'criture avant la lecture, la lecture ne renverra pas la valeur prsente avant l'criture, mais celle qui
vient d'tre crite. Il est donc strictement impossible de changer l'ordre des lectures/critures dans ce cas prcis : si on le fait, le
rsultat enregistr en mmoire change et notre programme ne fait pas ce qu'il faut. Toutes les lectures de notre registre ou
adresse mmoire prcdant notre criture devront tre termines avant de pouvoir lancer notre criture.
Plus gnralement, si on change l'ordre de deux instructions ayant une dpendance de donne WAW ou WAR, nos deux
instructions vont utiliser le mme registre pour stocker des donnes diffrentes en mme temps. Manque de chance, un registre
ne peut contenir qu'une seule donne, et l'une des deux sera perdue.
Du moins, c'est le cas si on lit ou crit au mme endroit. Si ce n'est pas le cas, on n'observe pas d'apparition de dpendances.Et
une solution simple vient alors l'esprit. Il suffit de conserver ces diffrentes versions du mme registre dans plusieurs registres
www.openclassrooms.com
422/467
spars, et choisir le registre adquat l'utilisation. Ainsi, les oprations de lecture seront rediriges vers la copie de l'ancienne
valeur (celle lire), tandis que notre criture crira son rsultat dans un autre registre. Une fois que toutes les lectures prcdant
notre criture (dans l'ordre des instructions impos par le programmeur) seront termine, il suffira de remplacer l'ancienne valeur
(la copie utilise pour les lectures) par la nouvelle valeur (celle qui a t crite).
Lide est donc de stocker plusieurs versions d'un mme registre dans des registres spars. A chaque fois qu'on veut crire ou
modifier le contenu d'un registre, cette criture est redirige vers un autre registre. A chaque criture, on utilise un nouveau
registre pour stocker temporairement notre donne crire. Et toutes les lectures vers cette version du registre sont rediriges
vers ce registre supplmentaire. Une fois qu'une donne, une version d'un registre, devient inutile, celui-ci devient rutilisable.
Tout ce qui peut tre lu ou crit peut subir ce genre de modification, mais en pratique, seuls les registres subissent ce genre de
traitement. Certains processeurs permettent ainsi de faire la mme chose sur des adresses mmoires, mais sont vraiment rares.
Reservations stations
Le Scoreboarding est un algorithme assez simple. Mais il a un petit dfaut : il ne gre pas le renommage de registres. Pour grer
le renommage de registre, il existe un autre algorithme dexcution Out Of Order . Il s'agit de l'algorithme de Tomasulo. Cet
algorithme a un autre avantage : il essaye d'utiliser du forwarding ds que possible afin de limiter la casse ! Voyons un peu
comment est effectu le renommage de registre avec cet algorithme.
www.openclassrooms.com
423/467
Aperu
Pour commencer, voici un aperu du pipeline d'un processeur utilisant cet algorithme, ci-dessous.
Nous verrons dans la suite quoi ces tapes correspondent. Mais je tiens prciser une chose : les tapes marques en jaune
sont des tapes qui ne sont pas concerns par l'Out Of Order . C'est dire que les instructions sont charges depuis la mmoire,
dcodes, et Issues dans l'ordre du programme. C'est la suite de ces tapes que les instructions pourront sexcuter dans le
dsordre.
A premire vue, rien n'a chang compar au pipeline d'un processeur normal. Seul petit ajout : Reservations Stations. Tout
l'algorithme se base sur les Reservations Stations. Ce sont elles qui servent de registres virtuels. Et cela aura des consquences
sur le reste du processeur. Par exemple, l'tage d'Issue sera maintenant en charge du renommage de registres. Pour comprendre le
fonctionnement de cet algorithme, nous allons voir en dtail chaque tape du pipeline, dans l'ordre.
Issue
L'tape d'Issue a deux utilits. Pour commencer, c'est elle qui devra renommer les registres. C'est elle qui dcidera de donne un
Tag aux rsultats de nos instructions, notamment. Ensuite, c'est elle qui vrifiera si on disposera des ressources ncessaires
pour sexcuter. Si ce n'est pas le cas, l'unit d'Issue va bloquer les tages prcdents du pipeline, afin de faire patienter notre
instruction l'tage d'Issue.
On remarque tout de mme une petite chose assez amusante avec cette unit d'Issue. Celle-ci va dcider d'envoyer une
instruction dans la suite du pipeline, mais elle ne va pas vrifier les dpendances. Aprs tout, on pourrait trs bien imaginer une
unit d'Issue qui vrifie si toutes les oprandes sont disponibles. Mais ici, ce n'est pas le cas. La gestion de l'Issue est spare de
la dtection des dpendances. Cette sparation entre Issue et dtection des dpendances s'appelle le Schelving. Il existe d'autres
techniques de Schelving , dont certaines se foutent du renommage de registres. Mais toutes ces techniques ncessitent de
stocker les instructions entre l'tage d'Issue et celui de vrification des dpendances.
Ce stockage va se faire dans une sorte de mmoire tampon, qui stockera les instructions dont on doit s'occuper des
dpendances. Tout ce qu' faire l'tape d'Issue, c'est renommer les registres et vrifier qu'il y a suffisamment de place dans cette
mmoire tampon.
Reservation Stations
Mais voyons plus en dtail le rle de cette mmoire tampon. Une fois qu'une instruction a t dcode et que ses registres ont
www.openclassrooms.com
424/467
ts renomms, celle-ci est alors libre de toute dpendance WAR ou WAW. Le renommage de registre, effectu par l'tage
d'Issue, a bien fait son travail. Mais rien n'indique que ses oprandes sont prtes. Il se peut qu'une dpendance RAW vienne
jouer les trouble-fte.
Pour rsoudre cette dpendance RAW, l'instruction est mise en attente en attendant que ses oprandes soient disponibles.
Jusque-l, pas grande diffrence avec le scoreboarding . Mais la nouveaut vient de la faon dont cette instruction est mise en
attente. Avec le Scoreboarding , notre instruction tait mise en attente, mais ses oprandes taient lues depuis les registres
architecturaux, une fois disponibles. On ne pouvait pas lire depuis un registre virtuel.
Avec l'algorithme de Tomasulo, notre instruction sera stocke dans une grosse mmoire tampon, situe juste avant les units de
calcul. Chaque unit de calcul se voit attribuer une de ces mmoires tampon, qui lui est propre et laquelle elle seule peut
accder. Cette mmoire tampon va servir stocker aussi les signaux de commande de nos instructions en attente, ainsi que leurs
oprandes. Pour cela, notre mmoire tampon est compose de blocs bien organiss. Chacun de ces blocs s'appelle une
Reservation Station .
Chaque Reservation Station peut stocker toutes les informations ncessaires pour xecuter une instruction. C'est dire ses
signaux de commande, et ses oprandes.
Empty Bit
Lorsque notre unit d'Issue va vouloir xecuter une instruction, elle va d'abord devoir vrifier si une Reservation Station est libre
devant l'unit de calcul devant xecuter notre instruction. Si ce n'est pas le cas, l'unit d'Issue va devoir se bloquer, et bloquer
aussi les tages du pipeline qui la prcdent. Dans le cas contraire, si une Reservation Station est libre, l'unit d'Issue va la
remplir avec les informations ncessaires sur son excution.
Reste savoir comment fait notre unit d'Issue pour savoir que nos Reservation Stations sont libres. Pour cela, chaque
Reservation Station possde un bit nomm Empty qui indique si celle-ci est vide ou remplie par une instruction. Quand une
Reservation Station se remplie, elle positionne automatiquement ce bit 1. L'unit d'Issue a juste lire des bits des diffrentes
Reservation Station pour savoir lesquelles sont libres.
Valid Bit
Une instruction place dans une Reservation Station sera excute une fois que toute ses oprandes seront disponible (sauf
optimisations bizarres). Pour xecuter l'instruction au bon moment, il faut trouver un moyen pour savoir que toutes les oprandes
d'une instruction sont disponibles.
Pour cela, il suffit d'ajouter des bits de prsence qui permettront de savoir si l'oprande est bien crite dans la Reservation
www.openclassrooms.com
425/467
Station. Quand une oprande est crite dans la Reservation station, le bit de prsence correspondant sera mis jour. Des
circuits relis la Reservation station se chargeront alors de vrifier chaque cycle d'horloge si toutes les oprandes de
l'instruction sont disponible.
On remarque facilement une chose : toutes les instructions n'ont pas le mme nombre d'oprandes. Et donc, ces circuits doivent
dcider quand dmarrer une instruction en fonction non seulement des oprandes disponibles dans la Reservation Station, mais
aussi de l'instruction : on doit donc utiliser l'opcode de l'instruction pour cette dcision.
Tag
Je ne sais pas si vous avez remarqus, mais ces Reservation Station sont des registres virtuels. Ces sont elles qui stockent les
oprandes de nos instructions. Au lieu de lire des donnes depuis le Register File, non donnes peuvent tre lues directement
depuis la sortie de l'ALU. Reprenez le schma dcrivant l'algorithme de Tomasulo, que j'ai mit au-dessus. Vous verrez qu'il existe
une sorte de bus qui relie les sorties des ALUs directement sur leurs entres. Et bien sachez que ce mcanisme permet non
seulement de faire du Bypass de faon efficace, mais qu'il permet aussi de faire du renommage de registre une fois coupl aux
Reservation Station.
En fait, nos Reservation Station vont stocker des donnes directement sorties de l'ALU, et qui ne sont pas forcment
enregistres dans le Register File. Sans Reservation Station, on devrait attendre que le registre soit libre, c'est dire attendre
que toutes les lectures de ce registre soient termines. A la place, on prfre crire dans une Reservation Station, qui stockera le
rsultat temporairement, avant qu'il soit recopi dans le Register File. On voit bien que nos Reservation Stations servent de
registres virtuels.
Pour grer le processus de renommage, une instruction va devoir indiquer dans quels registres virtuels stocker son rsultat. Pour
cela, chaque instruction se voit attribuer un Tag , qui permet d'identifier ce rsultat parmi tous les autres. Ce Tag est stock
directement dans la Reservation Station, cot des oprandes, de l'opcode de l'instruction et de tout le reste.
Oprandes Sources
Ce rsultat, une fois fourni par l'unit de calcul, peut tre rutilis par une autre instruction. Si c'est le cas, il doit tre stock dans
la Reservation Station attribue l'instruction ayant besoin de ce rsultat. Pour identifier celle-ci, on utilise le fait que chaque
Reservation Station stocke les oprandes de l'instruction qu'elle stocke. Chacune de ces oprandes est fournie par une
instruction : il s'agit donc d'un rsultat d'instruction comme un autre, qui est fourni par une unit de calcul. Et ce rsultat possde
un Tag . Pour chaque oprande stocke dans une Reservation Station, il faut donc ajouter de quoi stocker les Tags de cette
oprande.
Lorsqu'une instruction renvoie un rsultat, celui-ci est envoy toutes les Reservation Station via le Common Memory Bus.
Celles-ci vont alors comparer chacun des Tags de leurs oprandes avec celui-ci de l'oprande qui est disponible sur ce bus. Si il
y a correspondance, le rsultat est alors stock dans la Reservation Station.
Dispatch
Une fois passe l'tape d'Issue, les instructions doivent attendre que leurs oprandes soient disponibles dans les Reservations
Stations. Elles sont d'abord Issue, puis elles sont autorises sexcuter. Cette autorisation est une tape particulire de
www.openclassrooms.com
426/467
Bypassing
Avec l'algorithme de Tomasulo, on peut renvoyer ce rsultat dans une Reservation Station et ainsi effectuer du Bypassing . Pour
cela, le rsultat va tre envoy sur un bus qui distribuera le rsultat calcul aux circuits de Writeback ainsi qu'aux Reservations
Stations. Ce bus s'appelle le Common Memory Bus.
Ce rsultat est envoy sur le Common Memory Bus avec le Tag de linstruction qui l'a calcul.
Producers
Pour viter les problmes sur les processeurs utilisant plusieurs units de calculs, nos units de calcul ne vont pas crire
directement sur ce bus : imaginez les problmes d'arbitrage que cela pourrait donner ! A la place, on va en intercaler des registres
entre les units de calcul et ce bus. Ces registres sont appels les Producers. Seul un de ces Producers pourra transfrer ces
donnes dans le Common Memory Bus un moment donn : si plusieurs Procuders veulent crire sur le bus, seul un seul d'entre
eux sera autoris le faire, ce qui limine le problme voqu au-dessus.
www.openclassrooms.com
427/467
Quand celui-ci est libre, un de ces Producers sera choisit et pourra envoyer son contenu dans le Common Memory Bus. En
choisissant correctement le Producer chaque fois, on est certain que les donnes seront envoyes dans le bon ordre.
Accs mmoires
Il faut prciser une chose : les accs la mmoire principale (la RAM) sont traits part des autres instructions. En effet, ces
instructions d'accs mmoires doivent sexcuter dans l'ordre impos par le programme. On ne sait pas supprimer les
dpendances WAR et WAW sur ces instructions : le renommage de registre ne permet de supprimer de telles dpendances que
pour les registres. Pour viter les problmes, notre processeur contient des units spcialiss, qui prennent en charge les
instructions de lecture (Load) ou dcriture (Store) en mmoire. Ce sont les Load Unit (pour les lectures) et les Store Unit
(pour les critures).
Ces units sont relies au Common Memory Bus. Lorsqu'une donne est lue depuis la mmoire, elle atterrit aussi bien dans le
Register File que Dans les Reservations Stations. Petite remarque : l'unit charge des lecture est aussi prcde par des
Reservations Stations qui lui sont rserves. Elles servent mettre en attente des instructions de lecture dont on ne connait pas
encore l'adresse. Linstruction est alors stocke, et dmarre quand la mmoire est libre, et que l'adresse lire est connue.
Pour les critures, c'est un peu diffrent. Si jamais une donne doit tre crite, celle-ci est envoye sur le Common Memory Bus et
rceptionne par l'unit d'criture. Celle-ci sera alors stocke dans une Reservation Station, place juste devant l'unit ddies
aux critures. Une fois que la donne et l'adresse laquelle crire sont connues, et que la mmoire est libre, l'criture est lance.
Bilan
On le voit, cet algorithme se base sur lexistence de Reservations Stations pour effectuer du renommage de registres. Dans la
version vue plus haut de l'algorithme de Tomasulo, ces Reservations Stations servent de registres virtuels. On verra dans la
suite que ce n'est pas toujours le cas.
Lexcution d'une instruction avec cet algorithme de Tomasulo est donc dcoupe en plusieurs tapes. Ce dcoupage en tape
peut servir organiser le pipeline d'un processeur.
Aussi, il n'est pas rare que les processeurs Out Of Order utilisant le renommage de registres aient un pipeline similaire celui-ci :
Fetch ;
Decode ;
Issue/Rename : renommage des registres et allocation dans les Reservations Stations ;
Dispatch : autorisation dexcution, parfois prcde d'un temps d'attente des oprandes dans les Reservation Stations ;
Execution ;
Completion : le rsultat est disponible sur le Common Memory Bus et enregistr dans les registres.
Mais pour le moment, il y a une chose que l'on a oubli de dire. Si nos Reservations Stations sont des registres virtuels, les
critures dans le Register File se font l'tape de Completion. C'est lors de cette tape que les critures en mmoire et dans les
registres seffectuent. Et cette completion se fait dans le dsordre le plus total.
Re-Orders Buffers
La version de l'algorithme de Tomasulo que l'on a vue a un lger problme : la moindre interruption ou mauvaise prdiction de
branchement peut tout casser ! Les mauvaises prdiction de branchements, les interruptions et les exceptions matrielles
peuvent mettre un sacr bazar si l'ordre des lectures/critures n'est pas celui prvu par le programmeur. Si une instruction qui
n'aurait pas du tre excute (parce que prcde par un branchement, une interruption, ou une exception dans l'ordre du
www.openclassrooms.com
428/467
programme) modifie un registre alors qu'elle n'aurait pas du, on est mal. Pour viter ce genre de problmes et grer les
interruptions et branchements correctement, notre processeur va se charger de "remettre les lectures et critures dans l'ordre".
Pour cela, les rsultats des instructions vont devoir attendre avant d'tre enregistrs dans les registres ou la mmoire. Cette
attente dure jusqu' ce que toutes les instructions qui prcdent l'instruction qui a fournie le rsultat (dans l'ordre normal du
programme) soient toutes excutes.
Cette attente se fait dans un tage supplmentaire du pipeline, rajout la suite des prcdents. Un nouvel tage fait son
apparition : Commit.
Le pipeline de notre processeur devient donc :
Fetch ;
Decode ;
Issue/Rename : renommage des registres et allocation dans les Reservations Stations ;
Execution ;
Completion : le rsultat est disponible sur le Common Memory Bus et mis en attente ;
Commit : le rsultat est enregistr dans les registres.
Le Reorder Buffer
Pour s'assurer que les rsultats sont crits dans l'ordre du programme, et pas n'importe comment, notre Reorder Buffer est
organis d'une certaine faon.
Ce Reorder Buffer est compos de plusieurs entres, des espces de blocs dans lesquels il va stocker des informations sur les
rsultats crire, et leur ordre. Ainsi, il saura prendre en charge les critures dans les registres, et les remettre dans le bon ordre.
Voyons un peu son contenu.
Tag
Il va de soit que notre Reorder Buffer contient les donnes crire. Mais il doit aussi les remettre dans l'ordre.
Lorsqu'une instruction vient d'tre dcode durant l'tape d'Issue, celle-ci est alors ajoute dans le Reorder Buffer la suite des
autres. Les instructions tant dcodes dans l'ordre du programme, l'ajout des instructions dans le Reorder Buffer se fera dans
l'ordre du programme, automatiquement. Elle va rserver une entre dans le Reorder Buffer. Pour savoir quelle instruction cette
entre est rserve, on y ajoute le Tag de l'instruction.
www.openclassrooms.com
429/467
En consquence, une entre de notre Reorder Buffer contient donc de quoi stocker un rsultat, et aussi de quoi placer le Tag
d'une instruction.
Lorsque le rsultat de l'instruction est connu, il est disponible sur le Common Memory Bus avec son Tag . A chaque envoi sur ce
bus, le Reorder Buffer va regarder s'il y a une correspondance entre ce Tag , et un des Tags qu'il contient. Si c'est le cas, le
rsultat est crit dans le Reorder Buffer, dans l'entre dont le Tag correspond.
Valid Bit
Maintenant, prenons un cas particulier. Imaginons que nous ayons une instruction dans notre Reorder Buffer. Toutes les
instructions prcdentes ont crit leurs rsultats en mmoire ou dans les registres. Je suis sur que vous pensez que l'on peut
crire le rsultat de notre instruction dans les registres sans problme. Elle peut alors quitter le Reorder Buffer.
Mais et si son rsultat n'est pas disponible ? Il faut alors garder cette instruction dans le Reorder Buffer. Pour savoir si notre
instruction a bien produit un rsultat ou s'il faut attendre, chaque entre du Reorder Buffer contient un bit de presence. Celui-ci
est mit 1 quand le rsultat de l'instruction est crit dans l'entre.
Autres informations
Suivant le processeur, le Reorder Buffer peut parfois contenir d'autres informations, comme le registre ou l'adresse o crire.
Mais cela dpend du processeur utilis, aussi cela ne sert rien de rentrer dans les dtails.
Une File
Il faut prciser que les instructions ne quittent pas le Reorder Buffer n'importe quand. Un rsultat est enregistr dans un registre
lorsque les instructions prcdentes (dans l'ordre du programme) ont toutes crit leurs rsultats dans les registres. Pour cela,
notre Reorder Buffer est une sorte de mmoire, trie dans l'ordre d'ajout : les instructions sont tries des plus rcentes aux plus
anciennes. Seule l'instruction la plus ancienne peut quitter le Reorder Buffer et enregistrer son rsultat une fois si celui-ci est
prsent (pensez au bit de prsence). Les instructions plus rcentes doivent attendre.
Implmentation
Voyons un peu comment grer cet ordre d'criture. Notre Reorder Buffer contient un nombre d'entre qui est fix, cbl une fois
pour toute. Chacune de ces entres est identifie par un nombre, qui lui est attribu dfinitivement.
Cet identifiant pourra alors servir configurer un multiplexeur, qui slectionnera la bonne entre dans le Reorder Buffer, pour lire
son contenu ou y crire.
End Of Queue
Ces entres sont gres par leur identifiant. Le numro de l'entre la plus ancienne est ainsi mmoris dans une petite mmoire.
Cela permet de pointer sur cet entre, qui contient la prochaine donne enregistrer dans les registres ou la mmoire.
www.openclassrooms.com
430/467
Quand cette entre quitte le Reorder Buffer, le numro, le pointeurs sur la dernire entre est augment de 1, pour pointer sur la
prochaine entre.
Begining Of Queue
De mme, le numro de l'entre la plus rcente est aussi mmoris dans une petite mmoire. Il faut bien savoir o ajouter de
nouvelles entres. Ainsi, le Reorder Buffer sait quelles sont les entres valides : ce sont celles qui sont situes entre ces deux
entres.
Quand on ajoute des instructions dans le Reorder Buffer, il ne faut pas oublier d'augmenter ce numro de 1.
Petit dtail : quand on ajoute des instructions dans le Reorder Buffer, il se peut que l'on arrive au bout, l'entre qui a le plus
grand nombre. Pourtant, le Reorder Buffer n'est pas plein. De la place se libre dans les entres basses, au fur et mesure que le
Reorder Buffer. Dans ce cas, on n'hsite pas reprendre depuis le dbut.
Exemple : je prends l'exemple prcdent, avec l'entre 4 occupe. Si je rajoute une instruction, je remplirais l'entre 5.
www.openclassrooms.com
431/467
La prochaine entre tre remplie sera l'entre numrot 0. Et on poursuivra ainsi de suite.
Taille du R.O.B
Quand notre Reorder Buffer est plein, le processeur va automatiquement bloquer les tages de Fetch, Dcodage, et renommage
(Issue). Cela vite de charger des instructions dans celui-ci alors qu'il est plein. Consquence : cela empche de charger de
nouvelles instructions dans les Reservations Stations. Petite remarque : cela implique que plus un Reorder Buffer peu contenir
d'instruction, plus on pourra xecuter d'instructions de faon anticipe. Lexcution Out-Of-Order sera ainsi plus facile et
donnera de meilleurs rsultats.
Sur les processeurs utilisant un squenceur micro-cod, certaines amliorations au niveau de l'unit de dcodage d'instruction
permettent de mieux utiliser ce Reorder Buffer. Ces fameuses amliorations sont celles qui consistent fusionner une ou
plusieurs instructions machines en une seule micro-opration. Notre Reorder Buffer va en effet stocker des micro-instruction, et
non des instructions machines. En fusionnant plusieurs instructions machines ou micro-oprations en une seule, on diminue le
nombre d'instructions stocker dans le Reorder Buffer : on gagne un peu de place.
Spculation Recovery
Dans le chapitre parlant de la prdiction de branchement, j'avais dit qu'il y avait deux solutions pour remettre le pipeline son
tat originel en cas de mauvaise prdiction de branchement : empcher nos instructions fautives d'enregistrer leurs rsultats
dans les registres (sous entendu, les registres architecturaux), ou remettre les registres leurs valeurs originelles partir d'une
sauvegarde de ceux-ci. Le Reorder Buffer permet d'implmenter facilement la premire solution. C'est lui qui empche les
instructions excutes de faon anticipes d'enregistrer leurs rsultats dans les registres architecturaux. en cas de mauvaise
prdiction de branchement. Si une interruption ou une mauvaise prdiction de branchement a lieu, le Reorder Buffer se
dbarrassera des rsultats des instructions qui suivent l'instruction fautive (celle qui a dclench l'interruption ou la mauvaise
prdiction de branchement) : ces rsultats ne seront pas enregistrs dans les registres architecturaux. Les rsultats des
instructions prcdant l'instruction fautive auront alors dj t sauvegards, laissant le processeur propre.
Mais on doit amliorer le Reorder Buffer pour qu'il puisse grer tout cela.
O reprendre ?
Premire chose, dans de telles situations, il faut savoir o reprendre. Pour cela, chaque entre dans le Reorder Buffer contient en
plus l'adresse de l'instruction. Par adresse, on veut dire contenu du Program Counter quand linstruction a t Fetche. Le
Reorder Buffer utilise cette adresse pour savoir partir de quelle instruction il faut tout r-excuter. Parfois, cette adresse
remplace le Tag de l'instruction.
Spculative Bit
Pour cela, on rajoute un bit dans chaque entre du Reorder Buffer. Ce bit servira prciser si l'instruction a leve une exception
ou s'il s'agit d'un branchement mal pris. Si ce bit est 1, alors il y a eu une mauvaise prdiction de branchement ou une exception.
Les pointeurs sur l'entre la plus rcente et la plus ancienne sont alors rinitialiss, mis zro. Cela permet de vider le Reorder
Buffer, et vite d'enregistrer des rsultats faux en mmoire.
Sur certains processeurs, on fait une distinction entre branchements et exception, en utilisant un bit pour prciser une mauvaise
prdiction de branchement, et un autre pour prciser lexception (et si possible quelques autres pour prciser de quelle exception
www.openclassrooms.com
432/467
il s'agit).
Accs mmoire
Pour remettre les accs mmoire dans l'ordre, certains processeurs utilisent un Reorder Buffer ddi aux lectures/critures. Celuici est spar du Reorder Buffer ddi aux registres. Mais les deux communiquent ensemble. Sur d'autres processeurs, on utilise
un seul Reorder Buffer, charg de traiter la fois les instruction qui touchent aux registres et celles qui vont manipuler la
mmoire.
ROB
Commenons par faire une petite remarque sur l'algorithme de Tomasulo, auquel on a jout un Reorder Buffer. Dans cette version
de l'algorithme, les rsultats de nos instructions sont stocks en deux exemplaires : dans les Reservation Stations, et dans le
Reorder Buffer. Certains chercheurs ont alors eu l'ide de faire en sorte de ne pas copier inutilement nos donnes. Au lieu de
placer nos donnes en double ou triple, ils ont dcids de voir si on ne pouvait pas changer l'algorithme pour n'avoir qu'un seul
exemplaire de donnes.
L'ide est de stocker toutes les donnes en un seul exemplaire, dans le Reorder Buffer. On se retrouve donc avec un Reorder
buffer, qui est quivalent aux registres virtuels, et un Register File qui contient tous les registres architecturaux. Avec
ventuellement les fameuses Reservations Stations, mais sans que cela soit obligatoire : on peut trs bien s'en passer et les
remplacer par autre chose.
Fonctionnement
Avec cette technique, les Reservation Stations ne contiennent plus de donnes, mais vont stocker de quoi savoir dans quelle
entre du Reorder Buffer trouver la donne. Les Tags des oprandes seront remplacs par le numro des entres du Reorder
Buffer qui contiendra la donne. Mme chose pour le Tag du rsultat d'une instruction, qui remplac par le numro de l'entre du
Reorder Buffer destine laccueillir.
www.openclassrooms.com
433/467
Quand une instruction a toutes ses oprandes de prtes, celles-ci ne seront pas dans les Reservation Station, mais elles seront
disponibles dans le Reorder Buffer ou dans le Register File. Notre instruction aura juste les lire depuis le Reorder Buffer ou le
Register File, et les charger sur les entres de l'unit de calcul. Cela ncessite de connecter notre Reorder Buffer sur les entres
des units de calcul, mais le jeu en vaut la chandelle.
Attention : ne prenez pas ce schma trop la lettre. Dans ce schma, on pourrait croire que le Register File ne sert rien. En fait,
il faut se souvenir que les oprandes d'une instruction peuvent aussi tre lues depuis le Register File : il n'y a pas que le
Reorder Buffer qui peut contenir les oprandes.
De plus, je n'ai pas indiqu le Common Memory Bus, pour ne pas surcharger le tout. Et ce sera aussi le cas dans tous les
schmas qui vont suivre.
De mme, il arrive que certains processeurs fusionnent le Reorder Buffer et les Reservation Stations dans un seul gros circuit.
On n'est vraiment pas un dtail prt !
Pipeline
Une petite remarque : cette lecture des oprandes depuis un registre peut prendre un certain temps. Pour viter tout problme,
cette lecture est effectue dans un tage du pipeline spar.
Le pipeline de notre processeur devient donc :
Fetch ;
Decode ;
Issue/Rename : renommage des registres et allocation dans les Reservations Stations ;
Reorder Buffer Read : lecture des oprandes d'une instruction depuis le Reorder Buffer ;
Execution ;
Completion : le rsultat est disponible sur le Common Memory Bus et mis en attente ;
Commit : le rsultat est enregistr dans les registres.
Pour information, cette version de l'algorithme de Tomasulo tait utilise dans d'anciens processeurs commerciaux, comme les
Pentium Pro, le Pentium II, ou encore le Pentium III.
www.openclassrooms.com
434/467
Stations. Le Register File qui stocke les registres virtuels porte un nom : c'est le Rename Register File. Evidemmemnt, le
Register File qui stocke les registres architecturaux porte aussi un nom : c'est le Retiremment Register File.
Cette fois-ci, le Reorder Buffer subit le mme traitement qu'on a fait subir aux Reservations Stations : il ne contient plus la
moindre donne. Avec cette version de l'algorithme, Reorder Buffer et Reservations Stations contiennent la place le nom du
registre virtuel ou rel qui contient la donne.
Quand le Reorder Buffer veut crire une donne en mmoire, il a juste la lire depuis le Rename Register File, et l'crire
directement dans le Retiremment Register File. Pareil pour les Reservation Stations : quand toutes les oprandes d'une
instruction sont disponibles, elles sont lues depuis le Rename Register File ou le Retiremment Register File, et envoyes sur
l'entre de l'unit de calcul.
Le pipeline du processeur reste identique avec la version du renommage utilisant un Reorder Buffer, part que l'tape de lecture
des oprandes s'appelle maintenant Register Read .
www.openclassrooms.com
435/467
Aujourd 'hui, presque tous les processeurs utilisent ce genre de structure pour faire du renommage de registres. Il faut dire qu'un
Physical Register File consomme bien moins d'nergie que ses concurents. Il faut dire que les donnes ne sont pas copies d'un
Rename Register File vers un Retiremment Register File. Et de plus, les diverses structures matrielle associes, comme le
Reorder Buffer, contiennent des pointeurs vers nos registres, ce qui prend moins de place que stocker directement les donnes,
plus longues. C'est pour cela que cette amlioration est utilis sur les derniers processeurs actuels.
Autre avantage : certaines oprations deviennent inutiles si le renommage de registres est fait intelligemment. Il s'agit des
instructions de copie d'un registre dans un autre (les mov) ou dchange entre deux registres (xchg). Elles peuvent tre
supprimes via une application correcte du register renamming . Aprs la copie de notre registre dans un autre, le contenu des
deux registres est identique. Ce n'est que lors d'une criture lieu dans des deux registres que leurs contenus diffrents. Au lieu
de faire cette recopie, on peut utiliser un seul registre physique pour stocker la valeur recopier et renvoyer toute lecture des
deux registres architecturaux vers ce registre physique. Lors d'une criture dans un de ces deux registres, il suffira d'utiliser un
registre physique vide pour stocker la donne crire et l'associer avec le nom de ce registre. On peut considrer qu'il s'agit
d'une forme de Copy On Write, applique sur des registres, en considrant que le nom d'un registre est un pointeur (il vaudrait
mieux parler de rfrence, mais bon...) vers un registre physique.
L'unit de renommage
Dans nos processeurs, les registres sont identifis par ce qu'on appelle un nom de registre. Ce terme doit vous rappeler quelque
chose, et ce n'est pas un hasard : on a vu cela dans le chapitre sur l'assembleur. Quoiqu'il en soit, nos registres sont donc
identifis par ces noms de registres qui ne sont autre que des suites de bits dont la valeur va permettre d'identifier un registre
architectural parmi tous les autres. Nos registres physiques sont eux aussi identifis par un nom de registre, mais qui est
seulement connu du processeur : le Tag. Pour attribuer un registre architectural un registre physique, il suffit de remplacer le
nom du registre architectural par le tag du registre physique qui lui est attribu. On dit alors que le registre architectural est
renomm.
Dans un processeur utilisant le renommage de registres, il y a bien plus de registres physiques que de registres architecturaux.
Donc, le tag d'un registre physique est plus grand que le nom d'un registre architectural.
436/467
Ce remplacement est effectu par un circuit spcialis, cas dans un tage supplmentaire du pipeline. Celui-ci va prendre sur ses
entres le nom des registres architecturaux manipuler, et va fournir sur sa sortie les tag des registres physiques correspondant.
Ce circuit s'appelle la Register Map Table. Ce circuit est conceptuellement divis en deux gros sous-circuits. Je dis
conceptuellement, parce que ces deux circuits sont parfois fusionns en un seul, mais dans les explications qui vont suivre, on
fera comme si on disposait de deux circuits bien spars.
Free List
Pour commencer, nous allons prendre le premier de ces sous-circuits la Free List . Celle-ci sert renommer le ou les registres
modifis par notre instruction. En bref, ceux dans lesquels notre instruction va aller crire. Renommer ces registres est trs
simple. Pour viter que le registre de destination soit un registre dj utilis par une autre instruction (voire par l'instruction ellemme, si le registre de destination est un registre source), on doit prendre un registre physique inutilis la place. Notre Register
Map Table doit donc garder une liste des registres vides , utilisables librement par nos instructions. Pour cela, on garde cette
liste des registres inutiliss dans une petite mmoire qu'on appelle la Free List.
Lorsque la donne contenue dans un registre n'a plus tre utilises par les prochaines instruction, celle-ci devient inutile. On
peut alors rutiliser ce registre comme bon nous semble. A ce moment, ce registre passe dans la Free List. Dtecter les registres
rutilisables est assez complexe, et peut en plus se faire de plusieurs faons, suivant le nombre d'instruction dmarres
simultanment. Si ce nombre est faible, on peut dtecter facilement les registres physiques devenus rutilisables. Il suffit que
l'instruction qui a crit le rsultat dedans quitte le Re-Order Buffer. A ce moment, ce rsultat est copi du Registre virtuel vers le
Retiremment Register File. Toute lecture du rsultat sera fournie par le Retiremment Register File, et pas par le registre
physique. On peut donc le rutiliser comme bon nous semble. Par contre, si on peut Issue un grand nombre d'instructions par
cycle dhorloge, la situation est plus complexe.
Dtails
Sur les processeurs utilisant un Physical Register File, on n'a pas aller plus loin. Avec ce qu'on a dit plus haut, pas besoin de
rajouter quoi que ce soit pour effectuer du renommage de registres. Mais pour les autres processeurs, c'est autre chose. Il faut
dire que sur les autres processeurs, on dispose de deux Register File : un pour les registre architecturaux, et un pour les
registres physiques. Et on doit prciser si on doit lire une donne depuis les registres architecturaux ou depuis les registres
physiques. Quand on doit lire une donne depuis les registres physiques, on n'a strictement aucune correspondance entre le
registre architectural et un registre physique. La Register Alias Table a donc une entre de vide, ce qui est indiqu d'une facon
ou d'une autre l'instruction renommer.
Petite remarque : en cas de mauvaise prdiction de branchement ou d'exception matrielle, on doit remettre notre Register Alias
Table et la Free List dans l'tat dans lequel elle tait avant le chargement de l'instruction fautive. Cela peut se faire de diffrentes
manires, mais la plus courante est de stocker dans le Re-Order Buffer ce qui a t modifi dans l'unit de renommage de
registres par l'instruction correspondante. Ainsi, lorsqu'une instruction sera prte commit, et qu'une exception ou mauvaise
prdiction de branchement aura eu lieu, les modifications effectues dans l'unit de renommage de registres seront annules les
unes aprs les autres. Une autre solution consiste garder une copie valide de la Register Alias Table dans une mmoire part,
pour al restaurer au besoin. Par exemple, si jamais notre Register Alias Table dtecte un branchement, son contenu est
sauvegard dans une mmoire intgre au processeur.
Implmentation
www.openclassrooms.com
437/467
Il existe deux faons pour implmenter une Register Alias Table. La plus ancienne consiste utiliser une mmoire associative.
Cette mmoire peut tre vu comme une sorte de mmoire cache un peu spciale. Cette mmoire associative stocke des
correspondances entre registres architecturaux, et registres physiques. Son Tag correspond un nom de registre architectural,
tandis que la ligne de cache qui correspond contient le nom de registre virtuel associ. Quand on veut obtenir le registre
physique qui correspond un registre architectural, il suffit de comparer ce nom du registre architectural avec les Tags du cache
et de retourner le nom de registre physique si on a correspondance avec un Tag . Mais il faut faire attention au cas o plusieurs
instructions crivent dans le mme registre architectural des moments diffrents. Et c'est l que l'on saperoit de la diffrence
avec un cache : dans ce cas, cette mmoire associative va conserver plusieurs correspondances registre architectural - registre
physique. Dans ce cas, on doit renvoyer l'entre de l'instruction la plus rcente parmi toutes celles qui correspondent. Pour ce
faire, nos correspondances sont tries par ordre d'arrive.
Sur les processeurs plus rcents, on implmente notre Register Alias Table autrement. On utilise une mmoire RAM, dont les
adresses correspondent aux noms de registres architecturaux, et dont le contenu d'une adresse correspond au nom du registre
physique associ. C'est plus rapide et utilise moins de transistors. Mais dans ce cas, on n'a qu'une seule correspondance entre
registre physique et registre architectural. Cela ne pose pas vraiment de problmes, si on renomme nos instructions dans l'ordre.
www.openclassrooms.com
438/467
Dpendances, le retour !
Modifier l'ordre dexcution des accs la mmoire est une chose assez efficace en terme de performances. Par exemple, il vaut
mieux effectuer les lectures le plus tt possible. Il faut dire que ces lectures prennent un certain temps : accder une donne ne
se fait pas immdiatement. Cela peut prendre moins de 10 cycles d'horloge pour un accs au cache L1, mais peut facilement
monter et atteindre des nombres 2 chiffres pour les accs au L2, et trois chiffres pour les accs la mmoire. Autant dire que ne
rien faire durant cet accs au cache ou la mmoire, et faire attendre les instructions suivant une instruction de lecture n'est pas
une bonne chose. L'idal serait dexcuter des instructions indpendantes de l'accs en mmoire pendant qu'on attend que la
donne voulue soit lue. Pour ce faire, il suffit dexcuter la lecture le plus prcocement possible, et xecuter des instructions
indpendantes pendant ce temps.
Seul problme : il faut que toutes les instructions ayant une dpendance avec cette lecture aient dj finies de sexcuter avant
qu'on puisse lancer la lecture. Si on se trouve dans un tel cas, il se peut que l'on ne puisse dmarrer notre lecture aussi tt que
prvu, parce qu'une instruction ayant une dpendance avec notre lecture n'est pas termine : impossible de faire passer notre
lecture avant celle-ci. Reste savoir si ces dpendances sont monnaie courante.
Utilit
Dans le chapitre prcdent, on a vu que ces dpendances naissaient lorsque l'on des instructions diffrentes veulent lire ou
crire dans des emplacements mmoire identiques. Dans les cas des registres, cela arrive trs souvent : un processeur possde
souvent une faible quantit de registres, qui doit donc tre utilise au mieux. Ainsi, nos compilateurs nhsitent pas rutiliser
des registres ds que possible, et n'hsitent pas craser des donnes qui ne sont plus ncessaires pour stocker des rsultats
utiles. Rutiliser des registres le plus possible fait donc apparaitre de nombreuses dpendances WAR et WAW. Mais pour les
accs mmoires, c'est autre chose. Accder la mmoire n'est pas rare, certes, mais rutiliser de la mmoire l'est. Il est en effet trs
rare qu'on doive lire ou crire des adresses identiques dans un cours laps de temps, et rares sont les dpendances WAR et
WAW. Il faut dire que ces situations correspondent souvent des donnes qui sont stockes temporairement sur la pile, cause
d'un manque de registres. On pourrait donc croire que chercher supprimer les dpendances WAR et WAW pour les accs la
mmoire ne servirait que marginalement, et ne serait donc qu'un coup d'pe dans l'eau.
Mais la situation est beaucoup plus complique que ce que cette prsentation nave vous l'a laiss entendre.
De nouvelles dpendances
Le seul truc, c'est que notre processeur ne peut pas toujours savoir si deux accs la mmoire vont se faire au mme endroit ou
pas. Pour les instructions utilisant l'adressage absolu (l'adresse laquelle lire ou crire est stocke dans la suite de bits
reprsentant notre instruction), il n'y a pas de problmes. Mais le seul truc, c'est que ce n'est pas le cas pour d'autres modes
d'adressages. Par exemple, il n'est pas rare que nos adresses soient stockes dans des registres. Il est en effet monnaie courante
de ne pas connaitre l'avance les adresses laquelle lire ou crire, et calculer des adresses est une chose commune de nos jours.
Dans des cas pareils, il est impossible de savoir si deux accs la mmoire se font la mme adresse ou pas.
Bilan : deux accs la mmoire peuvent tre totalement indpendants, mais le processeur ne peut pas le savoir. Rsultat : il est
oblig de supposer par scurit que ces deux accs sont dpendants, ce qui va limiter ses possibilits. Il ne pourra pas changer
l'ordre de ses instructions pour gagner en efficacit. Et cela arrive trs souvent : presque chaque accs mmoire !
Il faut noter que ce genre de situations arrive aussi dans un domaine assez loign. Certains compilateurs doivent faire face un
problme similaire dans certaines situations : dans certaines conditions, ils ne savent pas si deux adresses mmoire utilises
dans un programme sont diffrentes ou pas. Et dans ces conditions, ils doivent viter de modifier l'ordre des accs ces
adresses, ce qui limite grandement les possibilits doptimisation. C'est ce qu'on appelle le phnomnes d'aliasing des pointeurs.
www.openclassrooms.com
439/467
Autre problme : il arrive qu'il ne soit pas possible de dplacer une lecture avant une autre. Cela arrive dans un cas simple :
quand on charge une adresse dans un registre et qu'on chercher lire le contenu de cet adresse. On a obligatoirement besoin de
charger l'adresse avant de charger la donne pointe par cette adresse. La premire lecture doit se faire avant l'autre. Une autre
dpendance fait son apparition.
Dpendances de nommage
Pour limiter la catastrophe, notre processeur va utiliser des mcanismes permettant de diminuer les effets de nos dpendances,
en supprimant ou attnuant celles-ci. Divers mcanismes de Memory Disambiguation ont ainsi ts invents.
Ces techniques sont bases sur un principe assez proche de celui qui est derrire le renommage de registres. crire notre
donnes au mme endroit que les lectures ou critures prcdentes va faire apparaitre des dpendances. Pour supprimer ces
dpendances, on va simplement crire la donne ailleurs, et attendre que les lectures ou critures prcdentes cette adresse
mmoire soient termines, avant de dplacer notre donne au bon endroit. Pour ce faire, on pourrait penser utiliser du
renommage d'adresses mmoires. Mais ce serait compliqu, et augmenterait le nombre d'critures en mmoire d'une faon assez
importante. Mme si certains processeurs utilisent cette technique, elle est tout de mme assez peu utilise, du fait de ses
dfauts. D'autres solutions existent, plus efficaces.
Store queue
Si on utilisait le renommage d'adresses mmoires, on devrait utiliser la mmoire pour stocker temporairement des donnes
crire, ces donne venant d'instructions excutes en avance compar ce qui tait prvu dans l'ordre du programme. Au lieu
d'utiliser la mmoire, on prfre crire ces donnes dans une mmoire intgre au processeur, spcialement conue dans ce but :
la store queue. Et oui, j'ose vous sortir un terme barbare sans prvenir : il faudra vous y habituer.
Ainsi, on peut enregistrer nos donnes dans cette Store Queue temporairement. Chaque donne prsente dans cette Store
Queue va quitter celle-ci pour tre enregistre en mmoire sous une condition bien particulire. Si dans l'ordre des instructions
du programme, on trouve des lectures ou des critures qui lisent ou modifient l'adresse laquelle on veut crire cette donne,
alors on doit attendre que celles-ci soient termines pour pouvoir dmarrer l'criture de notre donne et la faire quitter la Store
Queue.
L'utilisation d'une Store Queue a d'autres avantages : on peut xecuter notre criture avant certaines instructions qui pourraient
lever une exception matrielle. Par exemple, on peut effectuer notre criture avant une opration de division, qui peut
potentiellement lever une exception de division par zro. Sans Store Queue, on aurait excute notre criture et modifi la
mmoire alors que notre criture n'aurait jamais t excute, vu que lexception leve par la division aurait alors interrompu le
programme et aurait parfaitement pu faire zapper notre criture sous certaines circonstances. Avec une Store Queue, il suffit
deffacer la donne crire de la Store Queue, ainsi que les informations qui lui sont associe, sans rien crire dans la mmoire.
Cette Store Queue est localise dans les units Store, qui se chargent d'effectuer les oprations d'criture en mmoire.
Et bien dans ce cas l, la Store Queue se charge de donner la dernire donne avoir t crite, histoire de renvoyer la donne la
plus jour. En excutant les lectures dans le bon ordre, cela ne pose aucun problme.
Dependances d'alias
Comme je l'ai dit plus haut, le processeur ne peut pas toujours savoir si deux accs mmoires vont se faire au mme endroit ou
non. A cause de cela, des dpendances RAW, WAR, et WAW fictives apparaissent inutilement. Alors certes, l'utilisation d'une
www.openclassrooms.com
440/467
Store Queue permet de supprimer ces dpendances WAR et WAW. Mais pour supprimer les fausses dpendances RAW, il faut
trouver d'autres solutions.
Matrices de dpendances
Ces matrices forment une espce de tableau carr, organis en lignes et en colonnes. Chaque ligne et chaque colonne se voit
attribuer une instruction. A l'intersection d'une ligne et d'une colonne, on trouve un bit. Celui-ci permet de dire si l'instruction de
la ligne et celle de la colonne ont une dpendance. Si ce bit est 1, alors l'instruction de la ligne a une dpendance avec celle de
la colonne. Si ce bit est zro, les deux instructions sont indpendantes. Cette technique nous permet donc de comparer une
instruction avec toutes les autres, histoire de na pas rater la moindre dpendance. A chaque ligne, on attribue une lecture ou une
criture.
Commenons par voir la version la plus simple de ces matrices de dpendances. Avec celles-ci, on vrifie juste si toutes les
adresses des critures prcdentes sont connues ou non. Si elles ne sont pas toutes connues, les lectures vont attendre avant
de pouvoir sexcuter. Dans le cas contraire, on peut alors dmarrer nos accs mmoires. La vrification des dpendances (est-ce
que deux accs mmoires se font la mme adresse) se fait alors avec une Store Queue ou dans des circuits spcialiss.
Lorsque le processeur dmarre une criture dont il ne connait pas l'adresse de la donne crire, il va d'abord insrer cette
criture dans ce tableau carr dans une ligne. Cette ligne sera celle d'indice i. Puis, il va mettre tous les bits de la colonne de
mme indice (i) 1. Cela permet de dire que notre criture peut potentiellement avoir une dpendance avec chaque instruction en
attente. Vu qu'on ne connait pas son adresse, on ne peut pas savoir. Lorsque cette adresse est alors connue, les bits de la
colonne attribue l'criture sont remis zro. Quand tous les bits d'une ligne sont zro, la lecture ou criture correspondante
est envoye vers les circuits chargs de grer les lectures ou critures. Ceux-ci se chargeront alors de vrifier les adresses des
lectures et critures, grce une Store Queue et le Store-to-Load Forwarding associ.
Cette technique peut tre amliore, et grer la dtection des dpendances elle-mme, au lieu de les dlguer une Store Queue.
Dans ce cas, on doit commencer par ajouter l' adresse laquelle notre instruction va lire ou crire pour chaque ligne. Puis,
chaque fois qu'une adresse est ajoute dans une ligne, il suffit de la comparer avec les adresses des autres lignes et mettre jour
les bits de notre matrice en consquence.
Efficacit
Cette technique n'est pas trs efficace : il est en effet peu probable que toutes les adresses des critures prcdant une lecture
soit connue lorsque l'on veut lire notre donne. Autant dire que cette technique n'est pas utilise seule, et elle est complte par
d'autres techniques plus ou moins complmentaires.
Excution spculative
Les techniques vues prcdemment donnent des rsultats assez bons, et sont des techniques assez utiles. Mais c'est loin d'tre
la seule technique qui aie t invente pour diminuer l'effet des dpendances RAW. Parmi ces autres techniques, nombreuses
sont celles qui utilisent lexcution spculative. Le terme peut paraitre barbare, mais il consiste simplement excuter des
www.openclassrooms.com
441/467
instructions de faon anticipe, en supposant certaines choses, et en remettant le processeur zro si la supposition se rvle
tre fausse. La prdiction de branchement est un cas dexcution spculative assez connu.
Dans le cas des lectures et critures en mmoire, rien ne nous empche de rorganiser spculativement l'ordre des lectures et des
critures quelque soit la situation, mme si on ne sait pas si les dpendances RAW entre deux accs mmoires sont fictives ou
relles. Alors bien sr, on ne doit pas faire cela btement : notre processeur va vrifier si jamais il a fait une erreur en excutant
une lecture trop anticipe, en vrifiant les adresses auxquelles il va crire et lire. Si jamais le processeur a excut une lecture trop
tt (avant une criture la mme adresse dans l'ordre du programme), il va se charger d'liminer les modifications qui ont ts
faites par cette lecture foireuse, et reprendra lexcution du programme convenablement.
Pour pouvoir fonctionner correctement, notre processeur doit donc vrifier qu'il n'y a pas d'erreur. Une erreur correspond une
lecture la mme adresse qu'une criture, avec la lecture qui est place aprs l'criture dans l'ordre des instructions impos par le
programme. Pour faire ces vrifications, le processeur va garder la trace des lectures effectues dans une sorte de mmoire cache,
la Load Queue. Cette Load Queue va conserver pour chaque lecture : l'adresse de la lecture effectue, ainsi que la donne lue.
Cette Load Queue va conserver ces informations durant un certain temps, jusqu' ce que toutes les instructions prcdant la
lecture dans l'ordre du programme soient termines. Une fois que ces instructions sont finies, la lecture est efface de la Load
Queue, ou tout simplement oublie.
Ainsi, chaque criture, il suffit de vrifier si une lecture a accd la mme adresse se trouve dans cette Load Queue. Rien de
bien compliqu : on compare l'adresse de l'criture avec les tags de la Load Queue, qui contiennent l'adresse laquelle notre
lecture a accd. Si on ne trouve pas de correspondance, alors il n'y a pas d'erreurs. Mais si c'est le cas, on doit alors supprimer
du pipeline toutes les instructions excutes depuis la lecture anticipe fautive. En clair, on fait exactement la mme chose que
lors d'une mauvaise prdiction de branchement : on vide le pipeline. Petit dtail : sur certaines processeurs, la Load Queue, et la
Store Queue sont fusionnes dans une seul gros circuit.
Wait Table
Une des techniques les plus simple pour prdire les dpendances d'alias est celle de la Wait Table. Le principe de cette
technique est diablement simple : si jamais une lecture/criture va aller trifouiller la mme adresse qu'une de ses consurs, on
s'en souviens pour la prochaine fois.
Pour s'en souvenir, il suffit de rajouter quelque chose qui permettent de se souvenir des instructions mmoire ayant une
dpendance RAW avec une de leur consur. Pour cela, il suffit de rajouter une mmoire dans laquelle on va placer les adresses
(le Program Counter) des instructions ayant une dpendance. L'adresse de chaque instruction qui sexcute va ainsi tre
stocke dans cette mmoire, et va tre associe un bit. Ce bit vaudra 0 si l'instruction correspondante n'a aucune dpendance,
et 1 dans le cas contraire. Lunit de dcodage pourra alors dduire les dpendances de nos instructions. C'est cette technique
qui tait utilise sur les processeurs Alpha 21264. Pour viter les faux positifs, le bit associ une instruction tait remis zro au
bout d'un certain temps. Tous les 100 000 cycles d'horloge, pour tre prcis.
On peut aussi amliorer l'ide en se passant du bit, et en ne stockant dans cette mmoire cache que les instructions ayant une
dpendance, et pas les autres. Et l encore, on peut dcider de virer une instruction de cette mmoire au bout d'un certain temps
pour viter les faux positifs.
Autres
La technique vue au-dessus a un sacr dfaut. Si jamais une instruction mmoire est indique comme ayant une dpendance
avec une autre, on ne sait pas avec quelle instruction elle a cette dpendance. Notre instruction doit donc attendre que toutes
les lectures et critures qui la prcdent soient termine avant de pouvoir sexcuter. Mme celles avec laquelle notre instruction
www.openclassrooms.com
442/467
n'a aucune dpendance. Nos instructions peuvent donc se retrouver attendre inutilement avant de pouvoir sexcuter. Pour
viter cela, d'autres techniques de prdiction de dpendances mmoires ont ts inventes.
Last Adress
Commenons par aborder la premire technique. Celle-ci est trs simple : il suffit de supposer que chaque instruction de lecture
accde toujours la mme adresse.
Pourquoi a marche ?
On pourrait se demander pourquoi une lecture ou criture irait accder plusieurs fois la mme adresse. Pour rpondre cela, il
faut savoir que nos programmes sont parfois obligs daccder la mme adresse cause du compilateur.
Il arrive que les compilateurs n'arrivent pas grer efficacement les accs mmoires. Diverses raisons existent pour cela :
certaines dpendances entre instructions forcent certaines donnes tre relues depuis la mmoire. Cela arrive notamment
lorsque l'on utilise des pointeurs ou des rfrences : divers phnomnes complexes d'aliasing des pointeurs peuvent gnrer
des relectures intempestives de donnes en mmoire. Cela peut aussi venir de machins qui arrivent lorsqu'on compile du code
qui provient de plusieurs librairies, bref.
Implmentation
Pour implmenter cette technique, rien de plus simple : il suffit de stocker un historique pour chaque instruction dans une petite
mmoire. Cette mmoire cache stockera l'adresse accde pour chaque instruction mmoire rcemment utilise. Pour faire
l'association instruction <-> adresse lue/crite, il suffit de mettre l'adresse de notre instruction (le Program Counter) dans le Tag
associe une adresse.
Voici donc quoi ressemble une ligne de cache de cette petite mmoire.
Bien sr, il est rare qu'une instruction de lecture ou d'criture accde la mme case mmoire plusieurs fois de suite. On doit
donc trouver un moyen de savoir si notre instruction accde plusieurs fois la mme adresse ou pas. Pour cela, on ajoute des
compteurs saturation pour chaque instruction (chaque ligne de cache). Ces compteurs sont incrments chaque fois qu'une
instruction rutilise la mme adresse, et dcrment en cas de changements. Vu que les instructions qui accdent toujours la
mme adresse sont rares, il est prfrable dinitialiser ces compteurs de faon ce qu'ils disent que toute nouvelle instruction
change d'adresse.
Stride
Autre mthode pour prdire l'adresse d'une lecture/criture. Supposer que cette lecture/criture va accder des adresses
spares par des intervalles rguliers.
www.openclassrooms.com
443/467
Les accs des adresses conscutives rentrent dans ce cadre. Mais les accs mmoires sur des adresses spares par une
distance fixe sont aussi pris en compte. Cette distance entre deux adresses, on l'appelle le Stride.
Pourquoi a marche ?
Ce genre d'accs doit vous rappeler quelque chose. Si vous tes arriv jusqu' ce chapitre, vous devez surement vous souvenir
du chapitre sur le Prefetching . Et on y a vu que des accs mmoire de ce type provenait de lutilisation des tableaux. Quand on
parcourt ceux-ci, on accde la mmoire de cette faon. Et cette fois, on sort vraiment d'artillerie lourde. Il faut dire que ce genre
d'accs des tableaux est vraiment courant et que beaucoup de programmes sont concerns. Prdire les adresses de cette faon
peut donc donner lieu des gains pas vraiment ngligeables.
Implmentation
Reste savoir comment implmenter cette technique dans notre processeur. Et il n'y a rien de plus simple : il suffit de reprendre
notre mmoire vue au-dessus, et d'y rajouter de quoi stocker le Stride pour chaque adresse. Ce Stride sera la distance entre une
adresse, et celle accde prcdemment par notre instruction.
Ce Stride est dtermin par notre circuit charg de la prdiction. Celui-ci garde en mmoire la dernire adresse accde par notre
instruction, et il fait la diffrence avec l'adresse lue. Il en dduit le Stride, et stocke celui-ci dans notre mmoire cache. A chaque
accs, ce Stride est ajout l'adresse contenue dans notre cache. L'ancienne adresse dans le cache est remplace par la nouvelle
une fois qu'on dispose de l'adresse valide.
Ce genre d'accs se trouve assez souvent lorsque l'on manipule des listes chaines ou des structures de donnes assez
irrgulires comme des arbres, des graphes, etc.
Pour grer ces accs, on stocke les dernires adresses accdes dans une petite mmoire cache. Cette mmoire cache stockera
une instruction par ligne, dont l'adresse sera place dans le Tag . La ligne de cache associe contiendra les dernires adresses
accdes par l'instruction. Voici quoi ressemble une ligne de cache de cette mmoire.
Le tout est complt par une unit qui se charge de dterminer laquelle de ces adresses est la bonne. Le tout est ensuite
complt par une unit charge de mettre jour la mmoire cache qui contient les adresses de chaque instruction.
L'implmentation de ces units peut fortement varier suivant les processeurs, aussi je ne rentrerais pas dans les dtails.
www.openclassrooms.com
444/467
Efficacit
A ce stade, je dois prciser que cette technique n'est pas encore tout fait mature, et quaucun processeur ne l'implmente
encore. En tout cas, la recherche sur le sujet est encore en cours, et mme si aucun processeur n'a encore implment de
technique de ce genre, cela ne saurait tarder. Quoiqu'il en soit, ces units de prdiction sont tout de mme utilises dans d'autres
circonstances. Des variantes de ces units de prdiction d'adresse sont utilises dans les Prefetchers, ceux utilises pour
prcharger des donnes depuis le cache de donne. Et leur efficacit est assez bonne, voire excellente dans certains cas. Mais
pour le moment, ces units de prdiction d'adresse ne sont pas encore utilises pour prdire les adresses lire depuis le cache
vers les registres - ce qui est le sujet de cette sous-partie.
Value prediction
Cette fois-ci, cela va beaucoup plus loin que prvu. Pour diminuer les effets de la Dataflow Limit, certains concepteurs de
processeurs sont alls beaucoup plus loin. D'ordinaire, le processeur parie sur des choses simples, pour lesquelles il a peu de
chances de se tromper. Un branchement est pris ou non-pris, deux adresses sont dpendantes ou ne le sont pas, etc. Dans les
cas prcdemment cits, on n'a que deux possibilits : pris/non-pris, dpendantes/indpendantes. De plus, on peut optimiser ces
techniques de faon utiliser certaines rgularits dans nos programmes, afin de prendre de meilleures dcisions, et obtenir au
final de bons rsultats.
Mais cette fois-ci, on change totalement de plan. Je vais vous parler des techniques de Value Prediction, qui consistent
prdire quelle est la valeur prsente dans un registre ou une adresse mmoire laquelle on veut accder. Oui, vous avez bien lus :
notre processeur est capable de parier sur la valeur qui sera charge depuis la mmoire et tenter de dcider si cette valeur vaut 0,
1, 1024, etc. Une fois son pari fait, il excute les instructions du programme avec la valeur qu'il a pari de faon spculative. Si le
pari est correct, alors on continue lexcution. Sinon, on est oblig de faire comme lorsque l'on se trompe lors d'une prdiction de
branchement ou une prdiction de dpendances d'adresses mmoires : on vide le pipeline, et on recommence avec la bonne
valeur.
Au premier abord, cette technique semble franchement mal parti. Tenter de prdire quelle sera la valeur stocke dans un registre
de 32 bits parmi les 4 294 967 296 valeurs que ce registre peut stocker semble tre une aberration. Les chances de se tromper sont
tellement normes ! Mais le fait est que dans certains cas, il est possible de spculer correctement. Bon, videmment, ces cas
sont plutt rares, et dans la majorit des cas, le processeur refuse de parier. Il ne spcule pas, et nexcute pas d'instructions en
pariant sur les donnes qu'elle vont manipuler. Mais dans certains cas bien prcis, on peut spculer sur le rsultat fourni par une
instruction.
Ces cas bien prcis concernent souvent le rsultat fourni par une instruction de lecture en mmoire. Par exemple, on peut parier
qu'une instruction de lecture qui sexcute plusieurs fois de suite la mme adresse peut renvoyer la mme valeur chaque fois :
c'est parfaitement possible si il n'y a eu aucune criture cette adresse entre temps. Mais ce n'est pas toujours le cas : on est
donc oblig de parier. Cette technique qui consiste parier sur le rsultat d'une lecture s'appelle la Load Value Prediction. Nous
allons nous intresser cette technique dans la suite de ce tutoriel, et nous ne parlerons pas des technique qui essayent de
prdire le rsultats d'autres instructions (arithmtiques, etc).
Pourquoi a marche ?
On peut se demander quelles sont les raisons qui font qu'une instruction de lecture renvoie la mme valeur chaque fois. Aprs
tout, autant lire une seule fois la donne et la garder dans un registre une bonne fois pour toute ! Mais cela n'est possible que
dans un monde parfait. Dans la ralit, on fait face quelques limites.
Constant Pool
Cela arrive aussi quand on stocke des constantes en mmoire. Par exemple, sur les processeurs x86, les constantes flottantes ne
peuvent pas tre intgres dans nos instructions via le mode d'adressage immdiat. A la place, on les stocke en mmoire et on les
www.openclassrooms.com
445/467
Compilateurs
Il arrive aussi que les compilateurs n'arrivent pas grer efficacement les accs mmoires. Diverses raisons existent pour cela :
certaines dpendances entre instructions forcent certaines donnes tre relues depuis la mmoire. Cela arrive notamment
lorsque l'on utilise des pointeurs ou des rfrences : divers phnomnes complexes d'aliasing des pointeurs peuvent gnrer des
relectures intempestives de donnes en mmoire. Cela peut aussi venir de machins qui arrivent lorsqu'on compile du code qui
provient de plusieurs librairies, bref.
Branchements indirects
Enfin, certains branchements indirects doivent relire l'adresse laquelle il doive brancher depuis la mmoire rgulirement.
Quand vous utilisez des switch ou des fonctions virtuelles dans votre langage objet prfr, votre compilateur va relire l'adresse
laquelle brancher (l'adresse de la fonction ou du case) depuis la mmoire chaque accs. Il faut dire que cette adresse peut
changer a tout moment, et qu'on est donc oblig d'aller la relire chaque fois. Mais vu que cette adresse change peu, et qu'elle
est souvent la mme, les techniques de Load Value Prediction fonctionnent bien.
Implmentation
Pour implmenter cette technique, il suffit d'intgrer dans notre processeur une mmoire cache un peu spciale. De la mme faon
qu'un utilise un Branch Target Buffer lorsqu'on parie sur les branchements, on doit utilise un cache quivalent pour la
spculation sur les lectures.
Efficacit
A ce stade, je dois prciser que cette technique n'est pas encore tout fait mature, et quaucun processeur ne l'implmente
www.openclassrooms.com
446/467
encore. En tout cas, la recherche sur le sujet est encore en cours, et mme si aucun processeur n'a encore implment de
technique de ce genre, cela ne saurait tarder. Quoiqu'il en soit, l'efficacit de cette technique a dj t tudies grce des
simulateurs. Suivant les tudes ou les programmes, on trouve des rsultats qui varient pas mal. Dans certains cas, la
performances baisse un peu, et dans d'autres, on peut avoir des gains de plus de 60% ! Mais dans des cas normaux, on trouve
des gains de 4-5% environ. Ce qui est tout de mme pas mal l'heure actuelle.
www.openclassrooms.com
447/467
Processeurs superscalaires
Dans les chapitres prcdents, on a vu que nos processeurs utilisaient plusieurs units de calcul spares pour mieux grer les
instructions multicycles. Dans le mme genre, il arrive que certains processeurs, qu'ils soient In Order ou Out Of Order ,
possdent des units de calcul spares pour les nombres flottants (des FPU), ou pour grer des calculs spciaux. Par exemple,
un processeur peut contenir une unit de calcul spcialise dans les nombres entiers, un autre dans le calcul d'adresse, une autre
pour les flottants, une autre pour les dcalages, etc.
Bref, un processeur peut contenir un grand nombre d'units de calcul, servant dans certaines situations, mais pas forcment en
mme temps : il arrive que certaines de ces units soient inutilises durant un paquet de temps. Et ces units en plus sont trs
souvent inutilises : il faut au minimum lexcution d'une instruction multicycle pour que cela fonctionne. Si on a un gros paquet
d'instructions un seul cycle, on les excutera les unes aprs les autres, sans pouvoir en lancer plusieurs indpendamment dans
des units de calcul spares. Et la raison est trs simple : sur des processeurs pareils, on ne peut lancer qu'une nouvelle
instruction par cycle d'horloge, pas plusieurs.
Pour rentabiliser ces units de calcul, divers chercheurs et ingnieurs se sont dits qu'ils serait pas mal de les remplir au maximum
par des instructions indpendantes chaque cycle d'horloge. Pour cela, ils ont invents des processeurs qui peuvent dmarrer
lexcution de plusieurs instructions simultanment, dans des units de calculs spares, pour les remplir au maximum. Pour que
cela fonctionne, ces processeur doivent rpartir les instructions sur ces diffrentes units de calcul, et cela n'est pas une mince
affaire. Pour cela, deux techniques existent :
soit on rpartit les instructions sur les units de calcul lexcution, en faisant faire tout le travail par le processeur ;
soit le compilateur ou le programmeur se charge de rpartir ces instructions sur les units de calcul la cration du
programme.
Ces deux solutions ont leurs avantages et leurs inconvnients, et dcider quelle est la meilleure des solutions est assez difficile.
Il existe mme une sorte de querelle entre les partisans de la premire solution et ceux qui prfrent le seconde. Mais ce fameux
dbat entre "brainiacs" (ceux qui veulent un processeur intelligent qui fait le caf et te paralllise tout seul des instructions) et
"speed demons" (ceux qui veulent que le compilateur fasse le travail la place du processeur, parce que les circuits c'est pas
gratuit) est loin d'tre termin. C'est un peu comme la guerre entre processeurs CISC et RISC, ou encore Linux versus Windows :
linformatique est pleine de ce genre de querelles stupides, rien d'tonnant ce que le domaine de l'architecture des ordinateurs
le soit aussi.
Processeurs superscalaires
La premire solution est celle utilise apr les processeurs superscalaires. Avec ces processeurs, la rpartition des instructions
sur les diffrentes units de calcul se fait l'xecution. Ces processeurs fonctionnent comme s'ils avaient plusieurs pipelines.
Le nombre de " pipelines " indiquant le nombre d'instructions diffrentes pouvant commencer leur excution simultanment. Par
exemple, un processeur superscalaire pouvant dmarrer lexcution de deux instructions chaque cycle dhorloge se comportera
comme s'il avait deux pipelines.
www.openclassrooms.com
448/467
Attention : j'ai dit qu'il se comportera comme un processeur ayant deux pipelines, pas qu'il est rellement compos de deux
pipelines. Croyez-moi, cette prcaution n'est pas l pour rien. Les processeurs superscalaires ne sont pas vraiment cres avec
plusieurs pipelines qu'on aurait colls les uns cot des autres : pour simplifier, tous les circuits en charge d'une tape du
pipeline ne sont pas forcment dupliqus. Mais pour expliquer cela, il nous faut rentrer plus profondment dans les circuits d'un
tel processeur.
Pour que notre processeur rpartisse ses instructions sur plusieurs units de calcul tout seul comme un grand (avec un peu
d'aide du compilateur si besoin), il suffit juste de modifier le fonctionnement des tapes de dcodage et d'Issue, et toutes les
autres tapes ventuelles qu'on trouve entre le Fetch et les units de calcul. C'est ainsi qu'on peut crer un processeur
superscalaire : il suffit de modifier le squenceur de faon ce que celui-ci puisse rpartir plusieurs instructions en mme temps
sur des units de calcul diffrentes.
www.openclassrooms.com
449/467
jeux.
Il existe des processeurs plus volus, capables de faire mieux : les processeurs superscalaires Out Of Order. Avec ceux-ci, pas
besoin que plusieurs instructions se suivent pour pouvoir tre excutes simultanment. Ces processeurs peuvent excuter des
instructions indpendantes, sous certaines conditions. Le processeur a beaucoup de travail faire dans ces conditions. Il doit
notamment vrifier quelles sont les instructions indpendantes, comme sur les processeurs superscalaires In Order. Qui plus est,
il doit trouver comment rpartir au mieux les instructions sur les diffrentes units de calcul en modifiant l'ordre des instructions.
Ce qui n'est pas simple du tout ! Mais les performances s'en ressentent : on peut excuter un plus grand nombre d'instructions
simultanes.
Fetch
Sur les processeurs superscalaires, l'unit de Fetch est capable de charger plusieurs instructions depuis la mmoire en mme
temps. Gnralement, cette unit va simplement charger une instruction, ainsi que celles qui suivent. Ainsi, notre unit de Fetch
va prcharger plusieurs instructions la fois, et le Program Counter est modifi en consquence.
Bien sur, les branchements peuvent poser quelques problmes dans ce genre de situations : si un branchement fait partie des
instructions prcharges, que faire des instructions qui suivent : peut-on les xecuter ou pas ? On demande alors de l'aide
l'unit de prdiction de branchement, videmment. Mais passons cela sous le tapis.
Dcodeur d'instruction
Le squenceur est lui aussi modifi : celui-ci est maintenant capable de dcoder plusieurs instructions la fois (et il peut aussi
ventuellement renommer les registres de ces instructions). Aprs tout, c'est normal : si on veut excuter plusieurs instructions
en mme temps, il faudra bien charger et dcoder plusieurs instructions simultanment !
Un ou plusieurs ?
Pour ce faire, on peut utiliser une seule unit de dcodage d'instructions capable de dcoder plusieurs instructions par cycle.
Mais il est aussi possible d'utiliser un processeur qui possde plusieurs squenceurs bien spars. On peut se dbrouiller pour
faire en sorte de dupliquer tous les circuits du processeur, sauf celui de Fetch. videmment, cela coute pas mal en circuits, mais
cela peut tre supportable.
www.openclassrooms.com
450/467
Fusion de micro-oprations
Ces processeurs superscalaires peuvent effectuer pas mal d'optimisations que d'autres processeurs ne peuvent pas faire. Dans
certains cas, le squenceur peut fusionner plusieurs instructions machines sexcutant l'une aprs l'autre en une seule microopration. Par exemple, un processeur peut dcider de fusionner une instruction de test suivie d'un branchement en une seule
micro-opration effectuant le comparaison et le branchement et une seule fois. Cette dernire technique est trs efficace : il faut
savoir qu'environ une instruction sur 10 est un branchement prcd d'une instruction de test. Implmenter une telle fusion entre
branchements et tests permet ainsi de gagner en performance assez rapidement et a pas mal d'avantages sur les architectures
actuelles.
Cette fusion se fait lors du dcodage de plusieurs instructions en mme temps : notre dcodeur d'instructions va en effet dcider
plusieurs instructions la fois et peut identifier certaines suites d'instructions simplifiables.
www.openclassrooms.com
451/467
Comme vous le voyez, cela se fait simplement avec l'aide de quelques comparateurs.
Correction du rsultat
Ensuite, il nous faut savoir comment corriger le rsultat du renommage en fonction des dpendances. Et bien sachez que c'est
super simple mettre en uvre : il suffit d'utiliser des multiplexeurs. Le principe est tout simple. Si une instruction n'a pas de
dpendance avec une autre, on la laisse telle qu'elle. Par contre, si elle a une dpendance avec une instruction prcdente, cela
signifie que un de ces registre oprande sera identique avec le registre de destination d'une instruction prcdente. Et dans ce
cas, le registre oprande n'est pas le bon une fois renomm : on doit le remplacer par le registre de destination renomm de
l'instruction avec laquelle il y a dpendance. Cela se fait simplement en utilisant un multiplexeur dont les entres sont relies
l'unit de dtection des dpendances.
www.openclassrooms.com
452/467
On doit faire ce replacement pour chaque registre oprande. Et vu que notre processeur superscalaire a besoin de renommer un
groupe de plusieurs instructions simultanment, on doit aussi faire cela pour chaque instruction du groupe renomm (sauf la
toute premire, celle qui prcde toutes les autres). Cela ncessite d'utiliser beaucoup de multiplexeurs.
Processeurs VLIW
Dans ce qui prcde, on a vu les processeurs superscalaires. Avec ceux-ci, on prenait un processeur, et celui-ci se dbrouillait
pour vrifier les dpendances entre instructions et tenter de remplir les units de calcul du processeur. Avec les processeurs
superscalaires Out Of Order et In Order, surtout avec les processeurs superscalaires Out Of Order . Bien sr, l'aide du
compilateur est prcieuse pour obtenir de bonnes performances : un bon compilateur pourra rorganiser les instructions d'un
programme de faon placer des instructions indpendantes le plus prt possible, histoire de donner des opportunits au
Scheduler.
Le fait est que ces processeurs superscalaires sont tout de mme assez complexes, particulirement les processeurs
superscalaires Out Of Order . Une bonne part de leurs circuits permet dexcuter des instructions simultanment, et ces circuits
ne sont pas gratuits : ils chauffent, consomment de llectricit, ont un certain temps de propagation qui limite la frquence,
prennent de la place, coutent "cher", etc. Certains se sont dits que quitte faire travailler le compilateur, autant que ce soit lui qui
fasse tout le boulot ! Si on dporte ce travail de rorganisation des instruction et leur rpartition sur les diffrentes units de
calcul hors du processeur, cela fera des circuits en moins, et de la frquence en plus. C'est ainsi que les processeurs VLIW sont
ns.
Ces processeurs sont des processeurs In Order : ils excutent les instructions dans l'ordre dans lesquelles elles sont envoyes
au processeurs. Mais il y a une diffrence avec les processeurs superscalaires habituels : les processeurs VLIW ne vont pas
regarder si deux instructions conscutives peuvent tre excutes en mme temps, et ils ne vont pas non plus rpartir eux-mme
les instructions sur les units de calculs. Cette tache sera plus ou moins dlgue au compilateur. Pour ce faire, le compilateur va
devoir garantir que les instructions qui se suivent sont strictement indpendantes. Qui plus est, il va falloir lui fournir un moyen
de prciser sur quelle unit de calcul lancer l'instruction.
Bundles
www.openclassrooms.com
453/467
Pour ce faire, notre compilateur va regrouper des instructions dans ce qu'on appelle des Bundles, des sortes de superinstructions. Ces bundles sont dcoups en Slots, en morceaux de taille bien prcise, dans lesquels il va venir placer les
instructions lmentaires faire excuter.
Instruction
VLIW
3 slots
Slot 1
Slot 2
Slot 3
Addition
Multiplication
Dcalage gauche
Chaque slot sera attribu une unit de calcul bien prcise. Par exemple, le premier slot sera attribu la premire ALU, la second
une autre ALU, le troisime la FPU, etc. Ainsi, l'unit de calcul excutant l'instruction sera prcise via la place de l'instruction
lmentaire, le slot dans lequel elle se trouve. Qui plus est, vu que chaque slot sera attribu une unit de calcul diffrente, le
compilateur peut se dbrouiller pour que chaque instruction dans un bundle soit indpendante de toutes les autres instructions
dans ce bundle.
Lorsqu'on excute un bundle, il sera dcompose par le squenceur en petites instructions lmentaires qui seront chacune
attribue l'unit de calcul prcise par le slot qu'elles occupent. Pour simplifier la tache du dcodage, on fait en sorte que
chaque slot aie une taille fixe.
Exemple avec plusieurs units de dcodage.
Au passage, VLIW est un acronyme pour Very Long Instruction Word . Et cet acronyme nous dit presque tout ce qu'il faut
savoir sur ces architectures
. Un bundle peut tre vu comme une sorte de super-instruction trs longues : ils font plus de 64
bits de long (plus de 8 octets) ! Et ils peuvent avoir une longueur pouvant aller jusqu' 256 512 bits (64 octets) !
Problmes
C'est le compilateur qui est charg de faire tout le travail en regroupant des instructions pouvant tre excutes en mme temps
dans des units de calcul diffrentes dans une seule grosse instruction, un seul bundle. On n'a donc pas besoin de rajouter des
circuits lectroniques chargs de rpartir les instructions sur diffrentes units de calculs. Mais on a intrt ce que le
compilateur soit de qualit, parce que sinon, on est mort ! Et c'est un peu le problme de ces architectures : si le compilateur ne
peut pas trouver de quoi remplir ces bundles avec des instructions indpendantes, il va devoir ruser. Et hormis quelques
applications bien spcifiques, il est difficile de remplir ces bundles correctement. Pour les programmes ayant beaucoup
d'instructions indpendantes, cela ne pose pas trop de problmes : certains programmes de traitement d'image ou faisant des
traitements spcifiques peuvent tirer partie des architectures VLIW. Mais ceux-ci sont loin dtre une majorit.
Sur les anciens processeurs VLIW, les instructions VLIW, les bundles, taient de taille fixe. Le compilateur devait donc remplir
ceux-ci totalement, et remplissait les vides avec des nop, des instructions qui ne font rien. Dans ce genre de cas, pas mal de bits
sont utiliss dans ces bundles pour rien : ils n'encodent pas une instruction et se contentent de dire de ne rien faire lunit de
calcul qui leur est attribu. On utilise donc de la place rien. Le programme compil pour une architecture VLIW sera donc plus
www.openclassrooms.com
454/467
gros, et prendra plus de place en mmoire ou dans le cache. Ce qui peut rapidement foutre en l'air les performances si on ne peut
pas remplir les bundles correctement. Ces processeurs doivent donc tre fournis avec des caches normes, des bus rapides,
utilisent une grande quantit de mmoire, etc. Autant dire qu'en terme de consommation nergtique ou de performances, cela
peut rduire nant les performances gagnes en simplifiant le processeur.
Nanmoins, il faut citer que la majorit des processeurs VLIW rcents arrive rsoudre ce problme, en utilisant les instructions
de longueur variable. Ainsi, les bundles vides, non remplit par des instructions, ne sont pas encods dans l'instruction. Les nop
ne sont pas stocks dans l'instruction et ne prennent aucune place : le compilateur utilise juste ce qu'il faut pour encoder les
instructions utiles, pas plus. Cela aide normment diminuer la code density des programmes compils pour ces architectures
VLIW rcentes.
Et c'est sans compter que certaines dpendances entre instructions ne peuvent tre supprimes qu' lexcution. Par exemple, le
fait que les accs la mmoire aient des dures variables (suivant que la donne soit dans le cache ou la RAM, par exemple) joue
sur les diffrentes dpendances. Un compilateur ne peut pas savoir combien de temps va mettre un accs mmoire, et il ne peut
organiser les instructions d'un programme en consquence. Par contre, un processeur le peu : on en touchera surement un mot
au chapitre suivant. Autre exemple : les dpendances d'instructions dues aux branchements. Les branchements ont en effet
tendance limiter fortement les possibilits d'optimisation du compilateur. Alors qu' lexcution, un processeur peut prdire les
branchements et supprimer un paquet de dpendances en fonction.
Qui plus est, ces processeurs n'ont strictement aucune compatibilit, ou alors celle-ci est trs limite. En effet, le format des
super-instructions VLIW, des bundles, est spcifique un processeur. Celui-ci va dire : telle instruction va sur telle ALU, et pas
ailleurs. Mais si on rajoute des units de calcul dans une nouvelle version du processeur, il faudra recompiler notre programme
pour que celui-ci puisse l'utiliser, voire mme simplement faire fonctionner notre programme. Dans des situations dans lesquelles
on se fout de la compatibilit, cela ne pose aucun problmes : par exemple, on utilise beaucoup les processeurs VLIW dans
l'embarqu. Mais pour un ordinateur de bureau, c'est autre chose...
Processeurs EPIC
Comme on l'a vu, les architectures VLIW ont quelques problmes. Une faible compatibilit, une code density pouvant tre assez
mauvaise. De plus, la performance de ces processeurs dpend fortement de l'efficacit du compilateur. Le but de ces
architectures est simple : on dlgue l'ordonnancement des instructions au compilateur, qui remplace totalement l'Out Of Order .
En l'aidant un peu si possible. Pas d'Out Of Order , un peu de Register Rennaming , mais pas trop, et peu de techniques volues
qui rendent le processeur capable de faire le caf.
En 1997, Intel et HP lancrent un nouveau processeur, l'Itanium. Son architecture ressemblait fortement aux processeurs VLIW,
mais avec les dfauts en moins. Dans un but marketing vident, Intel et HP prtendirent que l'architecture de ce processeur, bien
que ressemblant aux processeurs VLIW, n'tait pas du VLIW. Ils appelrent cette nouvelle architecture EPIC, pour Explicit
Parallelism Instruction Computing. Il faut avouer que cette architecture avait tout de mme de fortes diffrences avec le VLIW,
mais elle avait aussi beaucoup de points communs. Bien videmment, beaucoup ne furent pas dupes, et une gigantesque
controverse vit le jour : est-ce que les architectures EPIC sont des VLIW ou non ? On va passer celle-ci sous silence, et voir un
peu ce que peut recouvrir ce terme : EPIC.
Bundles
Pour commencer, la premire diffrence avec les processeurs VLIW vient de ce qu'on met dans les Bundles. Sur les processeurs
VLIW, les instructions taient places dans un Slot bien prcis qui spcifiait l'unit de calcul qui devait xecuter l'instruction.
Niveau compatibilit, c'tait une catastrophe. Mais les Bundles des architectures EPIC ne fonctionnent pas sur ce principe.
Ceux-ci sont simplement des groupes d'instructions indpendantes. Leur place dans l'instruction ne spcifie pas l'unit de calcul
qui s'occupera de l'instruction. C'est le processeur qui va dcouper ce Bundles et tenter de rpartir les instructions du mieux qu'il
peut sur les diffrentes ALU. En terme de compatibilit, c'est le rve : on peut rajouter des ALU sans avoir besoin de recompiler.
Le processeur pourra alors profiter de leur prsence sans rien faire de spcial.
Ces Bundles sont en plus de taille variable. Avec les processeurs VLIW, les Bundles avaient souvent une taille fixe. Et quand le
compilateur n'arrivait pas les remplir, il laissait des vides. a gchait de la RAM. Mais avec les processeurs EPIC, on n'a pas ce
genre de choses. Les Bundles des processeurs EPIC sont dlimits par un petit groupe de bits spcial, qui indique la fin d'un
Bundles. Ce petit groupe de bits s'appelle un Stop Bit .
Prdication
www.openclassrooms.com
455/467
Enfin, on peut signaler que les processeurs EPIC possdent un grand nombre d'instructions prdicats. Pour rappel, ces
instructions prdicat sont des instructions "normales", comme des additions, copie d'un registre dans un autre, multiplication,
accs mmoire, etc ; avec une diffrence : elles ne font quelque chose que si une condition est respecte, valide. Dans le cas
contraire, celles-ci se comportent comme un nop, c'est dire une instruction qui ne fait rien !
Utilit
Leur but ? Celles-ci servent remplacer un grand nombre de branchements. Il faut dire que les branchements sont une vritable
plaie pour les compilateurs : ceux-ci empchent d'effectuer de nombreuses optimisations. Par exemple, ils gnent fortement la
capacit du compilateur dplacer des instructions et changer leur ordre. En supprimer le plus possible permet d'amliorer la
situation. En consquence, ces instructions prdicats sont une vritable ncessite sur une architecture qui ne gre pas l'Out
Of Order.
Itanium d'Intel
Pour donner un exemple d'instructions prdicats, je vais vous parler des instructions de l'Itanium.
L'Itanium possde plusieurs registres d'tats de un bit ! Il y en a en tout 64, qui sont numrots de 0 63. Chacun de ces
registres peut stocker une valeur : vrai (un) ou faux (zro). Le registre 0 est en lecture seule : il contient toujours la valeur vrai,
sans qu'on puisse le modifier. Ces registres sont modifis par des instructions de comparaison, qui peuvent placer leur rsultat
dans n'importe quel registre prdicat. Elle doivent tout de mme prciser le registre dans lequel stocker le rsultat.
Chaque instruction prdicat va prciser quel est le registre qui contient la valeur vrai ou faux permettant d'autoriser ou
d'interdire son excution en utilisant un mode d'adressage spcial. L'instruction sexcutera normalement si ce registre contient la
valeur vrai, et elle ne fera rien sinon. Petite remarque : une instruction peut carrment spcifier plusieurs registres. Ainsi, une
instruction peut sexcuter si deux registres prdicats sont vrais. Par exemple, elle peut faire un ET logique sur ces deux bits
et dcide de sexcuter si jamais le rsultat est true. Elle peut aussi faire un OU logique, un XOR, un NAND, etc.
Petite remarque : sur l'Itanium, presque toutes les instructions sont des instructions prdicats. Le truc, c'est que toutes les
instructions qui sexcutent normalement, de faon inconditionnelles, sont des instructions qui vrifient le registre prdicat r0,
qui vaut vrai, et qui est lecture seule. Cela implique aussi pas mal de choses bizarres. Par exemple, des comparaisons, qui crivent
donc dans un registre prdicat, peuvent aussi tre prdicates.
Delayed Exceptions
Les branchements ne sont pas les seules instructions qui peuvent gner les compilateurs. Les instructions qui peuvent gnrer
des exceptions matrielles leur pose aussi des problmes. La raison est simple : pour qu'une exception sexcute correctement,
toutes les instructions qui prcdent l'exception doivent se terminer avant qu'on effectue l'exception. Et inversement, toutes les
instructions qui sont aprs l'exception ne doivent pas sexcuter si celle-ci a lieu. En clair, notre compilateur ne peut pas faire
passer des instructions avant ou aprs une de leur congnre, si cette dernire peut lever une exception. Cela limite les
possibilits de rorganisation des instructions : une instruction qui peut lever une exception est considre par le compilateur
comme une sorte de barrire infranchissable. Pour rsoudre le problme, l'Itanium implmente ce qu'on appelle les Delayed
Exceptions.
Avec la technique des Delayed Exceptions, le compilateur peut crer deux versions d'un mme code : une qui suppose
qu'aucune exception matrielle n'est leve, et une autre version qui suppose qu'une exception est leve. La premire version est
bien optimise, les instructions sont rorganise en ne tenant pas compte du fait qu'une instruction pouvant lever une exception
est cense tre une barrire. La seconde version est compile normalement.
Le programme est conu pour xecuter la premire version en premier. Une fois le code de cette version termin, le programme va
alors utiliser une instruction pour vrifier que tout s'est bien pass. S'il n'y a pas eu d'exception, alors on continue dexcuter
notre programme. Mais sinon, on branche vers la version du code non-optimise, correcte, et on lexcute.
Pour vrifier que tout s'est bien pass, chaque registre est associ un bit cach, qui stocke un bit spcial. Ce bit, le bit Not A
Thing , est mit 1 quand le registre contient une valeur invalide. Ainsi, si une instruction lve une exception, cette exception est
passe sous silence, et notre instruction continue son excution. Elle crira alors un rsultat faux dans un registre, et le bit Not A
Thing de ce registre est mit 1. Les autres instructions utiliseront alors cette valeur, et auront comme rsultat une valeur
invalide, avec le bit Not A Thing mit 1. Une fois le code fini, il suffit d'utiliser une instruction qui teste ce fameux bit Not A
Thing , et qui branche en consquence.
www.openclassrooms.com
456/467
aussi de fournir une fonctionnalit similaire pour les instructions de lecture en mmoire.
Principe
Pour voir quoi cela peut servir, il nous faut faire un petit rappel. Comme vous le savez, nos instructions de lecture en mmoire
prennent un certain temps sexcuter. Cela peut aller de 2 3 cycles bien plus. Pour limiter la casse, le processeur peut
parfaitement xecuter des instructions indpendantes de la lecture en attendant qu'elle se termine. Sur un processeur Out Of
Order, le processeur et le compilateurs se chargent de dexcuter la lecture le plus prcocement possible, histoire dexcuter un
maximum d'instructions indpendantes aprs la lecture.
Le seul problme, c'est que sur les architectures EPIC, on est limit par le compilateur. Celui-ci ne peut pas dplacer la lecture trop
tt sans changer le comportement du programme. Par exemple, il ne peut pas dplacer la lecture avant une criture si les adresses
de ces deux instructions ne sont pas connues : si ces deux instructions travaillent sur la mme adresse, ce dplacement peut
changer le comportement du programme. Les dpendances RAW, WAR, et WAW vont venir jouer les trouble-ftes. Et la mme
chose arrive avec les branchements : faites passer une lecture avant un branchement, et il y a un risque que a fasse des
chocapics ! Pour viter tout problme, un compilateur a interdiction de dplacer une lecture avant une instruction de
branchement, une autre lecture, ou une criture.
Pour rsoudre ce problme, l'Itanium fournit quelques instructions spciales, qui permettent au compilateur dexcuter des
lectures en avance de faon totalement spculative, et de revenir la normale en cas de problme. Avec ces instructions, un
compilateur peut dplacer une lecture avant une autre instruction d'accs mmoire ou un branchement. Cette lecture devient
alors une lecture spculative. Reste ensuite vrifier que la spculation tait correcte. Si jamais la spculation rate, une
dpendance a t viole et la lecture ne renvoie pas le bon rsultat. Vrifier qu'aucune dpendance n'a t viole ne se fait pas de
la mme faon selon que la lecture aie t dplace avant un branchement ou avant une autre criture.
www.openclassrooms.com
457/467
Si jamais la lecture est effectues alors qu'elle ne devrait pas l'tre, le processeur dtecte automatiquement cette situation. Pour
rsoudre ce problme, il lve une Delayed Exception , et le bit Not A Thing du registre contenant la donne lue est alors mit 1.
chk.s ne fait rien d'autre que vrifier ce bit. Si jamais la spculation n'a pas march, chk.s va brancher sur un morceau de
programme qui traite cette exception lance pas notre lecture trop anticipe.
www.openclassrooms.com
458/467
Lorsqu'il excute l'instruction ld.a, le processeur va remplir l'ALAT avec les informations sur la lecture, et va dmarrer celle-ci.
Puis, le processeur continue dexcuter le programme. Si jamais une criture la mme adresse a lieu, les informations sur la
lecture sont supprimes de l'ALAT.
Pour vrifier que notre lecture s'est bien passe, on utilise l'instruction chk.a. Celle-ci va vrifier si tout s'est bien pass en
lisant ce qui est stock dans l'ALAT. Si il trouve une correspondance dans l'ALAT, alors la lecture s'est passe correctement.
Sinon, c'est qu'une criture l'a supprime et que le contenu fourni apr la lecture est prim : on doit recommencer la lecture pour
obtenir un rsultat correct.
Bilan
Mettons les choses au point : l'Itanium est aujourd'hui abandonn. Il ne fut pas un franc succs. La raison : cette architecture se
basait trop sur le compilateur pour gagner en performances. En thorie, il est possible d'utiliser cette architecture au maximum de
ses capacit si on dispose d'un bon compilateur. Le seul problme, c'est qu'aucun compilateur n'est suffisant pour tirer
correctement parti d'une telle architecture. Et c'est pas faute d'avoir essay : l'Itanium fournissait pas mal de fonctionnalits pour
aider le compilateur. Mais le problme, c'est que le compilateur ne peut pas tout, et que le Hardware a une meilleure capacit
optimiser un programme la vole. Dans un code remplit de branchements, avec beaucoup de dpendances, les architectures
VLIW et EPIC sont mauvaises, et les processeurs Out Of Order sont les rois. Cependant, la situation s'inverse souvent dans des
programmes avec peu de branchements et de dpendances. Bref, la morale de l'Itanium, c'est que le compilateur ne peut pas tout,
et que tenter de tout lui dlguer ne marche pas quand on cherche la Performance Ultime, avec un grand P.
www.openclassrooms.com
Partie 8 : Annexes
459/467
Partie 8 : Annexes
Dans cette partie, nous allons voir quelques petites choses pas vraiment fondamentales, mais assez intressantes.
Alignement mmoire
Si vous vous souvenez des chapitres prcdents, vous vous rappelez que le bus de donne a souvent une largeur de plusieurs
octets. Le processeur peut ainsi charger 2, 4 ou 8 octets d'un seul coup (parfois plus). On dit que le processeur accde un mot en
mmoire. Ce mot n'est rien d'autre qu'une donne qui a la mme taille que le bus de donne.
Suivant le processeur, il existe parfois des restrictions sur la place de chacun de ces mots en mmoire.
On peut parfaitement vouloir lire 1, 2, 4, 8 octets individuellement. Par exemple, on peut vouloir charger un octet depuis la
mmoire dans un registre. Pour cela, notre processeur dispose de modes d'adressages, voir d'instruction diffrentes, suivant
qu'on veuille lire ou crire 1, 2, 4, 8, 16 octets.
Quand on veut charger une donne sur un bus plus grand que celle-ci, les cases mmoires immdiatement suivantes sont aussi
copies sur le bus. Mais rassurez-vous : le processeur les ignore. En choisissant la bonne instruction ou le bon mode
d'adressage, les bits en trop chargs sur le bus de donne ne seront pas pris en compte. Bien sr, cela marche aussi pour
l'criture.
www.openclassrooms.com
Partie 8 : Annexes
460/467
Exemple : on souhaite charger un octet dans un registre de trois octets, en passant par un bus de trois octets.
Sur de tels processeurs et mmoires, on peut lire ou crire n'importe quelle adresse, sans aucune restriction. Toute donne est
accessible en une seule fois, du moment que celle-ci est plus petite que le bus de donne : elle peut faire 1, 2, 4, 8 octets, si le bus
peut contenir celle-ci, on peut la charger en une seule fois quelque soit la situation, quelque soit son adresse. On dit que ces
processeurs accdent la mmoire la granularit de l'octet.
Pour donner un exemple, je peux parfaitement dcider de charger dans mon registre une donne de 16 bits localise l'adresse 4,
puis lire une autre donne de 16 bits localise l'adresse 5 pour la charger dans un autre registre sans aucun problme.
www.openclassrooms.com
Partie 8 : Annexes
461/467
Partie 8 : Annexes
462/467
Mais d'autres processeurs ou certaines mmoires imposent des restrictions assez drastiques dans la faon de grer ces mots.
Certains processeurs (ou certaines mmoires) regroupent les cases mmoires en "blocs" de la taille d'un mot : ceux-ci utilise un
certain alignement mmoire. On peut voir chacun de ces blocs comme une "case mmoire" fictive un peu plus grosse que les
cases mmoires relles et considrer que chacun de ces blocs possde une adresse. L'adresse d'un de ces groupes est l'adresse
de l'octet de poids faible. Les adresses des octets situ dans le groupe (c'est dire autre que l'octet de poids faible) sont
inutilisables : on ne peut adresser qu'un groupe, via son octet de poids faible, et charger l'intgralit de ce mot sur le bus, mais
pas accder un octet en particulier.
L'adressage de la mmoire est donc moins "fin" : on travaille sur des blocs de plusieurs bits, plutt que sur des petits paquets.
www.openclassrooms.com
Partie 8 : Annexes
463/467
20
...
Ceux qui sont observateurs remarqueront que seules les adresses multiples de 4 sont utilisables. Et ceux qui sont encore plus
observateurs remarqueront que 4 est la taille d'un mot. Dans notre exemple, les adresses utilisables sont multiples de la taille d'un
mot. Et bien sachez que cela fonctionne aussi avec d'autres tailles de mot que 4. En fait, a fonctionne mme tout le temps !
Si
est la taille d'un mot, alors seules les adresses multiples de
seront utilisables.
Dans la ralit, ces blocs ont une taille gale une puissance de deux : cela permet de faire quelques bidouilles sur le bus
d'adresse pour conomiser des fils. Si la taille d'un mot est gale , seules les adresses multiples de
seront utilisables.
Hors, ces adresses se reconnaissent facilement : leurs bits de poids faibles valent zro. On n'a donc pas besoin de cbler les
fils correspondant ces bits de poids faible et on peut se contenter de les connecter la masse (le zro volt vu dans le second
chapitre).
Octet 4
Octet 3
Octet 2 Octet 1
Entier
Entier
Donne Donne -
0x 0000 0008 -
Pour charger mon caractre dans un registre, pas de problmes : celui-ci tient dans un mot. Il me suffit alors de charger mon mot
dans un registre en utilisant une instruction de mon processeur qui charge un octet.
Pour ma donne de 2 octets, pas de problmes non plus ! Mais c'est parce que mon processeur est prvu pour. Dans ce genre de
cas, il suffit que je donne mon instruction l'adresse laquelle commence ma donne : ici, ce serait l'adresse 0x 0000 0009. Je ne
donne pas l'adresse du mot, mais l'adresse relle de ma donne. L'instruction dtectera que ma donne est stocke intgralement
dans un mot, chargera celui-ci, et fera en sorte de n'crire que la donne voulue dans mon registre.
Mais si je demande mon processeur de charger mon entier, a ne passe pas ! Mon entier est en effet stock sur deux mots
diffrents, et on ne peut le charger en une seule fois : mon entier n'est pas align en mmoire. Dans ce cas, il peut se passer des
tas de choses suivant le processeur qu'on utilise. Sur certains processeurs, la donne est charge en deux fois : c'est lgrement
plus lent que la charger en une seule fois, mais a passe. Mais sur d'autres processeurs, la situation devient nettement plus
grave : notre processeur ne peut en effet grer ce genre d'accs mmoire dans ses circuits et considre qu'il est face une erreur,
similaire une division par zro ou quelque chose dans le genre. Il va alors interrompre le programme en cours dexcution et
excuter un petit sous-programme qui grera cette erreur. On dit que notre processeur effectue une exception matrielle.
Si on est chanceux, ce programme de gestion d'erreur chargera cette donne en deux fois : a prend beaucoup de temps. Mais sur
d'autres processeurs, le programme responsable de cet accs mmoire en dehors des clous se fait sauvagement planter. Par
exemple, essayez de manipuler une donne qui n'est pas "aligne" dans un mot de 16 octets avec une instruction SSE, vous
aurez droit un joli petit crash ! C'est pas pour rien que ce genre d'instructions est si peu utilis par nos compilateurs.
Pour viter ce genre de choses, les compilateurs utiliss pour des langages de haut niveau prfrent rajouter des donnes
inutiles (on dit aussi du padding ) de faon ce que chaque donne soit bien aligne sur le bon nombre d'octets. En reprenant
notre exemple du dessus, et en notant le padding X, on obtiendrait ceci :
Adresse
Octet 4
www.openclassrooms.com
Partie 8 : Annexes
464/467
0x 0000 0004 Entier
Entier
Entier
Donne X
Entier
X
Comme vous le voyez, a prend un peu plus de place, et de la mmoire est gche inutilement. C'est pas grand chose, mais quand
on sait que de la mmoire cache est gche ainsi, a peut jouer un peu sur les performances. Il y a aussi des situations dans
lesquelles rajouter du padding est une bonne chose et permet des gains en performances assez abominables : une sombre
histoire de cache dans les architectures multiprocesseurs ou multicores, mais je n'en dit pas plus. Moralit : programmeurs, faites
gaffe bien grer l'alignement en mmoire !
Cet alignement se gre dans certains langages (comme le C, le C++ ou l'ADA), en grant l'ordre de dclaration de vos variables.
Essayez toujours de dclarer vos variables de faon remplir un mot intgralement ou le plus possible. Renseignez-vous sur le
padding , et essayez de savoir quelle est la taille de vos donnes en regardant la norme de vos langages.
Endianness
Vous savez tous, depuis le premier chapitre, comment reprsenter des donnes simples (des nombres entiers, flottants) en binaire
sous la forme d'une suite de bits. Vous savez que votre donne sera reprsente sous la forme d'une suite de bits stocke dans
des octets qui se suivent dans la mmoire. Mais il y a une chose que vous ne savez pas encore : la faon dont ces bits seront
repartis dans des octets varie suivant le processeur !
On peut faire une analogie avec les langues humaines : certaines scrivent de gauche droite (le franais, l'anglais) ; et d'autres
de droite gauche. Dans un ordinateur, c'est un peu pareil : nos donnes ont diverses sens d'criture. Lorsqu'ils crivent des
donnes prenant plusieurs octets en mmoire, ceux-ci vont les crire de gauche droite dans un octet, ou l'inverse. Quand on
veut parler de cet ordre d'criture, on parle d'endianness. Il existe divers endianness, variables suivant le processeur. Voyons
lesquels et ce qui peut les diffrencier.
Big Endian
Certains processeurs sont de type Big endian . Sur ces processeurs, l'octet de poids fort de notre donne est stock dans la case
mmoire ayant l'adresse la plus faible.
Little Endian
Sur les processeurs Little endian, c'est l'inverse : l'octet de poids faible de notre donne est stock dans la case mmoire ayant
l'adresse la plus faible.
www.openclassrooms.com
Partie 8 : Annexes
465/467
Un des avantages de ces architectures est qu'on peut accder une donne quelques soit sa longueur sans changer l'adresse de
la donne charger, mme avec les contraintes dues l'alignement. En Big endian , il faudrait changer l'adresse laquelle accder
en fonction du nombre de bytes lire ou crire.
Bi-Endian
Certains processeurs sont un peu plus souples : ils laissent le choix de l'endianness, et permettent de le configurer de faon
logicielle ou matrielle. Ces processeurs sont dits Bi-endian.
Icne
Titre
Multicoeurs, Hyperthreading, paralllisme : qu'est-ce que c'est ?
www.openclassrooms.com
Partie 8 : Annexes
466/467
Les Caches adresss par somme (Sum Adressed Caches)
Remerciements
Un petit merci :
Spacefox pour son travail de validateur attitr du tutoriel,
Macros le noir pour sa relecture attentive de mon tutoriel,
et Lucas-84, pour l'ensemble de son uvre.
www.openclassrooms.com