Cours Microprocesseu

Support de Cours
Microprocesseur
Master I
Dr A. M. CHANA LEMALE
Tables des Matières
CHAPITRE 1: Représentation de l’information ......................................................................... 5

I. Généralités ................................................................................................................................ 5
II. Représentation des nombres dans les trois (3) systèmes .......................................................... 6
III. Conversion d’une base à une autre (nombres positifs) ......................................................... 6
1. Partie entière .......................................................................................................................... 6
2. La partie fractionnaire ........................................................................................................... 8
IV. Les opérations arithmétiques ............................................................................................... 10
1. Notion de chiffre significatif ............................................................................................... 11
2. Notion d'arrondi et d'erreur d'arrondi .................................................................................. 11
3. Notion de troncature et d'erreur de troncature ..................................................................... 12
V. Représentation des entiers ...................................................................................................... 12
1. Nombre en complément ...................................................................................................... 12
2. Soustraction en complément ............................................................................................... 14
a) Nombres sans signe ............................................................................................................. 14
b) Nombre avec signe .......................................................................................................... 15
VI. Représentation des réels ...................................................................................................... 17
1. Virgule fixe ......................................................................................................................... 17
2. Virgule Flottante ................................................................................................................. 18
3. Opérations arithmétiques en virgule flottante ..................................................................... 21
CHAPITRE 2: Fonctionnement de base des Microprocesseurs ................................................ 23
I. Introduction ......................................................................................................................... 23
II. Eléments de base d’un microprocesseur .......................................................................... 25
A. L’unité de commande .................................................................................................. 25
B. L’unité de traitement .................................................................................................. 26
a. Cycle d’exécution d’une instruction ................................................................................... 27
Phase 1: Recherche de l'instruction à traiter ...................................................................... 27
Phase 2 : Décodage de l’instruction et recherche de l'opérande...................................... 28
DR A. M. CHANA LEMALE Cours de Microprocesseur Page 2

Phase 3 : Exécution de l'instruction .................................................................................... 29
III. Performances d’un microprocesseur ............................................................................... 30
IV. Le jeu d’instructions ........................................................................................................ 30
A. Définition .................................................................................................................... 30
B. Type d’instruction...................................................................................................... 30
C. Codage ....................................................................................................................... 31
D. Le chemin de données d’un processeur .................................................................... 32
V. Notion d’architecture RISC et CISC ............................................................................... 34
A. L’architecture CISC ......................................................................................................... 34
B. L’architecture RISC ......................................................................................................... 34
C. Comparaison .................................................................................................................... 35
D. Processeurs spéciaux ....................................................................................................... 35
CHAPITRE 3: Principes d'architecture des microprocesseurs .................................................. 37
I. Introduction ......................................................................................................................... 37
A. Phases d'une instruction ................................................................................................... 37
B.Timing des phases (cas simplifié) .......................................................................................... 38
II. Architecture pipeline ....................................................................................................... 38
A. Principe ............................................................................................................................ 38
B. Gain de performance ....................................................................................................... 40
C. Table de réservation......................................................................................................... 41
D. Le pipeline instruction ..................................................................................................... 42
 Analyse du fonctionnement en mode pipeline.......................................................... 43
 Sémantique du pipeline: ordre d’exécution .............................................................. 44
III. Dépendances de données entre instructions .................................................................... 44
RAR (Consommateur/Consommateur) ........................................................................... 44
RAW (Producteur/Consommateur) ........................................................................................ 45
WAR (Consommateur/Producteur) ................................................................................. 45
WAW (Producteur/Producteur) ....................................................................................... 45
IV. Dépendances de contrôle entre instructions .................................................................... 47
A. La prédiction de branchement ......................................................................................... 49
B. Prédictions de branchement statiques .............................................................................. 54

i. Prédiction de branchement statique globale .................................................................... 54
ii. Prédiction de branchement statique positionnable ....................................................... 54
iii. Prédiction de branchement statique tenant compte du sens du branchement .............. 54
C. Prédictions de branchement dynamiques ........................................................................ 56
i. Prédiction de branchement dynamique à 1 bit ................................................................. 57
ii. Prédiction de branchement dynamique à 2 bits ........................................................... 57
iii. Suppression des instructions de branchement conditionnel (conditionnel move) ....... 58
V. Le processeur Pentium IV ............................................................................................... 60
CHAPITRE 4: La mémoire ....................................................................................................... 63
I. Introduction ......................................................................................................................... 63
II. Latence mémoire ............................................................................................................. 63
III. Hiérarchie mémoire ......................................................................................................... 64
IV. Mémoire Physique & Mémoire virtuelle ......................................................................... 66
A. Organisation en mémoire virtuelle ............................................................................. 67
B. Pagination ................................................................................................................... 70
C. Segmentation ............................................................................................................. 71
D. Systèmes mixtes ......................................................................................................... 72
E. Stratégies de remplacement en pagination .............................................................. 73

CHAPITRE 1: Représentation de l’infor mation
I. Généralités
Le système le plus couramment utilisé est le système décimal qui utilise les chiffres de 0
à 9, c'est le système de référence. Le nombre de chiffres utilisés dans un système
s'appelle sa base. Les machines digitales ou numériques fonctionnent en binaire, c'est-à-
dire selon le système de base 2.
En particulier on a :
0 et 1 : base 2
0à7: base 8
0 à 9 et de A à F : base 16
Si B est la base, alors un nombre entier N en base B s'exprime sous la forme :
𝑁 = 𝑎𝑛 𝑏 𝑛 + 𝑎𝑛−1 𝑏 𝑛−1 … . 𝑎1 𝑏1 + 𝑎0
Ou
𝑁 = 𝑎𝑛 𝑎𝑛−1 … . 𝑎1 𝑎0 en notation de position. La position d'un chiffre rappelle la
puissance de la base qui multiplie ce chiffre. Dans le cas des ai c'est Bi.
En base 10
152 = 1 x 102 + 5 x 101+ 2 x 100 ce qui s'écrit encore :
a2a1a0 = a2102 + a1101+a0100
Un nombre fractionnaire P, c'est-à-dire compris entre 0 et 1 s'exprime sous la forme
suivante dans la base B:
𝑃 = 𝑎−1 𝑏 −1 + 𝑎−2 𝑏 −2 + ⋯ + 𝑎−𝑛 𝑏 −𝑛
Ou
𝑃 = 0. 𝑎−1 𝑎−2 … . 𝑎−𝑛 en notation de position.
On fait précéder le premier chiffre non nul de "0." pour signifier que c'est un nombre
décimal. La puissance de la base qui correspond à un rang donné s'appelle le poids de ce
nombre. Pour éviter des confusions, du fait que les mêmes chiffres sont communs à
plusieurs bases, on spécifie la base de la manière suivante :
13  (13)10  (1101)2  (15)8  (D)16
Ou
13  1310  11012  158  D16

II. Représentation des nombres dans les trois (3) systèmes
Nous nous intéresserons particulièrement à trois systèmes
Binaire ou base 2 : chiffres 0 et 1
Octal ou base 8 : chiffres de 0 à 7
Hexadécimal ou base 16 : chiffres de 0 à 9 et lettres de A à F
On peut dresser le tableau de correspondance suivant entre différentes bases :
Décimal Binaire Octal Hexadécimal

0 0 0 0
1 1 1 1
2 10 2 2
3 11 3 3
4 100 4 4
5 101 5 5
6 110 6 6
7 111 7 7
8 1000 10 8
9 1001 11 9
10 1010 12 A
11 1011 13 B
12 1100 14 C
13 1101 15 D
14 1110 16 E
15 1111 17 F
III. Conversion d’une base à une autre (nombres positifs)
1. Partie entière
On a N = (anan-1…a1a0)𝛼 on veut avoir N =(cmcm-1…c1c0)𝛽
Il y a deux méthodes :
i. On connait la table de conversion de chiffre entre les deux bases, on connait la table de
multiplication dans la base 𝛽. On connait la table de l’addition dans la base 𝛽. On écrit N
dans sa base polynômiale qui est :
N=a0+ 𝛼(a1+ 𝛼(a2+…𝛼(an-1+𝛼an))) puis on remplace 𝛼 et chaque ai par leur représentation

en 𝛽 puis on fait l’arithmétique en base 𝛽.

Exemple : convertir X = (2BAD)16 en base 10
On a X= D+16(A+16(B+16 2))
=13+16(10+16(11+16 2)) =(11181)10
Rq : la difficulté de cette approche vient du fait qu’il faut une table de conversion et les
tables des opérations arithmétiques.
ii. On procède par division successive : Si on divise N par 𝛽 on a le quotient Q et le
reste c0. En répétant le processeur on retrouve c0 jusqu’à cm le processus s’arrête
lorsque le quotient est 0. Il faut retenir que les chiffres de la représentation de 𝛽 sont
retenus dans l’ordre inverse.
Exemple : convertir (3781)10 en base 2
3781 2
1890 2 1 c0
945 2 0 c1
472 2 1 c2
c11
On a donc (111011000101)2
En base 8 on a
3781 8
472 8 5
59 8 0 qui donne (7305)8
7 8 3
7 8 7
0
En base 16 on a
3781 16 5
236 16 C d’où (EC5)16
16 E
0

2. La partie fractionnaire
𝑚
𝑦 = ∑ 𝑐𝑘 𝛽 −𝑘 = (0. 𝑐1 𝑐2 … 𝑐𝑚 )𝛽
𝑘=1
𝑦𝛽 = 0. 𝑐1 𝑐2 𝑐3 … 𝑐𝑚
Chaque ci obtenu est la partie entière du produit yi*β. On recommence le processus avec
la partie fractionnaire de ce même produit jusqu’à ce que celle-ci devienne 0 ou qu’on
obtienne une séquence de répétions.
Soit x le nombre, on définit par E(x) la partie entière de x et F(x) la partie fractionnaire
de x avec 0 ≤ 𝑥 < 1. La conversion de x en base 𝛽 se fait de la manière suivante :
On définit d0= x et d1 = F(𝛽d0), c1=E(𝛽d0) ; d2=F(𝛽d1), c2=E(𝛽d1) jusqu’à
dm=F(𝛽dn-1), cm=E(𝛽dm-1). Obtient ainsi la représentation de x=(0.c1c2…cm)
Exemple : x=(0,825)10 convertir en binaire
0.825
× 2
d0= c0=1
1.650
0.650 0.600
× 2 × 2
d1= c1=1 d 3= c3=1
1.300 1.200
0.300 0.200
× 2 × 2
d2= c2=0 d 4= c4=0
0.600 0.400
0.400 0.800
× 2 × 2
d5= c5=0 d6= c6=1
0.800 1.600
d7=0.600=d3 d’où c7=1, c8=0, c9=0

D’où on a (0.825)10 = (0.1101001100110011…)

Remarques : La multiplication précédente pour la conversion de la partie décimale peut durer
longuement, alors se pose le problème de s'arrêter à la même précision que celle du nombre de
départ. Si la partie décimale a m chiffres, sa conversion aura n chiffres de façon que :
Base 2 : n=3,32 m
Base 8 : n=1,11 m
Base 16 : n=0,8 m
b = 10 → m=n logb
n m
n = m / logb
Ainsi par exemple, si m = 3(exemple précédent), on aura respectivement n = 10 en
binaire, 4 en octal et 3 en hexa.
a. Conversion 2 8 16
(i) 2 8
Etant donné un nombre en base 2 la conversion en base 8 se fait en subdivision de la

représentation en binaire en groupe de 3 bits par sa valeur en base 8.la subdivision
précède du point décimal vers la gauche pour la partie entière, vers la droite pour la
partie décimale.
Dans les deux cas on peut avoir à compléter le dernier groupe de 3 bits par des zéros
Exemple : 001101101001 . 110010100
On a donc en base 8 (1551.624)8
De façon générale on a 𝑥 = ∑𝑛𝑘=0 𝑎𝑘 2𝑘 + ∑𝑚
𝑘=1 𝑏𝑘 2
−𝑘
E(x) peut se mettre sous la forme suivante

(4𝑎𝑛 + 2𝑎𝑛−1 + 𝑎𝑛−2 )2𝑛−2 + 2𝑛−5 (4𝑎𝑛−3 + 2𝑎𝑛−4 + 𝑎𝑛−5 ) + ⋯ + 23 (4𝑎5 + 2𝑎4 + 𝑎3 )
+ 20 (4𝑎2 + 2𝑎1 + 𝑎0 )
On suppose que n+1 est un multiple de 3 sinon on adjoint des zéros au début pour en
faire. On constate alors que les puissances de 2 dans la nouvelle expression peuvent se
mettre sous forme d’une puissance de 8. Les coefficients de chacune de ces puissances
sont des chiffres de la base 8. Chacun étant constitué de 3 chiffres binaires, on retrouve
la subdivision précédente
F(𝑥) = 2−3 (4𝑏1 + 2𝑏2 + 𝑏3 ) + 2−6 (4𝑏4 + 2𝑏5 + 𝑏6 ) + ⋯ + 2−𝑚 (4𝑏𝑚−2 + 2𝑏𝑚−1 + 𝑏𝑚 )

En remarquant dans cette décomposition que les puissances négatives de 2 sont en
même temps ceux de 8 et que les coefficients de ces puissances sont les chiffres de la
base 8 ce qui justifie la subdivision précédente.
(ii) 2↔ 𝟏𝟔
La subdivision ou décomposition est identique au précédent mais en groupe de 4 bits.

On remplace chaque bit par sa valeur en base 16
(iii) La conversion entre la base 8 et 16 se fait en passant par la base 2 (8 → 16 on a
8 → 2 → 16 ou 16 → 8 on a 16 → 2 → 8)
IV. Les opérations arithmétiques

On distingue 4 opérations arithmétiques : l’addition, la multiplication, la division, la
soustraction
a) Addition
𝑥 𝑦 𝑥+𝑦 𝑟
0 0 0 0
0 1 1 0
1 0 1 0
1 1 0 1
b) Multiplication
𝑥 𝑦 𝑥∗𝑦
0 0 0
0 1 0
1 0 0
1 1 1
c) Division
𝑥 𝑦 𝑥/𝑦
0 0 !
0 1 0
1 0 !
1 1 1

d) Soustraction (𝑥 − 𝑦) ≥ 0
𝑥 𝑦 𝑥−𝑦 𝑐
0 0 0 0
0 1 1 1
1 0 1 0
1 1 0 0
1. Notion de chiffre significatif

On a 3 règles:
1) Un chiffre non nul est toujours significatif
2) Le chiffre 0 est significatif quand il est placé entre deux chiffres non nuls, tandis qu'il
n'est jamais significatif quand il précède tous les chiffres non nuls.
Exemples: 123 trois chiffres significatifs

42.51 quatre chiffres significatifs
621.042 six chiffres significatifs
10.004 cinq chiffres significatifs
0.00051 deux chiffres significatifs
11.0000700 neuf chiffres significatifs
3) Tous les zéros placés en fin de nombre sont significatifs si le nombre comporte une
virgule
Exemple : les nombres
230.0 2.3000 et 0.0023000 ont chacun cinq chiffres significatifs.
2. Notion d'arrondi et d'erreur d'arrondi

Problème: on voudrait représenter un nombre par un autre comportant moins de chiffres
décimaux ou un nombre donné de chiffres significatifs.
On va donc laisser tomber une certaine quantité de chiffres significatifs et arrondir au
niveau du dernier chiffre significatif abandonné: celui-ci est appelé : le chiffre test. On
va arrondir :
- à la valeur inférieure si le chiffre test est inférieur à 5,
- à la valeur supérieure si le chiffre test est supérieur à 5.
Exemples: Soit à arrondir à deux décimales après la virgule :
152.432617 = 152.43
0.002724 = 0.00

0.01841= 0.02
125.4370 = 125.44
La différence entre la véritable valeur et la valeur après arrondi est l'erreur d'arrondi.
Elle est toujours inférieure à 0.5
3. Notion de troncature et d'erreur de troncature

Ici on coupe le nombre pour ne conserver qu'une quantité fixe de chiffres. Il s'agit de
négliger les chiffres les moins significatifs.
Exemple: soit à réduire ces nombres à une seule décimale après la virgule
75.87 6.6798 -199.251 -0.0387624
75.8 6.6 -199.2 -0.0
V.Représentation des entiers
1. Nombre en complément
La représentation des nombres en complément facilite l’opération de soustraction dans les
ordinateurs. Ainsi, au lieu de soustraire, on ajoute le complément.
Exemple : 𝑥 − 𝑦 ⟺ 𝑥 + (𝑐𝑜𝑚𝑝𝑙𝑒𝑚𝑒𝑛𝑡 𝑑𝑒 𝑦).
Pour chaque base𝛽, il existe 2 types de complément d’un nombre.
- Le complément à 𝛽
- Le complément à 𝛽 − 1
Exemple : base 10 : complément à 10, à 9
Base 2 : complément à 2, à 1
i) complément à 𝛽 − 1
Soit x un nombre à n bits, le complément à 𝛽 − 1 de x est : (𝛽 𝑛 − 1) − 𝑥. L’opération

revient à soustraire chaque chiffre de 𝑥 de (𝛽 − 1) ainsi le complément à 𝛽 − 1 de 𝑥 c’est
le nombre obtenu en remplaçant chaque chiffre αi de x par son complément par rapport
à (𝛽 − 1). Le complément est de la forme (𝛽 − 1) − 𝛼𝑖

Exemple : si 𝛽 = 2 ⇒ 𝛽 − 1 = 1
Le complément à 1 c’est le nombre qu’on obtient en remplaçant chaque chiffre par
son complément. On remplace 1 par 0 et 0 par 1.
Soit N=1010 sur 4 bits N’= (24 - 1)-N

donc son complément à un de N :
N’=(16-1 )-(1010)2= (15 ) - (1010)2 = (1111)2 – (1010)2 = 0101
ii) complément à 𝛽
Soit un nombre x représenté avec n bits. x se mettant sous la forme : (𝛼𝑛−1 𝛼𝑛−2 … . . 𝛼0 )𝛽.
Le complément à 𝛽 𝑑𝑒 𝑥 est égal à : 𝛽 𝑛 − 𝑥 = (𝛽 𝑛 − 1) − 𝑥 + 1
Le complément à 𝛽 d’un nombre x est défini comme 𝛽 𝑛 − 𝑥 en l’exprimant sous la
forme(𝛽 𝑛 − 1) − 𝑥 + 1. On en déduit que le complément à 𝛽 est égal au complément à
(𝛽 − 1) + 1.
Exemple : complément à 10 de 72945

On a 72945 ↓ 1
27054
+ 1
27055
Pour 67940 ↓ 1
32059
+ 1
32060
Pour trouver le complément d’un nombre à 𝛽on parcoure le nombre de la droite vers la
gauche en copiant tous les 1ers zéros rencontrés avant la premier chiffre non nul qui
sera remplacé par son complément à 𝛽 et le reste des chiffres par leur complément à 𝛽 −
1.

Exemple : 1100110100
011001100
Remarque : Dans la représentation en complément il faut toujours fixer le nombre de

bits au départ avant de chercher le complément d’un nombre.
2. Soustraction en complément
a) Nombres sans signe

i) Complément à r
Pour l’opération 𝑀 − 𝑁 on a l’opération suivante 𝑀 − 𝑁 = 𝑀 + (𝑟 𝑛 − 𝑁)
- Ajouter à M le complément à r de N
- Si la somme génère une retenue ( c.à.d. M>=N), il faut ignorer
- Si la somme ne génère pas de retenue, le résultat est obtenu en prenant le
complément à r de la somme et en précédant du signe –
Exemple : n=5
1) 72532 – 03250 3) 1010100 – 1000011
+ 96750 + 0111101
1 69282 1 0010001
2) 1250 – 9456 4) 01001 – 11100

+ 0544 + 00100
1794 01101 résultat : - (01101)
-(8206)
Le résultat cherché est - 8206
ii) complément à r-1

- On ajoute à M le complément à r-1 de N
- S’il y a retenue, on ajoute la retenue à la somme
- S’il n’y a pas de retenue, le résultat est le complément à r-1 de la somme en
précédent du signe -

Exemple : 1) 72532 – 03250 3) 1010100 – 1000011
+ 96749 + 0111100
1 69281 1 0010000
+ 1 + 1
69282 0010001
2) 1250 – 9456 4) 01001 – 11100
+ 0543 + 00011
1793 01100
-(8206) -(10011)
L’inconvénient avec cette approche (nombre sans signe) c’est qu’il faut comparer M et N
pour savoir ce qu’il faut faire du résultat. On contourne cette difficulté en représentant
les nombres avec signe.
b) Nombre avec signe

On fixe au départ le nombre de chiffres qu’il faut pour représenter un nombre avec
pour convention que le 1er chiffre représente le signe pour la base 2. 0 pour + et 1 pour -
Il y a 3 types de représentation pour les nombres avec signe
- Signe + | |
- Complément à 1 avec signe
- Complément à 2 avec signe
i) Signe suivi de valeur absolue (| |)
Le premier bit représente le signe, le reste c.-à-d. n-1 la valeur absolue du nombre
Exemple : n=8 représentation de 5 et -5
00000101 et 10000101 respectivement
ii) complément à 1 avec le signe
On représente la valeur absolue du nombre sur les n bits et on le remplace par son
complément à r y compris le 1er bit (s’il est négatif on le remplace par son complément à r)
Exemple : n=8 représentation de 5 et -5

11111010 et 00000101
(-5) (5)

 complément à r
- On ajoute à M le complément à r de N, on ignore la retenue
- Si la retenue qui se propage dans la position signe est différente de celle qui se propage
hors de cette position, le résultat est mauvais
- Si les retenues sont identiques, le résultat est bon
 complément à r-1
On procède de la même façon mais on ajoute à la somme toute retenue générée. Si rn #rn+1
𝑟𝑛 = 0 𝑟𝑛 = 1
le résultat est mauvais. i.e. on peut avoir { 𝑒𝑡 𝑜𝑢
𝑟𝑛+1 = 1 𝑟𝑛+1 = 0
Lorsque rn#rn+1 il y a dépassement de mémoire parce que les résultats de l’opération ne
peuvent pas être représentés avec les n bits.
Remarque :
• Nous avons un débordement si la somme de deux nombres positifs donne un
nombre négatif.
• Ou la somme de deux nombres négatifs donne un Nombre positif
• Il n’y a jamais un débordement si les deux nombres sont de signes différents.
Exemple : n=4 complément à 2 complément à 1 signe + | |
7 0111 0111 0111

6 0110 0110 0110
5 0101 0101 0101
4 0100 0100 0100
3 0011 0011 0011
2 0010 0010 0010
1 0001 0001 0001
0 0000 0000 0000
-0 - 1111 1000
-1 1111 1110 1001
-2 1110 1101 1010
-3 1101 1100 1011
-4 1100 1011 1100
-5 1011 1010 1101

-6 1010 1001 1110
-7 1001 1000 1111
-8 1000 - -
De façon générale, pour n bits (base 2) on peut représenter les nombres compris entre
[-2n-1,2n-1-1] complément à 2, [-(2n-1-1),2n-1-1] complément à 1 et signe + | |
Exemple : n=4
-(23-1) [-7,7] complément à 1 et signe + | |
[-8,7] complément à 2
VI. Représentation des réels

Un nombre réel est constitué de deux parties : la partie entière et la partie fractionnelle
(les deux parties sont séparées par une virgule). Problème c’est comment indiquer à la
machine la position de la virgule ?
Il existe deux méthodes pour représenter les nombre réel :
– Virgule fixe : la position de la virgule est fixe
– Virgule flottante : la position de la virgule change (dynamique)
1. Virgule fixe
Dans cette représentation la partie entière est représentée sur n bits et la partie
fractionnelle sur p bits, en plus un bit est utilisé pour le signe.
Exemple : si n=3 et p=2 on va avoir les valeurs suivantes
Signe P.E P.F Valeur
0 000 00 + 0,0
0 000 01 + 0,25
0 000 10 + 0,5
0 000 11 + 0,75
0 001 .00 + 1,0
. . . .
. . . .

Dans cette représentation les valeurs sont limitées et nous n’avons pas une grande
précision
2. Virgule Flottante
En interne, les nombres réels sont représentés à l’aide d’une notation spéciale appelée
virgule flottante. La représentation se fait à l’aide d’un mot en précision simple et de
plusieurs mots en grande précision.
Pour un mot de n bits, la représentation se décompose de la façon suivante :
1 n1 n2
Signe de la
mantisse
Mantisse
Exposant
sur n2 bits
sur n1 bits
n=1+n1+n2 (nombre de chiffres qu’il faut pour la représentation)
Un nombre flottant a donc la représentation suivante :

𝑦 = ± 𝑓𝛽 𝑡 (𝑓 ≡ 𝑚𝑎𝑛𝑡𝑖𝑠𝑠𝑒, 𝛽 ≡ 𝑙𝑎 𝑏𝑎𝑠𝑒, 𝑡 ≡ 𝑙′𝑒𝑥𝑝𝑜𝑠𝑎𝑛𝑡)
1 1
- La mantisse est comprise entre et 1. ≤ 𝑓 < 1, elle est normalisée c.a.d si 𝑓=
𝛽 𝛽
0. 𝛼1 𝛼2 … 𝛼𝑛2 alors 𝛼1 ≠ 0 d’où on a pour 𝛼2 𝛼3 … . . 𝛼𝑛2 0 ≤ 𝛼𝑖 ≤ 𝛽 − 1
Pour 𝛼1 𝑜𝑛 𝑎 1 ≤ 𝛼𝑖 ≤ 𝛽 − 1
Si 𝛼𝑖 est égal à zéro alors 𝑓 = 0
- L’exposant t est un entier relatif, il peut être représenté sous la forme à complément ou
sous la forme signe + | | ou sous une forme spéciale dite biaisée.

Forme Complément à 2 (CA2)
On veut représenter les nombres (0,015)8 et -(15, 01)8 en virgule flottante dans une
machine ayant le format suivant :
Signe mantisse Exposant en CA2 Mantisse normalisée
1bit 4bits 8bits

(i) (0,015)8=(0,000001101)2= 0,1101 * 2 -5
Signe mantisse : positif (0)

Mantisse normalisé : 0,1101
Exposant = -5  utiliser le complément à deux pour représenter le -5
Sur 4 bits CA2(0101)=1011
0 1 0 1 1 1 1 0 1 0 0 0 0
(ii) - (15,01)8 = - (001101,000001)2= - 0,1101000001 * 24
Signe mantisse : négatif (1)

Mantisse normalisée : 0,1101000001
Exposant = 4 , en complément à deux il garde la même valeur (0100)
On remarque que la mantisse est sur 10 bits (1101 0000 01), et dans la machine
seulement 8 bits sont utilisés pour la mantisse. Dans ce cas on va prendre les 8
premiers bits de la mantisse.
1 0 1 0 0 1 1 0 1 0 0 0 0
Remarque : si la mantisse est sur k bits et si elle est représentée dans la machine sur
k’ bits tel que k> k’, alors la mantisse sera tronquée : on va prendre uniquement k’ bits
 perdre dans la précision.
Forme biaisée
En complément à 2, l’intervalle des valeurs qu’on peut représenter sur p bits :
-2 (p -1) ≤ N ≤ 2 (p -1) -1
Si on rajoute la valeur 2 (p -1) à tous les termes de cette inégalité :
- 2 (p -1) + 2 (p -1) ≤ N + 2 (p -1) ≤ 2 (p -1) - 1 + 2 (p -1)
0 ≤ N + 2 (p -1) ≤ 2p - 1

On pose N’= N + 2 (p -1) donc : 0 ≤ N’ ≤ 2p -1
Dans ce cas on obtient des valeurs positives.
La valeur 2p-1 s’appelle le biais ou le décalage
On a donc ainsi :
Exposant Biaisé = Exposant réel + Biais ou encore N’= N + 2 (p -1)
Exemple :
On veut représenter les nombres (0,015)8 et -(15, 01)8 en virgule flottante dans une
machine ayant le format suivant :
Signe mantisse Exposant biaisé Mantisse normalisée
1bit 4bits 11bits

(i) (0,015)8=(0,000001101)2= 0,1101 * 2 -5
Signe mantisse : positif ( 0)

Mantisse normalisé : 0,1101
Exposant réel = -5
Calculer le biais : b= 24-1 = 8
Exposant Biaisé = -5 + 8 = +3 = ( 0011)2
0 0011 1 1 0 1 0 0 0 0 0 0 0
(ii) - (15,01)8=(001101,000001)2= 0,1101000001 * 24
Signe mantisse : négatif ( 1)

Mantisse normalisée : 0,1101000001
Exposant réel = + 4
Calculer le biais : b= 24-1 = 8
Exposant Biaisé = 4 + 8 = +12 = ( 1100)2
1 1100 1 1 0 1 0 0 0 0 0 1 0

Convention IEEE : Format simple précision (32 bits)
Un nombre flottant simple précision est stocké dans un mot de 32 bit : 1 bit de signe, 8
bits pour l'exposant et 23 pour la mantisse.
L'exposant est décalé de 28 − 1 − 1 = 127 dans ce cas. L'exposant va donc de -126 à +127.
Un exposant de -127 serait décalé vers la valeur 0, mais celle-ci est réservée pour 0 et les
nombres dé-normalisés. Un exposant de 128 serait décalé vers 255, qui est réservé pour
coder les infinis, et les NaNs (Not a Numbers). Il y a trois cas particuliers :
 si l'exposant et la mantisse sont tous deux nuls, le nombre est ±0 (selon le bit de
signe)
 si l'exposant est égal à 2e – 1 (1 sur tous les bits de l’exposant), et si la
mantisse est nulle, le nombre est ±infini (selon le bit de signe)
 si l'exposant est égal à 2e − 1, mais que la mantisse n'est pas nulle, le nombre est
NaN (not a number : pas un nombre)
Remarque :
La version 1985 de la norme IEEE 754 définit 4 formats pour représenter des nombres à
virgule flottante :
 simple précision (32 bits : 1 bit de signe, 8 bits d'exposant (-126 à 127), 23 bits de
mantisse, avec bit 1 implicite),
 simple précision étendue (≥ 43 bits, obsolète, implémenté en pratique par la double
précision),
 double précision (64 bits : 1 bit de signe, 11 bits d'exposant (-1022 à 1023), 52 bits de
mantisse, avec bit 1 implicite),
 double précision étendue (≥ 79 bits, souvent implémenté avec 80 bits : 1 bit de signe,
15 bits d'exposant (-16382 à 16383), 64 bits de mantisse, sans bit 1 implicite).
3. Opérations arithmétiques en virgule flottante

Soit deux nombres réels N1 et N2 tel que
N1=M1*be1 et N2=M2*be2
On veut calculer N1+N2 ?
Deux cas se présentent :
– Si e1 = e2 alors N3= (M1+M2) be1

– Si e1 < > e2 alors élever au plus grand exposant et faire l’addition des mantisses et par la
suite normaliser la mantisse du résultat.
Exemple : Effectuer l’opération suivante : (0,15)8+ (1,5)8=(?) :

(0,15)8= (0,001101) = 0,1101 *2-2
(1,5)8= (001, 1 01) = 0,1101 *21
(0,15)8+ (1,5)8 = 0,1101 *2-2 + 0,1101 *21
= 0,0001101 *21 + 0,1101 *21
= 0, 1110101 * 21

CHAPITRE 2: Fonctionnement de base des
Microprocesseurs
I. Introduction
Un microprocesseur est un circuit intégré complexe caractérisé par une très grande
intégration et doté des facultés d'interprétation et d'exécution des instructions d'un
programme.
Il est chargé d’organiser les tâches précisées par le programme et d’assurer leur
exécution. Il doit aussi prendre en compte les informations extérieures au système et
assurer leur traitement. C’est le cerveau du système.
A l’heure actuelle, un microprocesseur regroupe sur quelques millimètres carrés des
fonctionnalités toujours plus complexes. Leur puissance continue de s’accroître et leur
encombrement diminue régulièrement, on parlera d'ici peu de "nanoprocesseur".
Les applications des systèmes à microprocesseurs sont multiples et variées :
 Ordinateur, PDA
 console de jeux
 calculatrice
 télévision
 téléphone portable
 distributeur automatique d’argent
 robotique
 lecteur carte à puce, code barre
 automobile
 instrumentation
 etc…

Figure 1 : Architecture d'un système microprogrammé

II. Eléments de base d’un microprocesseur
Un microprocesseur est construit autour de deux éléments principaux :
 Une unité de commande
 Une unité de traitement
Associés à des registres chargées de stocker les différentes informations à traiter. Ces
trois éléments sont reliés entre eux par des bus interne permettant les échanges
d’informations.
Remarque :
Il existe deux types de registres :
 les registres d'usage général permettent à l'unité de traitement de manipuler des
données à vitesse élevée. Ils sont connectés au bus de données interne au
microprocesseur.
 les registres d'adresses (pointeurs) connectés sur le bus adresses.
A. L’unité de commande
Elle permet de séquencer le déroulement des instructions. Elle effectue la recherche

en mémoire de l'instruction. Comme chaque instruction est codée sous forme binaire,
elle en assure le décodage pour enfin réaliser son exécution puis effectue la
préparation de l'instruction suivante. Pour cela, elle est composée par :
 le compteur de programme constitué par un registre dont le contenu est initialisé
avec l'adresse de la première instruction du programme. Il contient toujours l’adresse
de l’instruction à exécuter.
 le registre d'instruction et le décodeur d'instruction : chacune des instructions à
exécuter est rangée dans le registre instruction puis est décodée par le décodeur
d’instruction.

 Bloc logique de commande (ou séquenceur) : Il organise l'exécution des instructions
au rythme d’une horloge. Il élabore tous les signaux de synchronisation internes ou
externes (bus de commande) du microprocesseur en fonction des divers signaux de
commande provenant du décodeur d’instruction ou du registre d’état par exemple. Il
s'agit d'un automate réalisé soit de façon câblée (obsolète), soit de façon micro-
programmée, on parle alors de microprocesseur.
B. L’unité de traitement
C’est le cœur du microprocesseur. Elle regroupe les circuits qui assurent les
traitements nécessaires à l'exécution des instructions :
 L’Unité Arithmétique et Logique (UAL) est un circuit complexe qui assure les
fonctions logiques (ET, OU, Comparaison, Décalage, etc…) ou arithmétique
(Addition, soustraction).
 Le registre d'état est généralement composé de 8 bits à considérer individuellement.
Chacun de ces bits est un indicateur dont l'état dépend du résultat de la dernière
opération effectuée par l’UAL. On les appelle indicateur d’état ou flag ou drapeaux.
Dans un programme le résultat du test de leur état conditionne souvent le
déroulement de la suite du programme. On peut citer par exemple les indicateurs de :
- retenue (carry : C)
- retenue intermédiaire (Auxiliary-Carry : AC)
- signe (Sign : S)
- débordement (overflow : OV ou V)
- zéro (Z)
- parité (Parity : P)
 Les accumulateurs sont des registres de travail qui servent à stocker un opérande au
début d'une opération arithmétique et le résultat à la fin de l'opération

a. Cycle d’exécution d’une instruction
Le microprocesseur ne comprend qu’un certain nombre d’instructions qui sont
codées en binaire. Le traitement d’une instruction peut être décomposé en trois
phases.
Phase 1: Recherche de l'instruction à traiter

1. Le PC contient l'adresse de l'instruction suivante du programme. Cette valeur est
placée sur le bus d'adresses par l'unité de commande qui émet un ordre de
lecture.
2. Au bout d'un certain temps (temps d'accès à la mémoire), le contenu de la case
mémoire sélectionnée est disponible sur le bus des données.
3. L'instruction est stockée dans le registre instruction du processeur.

Phase 2 : Décodage de l’instruction et recherche de l'opérande
Le registre d'instruction contient maintenant le premier mot de l'instruction qui peut

être codée sur plusieurs mots. Ce premier mot contient le code opératoire qui définit
la nature de l'opération à effectuer (addition, rotation,...) et le nombre de mots de
l'instruction.
1. L'unité de commande transforme l'instruction en une suite de commandes
élémentaires nécessaires au traitement de l'instruction.
2. Si l'instruction nécessite une donnée en provenance de la mémoire, l'unité de
commande récupère sa valeur sur le bus de données.
3. L’opérande est stockée dans un registre.

Phase 3 : Exécution de l'instruction
1. Le microprogramme réalisant l'instruction est exécuté.
2. Les drapeaux sont positionnés (registre d'état).
3. L'unité de commande positionne le PC pour l'instruction suivante.

III. Performances d’un microprocesseur
On peut caractériser la puissance d’un microprocesseur par le nombre d’instructions
qu’il est capable de traiter par seconde. Pour cela, on définit :
 le CPI (Cycle Par Instruction) qui représente le nombre moyen de cycles d’horloge
nécessaire pour l’exécution d’une instruction pour un microprocesseur donné.
 le MIPS (Millions d'Instructions Par Seconde) qui représente la puissance de
traitement du microprocesseur.
𝐅𝐇
𝐌𝐈𝐏𝐒 = avec FH en MHz
𝐂𝐏𝐈
Pour augmenter les performances d’un microprocesseur, on peut donc soit

augmenter la fréquence d'horloge (limitation matérielle), soit diminuer le CPI (choix
d'un jeu d'instruction adapté).
IV. Le jeu d’instructions
A. Définition
La première étape de la conception d’un microprocesseur est la définition de son

jeu d’instructions. Le jeu d’instruction décrit l’ensemble des opérations élémentaires
que le microprocesseur pourra exécuter. Il va donc en partie déterminer
l’architecture du microprocesseur à réaliser et notamment celle du séquenceur. A un
même jeu d’instruction peut correspondre un grand nombre d’implémentations
différentes du microprocesseur. Il n’existe pas de consensus pour la définition du jeu
d’instructions mais, il est cependant important de considérer les aspects
fondamentaux suivants :
i) Les opérations, leur nombre et leur complexité
ii) Les types de données supportées par les opérations
iii) Les registres, leur nombre et la façon dont ils sont utilisés par les opérations
iv) L’adressage, qui précise comment est faite la référence aux données.
v) Le format de l’instruction (Taille, nombre, taille de champs).
B. Type d’instruction
Les instructions que l’on trouve dans chaque microprocesseur peuvent être
classées en quatre groupes :
i) Transfert de données : Pour charger ou sauvegarder en mémoire, effectuer des
transferts de registre à registre, …
ii) Opérations arithmétiques : Addition, soustraction, division et multiplication.

iii) Opérations logiques : Et, ou, non, Nand, comparaison, test…
iv) Contrôle de séquence : Branchement, test…
C. Codage
Les instructions et leurs opérandes (paramètres) sont stockés en mémoire

principale. La taille totale d’une instruction (nombre de bits nécessaires pour la
représenter en mémoire) dépend du type d’instruction et aussi du type d’opérande.
Chaque instruction est toujours codée sur un nombre entier d’octet afin de faciliter
son décodage par le processeur. Une instruction est composée de deux champs :
i) Code instruction (OPcode) : Qui indique au processeur quelle instruction réaliser.
ii) Le champ opérande qui contient la donnée ou la référence à une donnée en
mémoire (son adresse).
Il existe trois types de codage d’instruction :

- Le codage variable : il permet tous les modes adressage avec toutes les opérations et
est indiqué lorsqu’il y a beaucoup de mode d’adressage et d’opérations.
- Le codage fixe : il combine l’opération et le mode d’adressage dans le code-op. Il a
souvent une seule taille pour toutes les instructions.
- Le codage hybride : qui combine les deux autres principes de codage.
Opération et Spécificateur Champ Spécificateur Champ

--------------
Nbr d’opérandes d’adresse 1 d’adresse 1 d’adresse n d’adresse n
Codage variable (exemple processeur VAX
Champ Champ Champ

Opération
d’adresse 1 d’adresse 2 d’adresse 3
Codage fixe (exemple processeur DLX, MIPS, SPARC
Spécificateur Champ
Opération
d’adresse 1 d’adresse
Spécificateur Spécificateur Champ

Opération
d’adresse 1 d’adresse 2 d’adresse
Spécificateur Champ Champ

Opération
d’adresse d’adresse 1 d’adresse 2
Codage hybride (exemple processeur IBM 360/70, Intel 80x86

Le choix d’un type de codage dépend du choix entre la performance et la taille du
programme. Le codage variable essaie d’utiliser le moins de bits possible pour représenter le
programme. Mais le décodage des instructions n’est pas toujours facile. Le codage fixe
permet un décodage facile des instructions étant données que toutes ont la même taille et on
gagne ainsi en performance. Dans la suite, nous considérons le cas du codage fixe.
Généralement, le type d’un opérande (par exemple, entier, flottant simple précision,
caractère) donne sa taille. Les types courants d’opérandes comprennent le caractère (un
octet), le demi-mot (16 bits), le mot (32 bits), flottant simple précision (un mot) et flottant
double précision (deux mots). Les caractères sont presque toujours représentés en ASCII et
les entiers sont presque universellement représentées comme des binaires en compléments à
deux.
Remarque : Le nombre d’instructions du jeu d’instructions est directement lié au

format du code instruction. Ainsi, un octet (8 bits) permet de distinguer au maximum
256 instructions différentes.
Exemple : Le jeu d’instructions d’un processeur contient : 64 instructions à 3

opérandes de 16 bits chacune, 126 instructions à 2 opérandes et 16 instructions sans
opérande. Déterminer le nombre de bits du code instruction, le nombre de bits pour
coder une instruction et le nombre d’instructions à 1 opérande.
D. Le chemin de données d’un processeur
L’exécution des instructions nécessite des ressources fonctionnelles (UAL) et de

mémorisation (registre, mémoire). Il faut donc décrire comment ces ressources sont
utilisées pour chaque type d’instruction. Le chemin de donnée d’un processeur est la
définition des interactions entre les différentes ressources. Ces interactions
représentent la circulation des informations à travers l’architecture. C’est un résumé
de l’exécution des différentes opérations par le processeur ainsi que l’enchaînement
du matériel utilisé à cet effet. Exemple : Chemin de données du processeur DLX ci-
dessous.

Figure 2 : Chemin de donnée du processeur DLX

V. Notion d’architecture RISC et CISC
Actuellement l’architecture des microprocesseurs se composent de deux grandes familles :
 L’architecture CISC (Complex Instruction Set Computer)

 L’architecture RISC (Reduced Instruction Set Computer)
A. L’architecture CISC
Pourquoi
Par le passé la conception de machines CISC était la seule envisageable. En effet, vue que la
mémoire travaillait très lentement par rapport au processeur, on pensait qu’il était plus
intéressant de soumettre au microprocesseur des instructions complexes. Ainsi, plutôt que de
coder une opération complexe par plusieurs instructions plus petites (qui demanderaient autant
d’accès mémoire très lent), il semblait préférable d’ajouter au jeu d’instructions du
microprocesseur une instruction complexe qui se chargerait de réaliser cette opération. De plus,
le développement des langages de haut niveau posa de nombreux problèmes quant à la
conception de compilateurs. On a donc eu tendance à incorporer au niveau processeur des
instructions plus proches de la structure de ces langages.
Comment
C’est donc une architecture avec un grand nombre d’instructions où le microprocesseur doit
exécuter des tâches complexes par instruction unique. Pour une tâche donnée, une machine
CISC exécute ainsi un petit nombre d’instructions mais chacune nécessite un plus grand nombre
de cycles d’horloge. Le code machine de ces instructions varie d’une instruction à l’autre et
nécessite donc un décodeur complexe (micro-code)
B. L’architecture RISC
Pourquoi
Des études statistiques menées au cours des années 70 ont clairement montré que les
programmes générés par les compilateurs se contentaient le plus souvent d'affectations,
d'additions et de multiplications par des constantes. Ainsi, 80% des traitements des langages de
haut niveau faisaient appel à seulement 20% des instructions du microprocesseur. D’où l’idée
de réduire le jeu d’instructions à celles le plus couramment utilisées et d’en améliorer la vitesse
de traitement.

Comment
C’est donc une architecture dans laquelle les instructions sont en nombre réduit (chargement,
branchement, appel sous-programme). Les architectures RISC peuvent donc être réalisées à
partir de séquenceur câblé. Leur réalisation libère de la surface permettant d’augmenter le
nombre de registres ou d’unités de traitement par exemple. Chacune de ces instructions
s’exécutent ainsi en un cycle d’horloge. Bien souvent, ces instructions ne disposent que d’un
seul mode d’adressage. Les accès à la mémoire s’effectuent seulement à partir de deux
instructions (Load et Store). Par contre, les instructions complexes doivent être réalisées à partir
de séquences basées sur les instructions élémentaires, ce qui nécessite un compilateur très
évolué dans le cas de programmation en langage de haut niveau.
C. Comparaison
Le choix dépendra des applications visées. En effet, si on diminue le nombre d'instructions, on
crée des instructions complexes (CISC) qui nécessitent plus de cycles pour être décodées et si on
diminue le nombre de cycles par instruction, on crée des instructions simples (RISC) mais on
Augmente alors le nombre d'instructions nécessaires pour réaliser le même traitement.
Architecture RISC Architecture CISC
 instructions simples ne prenant qu’un seul  instructions complexes prenant

cycle plusieurs cycles
 instructions au format fixe  instructions au format variable
 décodeur simple (câblé)  décodeur complexe (microcode)
 beaucoup de registres  peu de registres
 seules les instructions LOAD et STORE  toutes les instructions sont susceptibles
ont accès à la mémoire d’accéder à la mémoire
 peu de modes d’adressage  beaucoup de modes d’adressage
 compilateur complexe  compilateur simple
D. Processeurs spéciaux
 Le microcontrôleur
Ce sont des systèmes minimum sur une seule puce. Ils contiennent un CPU, de la RAM, de la
ROM et des ports d’Entrée/Sorties (parallèles, séries, I2C, etc..). Ils comportent aussi des
fonctions spécifiques comme des compteurs programmables pour effectuer des mesures de
durées, des CAN voir des CNA pour s’insérer au sein de chaînes d’acquisition, des interfaces
pour réseaux de terrain, etc ...

Il est adapté pour répondre au mieux aux besoins des applications embarquées (appareil
électroménagers, chaîne d’acquisition, lecteur carte à puce, etc...). Il est par contre généralement
moins puissant en termes de rapidité, de taille de données traitables ou de taille de mémoire
adressable qu’un microprocesseur.
 Le processeur de signal
Le processeur de signal est beaucoup plus spécialisé. Alors qu'un microprocesseur n'est pas
conçu pour une application spécifique, le processeur DSP (Digital Signal Processor) est optimisé
pour effectuer du traitement numérique du signal (calcul de FFT, convolution, filtrage
numérique, etc...).
Les domaines d’application des D.S.P étaient à l’origine les télécommunications et le secteur
militaire. Aujourd’hui, les applications se sont diversifiées vers le multimédia (lecteur CD, MP3,
etc..) l’électronique grand public (télévision numérique, téléphone portable, etc…),
l’automatique, l’instrumentation, l’électronique automobile, etc…

CHAPITRE 3: Principes d'architecture des
microprocesseurs
I. Introduction
Nous présentons divers aspects de l'architecture des processeurs. Nous abordons les
notions de base nécessaires au lecteur voulant comprendre le fonctionnement d'un
microprocesseur. Notamment la notion de pipeline d'instruction et les traitements
qu'elle implique. Le fonctionnement des processeurs superscalaires, EPIC et VLIW sont
décrits afin d'illustrer l'utilisation des techniques matérielles d'accélération des calculs.
A. Phases d'une instruction

Le déroulement d’une instruction peut se décomposer simplement et uniformément en 4
phases:
1 : IF (Instruction Fetch): chargement de l’instruction et mise à jour du Compteur
Ordinal
2 : ID (Instruction Decode): lecture des registres sources/ calcul d’adresse
3 : EX (Execution): exécution (au sens production de la valeur résultat) plus ou moins
complexe suivant les instructions
4 : WB (Write Back): mise à jour des registres résultats.
Le tableau suivant décrit de manière simple les phases d'une instruction en fonction des
catégories.

Il faut noter que pour une même phase, chaque catégorie peut avoir à effectuer des
opérations très différentes. De plus, il est à noter que le cas des branchements est très
largement simplifié. Le timing des phases détermine la vitesse du pipeline.
REMARQUE: La décomposition (un peu arbitraire) en 4 phases d’une instruction à

pour but de simplifier les explications, nous en présentons d’autres plus complexes et
plus réalistes!!
B.Timing des phases (cas simplifié)

Pour chaque phase i et pour chaque instruction Ij, les durées d’exécution (notées Ti(Ij)) sont a
priori différentes.
Une première opération fondamentale dans la mise en œuvre consiste à les uniformiser
en se positionnant dans le pire des cas. Le temps de cycle du pipeline sera défini par:
Tcyc = Max i j (Ti(Ij))
Pour chaque instruction et pour chaque phase, le timing d’exécution sera aligné sur Tcyc
permettant de garantir que dans tous les cas la phase i de l’instruction Ij puisse avoir le
temps de s’exécuter.
II. Architecture pipeline

A. Principe
L’exécution d’une instruction est décomposée en une succession d’étapes et chaque étape
correspond à l’utilisation d’une des fonctions du microprocesseur. Lorsqu’une instruction se

trouve dans l’une des étapes, les composants associés aux autres étapes ne sont pas utilisés. Le
fonctionnement d’un microprocesseur simple n’est donc pas efficace.
L’architecture pipeline permet d’améliorer l’efficacité du microprocesseur. En effet, lorsque la
première étape de l’exécution d’une instruction est achevée, l’instruction entre dans la seconde
étape de son exécution et la première phase de l’exécution de l’instruction suivante débute. Il
peut donc y avoir une instruction en cours d’exécution dans chacune des étapes et chacun des
composants du microprocesseur peut être utilisé à chaque cycle d’horloge. L’efficacité est
maximale. Le temps d’exécution d’une instruction n’est pas réduit mais le débit d’exécution des
instructions est considérablement augmenté. Une machine pipeline se caractérise par le nombre
d’étapes utilisées pour l’exécution d’une instruction, on appelle aussi ce nombre d’étapes le
nombre d’étages du pipeline.
Exemple de l’exécution en 4 phases d’une instruction :

B. Gain de performance
Dans cette structure, la machine débute l’exécution d’une instruction à chaque cycle et le
pipeline est pleinement occupé à partir du quatrième cycle. Le gain obtenu dépend donc du
nombre d’étages du pipeline. En effet, pour exécuter n instructions, en supposant que chaque
instruction s’exécute en k cycles d’horloge, il faut :
 n.k cycles d’horloge pour une exécution séquentielle.
 k cycles d’horloge pour exécuter la première instruction puis n-1 cycles pour les n-1
instructions suivantes si on utilise un pipeline de k étages
Le gain obtenu est donc de :
n. k
G=
k + (n − 1)
Donc lorsque le nombre n d’instructions à exécuter est grand par rapport à k, on peut admettre
qu’on divise le temps d’exécution par k.
Remarque :
Le temps de traitement dans chaque unité doit être à peu près égal sinon les unités rapides
doivent attendre les unités lentes.
Exemples :
L’Athlon d’AMD comprend un pipeline de 11 étages.
Les Pentium 2, 3 et 4 d’Intel comprennent respectivement un pipeline de 12, 10 et 20 étages.
L’organisation matérielle
L'utilisation des ressources dans le pipeline est représentée par des tables de réservation.

C. Table de réservation
Table de réservation élémentaire: A chaque instruction est associée une table de
réservation: tableau bidimensionnel décrivant cycle à cycle l’utilisation des ressources
matérielles. Ce tableau est construit de la manière suivante:
 A chaque colonne est associé un numéro de cycle

 A chaque ligne est associée une ressource matérielle
 A l’intersection de la colonne i et de la ligne j, un symbole est inséré si et
seulement si la ressource matérielle j est utilisée au cycle i.
Par construction, dans notre première version simple du pipeline, toutes les instructions
ont exactement la même table de réservation.
Exemple de table de réservation élémentaire pour l'instruction I1
Table de réservation globale: il s’agit d’une extension directe de la notion de table de

réservation élémentaire, décrivant l’utilisation cycle à cycle des différents étages du
pipeline. Par exemple :

Coté logiciel
Les tables de réservation sont utilisées par exemple pour mettre en œuvre les techniques
d'ordonnancement de code. Dans ce cas, on distingue généralement trois types
d'utilisation de la ressource matérielle: lecture, écriture et occupation. Par exemple (table
de réservation proposée dans le système Salto):
Les unités fonctionnelles décrites au niveau logiciel ne reflètent pas directement

l'architecture
D. Le pipeline instruction
A la différence du fonctionnement classique en mode séquentiel, le pipeline n’attend pas
la fin complète d’une instruction avant de démarrer la suivante: une nouvelle
instruction est lancée à chaque cycle. Exemple de code:
1 LDR #2, R3
2 MUL R5, R6, R7
3 LDI 8(R9), R12
4 LDR #4, R10
5 ADD R13, R14, R15
NOTE: Attention, la séquence ci-dessus a été choisie avec soin: ni dépendances de
données, ni dépendances de contrôle !! Les 5 instructions ci-dessus sont rigoureusement
indépendantes!!

Diagramme d’exécution: mode pipeline
 Analyse du fonctionnement en mode pipeline
Au début de chaque cycle, les instructions « entrent » dans l’étage suivant puis
effectuent le traitement correspondant et enfin se « synchronisent » pour passer à l’étage
suivant.
Il n’y a pas de conflit d’accès à la ressource suivante car par construction en un cycle,
chaque instruction dispose d’un temps suffisant pour effectuer le traitement requis (cf.
choix du temps de cycle).
En pratique, la synchronisation entre étages du pipeline est assurée par la présence de

bascule (zone mémoire tampon) et d’une horloge commune (fonctionnement
synchrone).

 Sémantique du pipeline: ordre d’exécution
Les étages fonctionnent en parallèle mais les instructions entrent séquentiellement dans
le pipeline conformément à l’ordre d’exécution de référence. Plus précisément, cet ordre
de référence va être conservé pour TOUTES les phases, ainsi les instructions finiront
(phase WB) dans le même ordre. Cette propriété de conservation de l’ordre est due au
fait que toutes les instructions ont la même table de réservation!!
Analogie utile: l’organisation en mode pipeline est analogue à l’organisation d’une

chaîne d’assemblage dans le domaine de l’automobile: les instructions correspondent
aux voitures, les étages aux postes de travail.
La performance en mode pipeline ci-dessus ne peut être attends que s'il n'existe pas de
dépendances entre les instructions. Ces dépendances peuvent être de plusieurs ordres
III. Dépendances de données entre instructions
Deux instructions présentent une dépendance de données si et seulement si elles

utilisent (lire ou écrire) une même donnée (registre ou case mémoire). Supposons:
 I1 est avant I2 dans l’ordre d’exécution de référence,

 I1 et I2 utilisent une même donnée
Quatre cas sont possibles:
RAR: Read After Read RAW: Read After Write
I1 lit X; I1 écrit X;
I2 lit X I2 lit X
WAR: Write After Read WAW: Write After Write
I1 lit X; I1 écrit X;
I2 écrit X I2 écrit X
RAR (Consommateur/Consommateur)
I1 : ADD R1, R4, R7 (R7 <- R1 + R4)

I2 : LDR R9, R8 (R8 <- R9)
I3 : MUL R2, R4, R5 (R5 <- R2 * R4)
Dépendance RAR entre I1 et I3 car:

 I1 exécutée avant I3
 I1 et I3 utilisent toutes les deux en lecture le même registre R4
PAS DE CONTRAINTE D’ORDRE
RAW (Producteur/Consommateur)
I1 : MUL R1, R4, R7 (R7 <- R1 * R4)

I2 : LDR R9, R8 (R8 <- R9)
I3 : SUB R2, R7, R11 (R11 <- R2 - R7)
Dépendance RAW entre I1 et I3 car:
 I1 et I3 utilisent le même registre R7: I1 en écriture et I3 en lecture
CONTRAINTE D’ORDRE: R7 doit être écrit par I1 avant d’être lu par I3
WAR (Consommateur/Producteur)
I1 : ADD R1, R4, R7 (R7 <- R1 + R4)

I2 : MUL R9, R8, R10 (R10 <- R8*R9)
I3 : LDR R2, R4 (R4 <- R2)
Dépendance WAR entre I1 et I3 car:
 I1 et I3 utilisent le même registre R4: I1 en lecture et I3 en écriture
CONTRAINTE D’ORDRE: R4 doit être lu par I1 avant d’être écrit par I3
WAW (Producteur/Producteur)
I1 : ADD R1, R4, R7 (R7 <- R1 + R4)

I2 : MUL R9, R8, R10 (R10 <- R8 * R9)
I3 : ADD R2, R6, R7 (R7 <- R2 + R6)
Dépendance WAW entre I1 et I3 car:
 I1 et I3 utilisent toutes les deux le même registre R7 et en écriture

CONTRAINTE D’ORDRE: R7 doit être écrit par I1 avant d’être écrit par I3
Le code précédent est idiot (n’a aucune raison d’être généré par un compilateur décent):
aucune instruction n’utilise la valeur produite par I1 dans R7!!
Un code plus réaliste:
I1 : ADD R1, R4, R7 (R7 <- R1 + R4)

I2 : BNZ label1 (Branchement à label1 si flag = 1)
I3 : ADD R2, R6, R7 (R7 <- R2 + R6)
Les exemples précédents mettaient en jeu des registres mais le même type de
dépendance existe avec la mémoire. Le calcul des dépendances peut être effectué au
niveau matériel ou logiciel.
Il est à remarquer que la notion de dépendances de données est aussi utilisée pour les
programmes
Le renommage de registres permet de supprimer des contraintes d'ordre entre

instructions liées aux dépendances de type WAW et WAR. On peut distinguer les
registres logiques des registres physiques:
 registre logique = celui manipulé par le programmeur

 registre physique = l’endroit dans le processeur où la valeur est physiquement
stockée
Les principes de mise en œuvre du renommage des registres:
 Plus de registres physiques que de registres logiques dans l’ISA :

 Maintenir une liste de registres physiques disponibles
 Affecter un nouveau registre physique à chaque nouvelle écriture de registres
 Libérer les registres après leur dernière utilisation
NB : l'ISA (Instruction Set Architecture) c'est l’interface entre le matériel et le logiciel. On

trouve des ISA de type CISC, RISC, VLIW, EPIC.
Pour limiter l'impact des aléas RAW on utilise un mécanisme de by-pass.
La technique du by-pass (ou forwarding)

Pour limiter l'impact des aléas de données sur le pipeline instruction, un réseau de by-
pass permet de disposer du résultat d'une instruction plus rapidement.
Le résultat en sortie de l'ALU peut être intercepté avant l'écriture dans le fichier de
registres:
IV. Dépendances de contrôle entre instructions

Ce type de conflit est généralement lié aux instructions de contrôles. Pour connaître
l'adresse de l'instruction calculée par un branchement, il faut attendre la fin de la phase
EX de l'instruction. Le nombre de cycles perdu sur les branchements peut être très
important : 15 à 30% des instructions sont des branchements.
La cible et la direction d'un branchement sont connues très tard dans le pipeline. Au
plus tôt :
 Cycle 7 sur le DEC 21264

 Cycle 11 sur l'Intel Pentium III
 Cycle 18 sur l’Intel Pentium 4

Deux solutions
 la prédiction de branchement
 le délai de branchement

A. La prédiction de branchement
Le fonctionnement pipeline pose des problèmes de dépendance particuliers lorsque le

processeur doit exécuter des instructions de branchement conditionnel. En effet, les
instructions de branchement conditionnel ont la particularité d'avoir un comportement
qui dépend d'une condition qui, dans certains cas, peut ne pas être disponible à l'instant
souhaité. Prenons l'exemple du branchement conditionnel suivant :
@i SUB R1, R1, 1 // R1 = R1 - 1

@i+1 BRZ R1, @label // si R1 == 0 alors on saute a l'adresse label
Pour un processeur Von Neumann classique (non pipeline), l'exécution de l'instruction

SUB va positionner une valeur dans le registre R1. Cette valeur sera ensuite lue par
l'instruction de branchement conditionnel BRZ et utilisée pour décider si le saut doit être
pris ou pas. L'instruction suivante qui sera lue par le processeur sera donc soit
l'instruction de l'adresse @i+2 si la condition est fausse, soit l'instruction de l'adresse
@label si la condition est vraie.
Dans le cas d'un processeur pipeliné, la difficulté tient à l'indisponibilité de la condition

au moment où l'on doit décider de charger la prochaine instruction. Illustrons cela par la
figure ci-dessous.

La première instruction va modifier le contenu du registre R1 au cycle 5. Ce qui
permettra alors à la seconde instruction de savoir, au cycle 6, si le saut doit être exécuté
ou non. Mais regardons ce qui s'est passé dans les cycles précédents et imaginons que le
branchement attende la fin de l'exécution du SUB pour décider de son comportement.
 au cycle 0 : le processeur effectue la lecture de la première instruction à exécuter,

instruction Sub ;
 au cycle 1 : l'instruction Sub étant lue, elle est alors décodée, l'instruction suivante
est alors lue, instruction BrZ.
 au cycle 2 : l'instruction Sub débute son exécution, l'instruction BrZ est alors
décodée et une nouvelle instruction est alors lue, il s'agit alors forcément de
l'instruction située à l'adresse i+2.
 au cycle 3 : l'instruction Sub poursuit son exécution, l'instruction BrZ entre alors
dans les étages d'exécution, l'instruction de l'adresse i+2 est alors décodée et tout
naturellement, l'instruction de l'adresse i+3 est lue.
 au cycle 4 : les instructions Sub et BrZ poursuivent leur chemin dans le pipeline,
tandis que l'instruction de l'adresse i+4 entre dans ce même pipeline.

 au cycle 5 : les instructions Sub et BrZ poursuivent leur chemin dans le pipeline,
tandis que l'instruction de l'adresse i+5 entre dans ce même pipeline. A cette
étape, l'instruction Sub effectue l'écriture de son opérande destination, c'est-à-dire
que le registre R1 reçoit son résultat.
 etc ...
Arrêtons là l'analyse et revenons sur le cycle 2. Ce cycle fait apparaître un problème. En

effet, ne connaissant pas la valeur du registre R1 le branchement ne va pourvoir
déterminer comment il doit se comporter.
Une solution simple pour résoudre le problème est d'appliquer la technique du blocage
du pipeline jusqu'à ce que l'opérande source du branchement soit disponible. Cela
nécessite donc de bloquer le pipeline durant cinq cycles, avant de pouvoir débloquer
l'instruction de branchement. Cette solution est difficilement envisageable compte tenu
du nombre d'instructions de branchement conditionnel présent dans les programmes
classiques (environ une instruction sur cinq).
L'une des solutions possibles consiste à laisser le pipeline lire les instructions qui suivent
le branchement et à les annuler s'il le faut. Dans le cas ci-dessus, on constate qu'entre le
moment où le branchement entre dans le pipeline et le moment où l'on est capable de
savoir comment exécuter ce branchement, 5 instructions ont été lues par le processeur.
Au cycle 5, le registre R1 est produit, ce qui permet, au cycle 6 de connaître le
comportement du branchement. A partir de là, deux cas de figures peuvent se présenter:
 La condition de branchement est fausse (c'est à dire que le résultat de l'instruction

Sub n'est pas nul), alors le processeur doit poursuivre son exécution sur les
instructions des adresses i+2, i+3, i+4, i+5 etc. Dans ce cas, étant donné que ces
instructions sont déjà rentrées dans le pipeline, on peut donc les laisser s'exécuter
jusqu'au bout. Aucun problème particulier, pas de perte de cycles.
 La condition de branchement est vraie (c'est à dire que le résultat de l'instruction
Sub est nul), alors les instructions des adresses i+2, i+3, i+4, i+5, i+6 ne sont pas à
exécuter, et le processeur doit poursuivre son exécution par les instructions se
situant aux adresses label, label+1, label+2, etc. Dans ce cas, que fait-on des
instructions qui sont entrées dans le pipeline alors qu'elles n'avaient rien à y
faire?
La solution technique mise en œuvre pour annuler les instructions est une invalidation
des écritures des opérandes destinations. Le fait de rendre l'écriture dans les registres
résultats inactifs, transforme toutes ces instructions en instructions de type Nop. Cette
solution, bien que donnant un fonctionnement correct, n'est pas satisfaisante car elle

coûte cinq cycles processeur à chaque fois qu'un branchement conditionnel est pris. Ce
problème est d'autant plus critique que le nombre de branchements dans les
applications est globalement égal à 20 % (c'est-à-dire qu'une instruction sur cinq est un
branchement). Dans ces conditions, il devient difficilement acceptable de perdre autant
de cycles lors de l'exécution de ces applications.
La solution technique pour éviter de perdre trop de cycles processeur lorsqu'un

branchement conditionnel est exécuté par le processeur, consiste à tenter de prédire
comment va se comporter le branchement avant même que la condition ne soit connue
(calculée).
Lorsque l'instruction de branchement est lue par l'étage de lecture au cycle 1, le

processeur va tenter de prédire son comportement. Le processeur va donc calculer une
hypothèse concernant la suite des instructions à exécuter. Il va donc décider de :

 prendre le branchement ;
OU
 ne pas prendre le branchement.
Le cycle suivant, le processeur va donc faire entrer dans son pipeline des instructions
dont il suppose l'exécution. On qualifie ces instructions de prédites, puisque l'on prédit
leur exécution sans pour autant être sur qu'elles sont à exécuter. Lorsque l'instruction
Sub termine son exécution, alors le processeur peut vérifier l'hypothèse qu'il avait faite.
Deux situations peuvent alors se produire :
 L'hypothèse calculée est correcte, c'est-à-dire que le processeur à décidé de

continuer son exécution dans un certain sens (il a décidé de se brancher ou de ne
pas se brancher), et ce choix se révèle le bon. Dans ce cas, le processeur poursuit
son exécution sans perte de cycle ;
 L'hypothèse calculée est fausse, c'est-à-dire que le processeur a décidé de
continuer son exécution dans un certain sens, et ce choix se révèle incorrect. Dans
ce cas, le processeur doit éliminer les instructions qui sont entrées dans le
pipeline (puisqu'elles ne devaient pas être exécutées) et réamorcer son pipeline
avec la bonne branche du programme.
Voilà simplement la technique de la prédiction de branchement à mettre en œuvre et

finalement, la problématique des branchements conditionnels est alors ramenée à un
problème de calcul d'hypothèse sur le comportement de ces branchements. Si l'on est
capable de prévoir le comportement de tous les branchements conditionnels sans jamais
se tromper, alors aucun cycle processeur ne sera perdu à cause des branchements. Par
contre, il est clair que si, pour chaque branchement conditionnel, l'hypothèse calculée se
révèle fausse, alors le nombre de cycles perdus sera très important.
La question qui se pose alors est la suivante:
Comment prévoir le comportement d'un branchement ?
Plusieurs prédicteurs ont été développés. Les plus anciens prédicteurs étaient simples et
peu coûteux à implémenter, mais ils ont rapidement été remplacés par des prédicteurs
plus complexes offrant de bien meilleures performances (on appelle performance d'un
prédicteur de branchement le taux de bonnes prédictions de celui-ci). Il est relativement
aisé d'observer que le nombre de cycles perdus en cas de mauvaise prédiction dépend
de la longueur du pipeline. Cette observation n'empêche pas pour autant les
constructeurs à allonger le pipeline de leurs processeurs. Il leur faut donc compenser
l'augmentation du nombre de cycles perdus lors d'une mauvaise prédiction par un taux

de bonnes prédictions plus élevé. Des pédicteurs avec des taux de bonnes prédictions
voisins de 99%, et dans certains cas même supérieur, ont alors été développés.
Les sections suivantes vont détailler les différentes techniques que l'on peut globalement
classer en deux catégories qui sont les techniques statiques et dynamiques.
B. Prédictions de branchement statiques
Ces techniques sont dites statiques parce qu'elles proposent une méthode globale à tous
les branchements pour calculer l'hypothèse.
i. Prédiction de branchement statique globale
La première technique consiste à fixer une méthode (pour le calcul de l'hypothèse)

unique pour tous les branchements conditionnels de l'application. Par exemple, à
chaque fois que le processeur se trouve face à une instruction de branchement
conditionnel, celui-ci pose comme hypothèse de prendre le branchement. Cette
technique est évidemment peu souple et offre des performances (taux de bonnes
prédictions) assez faibles. Elle a toutefois l'avantage d'être peu coûteuse.
ii. Prédiction de branchement statique positionnable
Conscient des piètres performances de la première technique et sachant que le comportement

moyen des branchements peut être différent d'une application à l'autre, certains constructeurs ont
proposé un mécanisme permettant de positionner le sens de la prédiction. Par exemple, pour
l'application 1, le processeur peut avoir une hypothèse telle que les branchements sont prédits
pris, alors que pour une application 2, le processeur peut avoir l'hypothèse inverse (c'est-à-dire
que tout branchement est prédit non pris). Le positionnement du sens de la prédiction est à la
discrétion du développeur ou du compilateur. On peut dans ce cas s'appuyer sur une étude de
profiling de l'application afin de positionner, de la manière la plus adéquate possible, le sens de la
prédiction.
iii. Prédiction de branchement statique tenant compte du sens du

branchement
Des études sur le comportement des branchements ont montré que le comportement
moyen de ceux-ci dépendait beaucoup de leur sens. La notion de sens des branchements
permet de distinguer les branchements arrières et les branchements avants :

 On parle de branchement arrière lorsque le processeur se branche à une adresse
inférieure de l'adresse du branchement en question.
 On parle de branchement avant lorsque le processeur se branche à une adresse
supérieure de l'adresse du branchement en question.
Il a été montré que les branchements arrières ont plutôt tendance à être pris par le
processeur. En effet, les branchements conditionnels arrières résultent très souvent de la
compilation de boucles. Or la caractéristique principale d'une boucle est évidemment
que les instructions situées dans la boucle vont être exécuté plusieurs fois. On donne ci-
dessous le code de haut niveau d'une boucle exécutant N fois un calcul élémentaire.
for (i = 0 ; i < N ; i++) {

x[i] = u[i] + v[i];
}
La compilation va générer un code assembleur du type de celui donné ci-dessous.
Program LI R0, @U
LI R1, @V
LI R2, @X
LI R3, N
Boucle
LI R4, (R0)
LI R5, (R1)
ADD R6, R5, R4
LI (R2), R6
ADD R0, R0, 1
ADD R1, R1, 1
ADD R2, R2, 1
SUB R3, R3, 1
BRNZ R3, Boucle
End EXIT
Le comportement du branchement conditionnel arrière est presque toujours le même.

En effet, ce branchement sera pris N fois, puis il sera non pris 1 fois.
Pour ce qui concerne les branchements avants, ils sont typiquement issus de la
compilation d'un code ayant une structure si, alors, sinon telle que présentée dans le code
ci-dessous. Or, il a été montré, même si c'est moins évident, qu'ils ont plutôt tendance à
être non pris.
if (condition) else {
Instructions;
} else {
instructions ;
}

Compte tenu des résultats énoncés ci-dessus, il apparaît alors évident que si le
processeur dispose de moyen pour détecter le sens du branchement, alors il pourra
disposer de politiques de prédiction de branchement différentes, donc d'avoir un taux
de bonnes prédictions meilleur que dans le cas d'une prédiction de branchement
statique de base.
C. Prédictions de branchement dynamiques
Les techniques de prédiction de branchement statique donnent des performances assez

faibles et en tout cas pas suffisante dans le cas de pipelines très longs. Cela est
notamment du au fait que ces techniques sont globales à tout ou partie des
branchements d'une application. Elles ne tiennent donc pas du compte du
comportement spécifique de chaque branchement. L'idée qui a alors été proposée
consiste à tenter de conserver un historique du comportement de chaque branchement
afin de mieux prévoir le comportement des prochaines exécutions de ces branchements.
En effet, pour un branchement dont tous les comportements précédents ont conduit le
processeur à effectuer un saut, il semble intéressant de conserver cette information et de
l'exploiter lorsque ce branchement sera à nouveau à exécuter. Si le branchement a été,
historiquement pris (respectivement non pris), alors il sera prédit comme devant être pris
(respectivement non pris) une nouvelle fois.
La question qui se pose alors est de savoir comment on conserve cet historique. La
première solution développée a consisté à attribuer un bit d'historique par branchement.
Une seconde solution a ensuite été développée accordant 2 bits pour le stockage du
comportement de chaque branchement.
Une table pour le stockage de cet historique des branchements est alors mise en place
dans le processeur. Comme sa taille est forcement limitée et que tous les historiques de
tous les branchements ne peuvent pas être conservés, alors le fonctionnement de cette
table d'historique est assimilable à un cache. Ne sont conservés que les historiques des
branchements les plus récemment exécutés. Cette table est ensuite utilisée par le
processeur afin de calculer l'hypothèse (la prédiction) et elle est mise à jour lorsque le
branchement s'exécute (vérification hypothèse). La figure ci-dessous montre dans quels
étages cette table est utilisée pour permettre une cohérence dans le processeur.

i. Prédiction de branchement dynamique à 1 bit
La prédiction de branchement dynamique à 1 bit met en œuvre un seul bit pour stocker
le comportement de chaque branchement. Ce bit mémorise alors un historique peu
ancien indiquant simplement comment le branchement s'est comporté lors de
l'exécution précédente.
Cette technique permet d'exploiter le caractère spécifique du comportement de chaque

branchement conditionnel, mais l'historique conservé étant faible, ce prédicteur n'est pas
très performant.
ii. Prédiction de branchement dynamique à 2 bits
Les performances plutôt décevantes du prédicteur dynamique à 1 bit, ont amené les
concepteurs à proposer un prédicteur conservant un historique plus important. Une
solution mettant en œuvre 2 bits pour stocker l'historique des branchements a alors été
proposée. Les 2 bits de stockage de l'historique sont à nouveau utilisés pour calculer

l'hypothèse. On représente ces valeurs possibles de ces 2 bits par une machine d'états
dont les états sont les suivantes (voire aussi illustration dans la figure suivante) :
 P : branchement historiquement pris ;

 FP : branchement historiquement faiblement pris ;
 NP : branchement historiquement non pris ;
 FNP : branchement historiquement faiblement non pris ;
Les états vont permettre le calcul de la prédiction de branchement. Si la machine se

trouve dans l'état P ou FP alors le branchement est prédit pris. Inversement, si la
machine se trouve dans l'état NP ou FNP alors le branchement est prédit non pris.
Lors de l'exécution effective du branchement, le processeur vient faire une mise à jour
de la machine d'états. Les mises à jour sont symbolisées par les changements d'états
(flèches d'état à état sur la figure ci-dessus).
iii. Suppression des instructions de branchement conditionnel

(conditionnel move)
Nous avons donné dans les sections précédentes, les solutions qui peuvent être mises en
œuvre dans le cas où le processeur doit exécuter des instructions de branchements
conditionnels. Les constructeurs ont déployé des efforts importants pour fournir des
prédicteurs de branchements efficaces. Il n'en reste pas moins que le problème est de
plus en plus critique lorsque le pipeline du processeur s'allonge.
Il existe une autre voie pour limiter les risques de pertes de cycles dans les contrôleurs
pipelines des processeurs dans le cas d'un branchement. Il s'agit tout simplement
d'essayer de supprimer les instructions de branchements conditionnels. Cette solution
qui peut sembler, a priori, utopique est toutefois réalisable par le biais du
conditionnement de toutes les instructions du processeur. Considérons le code suivant :
if (condition) then {

instruction1 ;
instruction2 ;
} else {
instruction3 ;
instruction4 ;
}
La compilation de ce code va donner un listing assembleur du type de celui ci-dessous
...
BR condition, @then
else
instruction3 ;
instruction4 ;
BRA @suite
then
instruction1 ;
instruction2 ;
suite
...
...
Ce code fait nécessairement apparaître un branchement conditionnel dont le calcul

d'hypothèse est assez délicat. L'idée consiste alors à proposer de supprimer ce
branchement conditionnel au profit d'instructions dont l'exécution est rendue
conditionnelle. Nous donnons ci-dessous un exemple de code assembleur avec
utilisation d'instructions conditionnelles.
p1, p2 = eval (condition)

<p1> instruction1 ;
<p1> instruction2 ;
<p2> instruction3 ;
<p2> instruction4 ;
La première instruction de ce code permet une évaluation de la condition. Cette

évaluation est utilisée pour positionner deux registres booléens spécifiques. Le premier
registre est positionné à true si la condition est vraie, ou à false si la condition est fausse.
Le second registre prend la valeur complémentaire.
Les instructions suivantes (partie the et else) sont ensuite alignées les unes à la suite des
autres sans faire de saut. Les instructions circuleront donc dans le pipeline du
processeur, mais seules deux de ces instructions auront s'exécuteront normalement, les
deux autres auront le comportement d'instruction Nop. Les instructions qui
s'exécuteront normalement sont celles dont le registre pi est vrai.

V. Le processeur Pentium IV
Le processeur Pentium IV est basé sur l’architecture NetBurst se distingue par une
profondeur de pipeline jamais atteinte à ce jour par un processeur x86, puisquélle est de
20 niveaux, contre 10 par exemple pour une architecture de type P6. A titre de rappel,
un pipeline est un ensemble dúnités effectuant un travail à la chaîne, dans le but final
de traiter les instructions. Lorsque lón augmente la profondeur du pipeline, on
augmente le nombre dúnités, et on réduit donc le travail que chacune doit effectuer.
Cela à des avantages, mais aussi des inconvénients.
La bonne nouvelle, cést que láugmentation de la profondeur du pipeline permet

dáugmenter la fréquence facilement et sans changement de technologie immédiat. En
effet, chacune des taches effectuées par les unités étant moins lourde et nécessitant un
nombre moindre de transistor, il est possible de léffectuer en un temps plus court.
La prédiction de branchement utilise un principe assez simple. En effet, la plupart du

temps le processeur exécute des suites dínstructions quíl a déjà rencontré peu
auparavant, et donc des tests dont il connaît déjà líssue probable. Le processeur va
donc stocker dans ce que lón appelle le BTB (Branch Target Buffer) l´historique des tests
déjà traités. Síl rencontre un test du même type, il prendra le branchement déjà pris
auparavant. Cette technique est plutôt efficace, avec un taux de réussite dénviron 93%
sur Pentium 4 (BTB de 4 Ko), contre 90% sur Pentium III (BTB de 512 octets).
Malheureusement, chaque échec a un impact très important sur les performances,

puisque síl y a eu une mauvaise prédiction de branchement, le pipeline doit être remis
à zéro afin de recommencer avec le bon branchement. Vous comprendrez donc que cela
est plus pénalisant avec un pipeline à 20 niveaux quún autre à 10 !
Il est à noter que lárchitecture NetBurst est également capable déxécuter les
instructions dans le désordre (out of order execution). Ainsi, si par exemple la première
ALU traite le calcul A = 5 x 6 et que le calcul suivant est B = A + 2; la seconde ALU ne
peut rien faire dans le cas dúne exécution in order (dans lórdre), si ce nést attendre le
résultat du calcul A. Avec un le système out of order, la deuxième ALU peut sauter ce
calcul pour passer à un suivant, tous les résultats étant bien sur remis dans lórdre à la
fin.

Les 20 étapes du pipeline couvrent les quatre grandes étapes du traitement des
instructions :
 Le « in-order front end » charge les instructions et les décode. Elle nécessite 5
étages du pipeline (1 à 5).
 Le « out-of-order (OOO) execution logic » réordonne les instructions et les
répartit vers les unités de calcul. Il occupe 7 étapes du pipeline (6 à 12).
 La phase d'exécution fait intervenir les unités de calcul proprement dites : 5
étapes (13 à 17).
 La phase de « retirement » réordonne les résultats du calcul de façon cohérente : 3
étapes (18 à 20).
La prédiction de branchement est un facteur de performances important, car le

remplissage du pipeline est une opération très coûteuse en cycles processeur ; en effet, le
pipeline n'est capable de traiter que des micro-opérations (µops), elles-mêmes étant le
résultat du décodage des instructions plus complexes arrivant dans le bus du
processeur.
Afin d'accélérer cette phase de décodage, les processeurs modernes multiplient les
unités de décodage. Ainsi le Pentium III et l'Athlon sont capables de décoder jusqu'à
trois instructions IA-32 par cycle. Le Pentium 4 quant à lui utilise une technique
différente : il n'est capable de décoder qu'une seule instruction IA-32 par cycle, mais en
revanche il dispose d'une mémoire tampon permettant de stocker le résultat des
décodages; il s'agit du Trace Cache.
A la différence d'un cache code classique qui contient des instructions non décodées, le
Trace Cache est inséré dans les premières étapes du pipeline, il contient donc des µops
directement utilisables par les étapes suivantes du pipeline.
Ce système présente deux intérêts majeurs :
 Réduire les cycles de pénalités en cas d'échec de branchement. En effet, dans une
telle situation, le pipeline doit être vidé puis remplit à nouveau avec les bonnes
instructions, qui avec un peu de chance sont contenues dans le cache code. Un
cache code classique contient des instructions IA-32 qui doivent alors être à
nouveau décodées pour être utilisables par le pipeline. Le Trace Cache, contenant
des µops déjà décodées, permet d'éviter cette phase de décodage.
 Par rapport à un cache code classique, le Trace Cache se situe après l'unité de
prédiction de branchement (BPU) ; cela implique que les µops contenues dans le
Trace Cache sont celles prévues par la prédiction de branchement, alors qu'un

cache code classique contient les instructions des deux branches, dont une seule
sera prise.
Cependant le Trace Cache présente quelques désagréments, liés au fait qu'il est une
mémoire insérée dans le pipeline. En effet, rechercher une information dans une
mémoire n'est pas immédiat, et la latence engendrée dépend directement de sa taille et
de son organisation. Afin de ne pas insérer trop de latences au sein même du pipeline, le
Trace Cache se doit d'avoir une taille limitée. Et plus la taille est faible, moins les
chances d'y trouver l'information sont grandes, c'est là l'éternel dilemme des mémoires
caches.
L'autre désavantage est lié à l'architecture physique de la mémoire qui occupe une
surface assez importante dans la puce. Le fonctionnement optimal du pipeline nécessite
que les unités impliquées dans les étapes successives soient le plus rapprochées possible
d'un point de vue physique, afin de réduire la distance de parcourt des signaux. A ce
titre, le Trace Cache représente une importante quantité de transistors, et propager une
donnée jusqu'à l'étape suivante du pipeline peut s'avérer problématique en terme de
distance. Le résultat est que le pipeline possède une étape dédiée à la propagation du
signal depuis le Trace Cache vers l'étape suivante, justement nommée étape Drive. Le
pipeline du Pentium 4 possède en tout deux étapes Drive dédiées à la propagation du
signal.

CHAPITRE 4: La mémoire
I. Introduction
On appelle mémoire un composant électronique permettant de stocker une information

sous forme binaire. On distingue les mémoires à lecture seule appelées ROM pour Read
Only Memory et les mémoires à lecture/écriture appelées improprement RAM pour
Random Access Memory. Le contenu des mémoires à lecture seule est fixé lors de la
fabrication en usine et reste dans la mémoire lorsque celle-ci n'est pas alimentée. Au
contraire, les mémoires à lecture/écriture sont volatiles. Le contenu est perdu dès qu'elles
ne sont plus alimentées.
Plus une mémoire est grande, plus son temps d’accès est long
Trois types de mémoire
 banc de registres
o peu d’entrées, temps d’accès court (< 1 cycle), plusieurs ports
 mémoire dynamique (DRAM)
o mémorisation d’une charge sur une capacité,
o 1 transistor par bit grande densité d’intégration (16-64 Mbits)
o temps d’accès long: 50-100 ns
o utilisé comme mémoire principale
 mémoire statique (SRAM)
o mémorisation par bouclage de 2 portes: 1-4 Mbits
o cher
o temps d’accès court: 5-10 ns
II. Latence mémoire
La latence mémoire n’est pas seulement constituée par le temps d’accès DRAM, il faut
aussi ajouter:
 la translation d’adresse
 la traverser les broches du processeur et le bus externe
 le multiplexage si plusieurs bancs mémoires
Latence de la mémoire principale: 100-200 ns à 1 GHz, ça fait 100 à 200 cycles CPU

III. Hiérarchie mémoire
Les différents éléments de la mémoire d’un ordinateur sont ordonnés en fonction des
critères: temps d’accès, capacité et coût par bit. Les différents mémoires situées dans
l’unité centrale de traitement sont:
 Les registres: accessibles immédiatement par le processeur, ils sont caractérisés par
une grande vitesse et servent principalement au stockage des opérandes et des
résultats intermédiaires.
 La mémoire cache ou l’antémémoire: rapide, de faible capacité par rapport à la

mémoire centrale, utilisée comme mémoire tampon entre le CPU et la mémoire
centrale. Elle permet au CPU de faire moins d'accès à la mémoire centrale et ainsi
gagner du temps.
 La mémoire centrale: c'est l'organe principal de rangement des informations

utilisées par le CPU. Pour exécuter un programme, il faut le charger en mémoire
centrale. Cette mémoire est une mémoire à semi-conducteur, mais son temps
d'accès est beaucoup plus grand que celui des registres et du cache.
 La mémoire d'appui: sert de mémoire intermédiaire entre la mémoire centrale et

les mémoires auxiliaires. Elle est présente dans les ordinateurs les plus évolués et
permet d'augmenter la vitesse d'échange des informations entre ces deux niveaux.
 la mémoire auxiliaire: c'est une mémoire périphérique de grande capacité et de

coût relativement faible utilisée pour le stockage permanent des informations, et
utilisent pour cela des supports magnétiques ou optiques.
La figure suivante montre une comparaison des différentes catégories de mémoires dans un
ordinateur, plus on s’éloigne du CPU vers les mémoires auxiliaires, on constate que le
temps d’accès et la capacité des mémoires augmentent, mais que le coût par bit diminue.

Le principe de fonctionnement est que les niveaux les plus hauts interceptent la majeure
partie des références mémoires. Pour ce faire, ils gardent les adresses les plus
récemment référencées (exploitation de la localité temporelle). Attention, il y a une
contrainte d'espace liée à la faible capacité des niveaux les plus hauts.
La localité spatiale est exploitée lors des transferts entre niveaux: au lieu d'effectuer des
transferts mot à mot, les transferts seront faits par blocs d'adresses contiguës
Localité spatiale
Un programme exhibe de la localité spatiale lorsque des données ou des instructions qui
sont à des adresses proches ont tendance à être accédées dans des temps rapprochés. Sur
un défaut de cache, on ne chargera pas une seule donnée ou une seule instruction, mais
un bloc de plusieurs instructions ou données.
Impact sur les performances de la localité spatiale
La localité spatiale influence les performances des codes.

Bonne localité spatiale Dégradation de la localité spatiale avec un pas d'accès
supérieur à 1.
subroutine reference(x,y,n,rep) subroutine TEST(x,y,n,pas,rep)
implicit none implicit none
integer n,rep integer n,pas,rep
real x(n),y(n) real x(pas*n),y(n)
integer i,j integer i,j
do i=1,rep do i=1,rep
do j = 1,n do j = 1,n
y(i) = y(i) + x(j) y(i) = y(i) +x(pas*j)
enddo enddo
enddo enddo
end end
Localité temporelle
Un programme exhibe de la localité temporelle lorsque des données ou des instructions

déjà accédées dans le passé sont souvent réutilisées dans un futur proche.
IV. Mémoire Physique & Mémoire virtuelle

Lorsqu'un programme utilisateur est trop volumineux pour tenir en mémoire, le
système d'exploitation utilise un espace du disque qu'il nomme mémoire virtuelle pour
le stockage. Le problème à résoudre en ce moment est la gestion et la correspondance
adresse virtuelle et adresse physique qui est l'adresse effective en mémoire.

A. Organisation en mémoire virtuelle
Le principe fondamental est la dissociation entre

 l'adresse référencée dans un processus en exécution : adresse virtuelle
 l'adresse utilisée en mémoire principale : adresse physique ou réelle

La correspondance entre l'adresse virtuelle et l'adresse physique est effectuée par un
"mapping" (Dynamic AddressTranslation)
Chaque fois qu'une adresse virtuelle est référencée, le mapping (ou topographie)
convertit cette adresse en une adresse physique qui est l'emplacement du début de bloc
en mémoire principale. Bien entendu, ceci suppose que le bloc a préalablement été
chargé en mémoire principale. Si ce n'est pas le cas, un processus d'interruption permet
de rechercher le bloc en mémoire secondaire, de le charger en mémoire principale (il
possède alors une adresse physique) et d'effectuer la correspondance adresse virtuelle
vers adresse physique.
Les intérêts du concept de mémoire virtuelle sont évidents :

 L'espace physique de stockage (et notamment la hiérarchie des mémoires) est
utilisé de manière optimale.
 L'utilisateur est libéré des contraintes de stockage
 L'utilisateur a une vue logique de l'espace de stockage.
A un instant donné, la situation est la suivante, pour plusieurs programmes en

exécution :

Les transferts entre la mémoire principale et la mémoire secondaire nécessitent une
organisation de l'information en blocs ; le système d'exploitation possède à tout moment
la liste des blocs qui sont en mémoire principale. Si les blocs ont une taille fixe, on les
appelle des pages ; s'ils sont de taille variable, on les appelle des segments.
La structure d'une adresse virtuelle est la suivante :
et le schéma ci-dessous explicite le mécanisme général du mapping :

le numéro de bloc b, combiné à une
adresse de base située dans un registre,
permet d'atteindre un élément de la
table des blocs. Cet élément donne,
entre autres informations, l'adresse
d'un bloc en mémoire principale ;
la partie d est la même pour l'adresse
virtuelle et l'adresse physique : elle
permet de trouver un octet particulier
dans le bloc (adressage relatif).
B. Pagination
Les pages sont des blocs de taille fixe et l'adresse virtuelle est de la forme (p,d) où p est
le numéro de page en mémoire virtuelle. Un élément de la table des pages sera de la
forme (r, s, D, p') où r est le bit de résidence (0 si la page est en mémoire secondaire, 1 si
la page est chargée en mémoire principale), s est l'adresse en mémoire secondaire (si
r=0), p' est le numéro de page en mémoire principale (si r=1) ; D correspond aux droits
d'accès de la page (lecture, écriture, exécution).
On peut distinguer trois types de mapping :
mapping "direct" : p est converti

en p' d'après la table des pages.

mapping "associatif" : une
mémoire associative est utilisée
pour la table des pages (accès
par contenu et non par
adresse) ce qui permet
d'augmenter la
vitesse de traitement.
mapping "direct-associatif" : on
essaie d'abord de trouver p'
avec la table associative, sinon
on utilise la table générale.
C. Segmentation
Un segment est un bloc de taille variable ; une adresse virtuelle est de la forme (s,d) où s
est le numéro de segment. Le mécanisme de mapping est assez similaire à celui de la
pagination. Un élément de la table des segments sera de la forme (r, s, l, D, s') où r , s, D,
s' ont la même signification que précédemment (en remplaçant page par segment), l
désigne la longueur du segment.

D. Systèmes mixtes
Il existe des systèmes mêlant segmentation et pagination.

exemple : segment 1 = 4 pages ; segment 2 = 2 pages, etc...
Une adresse virtuelle est alors de la forme (s, p, d) où s est le numéro de segment, p le
numéro de page dans le segment et d le numéro d'octet dans la page (déplacement).
On essaie d'abord la recherche avec la table associative, sinon on utilise les tables
segment-pages.

E. Stratégies de remplacement en pagination
Lorsque le système est en fonctionnement, la mémoire principale contient des pages

chargées ; au bout d'un moment, elle peut être saturée ; pour charger une nouvelle page,
il faut en "écraser" une présente. En général c'est le principe d'optimalité qui guide ce
remplacement : on remplace les pages qui ne sont plus utilisées, mais, bien entendu, ceci
n'est qu'un vœu car il est difficile de prédire qu'une page ne sera plus utilisée par la
suite. C'est pourquoi, un certain nombre de stratégies ont été mises au point pour
s'approcher au plus près du principe d'optimalité.
LRU
La stratégie LRU (Least Recently Use) consiste à remplacer la page la moins récemment
utilisée. C'est donc ici l'utilisation et non le chargement qui guide la politique de
remplacement. Bien entendu, il faut estampiller chaque page avec une date chaque fois
qu'elle est utilisée. Le problème que l'on rencontre dans cette stratégie est celui des
traitements faisant intervenir des boucles de programme.

LFU
La stratégie LFU (Least Frequently Use) est plus affinée que la précédente ; ici c'est la
fréquence d'utilisation des pages qui est pris en compte, ce qui permet (théoriquement)
de résoudre le problème des boucles. On remplace donc la page la moins fréquemment
utilisée ; une page sera donc munie d'un compteur du nombre d'utilisations de cette
page. Bien évidemment, une page qui vient d'être chargée possède une probabilité
importante d'être remplacée.
NU R
La stratégie NUR (Not Used Recently) est assez populaire et a pour base l'idée suivante :
une page qui n'a pas été utilisée récemment a peu de chances de l'être ultérieurement.
Pour mettre en œuvre la stratégie NUR, 2 bits sont affectés à chaque page : rb (bit de
référence) et mb (bit de modification ou dirty bit)
rb = 0 si la page n'a pas été référencée et rb = 1 si la page a été référencée

mb = 0 si la page n'a pas été modifiée et mb = 1 si la page a été modifiée
Au départ, rb = mb = 0 ; l'algorithme de remplacement de page est le suivant :
Chercher une page avec rb = 0 (page non référencée)

Si on trouve alors
Si mb = 0 (page non modifiée) alors
Remplacer la page
sinon
Continuer la recherche
FinSi
sinon
Remplacer la page référencée
FinSi
Périodiquement, on remet rb à 0, ce qui signifie que, à un instant donné, il y a 4
catégories de pages :
rb = 0 et mb = 0 pages ayant une plus grande

rb = 0 et mb = 1 probabilité d'être remplacées

rb = 1 et mb = 0 pages ayant une probabilité
rb = 1 et mb = 1 plus faible d'être remplacées
F IF O
Chaque page qui vient d'être chargée est affectée d'une date (de chargement). En se
basant sur cette date, il est possible d'éliminer les pages les plus anciennes. Telle est la
stratégie FIFO (First In First Out).

Langue

Cours Microprocesseu

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Cours Microprocesseu

Transféré par

Droits d'auteur :

Formats disponibles

Support de Cours

CHAPITRE 1: Représentation de l’information ......................................................................... 5

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 2

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 3

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 4

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 5

Décimal Binaire Octal Hexadécimal

III. Conversion d’une base à une autre (nombres positifs)

N=a0+ 𝛼(a1+ 𝛼(a2+…𝛼(an-1+𝛼an))) puis on remplace 𝛼 et chaque ai par leur représentation

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 6

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 7

d7=0.600=d3 d’où c7=1, c8=0, c9=0

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 8

Etant donné un nombre en base 2 la conversion en base 8 se fait en subdivision de la

E(x) peut se mettre sous la forme suivante

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 9

La subdivision ou décomposition est identique au précédent mais en groupe de 4 bits.

IV. Les opérations arithmétiques

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 10

1. Notion de chiffre significatif

Exemples: 123 trois chiffres significatifs

2. Notion d'arrondi et d'erreur d'arrondi

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 11

3. Notion de troncature et d'erreur de troncature

V.Représentation des entiers

Soit x un nombre à n bits, le complément à 𝛽 − 1 de x est : (𝛽 𝑛 − 1) − 𝑥. L’opération

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 12

Soit N=1010 sur 4 bits N’= (24 - 1)-N

Exemple : complément à 10 de 72945

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 13

Remarque : Dans la représentation en complément il faut toujours fixer le nombre de

a) Nombres sans signe

2) 1250 – 9456 4) 01001 – 11100

ii) complément à r-1

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 14

b) Nombre avec signe

i) Signe suivi de valeur absolue (| |)

Exemple : n=8 représentation de 5 et -5

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 15

Exemple : n=4 complément à 2 complément à 1 signe + | |

7 0111 0111 0111

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 16

VI. Représentation des réels

Signe P.E P.F Valeur

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 17

Un nombre flottant a donc la représentation suivante :

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 18

1bit 4bits 8bits

Signe mantisse : positif (0)

(ii) - (15,01)8 = - (001101,000001)2= - 0,1101000001 * 24

Signe mantisse : négatif (1)

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 19

1bit 4bits 11bits

Signe mantisse : positif ( 0)

(ii) - (15,01)8=(001101,000001)2= 0,1101000001 * 24

Signe mantisse : négatif ( 1)

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 20

3. Opérations arithmétiques en virgule flottante

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 21

Exemple : Effectuer l’opération suivante : (0,15)8+ (1,5)8=(?) :

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 22

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 23

DR A. M. CHANA LEMALE Cours de Microprocesseur Page 24